blob: 8c4232df88510cf54d542b3459c8bdb523420668 [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 Pique9755fb72019-03-26 14:44:40 -070020#include <compositionengine/LayerFECompositionState.h>
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080021#include <compositionengine/OutputLayer.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070022#include <compositionengine/impl/CompositionEngine.h>
Lloyd Pique9370a482019-10-03 17:58:30 -070023#include <compositionengine/impl/Display.h>
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080024#include <compositionengine/impl/OutputLayerCompositionState.h>
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -070025#include <compositionengine/mock/DisplaySurface.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070026
Lloyd Pique90c115d2018-09-18 21:39:42 -070027#include "BufferQueueLayer.h"
28#include "BufferStateLayer.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070029#include "ContainerLayer.h"
Lloyd Piquef58625d2017-12-19 13:22:33 -080030#include "DisplayDevice.h"
Vishnu Nairfa247b12020-02-11 08:58:26 -080031#include "EffectLayer.h"
Ady Abrahamc581d3c2020-08-06 17:34:27 -070032#include "FakeVsyncConfiguration.h"
Lloyd Piqued6b579f2018-04-06 15:29:10 -070033#include "Layer.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070034#include "NativeWindowSurface.h"
Dominik Laskowski9dab3432019-03-27 13:21:10 -070035#include "Scheduler/MessageQueue.h"
Steven Thomas2bbaabe2019-08-28 16:08:35 -070036#include "Scheduler/RefreshRateConfigs.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070037#include "StartPropertySetThread.h"
Lloyd Piquef58625d2017-12-19 13:22:33 -080038#include "SurfaceFlinger.h"
Lloyd Pique24f3bfe2019-10-02 19:29:10 -070039#include "SurfaceFlingerDefaultFactory.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070040#include "SurfaceInterceptor.h"
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -070041#include "TestableScheduler.h"
Ady Abrahamabc27602020-04-08 17:20:29 -070042#include "mock/DisplayHardware/MockDisplay.h"
Yiwei Zhang7e666a52018-11-15 13:33:42 -080043
Lloyd Piquef58625d2017-12-19 13:22:33 -080044namespace android {
45
Lloyd Piquee39cad22017-12-20 17:01:29 -080046class EventThread;
47
Peiyong Lin833074a2018-08-28 11:53:54 -070048namespace renderengine {
Lloyd Pique90c115d2018-09-18 21:39:42 -070049
Lloyd Piquee39cad22017-12-20 17:01:29 -080050class RenderEngine;
Lloyd Pique90c115d2018-09-18 21:39:42 -070051
52} // namespace renderengine
Lloyd Piquee39cad22017-12-20 17:01:29 -080053
54namespace Hwc2 {
Lloyd Pique90c115d2018-09-18 21:39:42 -070055
Lloyd Piquee39cad22017-12-20 17:01:29 -080056class Composer;
Lloyd Pique90c115d2018-09-18 21:39:42 -070057
58} // namespace Hwc2
59
Peiyong Line9d809e2020-04-14 13:10:48 -070060namespace hal = android::hardware::graphics::composer::hal;
61
Lloyd Pique90c115d2018-09-18 21:39:42 -070062namespace surfaceflinger::test {
63
64class Factory final : public surfaceflinger::Factory {
65public:
66 ~Factory() = default;
67
Lloyd Pique90c115d2018-09-18 21:39:42 -070068 std::unique_ptr<HWComposer> createHWComposer(const std::string&) override {
Lloyd Pique90c115d2018-09-18 21:39:42 -070069 return nullptr;
70 }
71
72 std::unique_ptr<MessageQueue> createMessageQueue() override {
Lloyd Pique90c115d2018-09-18 21:39:42 -070073 return std::make_unique<android::impl::MessageQueue>();
74 }
75
Ady Abraham8287e852020-08-12 14:44:58 -070076 std::unique_ptr<scheduler::VsyncConfiguration> createVsyncConfiguration(
Ady Abraham9e16a482019-12-03 17:19:41 -080077 const scheduler::RefreshRateConfigs& /*refreshRateConfigs*/) override {
Ana Krulec757f63a2019-01-25 10:46:18 -080078 return std::make_unique<scheduler::FakePhaseOffsets>();
79 }
80
Dominik Laskowski8b01cc02020-07-14 19:02:41 -070081 std::unique_ptr<Scheduler> createScheduler(const scheduler::RefreshRateConfigs&,
Ady Abraham3a77a7b2019-12-02 18:46:59 -080082 ISchedulerCallback&) override {
Lloyd Pique90c115d2018-09-18 21:39:42 -070083 return nullptr;
84 }
85
86 std::unique_ptr<SurfaceInterceptor> createSurfaceInterceptor(SurfaceFlinger* flinger) override {
Lloyd Pique90c115d2018-09-18 21:39:42 -070087 return std::make_unique<android::impl::SurfaceInterceptor>(flinger);
88 }
89
90 sp<StartPropertySetThread> createStartPropertySetThread(bool timestampPropertyValue) override {
Lloyd Pique90c115d2018-09-18 21:39:42 -070091 return new StartPropertySetThread(timestampPropertyValue);
92 }
93
Lloyd Pique9370a482019-10-03 17:58:30 -070094 sp<DisplayDevice> createDisplayDevice(DisplayDeviceCreationArgs& creationArgs) override {
95 return new DisplayDevice(creationArgs);
Lloyd Pique90c115d2018-09-18 21:39:42 -070096 }
97
98 sp<GraphicBuffer> createGraphicBuffer(uint32_t width, uint32_t height, PixelFormat format,
99 uint32_t layerCount, uint64_t usage,
100 std::string requestorName) override {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700101 return new GraphicBuffer(width, height, format, layerCount, usage, requestorName);
102 }
103
104 void createBufferQueue(sp<IGraphicBufferProducer>* outProducer,
105 sp<IGraphicBufferConsumer>* outConsumer,
106 bool consumerIsSurfaceFlinger) override {
Lloyd Piquee300b312019-10-03 13:03:45 -0700107 if (!mCreateBufferQueue) {
108 BufferQueue::createBufferQueue(outProducer, outConsumer, consumerIsSurfaceFlinger);
109 return;
110 }
Lloyd Pique90c115d2018-09-18 21:39:42 -0700111 mCreateBufferQueue(outProducer, outConsumer, consumerIsSurfaceFlinger);
112 }
113
Lloyd Piquee300b312019-10-03 13:03:45 -0700114 sp<IGraphicBufferProducer> createMonitoredProducer(const sp<IGraphicBufferProducer>& producer,
115 const sp<SurfaceFlinger>& flinger,
116 const wp<Layer>& layer) override {
117 return new MonitoredProducer(producer, flinger, layer);
118 }
119
120 sp<BufferLayerConsumer> createBufferLayerConsumer(const sp<IGraphicBufferConsumer>& consumer,
121 renderengine::RenderEngine& renderEngine,
122 uint32_t textureName, Layer* layer) override {
123 return new BufferLayerConsumer(consumer, renderEngine, textureName, layer);
124 }
125
Lloyd Pique90c115d2018-09-18 21:39:42 -0700126 std::unique_ptr<surfaceflinger::NativeWindowSurface> createNativeWindowSurface(
127 const sp<IGraphicBufferProducer>& producer) override {
128 if (!mCreateNativeWindowSurface) return nullptr;
129 return mCreateNativeWindowSurface(producer);
130 }
131
Lloyd Pique70d91362018-10-18 16:02:55 -0700132 std::unique_ptr<compositionengine::CompositionEngine> createCompositionEngine() override {
133 return compositionengine::impl::createCompositionEngine();
134 }
135
Lloyd Pique90c115d2018-09-18 21:39:42 -0700136 sp<BufferQueueLayer> createBufferQueueLayer(const LayerCreationArgs&) override {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700137 return nullptr;
138 }
139
140 sp<BufferStateLayer> createBufferStateLayer(const LayerCreationArgs&) override {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700141 return nullptr;
142 }
143
Vishnu Nairfa247b12020-02-11 08:58:26 -0800144 sp<EffectLayer> createEffectLayer(const LayerCreationArgs&) override { return nullptr; }
Lloyd Pique90c115d2018-09-18 21:39:42 -0700145
146 sp<ContainerLayer> createContainerLayer(const LayerCreationArgs&) override {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700147 return nullptr;
148 }
149
150 using CreateBufferQueueFunction =
151 std::function<void(sp<IGraphicBufferProducer>* /* outProducer */,
152 sp<IGraphicBufferConsumer>* /* outConsumer */,
153 bool /* consumerIsSurfaceFlinger */)>;
154 CreateBufferQueueFunction mCreateBufferQueue;
155
156 using CreateNativeWindowSurfaceFunction =
157 std::function<std::unique_ptr<surfaceflinger::NativeWindowSurface>(
158 const sp<IGraphicBufferProducer>&)>;
159 CreateNativeWindowSurfaceFunction mCreateNativeWindowSurface;
Lloyd Pique70d91362018-10-18 16:02:55 -0700160
161 using CreateCompositionEngineFunction =
162 std::function<std::unique_ptr<compositionengine::CompositionEngine>()>;
163 CreateCompositionEngineFunction mCreateCompositionEngine;
Lloyd Pique90c115d2018-09-18 21:39:42 -0700164};
165
166} // namespace surfaceflinger::test
Lloyd Piquee39cad22017-12-20 17:01:29 -0800167
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700168class TestableSurfaceFlinger final : private ISchedulerCallback {
Lloyd Piquef58625d2017-12-19 13:22:33 -0800169public:
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700170 using HotplugEvent = SurfaceFlinger::HotplugEvent;
171
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700172 SurfaceFlinger* flinger() { return mFlinger.get(); }
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700173 TestableScheduler* scheduler() { return mScheduler; }
174
Lloyd Piquef58625d2017-12-19 13:22:33 -0800175 // Extend this as needed for accessing SurfaceFlinger private (and public)
176 // functions.
177
Peiyong Lin833074a2018-08-28 11:53:54 -0700178 void setupRenderEngine(std::unique_ptr<renderengine::RenderEngine> renderEngine) {
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700179 mFlinger->mCompositionEngine->setRenderEngine(std::move(renderEngine));
Lloyd Piquee39cad22017-12-20 17:01:29 -0800180 }
181
182 void setupComposer(std::unique_ptr<Hwc2::Composer> composer) {
Lloyd Pique441d5042018-10-18 16:49:51 -0700183 mFlinger->mCompositionEngine->setHwComposer(
184 std::make_unique<impl::HWComposer>(std::move(composer)));
Lloyd Piquee39cad22017-12-20 17:01:29 -0800185 }
186
Alec Mourie4034bb2019-11-19 12:45:54 -0800187 void setupTimeStats(const std::shared_ptr<TimeStats>& timeStats) {
188 mFlinger->mCompositionEngine->setTimeStats(timeStats);
189 }
190
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700191 // The ISchedulerCallback argument can be nullptr for a no-op implementation.
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700192 void setupScheduler(std::unique_ptr<DispSync> primaryDispSync,
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700193 std::unique_ptr<EventThread> appEventThread,
Ady Abraham8a82ba62020-01-17 12:43:17 -0800194 std::unique_ptr<EventThread> sfEventThread,
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700195 ISchedulerCallback* callback = nullptr, bool hasMultipleConfigs = false) {
Ady Abrahamabc27602020-04-08 17:20:29 -0700196 std::vector<std::shared_ptr<const HWC2::Display::Config>> configs{
197 HWC2::Display::Config::Builder(mDisplay, 0)
Dominik Laskowski983f2b52020-06-25 16:54:06 -0700198 .setVsyncPeriod(16'666'667)
Ady Abrahamabc27602020-04-08 17:20:29 -0700199 .setConfigGroup(0)
200 .build()};
201
Dominik Laskowski983f2b52020-06-25 16:54:06 -0700202 if (hasMultipleConfigs) {
203 configs.emplace_back(HWC2::Display::Config::Builder(mDisplay, 1)
204 .setVsyncPeriod(11'111'111)
205 .setConfigGroup(0)
206 .build());
207 }
208
Ady Abraham2139f732019-11-13 18:56:40 -0800209 mFlinger->mRefreshRateConfigs = std::make_unique<
Ana Krulec3f6a2062020-01-23 15:48:01 -0800210 scheduler::RefreshRateConfigs>(configs, /*currentConfig=*/HwcConfigIndexType(0));
Ady Abraham2139f732019-11-13 18:56:40 -0800211 mFlinger->mRefreshRateStats = std::make_unique<
212 scheduler::RefreshRateStats>(*mFlinger->mRefreshRateConfigs, *mFlinger->mTimeStats,
213 /*currentConfig=*/HwcConfigIndexType(0),
Peiyong Lin65248e02020-04-18 21:15:07 -0700214 /*powerMode=*/hal::PowerMode::OFF);
Ady Abraham8287e852020-08-12 14:44:58 -0700215 mFlinger->mVsyncConfiguration =
216 mFactory.createVsyncConfiguration(*mFlinger->mRefreshRateConfigs);
217 mFlinger->mVsyncModulator.emplace(mFlinger->mVsyncConfiguration->getCurrentConfigs());
Steven Thomas2bbaabe2019-08-28 16:08:35 -0700218
Dominik Laskowski983f2b52020-06-25 16:54:06 -0700219 constexpr bool kUseContentDetectionV2 = false;
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700220 mScheduler =
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700221 new TestableScheduler(std::move(primaryDispSync), *mFlinger->mRefreshRateConfigs,
222 *(callback ?: this), kUseContentDetectionV2);
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700223
Dominik Laskowski98041832019-08-01 18:35:59 -0700224 mFlinger->mAppConnectionHandle = mScheduler->createConnection(std::move(appEventThread));
225 mFlinger->mSfConnectionHandle = mScheduler->createConnection(std::move(sfEventThread));
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700226 resetScheduler(mScheduler);
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700227 }
228
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700229 void resetScheduler(Scheduler* scheduler) { mFlinger->mScheduler.reset(scheduler); }
230
Lloyd Pique90c115d2018-09-18 21:39:42 -0700231 using CreateBufferQueueFunction = surfaceflinger::test::Factory::CreateBufferQueueFunction;
Lloyd Pique5b36f3f2018-01-17 11:57:07 -0800232 void setCreateBufferQueueFunction(CreateBufferQueueFunction f) {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700233 mFactory.mCreateBufferQueue = f;
Lloyd Pique5b36f3f2018-01-17 11:57:07 -0800234 }
235
Lloyd Pique90c115d2018-09-18 21:39:42 -0700236 using CreateNativeWindowSurfaceFunction =
237 surfaceflinger::test::Factory::CreateNativeWindowSurfaceFunction;
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800238 void setCreateNativeWindowSurface(CreateNativeWindowSurfaceFunction f) {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700239 mFactory.mCreateNativeWindowSurface = f;
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800240 }
241
Daniel Solomon42d04562019-01-20 21:03:19 -0800242 void setInternalDisplayPrimaries(const ui::DisplayPrimaries& primaries) {
243 memcpy(&mFlinger->mInternalDisplayPrimaries, &primaries, sizeof(ui::DisplayPrimaries));
244 }
245
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700246 static auto& mutableLayerCurrentState(const sp<Layer>& layer) { return layer->mCurrentState; }
247 static auto& mutableLayerDrawingState(const sp<Layer>& layer) { return layer->mDrawingState; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700248
Valerie Haud251afb2019-03-29 14:19:02 -0700249 auto& mutableStateLock() { return mFlinger->mStateLock; }
250
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700251 static auto findOutputLayerForDisplay(const sp<Layer>& layer,
252 const sp<const DisplayDevice>& display) {
253 return layer->findOutputLayerForDisplay(display.get());
254 }
255
256 static void setLayerSidebandStream(const sp<Layer>& layer,
257 const sp<NativeHandle>& sidebandStream) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800258 layer->mDrawingState.sidebandStream = sidebandStream;
Lloyd Pique0b785d82018-12-04 17:25:27 -0800259 layer->mSidebandStream = sidebandStream;
Lloyd Piquede196652020-01-22 17:29:58 -0800260 layer->editCompositionState()->sidebandStream = sidebandStream;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700261 }
262
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700263 void setLayerCompositionType(const sp<Layer>& layer, hal::Composition type) {
264 auto outputLayer = findOutputLayerForDisplay(layer, mFlinger->getDefaultDisplayDevice());
Lloyd Pique37c2c9b2018-12-04 17:25:10 -0800265 LOG_ALWAYS_FATAL_IF(!outputLayer);
266 auto& state = outputLayer->editState();
267 LOG_ALWAYS_FATAL_IF(!outputLayer->getState().hwc);
Peiyong Line9d809e2020-04-14 13:10:48 -0700268 (*state.hwc).hwcCompositionType = type;
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700269 }
Lloyd Pique37c2c9b2018-12-04 17:25:10 -0800270
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700271 static void setLayerPotentialCursor(const sp<Layer>& layer, bool potentialCursor) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700272 layer->mPotentialCursor = potentialCursor;
273 }
274
Lloyd Piquef58625d2017-12-19 13:22:33 -0800275 /* ------------------------------------------------------------------------
276 * Forwarding for functions being tested
277 */
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800278
Lloyd Piquea482f992018-01-22 19:00:34 -0800279 auto createDisplay(const String8& displayName, bool secure) {
280 return mFlinger->createDisplay(displayName, secure);
281 }
282
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700283 auto destroyDisplay(const sp<IBinder>& displayToken) {
284 return mFlinger->destroyDisplay(displayToken);
285 }
Lloyd Piquea482f992018-01-22 19:00:34 -0800286
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700287 auto resetDisplayState() NO_THREAD_SAFETY_ANALYSIS { return mFlinger->resetDisplayState(); }
Lloyd Piqued6fbb8a2018-01-22 19:08:36 -0800288
Lloyd Pique9370a482019-10-03 17:58:30 -0700289 auto setupNewDisplayDeviceInternal(
290 const wp<IBinder>& displayToken,
291 std::shared_ptr<compositionengine::Display> compositionDisplay,
292 const DisplayDeviceState& state,
293 const sp<compositionengine::DisplaySurface>& dispSurface,
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700294 const sp<IGraphicBufferProducer>& producer) NO_THREAD_SAFETY_ANALYSIS {
Lloyd Pique9370a482019-10-03 17:58:30 -0700295 return mFlinger->setupNewDisplayDeviceInternal(displayToken, compositionDisplay, state,
296 dispSurface, producer);
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800297 }
298
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800299 auto handleTransactionLocked(uint32_t transactionFlags) {
Vishnu Nairfa5f8df2019-02-13 17:02:51 -0800300 Mutex::Autolock _l(mFlinger->mStateLock);
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800301 return mFlinger->handleTransactionLocked(transactionFlags);
302 }
Lloyd Piquef58625d2017-12-19 13:22:33 -0800303
Peiyong Line9d809e2020-04-14 13:10:48 -0700304 auto onHotplugReceived(int32_t sequenceId, hal::HWDisplayId display,
305 hal::Connection connection) {
Lloyd Pique6cf11032018-01-22 18:57:44 -0800306 return mFlinger->onHotplugReceived(sequenceId, display, connection);
307 }
308
Vishnu Nairce5d0cc2019-02-28 14:38:41 -0800309 auto setDisplayStateLocked(const DisplayState& s) {
310 Mutex::Autolock _l(mFlinger->mStateLock);
311 return mFlinger->setDisplayStateLocked(s);
312 }
Lloyd Pique9d9cf402018-02-16 17:47:13 -0800313
Dominik Laskowski83b88212018-12-11 13:34:06 -0800314 // Allow reading display state without locking, as if called on the SF main thread.
315 auto onInitializeDisplays() NO_THREAD_SAFETY_ANALYSIS {
316 return mFlinger->onInitializeDisplays();
317 }
Lloyd Pique86016da2018-03-01 16:09:38 -0800318
Lais Andrade3a6e47d2020-04-02 11:20:16 +0100319 auto notifyPowerBoost(int32_t boostId) { return mFlinger->notifyPowerBoost(boostId); }
320
Dominik Laskowski83b88212018-12-11 13:34:06 -0800321 // Allow reading display state without locking, as if called on the SF main thread.
322 auto setPowerModeInternal(const sp<DisplayDevice>& display,
Peiyong Lin65248e02020-04-18 21:15:07 -0700323 hal::PowerMode mode) NO_THREAD_SAFETY_ANALYSIS {
Dominik Laskowskie9774092018-12-11 10:04:24 -0800324 return mFlinger->setPowerModeInternal(display, mode);
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800325 }
326
Ady Abraham0ed31c92020-04-16 11:48:45 -0700327 auto onMessageReceived(int32_t what) { return mFlinger->onMessageReceived(what, systemTime()); }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700328
chaviw426b5c02020-07-27 11:20:15 -0700329 auto renderScreenImplLocked(const RenderArea& renderArea,
330 SurfaceFlinger::TraverseLayersFunction traverseLayers,
chaviwc6ad8af2020-08-03 11:33:30 -0700331 const sp<GraphicBuffer>& buffer, bool forSystem, int* outSyncFd,
332 bool regionSampling) {
chaviw426b5c02020-07-27 11:20:15 -0700333 ScreenCaptureResults captureResults;
chaviwc6ad8af2020-08-03 11:33:30 -0700334 return mFlinger->renderScreenImplLocked(renderArea, traverseLayers, buffer, forSystem,
335 outSyncFd, regionSampling, captureResults);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700336 }
337
chaviw4b9d5e12020-08-04 18:30:35 -0700338 auto traverseLayersInLayerStack(ui::LayerStack layerStack, int32_t uid,
Marin Shalamanov1c434292020-06-12 01:47:29 +0200339 const LayerVector::Visitor& visitor) {
chaviw4b9d5e12020-08-04 18:30:35 -0700340 return mFlinger->SurfaceFlinger::traverseLayersInLayerStack(layerStack, uid, visitor);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700341 }
342
Daniel Solomon42d04562019-01-20 21:03:19 -0800343 auto getDisplayNativePrimaries(const sp<IBinder>& displayToken,
344 ui::DisplayPrimaries &primaries) {
345 return mFlinger->SurfaceFlinger::getDisplayNativePrimaries(displayToken, primaries);
346 }
347
Valerie Haud251afb2019-03-29 14:19:02 -0700348 auto& getTransactionQueue() { return mFlinger->mTransactionQueues; }
349
350 auto setTransactionState(const Vector<ComposerState>& states,
351 const Vector<DisplayState>& displays, uint32_t flags,
352 const sp<IBinder>& applyToken,
353 const InputWindowCommands& inputWindowCommands,
354 int64_t desiredPresentTime, const client_cache_t& uncacheBuffer,
355 bool hasListenerCallbacks,
356 std::vector<ListenerCallbacks>& listenerCallbacks) {
357 return mFlinger->setTransactionState(states, displays, flags, applyToken,
358 inputWindowCommands, desiredPresentTime, uncacheBuffer,
359 hasListenerCallbacks, listenerCallbacks);
360 }
361
362 auto flushTransactionQueues() { return mFlinger->flushTransactionQueues(); };
363
Lloyd Pique86016da2018-03-01 16:09:38 -0800364 /* ------------------------------------------------------------------------
365 * Read-only access to private data to assert post-conditions.
366 */
367
368 const auto& getAnimFrameTracker() const { return mFlinger->mAnimFrameTracker; }
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800369 const auto& getHasPoweredOff() const { return mFlinger->mHasPoweredOff; }
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800370 const auto& getVisibleRegionsDirty() const { return mFlinger->mVisibleRegionsDirty; }
Lloyd Pique441d5042018-10-18 16:49:51 -0700371 auto& getHwComposer() const {
372 return static_cast<impl::HWComposer&>(mFlinger->getHwComposer());
373 }
Lloyd Pique9370a482019-10-03 17:58:30 -0700374 auto& getCompositionEngine() const { return mFlinger->getCompositionEngine(); }
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800375
Lloyd Pique86016da2018-03-01 16:09:38 -0800376 const auto& getCompositorTiming() const { return mFlinger->getBE().mCompositorTiming; }
377
Lloyd Piquef58625d2017-12-19 13:22:33 -0800378 /* ------------------------------------------------------------------------
379 * Read-write access to private data to set up preconditions and assert
380 * post-conditions.
381 */
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800382
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800383 auto& mutableHasWideColorDisplay() { return SurfaceFlinger::hasWideColorDisplay; }
Peiyong Lin13effd12018-07-24 17:01:47 -0700384 auto& mutableUseColorManagement() { return SurfaceFlinger::useColorManagement; }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800385
Lloyd Piquee39cad22017-12-20 17:01:29 -0800386 auto& mutableCurrentState() { return mFlinger->mCurrentState; }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800387 auto& mutableDisplayColorSetting() { return mFlinger->mDisplayColorSetting; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700388 auto& mutableDisplays() { return mFlinger->mDisplays; }
Lloyd Piquee39cad22017-12-20 17:01:29 -0800389 auto& mutableDrawingState() { return mFlinger->mDrawingState; }
Lloyd Piquee39cad22017-12-20 17:01:29 -0800390 auto& mutableEventQueue() { return mFlinger->mEventQueue; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700391 auto& mutableGeometryInvalid() { return mFlinger->mGeometryInvalid; }
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800392 auto& mutableInterceptor() { return mFlinger->mInterceptor; }
Lloyd Pique6cf11032018-01-22 18:57:44 -0800393 auto& mutableMainThreadId() { return mFlinger->mMainThreadId; }
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800394 auto& mutablePendingHotplugEvents() { return mFlinger->mPendingHotplugEvents; }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700395 auto& mutablePhysicalDisplayTokens() { return mFlinger->mPhysicalDisplayTokens; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700396 auto& mutableTexturePool() { return mFlinger->mTexturePool; }
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800397 auto& mutableTransactionFlags() { return mFlinger->mTransactionFlags; }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800398 auto& mutableUseHwcVirtualDisplays() { return mFlinger->mUseHwcVirtualDisplays; }
Peiyong Lin74ca2f42019-01-14 19:36:57 -0800399 auto& mutablePowerAdvisor() { return mFlinger->mPowerAdvisor; }
Lloyd Pique4fe29402019-08-12 16:51:24 -0700400 auto& mutableDebugDisableHWC() { return mFlinger->mDebugDisableHWC; }
Lloyd Piquee39cad22017-12-20 17:01:29 -0800401
Lloyd Pique6cf11032018-01-22 18:57:44 -0800402 auto& mutableComposerSequenceId() { return mFlinger->getBE().mComposerSequenceId; }
Lloyd Pique441d5042018-10-18 16:49:51 -0700403 auto& mutableHwcDisplayData() { return getHwComposer().mDisplayData; }
404 auto& mutableHwcPhysicalDisplayIdMap() { return getHwComposer().mPhysicalDisplayIdMap; }
405 auto& mutableInternalHwcDisplayId() { return getHwComposer().mInternalHwcDisplayId; }
406 auto& mutableExternalHwcDisplayId() { return getHwComposer().mExternalHwcDisplayId; }
Ady Abraham60e42ea2020-03-09 19:17:31 -0700407 auto& mutableUseFrameRateApi() { return mFlinger->useFrameRateApi; }
Lloyd Piquea618d852018-01-17 11:52:30 -0800408
Valerie Hau09e60052019-12-15 14:51:15 -0800409 auto fromHandle(const sp<IBinder>& handle) {
Valerie Hau09e60052019-12-15 14:51:15 -0800410 return mFlinger->fromHandle(handle);
411 }
412
Lloyd Piquee39cad22017-12-20 17:01:29 -0800413 ~TestableSurfaceFlinger() {
414 // All these pointer and container clears help ensure that GMock does
415 // not report a leaked object, since the SurfaceFlinger instance may
416 // still be referenced by something despite our best efforts to destroy
417 // it after each test is done.
418 mutableDisplays().clear();
Ady Abraham2939f092019-03-04 17:44:06 -0800419 mutableCurrentState().displays.clear();
420 mutableDrawingState().displays.clear();
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800421 mutableEventQueue().reset();
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800422 mutableInterceptor().reset();
Lloyd Pique2eb71eb2019-08-13 13:23:03 -0700423 mFlinger->mScheduler.reset();
Lloyd Pique441d5042018-10-18 16:49:51 -0700424 mFlinger->mCompositionEngine->setHwComposer(std::unique_ptr<HWComposer>());
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700425 mFlinger->mCompositionEngine->setRenderEngine(
426 std::unique_ptr<renderengine::RenderEngine>());
Lloyd Piquee39cad22017-12-20 17:01:29 -0800427 }
Lloyd Piquef58625d2017-12-19 13:22:33 -0800428
Lloyd Piquea618d852018-01-17 11:52:30 -0800429 /* ------------------------------------------------------------------------
430 * Wrapper classes for Read-write access to private data to set up
431 * preconditions and assert post-conditions.
432 */
Ana Krulec4593b692019-01-11 22:07:25 -0800433 struct HWC2Display : public HWC2::impl::Display {
Peiyong Lin74ca2f42019-01-14 19:36:57 -0800434 HWC2Display(Hwc2::Composer& composer,
Peiyong Line9d809e2020-04-14 13:10:48 -0700435 const std::unordered_set<hal::Capability>& capabilities, hal::HWDisplayId id,
436 hal::DisplayType type)
Peiyong Lin74ca2f42019-01-14 19:36:57 -0800437 : HWC2::impl::Display(composer, capabilities, id, type) {}
Lloyd Piquea618d852018-01-17 11:52:30 -0800438 ~HWC2Display() {
439 // Prevents a call to disable vsyncs.
Peiyong Line9d809e2020-04-14 13:10:48 -0700440 mType = hal::DisplayType::INVALID;
Lloyd Piquea618d852018-01-17 11:52:30 -0800441 }
442
443 auto& mutableIsConnected() { return this->mIsConnected; }
444 auto& mutableConfigs() { return this->mConfigs; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700445 auto& mutableLayers() { return this->mLayers; }
Lloyd Piquea618d852018-01-17 11:52:30 -0800446 };
447
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800448 class FakeHwcDisplayInjector {
449 public:
Peiyong Line9d809e2020-04-14 13:10:48 -0700450 static constexpr hal::HWDisplayId DEFAULT_HWC_DISPLAY_ID = 1000;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800451 static constexpr int32_t DEFAULT_WIDTH = 1920;
452 static constexpr int32_t DEFAULT_HEIGHT = 1280;
453 static constexpr int32_t DEFAULT_REFRESH_RATE = 16'666'666;
Ady Abraham2139f732019-11-13 18:56:40 -0800454 static constexpr int32_t DEFAULT_CONFIG_GROUP = 7;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800455 static constexpr int32_t DEFAULT_DPI = 320;
Peiyong Line9d809e2020-04-14 13:10:48 -0700456 static constexpr hal::HWConfigId DEFAULT_ACTIVE_CONFIG = 0;
Peiyong Lin65248e02020-04-18 21:15:07 -0700457 static constexpr hal::PowerMode DEFAULT_POWER_MODE = hal::PowerMode::ON;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800458
Peiyong Line9d809e2020-04-14 13:10:48 -0700459 FakeHwcDisplayInjector(DisplayId displayId, hal::DisplayType hwcDisplayType, bool isPrimary)
Dominik Laskowski075d3172018-05-24 15:50:06 -0700460 : mDisplayId(displayId), mHwcDisplayType(hwcDisplayType), mIsPrimary(isPrimary) {}
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800461
Peiyong Line9d809e2020-04-14 13:10:48 -0700462 auto& setHwcDisplayId(hal::HWDisplayId displayId) {
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800463 mHwcDisplayId = displayId;
464 return *this;
465 }
466
467 auto& setWidth(int32_t width) {
468 mWidth = width;
469 return *this;
470 }
471
472 auto& setHeight(int32_t height) {
473 mHeight = height;
474 return *this;
475 }
476
Ady Abraham8a82ba62020-01-17 12:43:17 -0800477 auto& setRefreshRate(int32_t refreshRate) {
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800478 mRefreshRate = refreshRate;
479 return *this;
480 }
481
482 auto& setDpiX(int32_t dpi) {
483 mDpiX = dpi;
484 return *this;
485 }
486
487 auto& setDpiY(int32_t dpi) {
488 mDpiY = dpi;
489 return *this;
490 }
491
Peiyong Line9d809e2020-04-14 13:10:48 -0700492 auto& setActiveConfig(hal::HWConfigId config) {
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800493 mActiveConfig = config;
494 return *this;
495 }
496
Peiyong Line9d809e2020-04-14 13:10:48 -0700497 auto& setCapabilities(const std::unordered_set<hal::Capability>* capabilities) {
Lloyd Piquee22f0332018-07-16 16:35:56 -0700498 mCapabilities = capabilities;
499 return *this;
500 }
501
Peiyong Lin65248e02020-04-18 21:15:07 -0700502 auto& setPowerMode(hal::PowerMode mode) {
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700503 mPowerMode = mode;
504 return *this;
505 }
506
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800507 void inject(TestableSurfaceFlinger* flinger, Hwc2::Composer* composer) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700508 static const std::unordered_set<hal::Capability> defaultCapabilities;
Lloyd Piquee22f0332018-07-16 16:35:56 -0700509 if (mCapabilities == nullptr) mCapabilities = &defaultCapabilities;
510
511 // Caution - Make sure that any values passed by reference here do
512 // not refer to an instance owned by FakeHwcDisplayInjector. This
513 // class has temporary lifetime, while the constructed HWC2::Display
514 // is much longer lived.
Peiyong Lin74ca2f42019-01-14 19:36:57 -0800515 auto display = std::make_unique<HWC2Display>(*composer, *mCapabilities, mHwcDisplayId,
516 mHwcDisplayType);
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800517
518 auto config = HWC2::Display::Config::Builder(*display, mActiveConfig);
519 config.setWidth(mWidth);
520 config.setHeight(mHeight);
521 config.setVsyncPeriod(mRefreshRate);
522 config.setDpiX(mDpiX);
523 config.setDpiY(mDpiY);
Ady Abraham2139f732019-11-13 18:56:40 -0800524 config.setConfigGroup(mConfigGroup);
Ady Abraham8a82ba62020-01-17 12:43:17 -0800525 display->mutableConfigs().emplace(static_cast<int32_t>(mActiveConfig), config.build());
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800526 display->mutableIsConnected() = true;
Peiyong Lin65248e02020-04-18 21:15:07 -0700527 display->setPowerMode(mPowerMode);
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800528
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800529 flinger->mutableHwcDisplayData()[mDisplayId].hwcDisplay = std::move(display);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700530
Peiyong Line9d809e2020-04-14 13:10:48 -0700531 if (mHwcDisplayType == hal::DisplayType::PHYSICAL) {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700532 flinger->mutableHwcPhysicalDisplayIdMap().emplace(mHwcDisplayId, mDisplayId);
533 (mIsPrimary ? flinger->mutableInternalHwcDisplayId()
534 : flinger->mutableExternalHwcDisplayId()) = mHwcDisplayId;
535 }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800536 }
537
538 private:
Dominik Laskowski075d3172018-05-24 15:50:06 -0700539 const DisplayId mDisplayId;
Peiyong Line9d809e2020-04-14 13:10:48 -0700540 const hal::DisplayType mHwcDisplayType;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700541 const bool mIsPrimary;
542
Peiyong Line9d809e2020-04-14 13:10:48 -0700543 hal::HWDisplayId mHwcDisplayId = DEFAULT_HWC_DISPLAY_ID;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800544 int32_t mWidth = DEFAULT_WIDTH;
545 int32_t mHeight = DEFAULT_HEIGHT;
Ady Abraham8a82ba62020-01-17 12:43:17 -0800546 int32_t mRefreshRate = DEFAULT_REFRESH_RATE;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800547 int32_t mDpiX = DEFAULT_DPI;
Ady Abraham2139f732019-11-13 18:56:40 -0800548 int32_t mConfigGroup = DEFAULT_CONFIG_GROUP;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800549 int32_t mDpiY = DEFAULT_DPI;
Peiyong Line9d809e2020-04-14 13:10:48 -0700550 hal::HWConfigId mActiveConfig = DEFAULT_ACTIVE_CONFIG;
Peiyong Lin65248e02020-04-18 21:15:07 -0700551 hal::PowerMode mPowerMode = DEFAULT_POWER_MODE;
Peiyong Line9d809e2020-04-14 13:10:48 -0700552 const std::unordered_set<hal::Capability>* mCapabilities = nullptr;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800553 };
554
555 class FakeDisplayDeviceInjector {
556 public:
Dominik Laskowski075d3172018-05-24 15:50:06 -0700557 FakeDisplayDeviceInjector(TestableSurfaceFlinger& flinger,
Lloyd Pique9370a482019-10-03 17:58:30 -0700558 std::shared_ptr<compositionengine::Display> compositionDisplay,
Dominik Laskowski55c85402020-01-21 16:25:47 -0800559 std::optional<DisplayConnectionType> connectionType,
Peiyong Line9d809e2020-04-14 13:10:48 -0700560 std::optional<hal::HWDisplayId> hwcDisplayId, bool isPrimary)
Lloyd Pique9370a482019-10-03 17:58:30 -0700561 : mFlinger(flinger),
Marin Shalamanov700e6392020-02-12 20:22:26 +0100562 mCreationArgs(flinger.mFlinger.get(), mDisplayToken, compositionDisplay),
563 mHwcDisplayId(hwcDisplayId) {
Dominik Laskowski55c85402020-01-21 16:25:47 -0800564 mCreationArgs.connectionType = connectionType;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700565 mCreationArgs.isPrimary = isPrimary;
566 }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800567
568 sp<IBinder> token() const { return mDisplayToken; }
569
570 DisplayDeviceState& mutableDrawingDisplayState() {
571 return mFlinger.mutableDrawingState().displays.editValueFor(mDisplayToken);
572 }
573
574 DisplayDeviceState& mutableCurrentDisplayState() {
575 return mFlinger.mutableCurrentState().displays.editValueFor(mDisplayToken);
576 }
577
Lloyd Pique9d9cf402018-02-16 17:47:13 -0800578 const auto& getDrawingDisplayState() {
579 return mFlinger.mutableDrawingState().displays.valueFor(mDisplayToken);
580 }
581
582 const auto& getCurrentDisplayState() {
583 return mFlinger.mutableCurrentState().displays.valueFor(mDisplayToken);
584 }
585
Dominik Laskowski9fae1022018-05-29 13:17:40 -0700586 auto& mutableDisplayDevice() { return mFlinger.mutableDisplays()[mDisplayToken]; }
Lloyd Pique9d9cf402018-02-16 17:47:13 -0800587
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800588 auto& setNativeWindow(const sp<ANativeWindow>& nativeWindow) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700589 mCreationArgs.nativeWindow = nativeWindow;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800590 return *this;
591 }
592
Lloyd Pique542307f2018-10-19 13:24:08 -0700593 auto& setDisplaySurface(const sp<compositionengine::DisplaySurface>& displaySurface) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700594 mCreationArgs.displaySurface = displaySurface;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800595 return *this;
596 }
597
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800598 auto& setSecure(bool secure) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700599 mCreationArgs.isSecure = secure;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800600 return *this;
601 }
602
Peiyong Lin65248e02020-04-18 21:15:07 -0700603 auto& setPowerMode(hal::PowerMode mode) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700604 mCreationArgs.initialPowerMode = mode;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700605 return *this;
606 }
607
Valerie Hau9758ae02018-10-09 16:05:09 -0700608 auto& setHwcColorModes(
609 const std::unordered_map<ui::ColorMode, std::vector<ui::RenderIntent>>
610 hwcColorModes) {
611 mCreationArgs.hwcColorModes = hwcColorModes;
612 return *this;
613 }
614
615 auto& setHasWideColorGamut(bool hasWideColorGamut) {
616 mCreationArgs.hasWideColorGamut = hasWideColorGamut;
617 return *this;
618 }
619
Lloyd Pique33050472019-12-19 17:12:44 -0800620 auto& setPhysicalOrientation(ui::Rotation orientation) {
621 mCreationArgs.physicalOrientation = orientation;
622 return *this;
623 }
624
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800625 sp<DisplayDevice> inject() {
Lloyd Pique9370a482019-10-03 17:58:30 -0700626 const auto displayId = mCreationArgs.compositionDisplay->getDisplayId();
627
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800628 DisplayDeviceState state;
Dominik Laskowski55c85402020-01-21 16:25:47 -0800629 if (const auto type = mCreationArgs.connectionType) {
Lloyd Pique9370a482019-10-03 17:58:30 -0700630 LOG_ALWAYS_FATAL_IF(!displayId);
Marin Shalamanov700e6392020-02-12 20:22:26 +0100631 LOG_ALWAYS_FATAL_IF(!mHwcDisplayId);
Marin Shalamanova524a092020-07-27 21:39:55 +0200632 state.physical = {.id = static_cast<PhysicalDisplayId>(*displayId),
633 .type = *type,
634 .hwcDisplayId = *mHwcDisplayId};
Dominik Laskowski55c85402020-01-21 16:25:47 -0800635 }
636
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700637 state.isSecure = mCreationArgs.isSecure;
638
Lloyd Pique9370a482019-10-03 17:58:30 -0700639 sp<DisplayDevice> device = new DisplayDevice(mCreationArgs);
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700640 mFlinger.mutableDisplays().emplace(mDisplayToken, device);
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800641 mFlinger.mutableCurrentState().displays.add(mDisplayToken, state);
642 mFlinger.mutableDrawingState().displays.add(mDisplayToken, state);
643
Dominik Laskowski55c85402020-01-21 16:25:47 -0800644 if (const auto& physical = state.physical) {
645 mFlinger.mutablePhysicalDisplayTokens()[physical->id] = mDisplayToken;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800646 }
647
648 return device;
649 }
650
651 private:
652 TestableSurfaceFlinger& mFlinger;
653 sp<BBinder> mDisplayToken = new BBinder();
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700654 DisplayDeviceCreationArgs mCreationArgs;
Peiyong Line9d809e2020-04-14 13:10:48 -0700655 const std::optional<hal::HWDisplayId> mHwcDisplayId;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800656 };
657
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700658private:
659 void setVsyncEnabled(bool) override {}
660 void changeRefreshRate(const Scheduler::RefreshRate&, Scheduler::ConfigEvent) override {}
661 void repaintEverythingForHWC() override {}
662 void kernelTimerChanged(bool) override {}
663
Lloyd Pique90c115d2018-09-18 21:39:42 -0700664 surfaceflinger::test::Factory mFactory;
665 sp<SurfaceFlinger> mFlinger = new SurfaceFlinger(mFactory, SurfaceFlinger::SkipInitialization);
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700666 TestableScheduler* mScheduler = nullptr;
Ady Abrahamabc27602020-04-08 17:20:29 -0700667 Hwc2::mock::Display mDisplay;
Lloyd Piquef58625d2017-12-19 13:22:33 -0800668};
669
670} // namespace android