blob: b85c1b622e453e969cebcb0a8a1f8251faac64eb [file] [log] [blame]
Lloyd Piquef58625d2017-12-19 13:22:33 -08001/*
2 * Copyright (C) 2018 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#pragma once
18
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080019#include <compositionengine/Display.h>
Lloyd Pique0b785d82018-12-04 17:25:27 -080020#include <compositionengine/Layer.h>
Lloyd Pique9755fb72019-03-26 14:44:40 -070021#include <compositionengine/LayerFECompositionState.h>
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080022#include <compositionengine/OutputLayer.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070023#include <compositionengine/impl/CompositionEngine.h>
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080024#include <compositionengine/impl/OutputLayerCompositionState.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070025
Lloyd Pique90c115d2018-09-18 21:39:42 -070026#include "BufferQueueLayer.h"
27#include "BufferStateLayer.h"
28#include "ColorLayer.h"
29#include "ContainerLayer.h"
Lloyd Piquef58625d2017-12-19 13:22:33 -080030#include "DisplayDevice.h"
Ana Krulec757f63a2019-01-25 10:46:18 -080031#include "FakePhaseOffsets.h"
Lloyd Piqued6b579f2018-04-06 15:29:10 -070032#include "Layer.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070033#include "NativeWindowSurface.h"
Dominik Laskowski9dab3432019-03-27 13:21:10 -070034#include "Scheduler/MessageQueue.h"
Steven Thomas2bbaabe2019-08-28 16:08:35 -070035#include "Scheduler/RefreshRateConfigs.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070036#include "StartPropertySetThread.h"
Lloyd Piquef58625d2017-12-19 13:22:33 -080037#include "SurfaceFlinger.h"
Lloyd Pique24f3bfe2019-10-02 19:29:10 -070038#include "SurfaceFlingerDefaultFactory.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070039#include "SurfaceInterceptor.h"
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -070040#include "TestableScheduler.h"
Yiwei Zhang7e666a52018-11-15 13:33:42 -080041
Lloyd Piquef58625d2017-12-19 13:22:33 -080042namespace android {
43
Lloyd Piquee39cad22017-12-20 17:01:29 -080044class EventThread;
45
Peiyong Lin833074a2018-08-28 11:53:54 -070046namespace renderengine {
Lloyd Pique90c115d2018-09-18 21:39:42 -070047
Lloyd Piquee39cad22017-12-20 17:01:29 -080048class RenderEngine;
Lloyd Pique90c115d2018-09-18 21:39:42 -070049
50} // namespace renderengine
Lloyd Piquee39cad22017-12-20 17:01:29 -080051
52namespace Hwc2 {
Lloyd Pique90c115d2018-09-18 21:39:42 -070053
Lloyd Piquee39cad22017-12-20 17:01:29 -080054class Composer;
Lloyd Pique90c115d2018-09-18 21:39:42 -070055
56} // namespace Hwc2
57
58namespace surfaceflinger::test {
59
60class Factory final : public surfaceflinger::Factory {
61public:
62 ~Factory() = default;
63
Dominik Laskowski98041832019-08-01 18:35:59 -070064 std::unique_ptr<DispSync> createDispSync(const char*, bool) override {
Lloyd Pique90c115d2018-09-18 21:39:42 -070065 // TODO: Use test-fixture controlled factory
66 return nullptr;
67 }
68
69 std::unique_ptr<EventControlThread> createEventControlThread(
70 std::function<void(bool)>) override {
71 // TODO: Use test-fixture controlled factory
72 return nullptr;
73 }
74
75 std::unique_ptr<HWComposer> createHWComposer(const std::string&) override {
76 // TODO: Use test-fixture controlled factory
77 return nullptr;
78 }
79
80 std::unique_ptr<MessageQueue> createMessageQueue() override {
81 // TODO: Use test-fixture controlled factory
82 return std::make_unique<android::impl::MessageQueue>();
83 }
84
Ana Krulec757f63a2019-01-25 10:46:18 -080085 std::unique_ptr<scheduler::PhaseOffsets> createPhaseOffsets() override {
86 return std::make_unique<scheduler::FakePhaseOffsets>();
87 }
88
Ady Abraham09bd3922019-04-08 10:44:56 -070089 std::unique_ptr<Scheduler> createScheduler(std::function<void(bool)>,
90 const scheduler::RefreshRateConfigs&) override {
Lloyd Pique90c115d2018-09-18 21:39:42 -070091 // TODO: Use test-fixture controlled factory
92 return nullptr;
93 }
94
95 std::unique_ptr<SurfaceInterceptor> createSurfaceInterceptor(SurfaceFlinger* flinger) override {
96 // TODO: Use test-fixture controlled factory
97 return std::make_unique<android::impl::SurfaceInterceptor>(flinger);
98 }
99
100 sp<StartPropertySetThread> createStartPropertySetThread(bool timestampPropertyValue) override {
101 // TODO: Use test-fixture controlled factory
102 return new StartPropertySetThread(timestampPropertyValue);
103 }
104
105 sp<DisplayDevice> createDisplayDevice(DisplayDeviceCreationArgs&& creationArgs) override {
106 // TODO: Use test-fixture controlled factory
107 return new DisplayDevice(std::move(creationArgs));
108 }
109
110 sp<GraphicBuffer> createGraphicBuffer(uint32_t width, uint32_t height, PixelFormat format,
111 uint32_t layerCount, uint64_t usage,
112 std::string requestorName) override {
113 // TODO: Use test-fixture controlled factory
114 return new GraphicBuffer(width, height, format, layerCount, usage, requestorName);
115 }
116
117 void createBufferQueue(sp<IGraphicBufferProducer>* outProducer,
118 sp<IGraphicBufferConsumer>* outConsumer,
119 bool consumerIsSurfaceFlinger) override {
120 if (!mCreateBufferQueue) return;
121 mCreateBufferQueue(outProducer, outConsumer, consumerIsSurfaceFlinger);
122 }
123
124 std::unique_ptr<surfaceflinger::NativeWindowSurface> createNativeWindowSurface(
125 const sp<IGraphicBufferProducer>& producer) override {
126 if (!mCreateNativeWindowSurface) return nullptr;
127 return mCreateNativeWindowSurface(producer);
128 }
129
Lloyd Pique70d91362018-10-18 16:02:55 -0700130 std::unique_ptr<compositionengine::CompositionEngine> createCompositionEngine() override {
131 return compositionengine::impl::createCompositionEngine();
132 }
133
Lloyd Pique90c115d2018-09-18 21:39:42 -0700134 sp<BufferQueueLayer> createBufferQueueLayer(const LayerCreationArgs&) override {
135 // TODO: Use test-fixture controlled factory
136 return nullptr;
137 }
138
139 sp<BufferStateLayer> createBufferStateLayer(const LayerCreationArgs&) override {
140 // TODO: Use test-fixture controlled factory
141 return nullptr;
142 }
143
144 sp<ColorLayer> createColorLayer(const LayerCreationArgs&) override {
145 // TODO: Use test-fixture controlled factory
146 return nullptr;
147 }
148
149 sp<ContainerLayer> createContainerLayer(const LayerCreationArgs&) override {
150 // TODO: Use test-fixture controlled factory
151 return nullptr;
152 }
153
154 using CreateBufferQueueFunction =
155 std::function<void(sp<IGraphicBufferProducer>* /* outProducer */,
156 sp<IGraphicBufferConsumer>* /* outConsumer */,
157 bool /* consumerIsSurfaceFlinger */)>;
158 CreateBufferQueueFunction mCreateBufferQueue;
159
160 using CreateNativeWindowSurfaceFunction =
161 std::function<std::unique_ptr<surfaceflinger::NativeWindowSurface>(
162 const sp<IGraphicBufferProducer>&)>;
163 CreateNativeWindowSurfaceFunction mCreateNativeWindowSurface;
Lloyd Pique70d91362018-10-18 16:02:55 -0700164
165 using CreateCompositionEngineFunction =
166 std::function<std::unique_ptr<compositionengine::CompositionEngine>()>;
167 CreateCompositionEngineFunction mCreateCompositionEngine;
Lloyd Pique90c115d2018-09-18 21:39:42 -0700168};
169
170} // namespace surfaceflinger::test
Lloyd Piquee39cad22017-12-20 17:01:29 -0800171
Lloyd Piquef58625d2017-12-19 13:22:33 -0800172class TestableSurfaceFlinger {
173public:
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700174 TestableScheduler* scheduler() { return mScheduler; }
175
Lloyd Piquef58625d2017-12-19 13:22:33 -0800176 // Extend this as needed for accessing SurfaceFlinger private (and public)
177 // functions.
178
Peiyong Lin833074a2018-08-28 11:53:54 -0700179 void setupRenderEngine(std::unique_ptr<renderengine::RenderEngine> renderEngine) {
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700180 mFlinger->mCompositionEngine->setRenderEngine(std::move(renderEngine));
Lloyd Piquee39cad22017-12-20 17:01:29 -0800181 }
182
183 void setupComposer(std::unique_ptr<Hwc2::Composer> composer) {
Lloyd Pique441d5042018-10-18 16:49:51 -0700184 mFlinger->mCompositionEngine->setHwComposer(
185 std::make_unique<impl::HWComposer>(std::move(composer)));
Lloyd Piquee39cad22017-12-20 17:01:29 -0800186 }
187
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700188 void setupScheduler(std::unique_ptr<DispSync> primaryDispSync,
189 std::unique_ptr<EventControlThread> eventControlThread,
190 std::unique_ptr<EventThread> appEventThread,
191 std::unique_ptr<EventThread> sfEventThread) {
Steven Thomas2bbaabe2019-08-28 16:08:35 -0700192 std::vector<scheduler::RefreshRateConfigs::InputConfig> configs{{/*hwcId=*/0, 16666667}};
193 mFlinger->mRefreshRateConfigs =
194 std::make_unique<scheduler::RefreshRateConfigs>(/*refreshRateSwitching=*/false,
195 configs, /*currentConfig=*/0);
196 mFlinger->mRefreshRateStats =
197 std::make_unique<scheduler::RefreshRateStats>(*mFlinger->mRefreshRateConfigs,
198 *mFlinger->mTimeStats,
199 /*currentConfig=*/0,
200 /*powerMode=*/HWC_POWER_MODE_OFF);
201
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700202 mScheduler =
203 new TestableScheduler(std::move(primaryDispSync), std::move(eventControlThread),
Steven Thomas2bbaabe2019-08-28 16:08:35 -0700204 *mFlinger->mRefreshRateConfigs);
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700205
Dominik Laskowski98041832019-08-01 18:35:59 -0700206 mFlinger->mAppConnectionHandle = mScheduler->createConnection(std::move(appEventThread));
207 mFlinger->mSfConnectionHandle = mScheduler->createConnection(std::move(sfEventThread));
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700208
209 mFlinger->mScheduler.reset(mScheduler);
210 mFlinger->mVSyncModulator.emplace(*mScheduler, mFlinger->mAppConnectionHandle,
211 mFlinger->mSfConnectionHandle,
212 mFlinger->mPhaseOffsets->getCurrentOffsets());
213 }
214
Lloyd Pique90c115d2018-09-18 21:39:42 -0700215 using CreateBufferQueueFunction = surfaceflinger::test::Factory::CreateBufferQueueFunction;
Lloyd Pique5b36f3f2018-01-17 11:57:07 -0800216 void setCreateBufferQueueFunction(CreateBufferQueueFunction f) {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700217 mFactory.mCreateBufferQueue = f;
Lloyd Pique5b36f3f2018-01-17 11:57:07 -0800218 }
219
Lloyd Pique90c115d2018-09-18 21:39:42 -0700220 using CreateNativeWindowSurfaceFunction =
221 surfaceflinger::test::Factory::CreateNativeWindowSurfaceFunction;
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800222 void setCreateNativeWindowSurface(CreateNativeWindowSurfaceFunction f) {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700223 mFactory.mCreateNativeWindowSurface = f;
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800224 }
225
Daniel Solomon42d04562019-01-20 21:03:19 -0800226 void setInternalDisplayPrimaries(const ui::DisplayPrimaries& primaries) {
227 memcpy(&mFlinger->mInternalDisplayPrimaries, &primaries, sizeof(ui::DisplayPrimaries));
228 }
229
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800230 using HotplugEvent = SurfaceFlinger::HotplugEvent;
231
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800232 auto& mutableLayerCurrentState(sp<Layer> layer) { return layer->mCurrentState; }
233 auto& mutableLayerDrawingState(sp<Layer> layer) { return layer->mDrawingState; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700234
Valerie Haud251afb2019-03-29 14:19:02 -0700235 auto& mutableStateLock() { return mFlinger->mStateLock; }
236
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700237 void setLayerSidebandStream(sp<Layer> layer, sp<NativeHandle> sidebandStream) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800238 layer->mDrawingState.sidebandStream = sidebandStream;
Lloyd Pique0b785d82018-12-04 17:25:27 -0800239 layer->mSidebandStream = sidebandStream;
Lloyd Pique9755fb72019-03-26 14:44:40 -0700240 layer->getCompositionLayer()->editFEState().sidebandStream = sidebandStream;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700241 }
242
Lloyd Pique37c2c9b2018-12-04 17:25:10 -0800243 void setLayerCompositionType(sp<Layer> layer, HWC2::Composition type) {
244 auto outputLayer = layer->findOutputLayerForDisplay(mFlinger->getDefaultDisplayDevice());
245 LOG_ALWAYS_FATAL_IF(!outputLayer);
246 auto& state = outputLayer->editState();
247 LOG_ALWAYS_FATAL_IF(!outputLayer->getState().hwc);
248 (*state.hwc).hwcCompositionType = static_cast<Hwc2::IComposerClient::Composition>(type);
249 };
250
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700251 void setLayerPotentialCursor(sp<Layer> layer, bool potentialCursor) {
252 layer->mPotentialCursor = potentialCursor;
253 }
254
Lloyd Piquef58625d2017-12-19 13:22:33 -0800255 /* ------------------------------------------------------------------------
256 * Forwarding for functions being tested
257 */
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800258
Lloyd Piquea482f992018-01-22 19:00:34 -0800259 auto createDisplay(const String8& displayName, bool secure) {
260 return mFlinger->createDisplay(displayName, secure);
261 }
262
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700263 auto destroyDisplay(const sp<IBinder>& displayToken) {
264 return mFlinger->destroyDisplay(displayToken);
265 }
Lloyd Piquea482f992018-01-22 19:00:34 -0800266
Lloyd Piqued6fbb8a2018-01-22 19:08:36 -0800267 auto resetDisplayState() { return mFlinger->resetDisplayState(); }
268
Dominik Laskowski075d3172018-05-24 15:50:06 -0700269 auto setupNewDisplayDeviceInternal(const wp<IBinder>& displayToken,
270 const std::optional<DisplayId>& displayId,
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800271 const DisplayDeviceState& state,
Lloyd Pique542307f2018-10-19 13:24:08 -0700272 const sp<compositionengine::DisplaySurface>& dispSurface,
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800273 const sp<IGraphicBufferProducer>& producer) {
Dominik Laskowski7e045462018-05-30 13:02:02 -0700274 return mFlinger->setupNewDisplayDeviceInternal(displayToken, displayId, state, dispSurface,
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800275 producer);
276 }
277
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800278 auto handleTransactionLocked(uint32_t transactionFlags) {
Vishnu Nairfa5f8df2019-02-13 17:02:51 -0800279 Mutex::Autolock _l(mFlinger->mStateLock);
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800280 return mFlinger->handleTransactionLocked(transactionFlags);
281 }
Lloyd Piquef58625d2017-12-19 13:22:33 -0800282
Lloyd Pique6cf11032018-01-22 18:57:44 -0800283 auto onHotplugReceived(int32_t sequenceId, hwc2_display_t display,
284 HWC2::Connection connection) {
285 return mFlinger->onHotplugReceived(sequenceId, display, connection);
286 }
287
Vishnu Nairce5d0cc2019-02-28 14:38:41 -0800288 auto setDisplayStateLocked(const DisplayState& s) {
289 Mutex::Autolock _l(mFlinger->mStateLock);
290 return mFlinger->setDisplayStateLocked(s);
291 }
Lloyd Pique9d9cf402018-02-16 17:47:13 -0800292
Dominik Laskowski83b88212018-12-11 13:34:06 -0800293 // Allow reading display state without locking, as if called on the SF main thread.
294 auto onInitializeDisplays() NO_THREAD_SAFETY_ANALYSIS {
295 return mFlinger->onInitializeDisplays();
296 }
Lloyd Pique86016da2018-03-01 16:09:38 -0800297
Dominik Laskowski83b88212018-12-11 13:34:06 -0800298 // Allow reading display state without locking, as if called on the SF main thread.
299 auto setPowerModeInternal(const sp<DisplayDevice>& display,
300 int mode) NO_THREAD_SAFETY_ANALYSIS {
Dominik Laskowskie9774092018-12-11 10:04:24 -0800301 return mFlinger->setPowerModeInternal(display, mode);
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800302 }
303
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700304 auto onMessageReceived(int32_t what) { return mFlinger->onMessageReceived(what); }
305
Robert Carr108b2c72019-04-02 16:32:58 -0700306 auto captureScreenImplLocked(
307 const RenderArea& renderArea, SurfaceFlinger::TraverseLayersFunction traverseLayers,
308 ANativeWindowBuffer* buffer, bool useIdentityTransform, bool forSystem, int* outSyncFd) {
309 bool ignored;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700310 return mFlinger->captureScreenImplLocked(renderArea, traverseLayers, buffer,
Robert Carr108b2c72019-04-02 16:32:58 -0700311 useIdentityTransform, forSystem, outSyncFd,
312 ignored);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700313 }
314
chaviw0e3479f2018-09-10 16:49:30 -0700315 auto traverseLayersInDisplay(const sp<const DisplayDevice>& display,
316 const LayerVector::Visitor& visitor) {
317 return mFlinger->SurfaceFlinger::traverseLayersInDisplay(display, visitor);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700318 }
319
Daniel Solomon42d04562019-01-20 21:03:19 -0800320 auto getDisplayNativePrimaries(const sp<IBinder>& displayToken,
321 ui::DisplayPrimaries &primaries) {
322 return mFlinger->SurfaceFlinger::getDisplayNativePrimaries(displayToken, primaries);
323 }
324
Valerie Haud251afb2019-03-29 14:19:02 -0700325 auto& getTransactionQueue() { return mFlinger->mTransactionQueues; }
326
327 auto setTransactionState(const Vector<ComposerState>& states,
328 const Vector<DisplayState>& displays, uint32_t flags,
329 const sp<IBinder>& applyToken,
330 const InputWindowCommands& inputWindowCommands,
331 int64_t desiredPresentTime, const client_cache_t& uncacheBuffer,
332 bool hasListenerCallbacks,
333 std::vector<ListenerCallbacks>& listenerCallbacks) {
334 return mFlinger->setTransactionState(states, displays, flags, applyToken,
335 inputWindowCommands, desiredPresentTime, uncacheBuffer,
336 hasListenerCallbacks, listenerCallbacks);
337 }
338
339 auto flushTransactionQueues() { return mFlinger->flushTransactionQueues(); };
340
Lloyd Pique86016da2018-03-01 16:09:38 -0800341 /* ------------------------------------------------------------------------
342 * Read-only access to private data to assert post-conditions.
343 */
344
345 const auto& getAnimFrameTracker() const { return mFlinger->mAnimFrameTracker; }
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800346 const auto& getHasPoweredOff() const { return mFlinger->mHasPoweredOff; }
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800347 const auto& getVisibleRegionsDirty() const { return mFlinger->mVisibleRegionsDirty; }
Lloyd Pique441d5042018-10-18 16:49:51 -0700348 auto& getHwComposer() const {
349 return static_cast<impl::HWComposer&>(mFlinger->getHwComposer());
350 }
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800351
Lloyd Pique86016da2018-03-01 16:09:38 -0800352 const auto& getCompositorTiming() const { return mFlinger->getBE().mCompositorTiming; }
353
Lloyd Piquef58625d2017-12-19 13:22:33 -0800354 /* ------------------------------------------------------------------------
355 * Read-write access to private data to set up preconditions and assert
356 * post-conditions.
357 */
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800358
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800359 auto& mutableHasWideColorDisplay() { return SurfaceFlinger::hasWideColorDisplay; }
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700360 auto& mutablePrimaryDisplayOrientation() { return SurfaceFlinger::primaryDisplayOrientation; }
Peiyong Lin13effd12018-07-24 17:01:47 -0700361 auto& mutableUseColorManagement() { return SurfaceFlinger::useColorManagement; }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800362
Lloyd Piquee39cad22017-12-20 17:01:29 -0800363 auto& mutableCurrentState() { return mFlinger->mCurrentState; }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800364 auto& mutableDisplayColorSetting() { return mFlinger->mDisplayColorSetting; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700365 auto& mutableDisplays() { return mFlinger->mDisplays; }
Lloyd Piquee39cad22017-12-20 17:01:29 -0800366 auto& mutableDrawingState() { return mFlinger->mDrawingState; }
Lloyd Piquee39cad22017-12-20 17:01:29 -0800367 auto& mutableEventQueue() { return mFlinger->mEventQueue; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700368 auto& mutableGeometryInvalid() { return mFlinger->mGeometryInvalid; }
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800369 auto& mutableInterceptor() { return mFlinger->mInterceptor; }
Lloyd Pique6cf11032018-01-22 18:57:44 -0800370 auto& mutableMainThreadId() { return mFlinger->mMainThreadId; }
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800371 auto& mutablePendingHotplugEvents() { return mFlinger->mPendingHotplugEvents; }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700372 auto& mutablePhysicalDisplayTokens() { return mFlinger->mPhysicalDisplayTokens; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700373 auto& mutableTexturePool() { return mFlinger->mTexturePool; }
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800374 auto& mutableTransactionFlags() { return mFlinger->mTransactionFlags; }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800375 auto& mutableUseHwcVirtualDisplays() { return mFlinger->mUseHwcVirtualDisplays; }
Peiyong Lin74ca2f42019-01-14 19:36:57 -0800376 auto& mutablePowerAdvisor() { return mFlinger->mPowerAdvisor; }
Lloyd Pique4fe29402019-08-12 16:51:24 -0700377 auto& mutableDebugDisableHWC() { return mFlinger->mDebugDisableHWC; }
Lloyd Piquee39cad22017-12-20 17:01:29 -0800378
Lloyd Pique6cf11032018-01-22 18:57:44 -0800379 auto& mutableComposerSequenceId() { return mFlinger->getBE().mComposerSequenceId; }
Lloyd Pique441d5042018-10-18 16:49:51 -0700380 auto& mutableHwcDisplayData() { return getHwComposer().mDisplayData; }
381 auto& mutableHwcPhysicalDisplayIdMap() { return getHwComposer().mPhysicalDisplayIdMap; }
382 auto& mutableInternalHwcDisplayId() { return getHwComposer().mInternalHwcDisplayId; }
383 auto& mutableExternalHwcDisplayId() { return getHwComposer().mExternalHwcDisplayId; }
Lloyd Piquea618d852018-01-17 11:52:30 -0800384
Lloyd Piquee39cad22017-12-20 17:01:29 -0800385 ~TestableSurfaceFlinger() {
386 // All these pointer and container clears help ensure that GMock does
387 // not report a leaked object, since the SurfaceFlinger instance may
388 // still be referenced by something despite our best efforts to destroy
389 // it after each test is done.
390 mutableDisplays().clear();
Ady Abraham2939f092019-03-04 17:44:06 -0800391 mutableCurrentState().displays.clear();
392 mutableDrawingState().displays.clear();
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800393 mutableEventQueue().reset();
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800394 mutableInterceptor().reset();
Lloyd Pique2eb71eb2019-08-13 13:23:03 -0700395 mFlinger->mScheduler.reset();
Lloyd Pique441d5042018-10-18 16:49:51 -0700396 mFlinger->mCompositionEngine->setHwComposer(std::unique_ptr<HWComposer>());
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700397 mFlinger->mCompositionEngine->setRenderEngine(
398 std::unique_ptr<renderengine::RenderEngine>());
Lloyd Piquee39cad22017-12-20 17:01:29 -0800399 }
Lloyd Piquef58625d2017-12-19 13:22:33 -0800400
Lloyd Piquea618d852018-01-17 11:52:30 -0800401 /* ------------------------------------------------------------------------
402 * Wrapper classes for Read-write access to private data to set up
403 * preconditions and assert post-conditions.
404 */
Ana Krulec4593b692019-01-11 22:07:25 -0800405 struct HWC2Display : public HWC2::impl::Display {
Peiyong Lin74ca2f42019-01-14 19:36:57 -0800406 HWC2Display(Hwc2::Composer& composer,
Lloyd Piquea618d852018-01-17 11:52:30 -0800407 const std::unordered_set<HWC2::Capability>& capabilities, hwc2_display_t id,
408 HWC2::DisplayType type)
Peiyong Lin74ca2f42019-01-14 19:36:57 -0800409 : HWC2::impl::Display(composer, capabilities, id, type) {}
Lloyd Piquea618d852018-01-17 11:52:30 -0800410 ~HWC2Display() {
411 // Prevents a call to disable vsyncs.
412 mType = HWC2::DisplayType::Invalid;
413 }
414
415 auto& mutableIsConnected() { return this->mIsConnected; }
416 auto& mutableConfigs() { return this->mConfigs; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700417 auto& mutableLayers() { return this->mLayers; }
Lloyd Piquea618d852018-01-17 11:52:30 -0800418 };
419
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800420 class FakeHwcDisplayInjector {
421 public:
422 static constexpr hwc2_display_t DEFAULT_HWC_DISPLAY_ID = 1000;
423 static constexpr int32_t DEFAULT_WIDTH = 1920;
424 static constexpr int32_t DEFAULT_HEIGHT = 1280;
425 static constexpr int32_t DEFAULT_REFRESH_RATE = 16'666'666;
426 static constexpr int32_t DEFAULT_DPI = 320;
427 static constexpr int32_t DEFAULT_ACTIVE_CONFIG = 0;
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700428 static constexpr int32_t DEFAULT_POWER_MODE = 2;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800429
Dominik Laskowski075d3172018-05-24 15:50:06 -0700430 FakeHwcDisplayInjector(DisplayId displayId, HWC2::DisplayType hwcDisplayType,
431 bool isPrimary)
432 : mDisplayId(displayId), mHwcDisplayType(hwcDisplayType), mIsPrimary(isPrimary) {}
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800433
434 auto& setHwcDisplayId(hwc2_display_t displayId) {
435 mHwcDisplayId = displayId;
436 return *this;
437 }
438
439 auto& setWidth(int32_t width) {
440 mWidth = width;
441 return *this;
442 }
443
444 auto& setHeight(int32_t height) {
445 mHeight = height;
446 return *this;
447 }
448
449 auto& setRefreshRate(int32_t refreshRate) {
450 mRefreshRate = refreshRate;
451 return *this;
452 }
453
454 auto& setDpiX(int32_t dpi) {
455 mDpiX = dpi;
456 return *this;
457 }
458
459 auto& setDpiY(int32_t dpi) {
460 mDpiY = dpi;
461 return *this;
462 }
463
464 auto& setActiveConfig(int32_t config) {
465 mActiveConfig = config;
466 return *this;
467 }
468
Lloyd Piquee22f0332018-07-16 16:35:56 -0700469 auto& setCapabilities(const std::unordered_set<HWC2::Capability>* capabilities) {
470 mCapabilities = capabilities;
471 return *this;
472 }
473
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700474 auto& setPowerMode(int mode) {
475 mPowerMode = mode;
476 return *this;
477 }
478
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800479 void inject(TestableSurfaceFlinger* flinger, Hwc2::Composer* composer) {
Lloyd Piquee22f0332018-07-16 16:35:56 -0700480 static const std::unordered_set<HWC2::Capability> defaultCapabilities;
481 if (mCapabilities == nullptr) mCapabilities = &defaultCapabilities;
482
483 // Caution - Make sure that any values passed by reference here do
484 // not refer to an instance owned by FakeHwcDisplayInjector. This
485 // class has temporary lifetime, while the constructed HWC2::Display
486 // is much longer lived.
Peiyong Lin74ca2f42019-01-14 19:36:57 -0800487 auto display = std::make_unique<HWC2Display>(*composer, *mCapabilities, mHwcDisplayId,
488 mHwcDisplayType);
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800489
490 auto config = HWC2::Display::Config::Builder(*display, mActiveConfig);
491 config.setWidth(mWidth);
492 config.setHeight(mHeight);
493 config.setVsyncPeriod(mRefreshRate);
494 config.setDpiX(mDpiX);
495 config.setDpiY(mDpiY);
496 display->mutableConfigs().emplace(mActiveConfig, config.build());
497 display->mutableIsConnected() = true;
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700498 display->setPowerMode(static_cast<HWC2::PowerMode>(mPowerMode));
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800499
Dominik Laskowski075d3172018-05-24 15:50:06 -0700500 flinger->mutableHwcDisplayData()[mDisplayId].hwcDisplay = display.get();
501
502 if (mHwcDisplayType == HWC2::DisplayType::Physical) {
503 flinger->mutableHwcPhysicalDisplayIdMap().emplace(mHwcDisplayId, mDisplayId);
504 (mIsPrimary ? flinger->mutableInternalHwcDisplayId()
505 : flinger->mutableExternalHwcDisplayId()) = mHwcDisplayId;
506 }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800507
508 flinger->mFakeHwcDisplays.push_back(std::move(display));
509 }
510
511 private:
Dominik Laskowski075d3172018-05-24 15:50:06 -0700512 const DisplayId mDisplayId;
513 const HWC2::DisplayType mHwcDisplayType;
514 const bool mIsPrimary;
515
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800516 hwc2_display_t mHwcDisplayId = DEFAULT_HWC_DISPLAY_ID;
517 int32_t mWidth = DEFAULT_WIDTH;
518 int32_t mHeight = DEFAULT_HEIGHT;
519 int32_t mRefreshRate = DEFAULT_REFRESH_RATE;
520 int32_t mDpiX = DEFAULT_DPI;
521 int32_t mDpiY = DEFAULT_DPI;
522 int32_t mActiveConfig = DEFAULT_ACTIVE_CONFIG;
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700523 int32_t mPowerMode = DEFAULT_POWER_MODE;
Lloyd Piquee22f0332018-07-16 16:35:56 -0700524 const std::unordered_set<HWC2::Capability>* mCapabilities = nullptr;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800525 };
526
527 class FakeDisplayDeviceInjector {
528 public:
Dominik Laskowski075d3172018-05-24 15:50:06 -0700529 FakeDisplayDeviceInjector(TestableSurfaceFlinger& flinger,
530 const std::optional<DisplayId>& displayId, bool isVirtual,
531 bool isPrimary)
532 : mFlinger(flinger), mCreationArgs(flinger.mFlinger.get(), mDisplayToken, displayId) {
533 mCreationArgs.isVirtual = isVirtual;
534 mCreationArgs.isPrimary = isPrimary;
535 }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800536
537 sp<IBinder> token() const { return mDisplayToken; }
538
539 DisplayDeviceState& mutableDrawingDisplayState() {
540 return mFlinger.mutableDrawingState().displays.editValueFor(mDisplayToken);
541 }
542
543 DisplayDeviceState& mutableCurrentDisplayState() {
544 return mFlinger.mutableCurrentState().displays.editValueFor(mDisplayToken);
545 }
546
Lloyd Pique9d9cf402018-02-16 17:47:13 -0800547 const auto& getDrawingDisplayState() {
548 return mFlinger.mutableDrawingState().displays.valueFor(mDisplayToken);
549 }
550
551 const auto& getCurrentDisplayState() {
552 return mFlinger.mutableCurrentState().displays.valueFor(mDisplayToken);
553 }
554
Dominik Laskowski9fae1022018-05-29 13:17:40 -0700555 auto& mutableDisplayDevice() { return mFlinger.mutableDisplays()[mDisplayToken]; }
Lloyd Pique9d9cf402018-02-16 17:47:13 -0800556
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800557 auto& setNativeWindow(const sp<ANativeWindow>& nativeWindow) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700558 mCreationArgs.nativeWindow = nativeWindow;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800559 return *this;
560 }
561
Lloyd Pique542307f2018-10-19 13:24:08 -0700562 auto& setDisplaySurface(const sp<compositionengine::DisplaySurface>& displaySurface) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700563 mCreationArgs.displaySurface = displaySurface;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800564 return *this;
565 }
566
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800567 auto& setSecure(bool secure) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700568 mCreationArgs.isSecure = secure;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800569 return *this;
570 }
571
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700572 auto& setPowerMode(int mode) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700573 mCreationArgs.initialPowerMode = mode;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700574 return *this;
575 }
576
Valerie Hau9758ae02018-10-09 16:05:09 -0700577 auto& setHwcColorModes(
578 const std::unordered_map<ui::ColorMode, std::vector<ui::RenderIntent>>
579 hwcColorModes) {
580 mCreationArgs.hwcColorModes = hwcColorModes;
581 return *this;
582 }
583
584 auto& setHasWideColorGamut(bool hasWideColorGamut) {
585 mCreationArgs.hasWideColorGamut = hasWideColorGamut;
586 return *this;
587 }
588
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800589 sp<DisplayDevice> inject() {
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800590 DisplayDeviceState state;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700591 state.displayId = mCreationArgs.isVirtual ? std::nullopt : mCreationArgs.displayId;
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700592 state.isSecure = mCreationArgs.isSecure;
593
594 sp<DisplayDevice> device = new DisplayDevice(std::move(mCreationArgs));
595 mFlinger.mutableDisplays().emplace(mDisplayToken, device);
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800596 mFlinger.mutableCurrentState().displays.add(mDisplayToken, state);
597 mFlinger.mutableDrawingState().displays.add(mDisplayToken, state);
598
Dominik Laskowski075d3172018-05-24 15:50:06 -0700599 if (!mCreationArgs.isVirtual) {
600 LOG_ALWAYS_FATAL_IF(!state.displayId);
601 mFlinger.mutablePhysicalDisplayTokens()[*state.displayId] = mDisplayToken;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800602 }
603
604 return device;
605 }
606
607 private:
608 TestableSurfaceFlinger& mFlinger;
609 sp<BBinder> mDisplayToken = new BBinder();
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700610 DisplayDeviceCreationArgs mCreationArgs;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800611 };
612
Lloyd Pique90c115d2018-09-18 21:39:42 -0700613 surfaceflinger::test::Factory mFactory;
614 sp<SurfaceFlinger> mFlinger = new SurfaceFlinger(mFactory, SurfaceFlinger::SkipInitialization);
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700615 TestableScheduler* mScheduler = nullptr;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800616
617 // We need to keep a reference to these so they are properly destroyed.
618 std::vector<std::unique_ptr<HWC2Display>> mFakeHwcDisplays;
Lloyd Piquef58625d2017-12-19 13:22:33 -0800619};
620
621} // namespace android