1 /* 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 19 #include <chrono> 20 #include <memory> 21 #include <variant> 22 23 #include <ftl/fake_guard.h> 24 #include <ftl/match.h> 25 #include <gui/LayerMetadata.h> 26 #include <gui/ScreenCaptureResults.h> 27 #include <ui/DynamicDisplayInfo.h> 28 29 #include <compositionengine/Display.h> 30 #include <compositionengine/LayerFECompositionState.h> 31 #include <compositionengine/OutputLayer.h> 32 #include <compositionengine/impl/CompositionEngine.h> 33 #include <compositionengine/impl/Display.h> 34 #include <compositionengine/impl/OutputLayerCompositionState.h> 35 #include <compositionengine/mock/DisplaySurface.h> 36 37 #include "DisplayDevice.h" 38 #include "FakeVsyncConfiguration.h" 39 #include "FrameTracer/FrameTracer.h" 40 #include "FrontEnd/LayerCreationArgs.h" 41 #include "FrontEnd/LayerHandle.h" 42 #include "FrontEnd/RequestedLayerState.h" 43 #include "Layer.h" 44 #include "NativeWindowSurface.h" 45 #include "Scheduler/RefreshRateSelector.h" 46 #include "Scheduler/VSyncTracker.h" 47 #include "Scheduler/VsyncController.h" 48 #include "SurfaceFlinger.h" 49 #include "TestableScheduler.h" 50 #include "android/gui/ISurfaceComposerClient.h" 51 52 #include "mock/DisplayHardware/MockComposer.h" 53 #include "mock/DisplayHardware/MockDisplayMode.h" 54 #include "mock/MockEventThread.h" 55 #include "mock/MockFrameTimeline.h" 56 #include "mock/MockFrameTracer.h" 57 #include "mock/MockSchedulerCallback.h" 58 #include "mock/MockVSyncTracker.h" 59 #include "mock/MockVsyncController.h" 60 #include "mock/PowerAdvisor/MockPowerAdvisor.h" 61 #include "mock/system/window/MockNativeWindow.h" 62 63 namespace android { 64 65 struct DisplayStatInfo; 66 67 namespace renderengine { 68 69 class RenderEngine; 70 71 } // namespace renderengine 72 73 namespace Hwc2 { 74 75 class Composer; 76 77 } // namespace Hwc2 78 79 namespace hal = android::hardware::graphics::composer::hal; 80 81 namespace surfaceflinger::test { 82 83 class Factory final : public surfaceflinger::Factory { 84 public: 85 ~Factory() = default; 86 createHWComposer(const std::string &)87 std::unique_ptr<HWComposer> createHWComposer(const std::string&) override { return nullptr; } 88 createVsyncConfiguration(Fps)89 std::unique_ptr<scheduler::VsyncConfiguration> createVsyncConfiguration( 90 Fps /*currentRefreshRate*/) override { 91 return std::make_unique<scheduler::FakePhaseOffsets>(); 92 } 93 createDisplayDevice(DisplayDeviceCreationArgs & creationArgs)94 sp<DisplayDevice> createDisplayDevice(DisplayDeviceCreationArgs& creationArgs) override { 95 return sp<DisplayDevice>::make(creationArgs); 96 } 97 createGraphicBuffer(uint32_t width,uint32_t height,PixelFormat format,uint32_t layerCount,uint64_t usage,std::string requestorName)98 sp<GraphicBuffer> createGraphicBuffer(uint32_t width, uint32_t height, PixelFormat format, 99 uint32_t layerCount, uint64_t usage, 100 std::string requestorName) override { 101 return sp<GraphicBuffer>::make(width, height, format, layerCount, usage, requestorName); 102 } 103 createBufferQueue(sp<IGraphicBufferProducer> * outProducer,sp<IGraphicBufferConsumer> * outConsumer,bool consumerIsSurfaceFlinger)104 void createBufferQueue(sp<IGraphicBufferProducer>* outProducer, 105 sp<IGraphicBufferConsumer>* outConsumer, 106 bool consumerIsSurfaceFlinger) override { 107 if (!mCreateBufferQueue) { 108 BufferQueue::createBufferQueue(outProducer, outConsumer, consumerIsSurfaceFlinger); 109 return; 110 } 111 mCreateBufferQueue(outProducer, outConsumer, consumerIsSurfaceFlinger); 112 } 113 createNativeWindowSurface(const sp<IGraphicBufferProducer> & producer)114 std::unique_ptr<surfaceflinger::NativeWindowSurface> createNativeWindowSurface( 115 const sp<IGraphicBufferProducer>& producer) override { 116 if (!mCreateNativeWindowSurface) return nullptr; 117 return mCreateNativeWindowSurface(producer); 118 } 119 createCompositionEngine()120 std::unique_ptr<compositionengine::CompositionEngine> createCompositionEngine() override { 121 return compositionengine::impl::createCompositionEngine(); 122 } 123 createBufferStateLayer(const LayerCreationArgs &)124 sp<Layer> createBufferStateLayer(const LayerCreationArgs&) override { return nullptr; } 125 createEffectLayer(const LayerCreationArgs &)126 sp<Layer> createEffectLayer(const LayerCreationArgs&) override { return nullptr; } 127 createLayerFE(const std::string & layerName,const Layer *)128 sp<LayerFE> createLayerFE(const std::string& layerName, const Layer* /* owner */) override { 129 return sp<LayerFE>::make(layerName); 130 } 131 createFrameTracer()132 std::unique_ptr<FrameTracer> createFrameTracer() override { 133 return std::make_unique<mock::FrameTracer>(); 134 } 135 136 std::unique_ptr<frametimeline::FrameTimeline> createFrameTimeline( 137 std::shared_ptr<TimeStats> timeStats, pid_t surfaceFlingerPid = 0) override { 138 return std::make_unique<mock::FrameTimeline>(timeStats, surfaceFlingerPid); 139 } 140 141 using CreateBufferQueueFunction = 142 std::function<void(sp<IGraphicBufferProducer>* /* outProducer */, 143 sp<IGraphicBufferConsumer>* /* outConsumer */, 144 bool /* consumerIsSurfaceFlinger */)>; 145 CreateBufferQueueFunction mCreateBufferQueue; 146 147 using CreateNativeWindowSurfaceFunction = 148 std::function<std::unique_ptr<surfaceflinger::NativeWindowSurface>( 149 const sp<IGraphicBufferProducer>&)>; 150 CreateNativeWindowSurfaceFunction mCreateNativeWindowSurface; 151 152 using CreateCompositionEngineFunction = 153 std::function<std::unique_ptr<compositionengine::CompositionEngine>()>; 154 CreateCompositionEngineFunction mCreateCompositionEngine; 155 }; 156 157 struct MockSchedulerOptions { 158 PhysicalDisplayId displayId = PhysicalDisplayId::fromPort(0); 159 bool useNiceMock = false; 160 }; 161 162 } // namespace surfaceflinger::test 163 164 class TestableSurfaceFlinger { 165 public: 166 using HotplugEvent = SurfaceFlinger::HotplugEvent; 167 mFlinger(flinger)168 TestableSurfaceFlinger(sp<SurfaceFlinger> flinger = nullptr) : mFlinger(flinger) { 169 if (!mFlinger) { 170 mFlinger = sp<SurfaceFlinger>::make(mFactory, SurfaceFlinger::SkipInitialization); 171 } 172 } 173 flinger()174 SurfaceFlinger* flinger() { return mFlinger.get(); } scheduler()175 scheduler::TestableScheduler* scheduler() { return mScheduler; } 176 177 // Extend this as needed for accessing SurfaceFlinger private (and public) 178 // functions. 179 setupRenderEngine(std::unique_ptr<renderengine::RenderEngine> renderEngine)180 void setupRenderEngine(std::unique_ptr<renderengine::RenderEngine> renderEngine) { 181 mFlinger->mRenderEngine = std::move(renderEngine); 182 mFlinger->mCompositionEngine->setRenderEngine(mFlinger->mRenderEngine.get()); 183 } 184 setupComposer(std::unique_ptr<Hwc2::Composer> composer)185 void setupComposer(std::unique_ptr<Hwc2::Composer> composer) { 186 mFlinger->mHWComposer = std::make_unique<impl::HWComposer>(std::move(composer)); 187 mFlinger->mCompositionEngine->setHwComposer(mFlinger->mHWComposer.get()); 188 mFlinger->mDisplayModeController.setHwComposer( 189 &mFlinger->mCompositionEngine->getHwComposer()); 190 } 191 setupPowerAdvisor(std::unique_ptr<adpf::PowerAdvisor> powerAdvisor)192 void setupPowerAdvisor(std::unique_ptr<adpf::PowerAdvisor> powerAdvisor) { 193 mFlinger->mPowerAdvisor = std::move(powerAdvisor); 194 } 195 setupTimeStats(const std::shared_ptr<TimeStats> & timeStats)196 void setupTimeStats(const std::shared_ptr<TimeStats>& timeStats) { 197 mFlinger->mCompositionEngine->setTimeStats(timeStats); 198 } 199 setupCompositionEngine(std::unique_ptr<compositionengine::CompositionEngine> compositionEngine)200 void setupCompositionEngine( 201 std::unique_ptr<compositionengine::CompositionEngine> compositionEngine) { 202 mFlinger->mCompositionEngine = std::move(compositionEngine); 203 } 204 205 enum class SchedulerCallbackImpl { kNoOp, kMock }; 206 207 struct DefaultDisplayMode { 208 // The ID of the injected RefreshRateSelector and its default display mode. 209 PhysicalDisplayId displayId; 210 }; 211 212 using RefreshRateSelectorPtr = scheduler::Scheduler::RefreshRateSelectorPtr; 213 214 using DisplayModesVariant = std::variant<DefaultDisplayMode, RefreshRateSelectorPtr>; 215 getFactory()216 surfaceflinger::Factory& getFactory() { return mFactory; } 217 getTimeStats()218 TimeStats& getTimeStats() { return *mFlinger->mTimeStats; } 219 220 void setupScheduler(std::unique_ptr<scheduler::VsyncController> vsyncController, 221 std::shared_ptr<scheduler::VSyncTracker> vsyncTracker, 222 std::unique_ptr<EventThread> appEventThread, 223 std::unique_ptr<EventThread> sfEventThread, 224 DisplayModesVariant modesVariant, 225 SchedulerCallbackImpl callbackImpl = SchedulerCallbackImpl::kNoOp, 226 bool useNiceMock = false) { 227 RefreshRateSelectorPtr selectorPtr = ftl::match( 228 modesVariant, 229 [](DefaultDisplayMode arg) { 230 constexpr DisplayModeId kModeId60{0}; 231 return std::make_shared<scheduler::RefreshRateSelector>( 232 makeModes(mock::createDisplayMode(arg.displayId, kModeId60, 60_Hz)), 233 kModeId60); 234 }, 235 [](RefreshRateSelectorPtr selectorPtr) { return selectorPtr; }); 236 237 mTokenManager = std::make_unique<frametimeline::impl::TokenManager>(); 238 239 using ISchedulerCallback = scheduler::ISchedulerCallback; 240 ISchedulerCallback& schedulerCallback = callbackImpl == SchedulerCallbackImpl::kNoOp 241 ? static_cast<ISchedulerCallback&>(mNoOpSchedulerCallback) 242 : static_cast<ISchedulerCallback&>(mSchedulerCallback); 243 244 if (useNiceMock) { 245 mScheduler = 246 new testing::NiceMock<scheduler::TestableScheduler>(std::move(vsyncController), 247 std::move(vsyncTracker), 248 std::move(selectorPtr), 249 mFactory, 250 *mFlinger->mTimeStats, 251 schedulerCallback); 252 } else { 253 mScheduler = new scheduler::TestableScheduler(std::move(vsyncController), 254 std::move(vsyncTracker), 255 std::move(selectorPtr), mFactory, 256 *mFlinger->mTimeStats, schedulerCallback); 257 } 258 259 mScheduler->initVsync(*mTokenManager, 0ms); 260 261 mScheduler->setEventThread(scheduler::Cycle::Render, std::move(appEventThread)); 262 mScheduler->setEventThread(scheduler::Cycle::LastComposite, std::move(sfEventThread)); 263 264 resetScheduler(mScheduler); 265 } 266 267 void setupMockScheduler(surfaceflinger::test::MockSchedulerOptions options = {}) { 268 using testing::_; 269 using testing::Return; 270 271 auto eventThread = makeMock<mock::EventThread>(options.useNiceMock); 272 auto sfEventThread = makeMock<mock::EventThread>(options.useNiceMock); 273 auto vsyncController = makeMock<mock::VsyncController>(options.useNiceMock); 274 auto vsyncTracker = makeSharedMock<mock::VSyncTracker>(options.useNiceMock); 275 276 EXPECT_CALL(*vsyncTracker, nextAnticipatedVSyncTimeFrom(_, _)).WillRepeatedly(Return(0)); 277 EXPECT_CALL(*vsyncTracker, currentPeriod()) 278 .WillRepeatedly(Return(FakeHwcDisplayInjector::DEFAULT_VSYNC_PERIOD)); 279 EXPECT_CALL(*vsyncTracker, minFramePeriod()) 280 .WillRepeatedly( 281 Return(Period::fromNs(FakeHwcDisplayInjector::DEFAULT_VSYNC_PERIOD))); 282 EXPECT_CALL(*vsyncTracker, nextAnticipatedVSyncTimeFrom(_, _)).WillRepeatedly(Return(0)); 283 setupScheduler(std::move(vsyncController), std::move(vsyncTracker), std::move(eventThread), 284 std::move(sfEventThread), DefaultDisplayMode{options.displayId}, 285 SchedulerCallbackImpl::kNoOp, options.useNiceMock); 286 } 287 resetScheduler(scheduler::Scheduler * scheduler)288 void resetScheduler(scheduler::Scheduler* scheduler) { mFlinger->mScheduler.reset(scheduler); } 289 mutableScheduler()290 scheduler::TestableScheduler& mutableScheduler() { return *mScheduler; } mockSchedulerCallback()291 scheduler::mock::SchedulerCallback& mockSchedulerCallback() { return mSchedulerCallback; } 292 293 using CreateBufferQueueFunction = surfaceflinger::test::Factory::CreateBufferQueueFunction; setCreateBufferQueueFunction(CreateBufferQueueFunction f)294 void setCreateBufferQueueFunction(CreateBufferQueueFunction f) { 295 mFactory.mCreateBufferQueue = f; 296 } 297 298 using CreateNativeWindowSurfaceFunction = 299 surfaceflinger::test::Factory::CreateNativeWindowSurfaceFunction; setCreateNativeWindowSurface(CreateNativeWindowSurfaceFunction f)300 void setCreateNativeWindowSurface(CreateNativeWindowSurfaceFunction f) { 301 mFactory.mCreateNativeWindowSurface = f; 302 } 303 setInternalDisplayPrimaries(const ui::DisplayPrimaries & primaries)304 void setInternalDisplayPrimaries(const ui::DisplayPrimaries& primaries) { 305 memcpy(&mFlinger->mInternalDisplayPrimaries, &primaries, sizeof(ui::DisplayPrimaries)); 306 } 307 mutableLayerDrawingState(const sp<Layer> & layer)308 static auto& mutableLayerDrawingState(const sp<Layer>& layer) { return layer->mDrawingState; } 309 mutableStateLock()310 auto& mutableStateLock() { return mFlinger->mStateLock; } 311 findOutputLayerForDisplay(uint32_t layerId,const sp<const DisplayDevice> & display)312 compositionengine::OutputLayer* findOutputLayerForDisplay( 313 uint32_t layerId, const sp<const DisplayDevice>& display) { 314 ftl::FakeGuard guard(kMainThreadContext); 315 if (mFlinger->mLegacyLayers.find(layerId) == mFlinger->mLegacyLayers.end()) { 316 return nullptr; 317 } 318 return mFlinger->mLegacyLayers[layerId]->findOutputLayerForDisplay(display.get()); 319 } 320 setLayerCompositionType(const sp<Layer> & layer,aidl::android::hardware::graphics::composer3::Composition type)321 void setLayerCompositionType(const sp<Layer>& layer, 322 aidl::android::hardware::graphics::composer3::Composition type) { 323 auto outputLayer = findOutputLayerForDisplay(static_cast<uint32_t>(layer->sequence), 324 mFlinger->getDefaultDisplayDevice()); 325 LOG_ALWAYS_FATAL_IF(!outputLayer); 326 auto& state = outputLayer->editState(); 327 LOG_ALWAYS_FATAL_IF(!outputLayer->getState().hwc); 328 (*state.hwc).hwcCompositionType = type; 329 } 330 331 /* ------------------------------------------------------------------------ 332 * Forwarding for functions being tested 333 */ 334 configure()335 void configure() { 336 ftl::FakeGuard guard(kMainThreadContext); 337 mFlinger->configure(); 338 } 339 340 void configureAndCommit(bool modeset = false) { 341 configure(); 342 commitTransactionsLocked(eDisplayTransactionNeeded, modeset); 343 } 344 345 void commit(TimePoint frameTime, VsyncId vsyncId, TimePoint expectedVsyncTime, 346 bool composite = false) { 347 ftl::FakeGuard guard(kMainThreadContext); 348 349 const auto displayIdOpt = mScheduler->pacesetterDisplayId(); 350 LOG_ALWAYS_FATAL_IF(!displayIdOpt); 351 const auto displayId = *displayIdOpt; 352 353 scheduler::FrameTargeter frameTargeter(displayId, 354 scheduler::Feature::kBackpressureGpuComposition); 355 356 frameTargeter.beginFrame({.frameBeginTime = frameTime, 357 .vsyncId = vsyncId, 358 .expectedVsyncTime = expectedVsyncTime, 359 .sfWorkDuration = 10ms, 360 .hwcMinWorkDuration = 10ms}, 361 *mScheduler->getVsyncSchedule()); 362 363 scheduler::FrameTargets targets; 364 scheduler::FrameTargeters targeters; 365 366 for (const auto& [id, display] : 367 FTL_FAKE_GUARD(mFlinger->mStateLock, mFlinger->mPhysicalDisplays)) { 368 targets.try_emplace(id, &frameTargeter.target()); 369 targeters.try_emplace(id, &frameTargeter); 370 } 371 mFlinger->setTransactionFlags(eTransactionFlushNeeded); 372 mFlinger->commit(displayId, targets); 373 374 if (composite) { 375 mFlinger->composite(displayId, targeters); 376 } 377 } 378 379 void commit(TimePoint frameTime, VsyncId vsyncId, bool composite = false) { 380 return commit(frameTime, vsyncId, frameTime + Period(10ms), composite); 381 } 382 383 void commit(bool composite = false) { 384 const TimePoint frameTime = scheduler::SchedulerClock::now(); 385 commit(frameTime, kVsyncId, composite); 386 } 387 commitAndComposite(TimePoint frameTime,VsyncId vsyncId,TimePoint expectedVsyncTime)388 void commitAndComposite(TimePoint frameTime, VsyncId vsyncId, TimePoint expectedVsyncTime) { 389 constexpr bool kComposite = true; 390 commit(frameTime, vsyncId, expectedVsyncTime, kComposite); 391 } 392 commitAndComposite()393 void commitAndComposite() { 394 constexpr bool kComposite = true; 395 commit(kComposite); 396 } 397 398 auto createVirtualDisplay(const std::string& displayName, bool isSecure, 399 float requestedRefreshRate = 0.0f) { 400 static const std::string kTestId = 401 "virtual:libsurfaceflinger_unittest:TestableSurfaceFlinger"; 402 return mFlinger 403 ->createVirtualDisplay(displayName, isSecure, 404 gui::ISurfaceComposer::OptimizationPolicy::optimizeForPower, 405 kTestId, requestedRefreshRate); 406 } 407 408 auto createVirtualDisplay(const std::string& displayName, bool isSecure, 409 gui::ISurfaceComposer::OptimizationPolicy optimizationPolicy, 410 const std::string& uniqueId, float requestedRefreshRate = 0.0f) { 411 return mFlinger->createVirtualDisplay(displayName, isSecure, optimizationPolicy, uniqueId, 412 requestedRefreshRate); 413 } 414 destroyVirtualDisplay(const sp<IBinder> & displayToken)415 auto destroyVirtualDisplay(const sp<IBinder>& displayToken) { 416 return mFlinger->destroyVirtualDisplay(displayToken); 417 } 418 getDisplay(const sp<IBinder> & displayToken)419 auto getDisplay(const sp<IBinder>& displayToken) { 420 Mutex::Autolock lock(mFlinger->mStateLock); 421 return mFlinger->getDisplayDeviceLocked(displayToken); 422 } 423 enableHalVirtualDisplays(bool enable)424 void enableHalVirtualDisplays(bool enable) { mFlinger->enableHalVirtualDisplays(enable); } 425 setupNewDisplayDeviceInternal(const wp<IBinder> & displayToken,std::shared_ptr<compositionengine::Display> compositionDisplay,const DisplayDeviceState & state,const sp<compositionengine::DisplaySurface> & dispSurface,const sp<IGraphicBufferProducer> & producer)426 auto setupNewDisplayDeviceInternal( 427 const wp<IBinder>& displayToken, 428 std::shared_ptr<compositionengine::Display> compositionDisplay, 429 const DisplayDeviceState& state, 430 const sp<compositionengine::DisplaySurface>& dispSurface, 431 const sp<IGraphicBufferProducer>& producer) NO_THREAD_SAFETY_ANALYSIS { 432 return mFlinger->setupNewDisplayDeviceInternal(displayToken, compositionDisplay, state, 433 dispSurface, producer); 434 } 435 436 void commitTransactionsLocked(uint32_t transactionFlags, bool modeset = false) { 437 Mutex::Autolock lock(mFlinger->mStateLock); 438 ftl::FakeGuard guard(kMainThreadContext); 439 mFlinger->processDisplayChangesLocked(); 440 mFlinger->commitTransactionsLocked(transactionFlags); 441 if (modeset) { 442 mFlinger->initiateDisplayModeChanges(); 443 } 444 } 445 onComposerHalHotplugEvent(hal::HWDisplayId hwcDisplayId,DisplayHotplugEvent event)446 void onComposerHalHotplugEvent(hal::HWDisplayId hwcDisplayId, DisplayHotplugEvent event) { 447 mFlinger->onComposerHalHotplugEvent(hwcDisplayId, event); 448 } 449 setDisplayStateLocked(const DisplayState & s)450 auto setDisplayStateLocked(const DisplayState& s) { 451 Mutex::Autolock lock(mFlinger->mStateLock); 452 return mFlinger->setDisplayStateLocked(s); 453 } 454 initializeDisplays()455 void initializeDisplays() FTL_FAKE_GUARD(kMainThreadContext) { mFlinger->initializeDisplays(); } 456 notifyPowerBoost(int32_t boostId)457 auto notifyPowerBoost(int32_t boostId) { return mFlinger->notifyPowerBoost(boostId); } 458 setDisplayBrightness(const sp<IBinder> & display,const gui::DisplayBrightness & brightness)459 auto setDisplayBrightness(const sp<IBinder>& display, 460 const gui::DisplayBrightness& brightness) { 461 return mFlinger->setDisplayBrightness(display, brightness); 462 } 463 464 // Allow reading display state without locking, as if called on the SF main thread. setPhysicalDisplayPowerMode(const sp<DisplayDevice> & display,hal::PowerMode mode)465 auto setPhysicalDisplayPowerMode(const sp<DisplayDevice>& display, 466 hal::PowerMode mode) NO_THREAD_SAFETY_ANALYSIS { 467 return mFlinger->setPhysicalDisplayPowerMode(display, mode); 468 } 469 renderScreenImpl(const sp<DisplayDevice> display,const Rect sourceCrop,ui::Dataspace dataspace,SurfaceFlinger::GetLayerSnapshotsFunction getLayerSnapshotsFn,const std::shared_ptr<renderengine::ExternalTexture> & buffer,bool regionSampling,bool isSecure,bool seamlessTransition)470 auto renderScreenImpl(const sp<DisplayDevice> display, const Rect sourceCrop, 471 ui::Dataspace dataspace, 472 SurfaceFlinger::GetLayerSnapshotsFunction getLayerSnapshotsFn, 473 const std::shared_ptr<renderengine::ExternalTexture>& buffer, 474 bool regionSampling, bool isSecure, bool seamlessTransition) { 475 Mutex::Autolock lock(mFlinger->mStateLock); 476 ftl::FakeGuard guard(kMainThreadContext); 477 478 ScreenCaptureResults captureResults; 479 const auto& state = display->getCompositionDisplay()->getState(); 480 auto layers = getLayerSnapshotsFn(); 481 482 SurfaceFlinger::ScreenshotArgs screenshotArgs; 483 screenshotArgs.captureTypeVariant = display; 484 screenshotArgs.displayIdVariant = std::nullopt; 485 screenshotArgs.sourceCrop = sourceCrop; 486 screenshotArgs.reqSize = sourceCrop.getSize(); 487 screenshotArgs.dataspace = dataspace; 488 screenshotArgs.isSecure = isSecure; 489 screenshotArgs.seamlessTransition = seamlessTransition; 490 screenshotArgs.displayBrightnessNits = state.displayBrightnessNits; 491 screenshotArgs.sdrWhitePointNits = state.sdrWhitePointNits; 492 screenshotArgs.renderIntent = state.renderIntent; 493 screenshotArgs.colorMode = state.colorMode; 494 495 return mFlinger->renderScreenImpl(screenshotArgs, buffer, regionSampling, 496 false /* grayscale */, false /* isProtected */, 497 captureResults, layers); 498 } 499 getLayerSnapshotsForScreenshotsFn(ui::LayerStack layerStack,uint32_t uid)500 auto getLayerSnapshotsForScreenshotsFn(ui::LayerStack layerStack, uint32_t uid) { 501 return mFlinger->getLayerSnapshotsForScreenshots(layerStack, uid, 502 std::unordered_set<uint32_t>{}); 503 } 504 getDisplayNativePrimaries(const sp<IBinder> & displayToken,ui::DisplayPrimaries & primaries)505 auto getDisplayNativePrimaries(const sp<IBinder>& displayToken, 506 ui::DisplayPrimaries& primaries) { 507 return mFlinger->SurfaceFlinger::getDisplayNativePrimaries(displayToken, primaries); 508 } 509 getTransactionQueue()510 auto& getTransactionQueue() NO_THREAD_SAFETY_ANALYSIS { 511 return mFlinger->mTransactionHandler.mLocklessTransactionQueue; 512 } getPendingTransactionQueue()513 auto& getPendingTransactionQueue() NO_THREAD_SAFETY_ANALYSIS { 514 ftl::FakeGuard guard(kMainThreadContext); 515 return mFlinger->mTransactionHandler.mPendingTransactionQueues; 516 } getPendingTransactionCount()517 size_t getPendingTransactionCount() { 518 ftl::FakeGuard guard(kMainThreadContext); 519 return mFlinger->mTransactionHandler.mPendingTransactionCount.load(); 520 } 521 setTransactionState(TransactionState && state)522 auto setTransactionState(TransactionState&& state) { 523 return mFlinger->setTransactionState(std::move(state)); 524 } 525 setTransactionStateInternal(QueuedTransactionState & transaction)526 auto setTransactionStateInternal(QueuedTransactionState& transaction) { 527 return FTL_FAKE_GUARD(kMainThreadContext, 528 mFlinger->mTransactionHandler.queueTransaction( 529 std::move(transaction))); 530 } 531 flushTransactionQueues()532 auto flushTransactionQueues() { 533 return FTL_FAKE_GUARD(kMainThreadContext, mFlinger->flushTransactionQueues()); 534 } 535 onTransact(uint32_t code,const Parcel & data,Parcel * reply,uint32_t flags)536 auto onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) { 537 return mFlinger->onTransact(code, data, reply, flags); 538 } 539 getGpuContextPriority()540 auto getGpuContextPriority() { return mFlinger->getGpuContextPriority(); } 541 calculateMaxAcquiredBufferCount(Fps refreshRate,std::chrono::nanoseconds presentLatency)542 auto calculateMaxAcquiredBufferCount(Fps refreshRate, 543 std::chrono::nanoseconds presentLatency) const { 544 return SurfaceFlinger::calculateMaxAcquiredBufferCount(refreshRate, presentLatency); 545 } 546 setDesiredDisplayModeSpecs(const sp<IBinder> & displayToken,const gui::DisplayModeSpecs & specs)547 auto setDesiredDisplayModeSpecs(const sp<IBinder>& displayToken, 548 const gui::DisplayModeSpecs& specs) { 549 return mFlinger->setDesiredDisplayModeSpecs(displayToken, specs); 550 } 551 onActiveDisplayChanged(const DisplayDevice * inactiveDisplayPtr,const DisplayDevice & activeDisplay)552 void onActiveDisplayChanged(const DisplayDevice* inactiveDisplayPtr, 553 const DisplayDevice& activeDisplay) { 554 Mutex::Autolock lock(mFlinger->mStateLock); 555 ftl::FakeGuard guard(kMainThreadContext); 556 mFlinger->onActiveDisplayChangedLocked(inactiveDisplayPtr, activeDisplay); 557 } 558 createLayer(LayerCreationArgs & args,const sp<IBinder> & parentHandle,gui::CreateSurfaceResult & outResult)559 auto createLayer(LayerCreationArgs& args, const sp<IBinder>& parentHandle, 560 gui::CreateSurfaceResult& outResult) { 561 args.parentHandle = parentHandle; 562 return mFlinger->createLayer(args, outResult); 563 } 564 mirrorLayer(const LayerCreationArgs & args,const sp<IBinder> & mirrorFromHandle,gui::CreateSurfaceResult & outResult)565 auto mirrorLayer(const LayerCreationArgs& args, const sp<IBinder>& mirrorFromHandle, 566 gui::CreateSurfaceResult& outResult) { 567 return mFlinger->mirrorLayer(args, mirrorFromHandle, outResult); 568 } 569 getDynamicDisplayInfoFromToken(const sp<IBinder> & displayToken,ui::DynamicDisplayInfo * dynamicDisplayInfo)570 void getDynamicDisplayInfoFromToken(const sp<IBinder>& displayToken, 571 ui::DynamicDisplayInfo* dynamicDisplayInfo) { 572 mFlinger->getDynamicDisplayInfoFromToken(displayToken, dynamicDisplayInfo); 573 } 574 createVirtualDisplayDevice(const sp<IBinder> displayToken,GpuVirtualDisplayId displayId,float requestedRefreshRate)575 sp<DisplayDevice> createVirtualDisplayDevice(const sp<IBinder> displayToken, 576 GpuVirtualDisplayId displayId, 577 float requestedRefreshRate) { 578 constexpr ui::Size kResolution = {1080, 1920}; 579 auto compositionDisplay = compositionengine::impl:: 580 createDisplay(mFlinger->getCompositionEngine(), 581 compositionengine::DisplayCreationArgsBuilder() 582 .setId(displayId) 583 .setPixels(kResolution) 584 .setPowerAdvisor(&mPowerAdvisor) 585 .build()); 586 DisplayDeviceCreationArgs creationArgs(mFlinger, mFlinger->getHwComposer(), displayToken, 587 compositionDisplay); 588 creationArgs.requestedRefreshRate = Fps::fromValue(requestedRefreshRate); 589 creationArgs.nativeWindow = sp<mock::NativeWindow>::make(); 590 return sp<DisplayDevice>::make(creationArgs); 591 } 592 getDisplayStats(const sp<IBinder> & displayToken,DisplayStatInfo * outInfo)593 status_t getDisplayStats(const sp<IBinder>& displayToken, DisplayStatInfo* outInfo) { 594 return mFlinger->getDisplayStats(displayToken, outInfo); 595 } 596 597 // Used to add a layer before updateLayerSnapshots is called. 598 // Must have transactionsFlushed enabled for the new layer to be updated. addLayer(std::unique_ptr<frontend::RequestedLayerState> & layer)599 void addLayer(std::unique_ptr<frontend::RequestedLayerState>& layer) { 600 std::scoped_lock<std::mutex> lock(mFlinger->mCreatedLayersLock); 601 mFlinger->mNewLayers.emplace_back(std::move(layer)); 602 } 603 604 // Used to add a layer before updateLayerSnapshots is called. 605 // Must have transactionsFlushed enabled for the new layer to be updated. addLayer(uint32_t layerId)606 void addLayer(uint32_t layerId) { 607 std::scoped_lock<std::mutex> lock(mFlinger->mCreatedLayersLock); 608 LayerCreationArgs args(std::make_optional(layerId)); 609 args.flinger = this->mFlinger.get(); 610 auto layer = std::make_unique<frontend::RequestedLayerState>(args); 611 auto legacyLayer = sp<Layer>::make(args); 612 injectLegacyLayer(legacyLayer); 613 mFlinger->mNewLayers.emplace_back(std::move(layer)); 614 } 615 616 /* ------------------------------------------------------------------------ 617 * Read-only access to private data to assert post-conditions. 618 */ 619 getVisibleRegionsDirty()620 const auto& getVisibleRegionsDirty() const { return mFlinger->mVisibleRegionsDirty; } getHwComposer()621 auto& getHwComposer() const { 622 return static_cast<impl::HWComposer&>(mFlinger->getHwComposer()); 623 } getCompositionEngine()624 auto& getCompositionEngine() const { return mFlinger->getCompositionEngine(); } 625 getFrameTracer()626 mock::FrameTracer* getFrameTracer() const { 627 return static_cast<mock::FrameTracer*>(mFlinger->mFrameTracer.get()); 628 } 629 injectLegacyLayer(sp<Layer> layer)630 void injectLegacyLayer(sp<Layer> layer) { 631 FTL_FAKE_GUARD(kMainThreadContext, 632 mFlinger->mLegacyLayers[static_cast<uint32_t>(layer->sequence)] = layer); 633 } 634 releaseLegacyLayer(uint32_t sequence)635 void releaseLegacyLayer(uint32_t sequence) { 636 FTL_FAKE_GUARD(kMainThreadContext, mFlinger->mLegacyLayers.erase(sequence)); 637 } 638 getLegacyLayer(uint32_t layerId)639 auto getLegacyLayer(uint32_t layerId) { 640 ftl::FakeGuard guard(kMainThreadContext); 641 return mFlinger->mLegacyLayers[layerId]; 642 }; 643 destroyAllLayerHandles()644 void destroyAllLayerHandles() { 645 ftl::FakeGuard guard(kMainThreadContext); 646 for (auto [layerId, legacyLayer] : mFlinger->mLegacyLayers) { 647 mFlinger->onHandleDestroyed(legacyLayer, layerId); 648 } 649 } 650 setLayerHistoryDisplayArea(uint32_t displayArea)651 auto setLayerHistoryDisplayArea(uint32_t displayArea) { 652 return mFlinger->mScheduler->onActiveDisplayAreaChanged(displayArea); 653 }; updateLayerHistory(nsecs_t now)654 auto updateLayerHistory(nsecs_t now) { 655 return FTL_FAKE_GUARD(kMainThreadContext, mFlinger->updateLayerHistory(now)); 656 }; setDaltonizerType(ColorBlindnessType type)657 auto setDaltonizerType(ColorBlindnessType type) { 658 mFlinger->mDaltonizer.setType(type); 659 return mFlinger->updateColorMatrixLocked(); 660 } updateLayerSnapshots(VsyncId vsyncId,nsecs_t frameTimeNs,bool transactionsFlushed,bool & out)661 auto updateLayerSnapshots(VsyncId vsyncId, nsecs_t frameTimeNs, bool transactionsFlushed, 662 bool& out) { 663 ftl::FakeGuard guard(kMainThreadContext); 664 return mFlinger->updateLayerSnapshots(vsyncId, frameTimeNs, transactionsFlushed, out); 665 } 666 /* ------------------------------------------------------------------------ 667 * Read-write access to private data to set up preconditions and assert 668 * post-conditions. 669 */ 670 displays()671 const auto& displays() const NO_THREAD_SAFETY_ANALYSIS { return mFlinger->mDisplays; } physicalDisplays()672 const auto& physicalDisplays() const NO_THREAD_SAFETY_ANALYSIS { 673 return mFlinger->mPhysicalDisplays; 674 } currentState()675 const auto& currentState() const { return mFlinger->mCurrentState; } drawingState()676 const auto& drawingState() const { return mFlinger->mDrawingState; } transactionFlags()677 const auto& transactionFlags() const { return mFlinger->mTransactionFlags; } 678 hwcPhysicalDisplayIdMap()679 const auto& hwcPhysicalDisplayIdMap() const { return getHwComposer().mPhysicalDisplayIdMap; } hwcDisplayData()680 const auto& hwcDisplayData() const { return getHwComposer().mDisplayData; } 681 mutableSupportsWideColor()682 auto& mutableSupportsWideColor() { return mFlinger->mSupportsWideColor; } 683 mutableDisplayModeController()684 auto& mutableDisplayModeController() { return mFlinger->mDisplayModeController; } mutableCurrentState()685 auto& mutableCurrentState() { return mFlinger->mCurrentState; } mutableDisplayColorSetting()686 auto& mutableDisplayColorSetting() { return mFlinger->mDisplayColorSetting; } mutableDisplays()687 auto& mutableDisplays() NO_THREAD_SAFETY_ANALYSIS { return mFlinger->mDisplays; } mutablePhysicalDisplays()688 auto& mutablePhysicalDisplays() NO_THREAD_SAFETY_ANALYSIS { 689 return mFlinger->mPhysicalDisplays; 690 } mutableDrawingState()691 auto& mutableDrawingState() { return mFlinger->mDrawingState; } mutableGeometryDirty()692 auto& mutableGeometryDirty() { return mFlinger->mGeometryDirty; } mutableVisibleRegionsDirty()693 auto& mutableVisibleRegionsDirty() { return mFlinger->mVisibleRegionsDirty; } mutableMainThreadId()694 auto& mutableMainThreadId() { return mFlinger->mMainThreadId; } mutablePendingHotplugEvents()695 auto& mutablePendingHotplugEvents() NO_THREAD_SAFETY_ANALYSIS { 696 return mFlinger->mPendingHotplugEvents; 697 } mutableTransactionFlags()698 auto& mutableTransactionFlags() { return mFlinger->mTransactionFlags; } mutableDebugDisableHWC()699 auto& mutableDebugDisableHWC() { return mFlinger->mDebugDisableHWC; } mutableMaxRenderTargetSize()700 auto& mutableMaxRenderTargetSize() { return mFlinger->mMaxRenderTargetSize; } 701 mutableHwcDisplayData()702 auto& mutableHwcDisplayData() { return getHwComposer().mDisplayData; } mutableHwcPhysicalDisplayIdMap()703 auto& mutableHwcPhysicalDisplayIdMap() { return getHwComposer().mPhysicalDisplayIdMap; } mutablePrimaryHwcDisplayId()704 auto& mutablePrimaryHwcDisplayId() { return getHwComposer().mPrimaryHwcDisplayId; } mutableActiveDisplayId()705 auto& mutableActiveDisplayId() NO_THREAD_SAFETY_ANALYSIS { return mFlinger->mActiveDisplayId; } mutablePreviouslyComposedLayers()706 auto& mutablePreviouslyComposedLayers() { return mFlinger->mPreviouslyComposedLayers; } 707 mutableActiveDisplayRotationFlags()708 auto& mutableActiveDisplayRotationFlags() { 709 return SurfaceFlinger::sActiveDisplayRotationFlags; 710 } 711 mutableMinAcquiredBuffers()712 auto& mutableMinAcquiredBuffers() { return SurfaceFlinger::minAcquiredBuffers; } mutableMaxAcquiredBuffers()713 auto& mutableMaxAcquiredBuffers() { return SurfaceFlinger::maxAcquiredBuffersOpt; } mutableLayerSnapshotBuilder()714 auto& mutableLayerSnapshotBuilder() NO_THREAD_SAFETY_ANALYSIS { 715 return mFlinger->mLayerSnapshotBuilder; 716 } 717 fromHandle(const sp<IBinder> & handle)718 auto fromHandle(const sp<IBinder>& handle) { return LayerHandle::getLayer(handle); } 719 initTransactionTraceWriter()720 auto initTransactionTraceWriter() { 721 mFlinger->mTransactionTracing.emplace(); 722 return mFlinger->initTransactionTraceWriter(); 723 } 724 notifyExpectedPresentIfRequired(PhysicalDisplayId displayId,Period vsyncPeriod,TimePoint expectedPresentTime,Fps frameInterval,std::optional<Period> timeoutOpt)725 void notifyExpectedPresentIfRequired(PhysicalDisplayId displayId, Period vsyncPeriod, 726 TimePoint expectedPresentTime, Fps frameInterval, 727 std::optional<Period> timeoutOpt) { 728 mFlinger->notifyExpectedPresentIfRequired(displayId, vsyncPeriod, expectedPresentTime, 729 frameInterval, timeoutOpt); 730 } 731 sendNotifyExpectedPresentHint(PhysicalDisplayId displayId)732 void sendNotifyExpectedPresentHint(PhysicalDisplayId displayId) { 733 ftl::FakeGuard guard(kMainThreadContext); 734 mFlinger->sendNotifyExpectedPresentHint(displayId); 735 } 736 verifyHintIsScheduledOnPresent(PhysicalDisplayId displayId)737 bool verifyHintIsScheduledOnPresent(PhysicalDisplayId displayId) { 738 return mFlinger->mNotifyExpectedPresentMap.at(displayId).hintStatus == 739 SurfaceFlinger::NotifyExpectedPresentHintStatus::ScheduleOnPresent; 740 } 741 verifyHintIsSent(PhysicalDisplayId displayId)742 bool verifyHintIsSent(PhysicalDisplayId displayId) { 743 return mFlinger->mNotifyExpectedPresentMap.at(displayId).hintStatus == 744 SurfaceFlinger::NotifyExpectedPresentHintStatus::Sent; 745 } 746 verifyHintStatusIsStart(PhysicalDisplayId displayId)747 bool verifyHintStatusIsStart(PhysicalDisplayId displayId) { 748 return mFlinger->mNotifyExpectedPresentMap.at(displayId).hintStatus == 749 SurfaceFlinger::NotifyExpectedPresentHintStatus::Start; 750 } 751 verifyHintStatusIsScheduledOnTx(PhysicalDisplayId displayId)752 bool verifyHintStatusIsScheduledOnTx(PhysicalDisplayId displayId) { 753 return mFlinger->mNotifyExpectedPresentMap.at(displayId).hintStatus == 754 SurfaceFlinger::NotifyExpectedPresentHintStatus::ScheduleOnTx; 755 } 756 verifyLastExpectedPresentTime(PhysicalDisplayId displayId,nsecs_t expectedPresentTime)757 bool verifyLastExpectedPresentTime(PhysicalDisplayId displayId, nsecs_t expectedPresentTime) { 758 return mFlinger->mNotifyExpectedPresentMap.at(displayId) 759 .lastExpectedPresentTimestamp.ns() == expectedPresentTime; 760 } 761 setNotifyExpectedPresentData(PhysicalDisplayId displayId,TimePoint lastExpectedPresentTimestamp,Fps lastFrameInterval)762 void setNotifyExpectedPresentData(PhysicalDisplayId displayId, 763 TimePoint lastExpectedPresentTimestamp, 764 Fps lastFrameInterval) { 765 auto& displayData = mFlinger->mNotifyExpectedPresentMap[displayId]; 766 displayData.lastExpectedPresentTimestamp = lastExpectedPresentTimestamp; 767 displayData.lastFrameInterval = lastFrameInterval; 768 } 769 resetNotifyExpectedPresentHintState(PhysicalDisplayId displayId)770 void resetNotifyExpectedPresentHintState(PhysicalDisplayId displayId) { 771 mFlinger->mNotifyExpectedPresentMap.at(displayId).hintStatus = 772 SurfaceFlinger::NotifyExpectedPresentHintStatus::Start; 773 } 774 ~TestableSurfaceFlinger()775 ~TestableSurfaceFlinger() { 776 // All these pointer and container clears help ensure that GMock does 777 // not report a leaked object, since the SurfaceFlinger instance may 778 // still be referenced by something despite our best efforts to destroy 779 // it after each test is done. 780 mutableDisplays().clear(); 781 mutableCurrentState().displays.clear(); 782 mutableDrawingState().displays.clear(); 783 mFlinger->mScheduler.reset(); 784 mFlinger->mHWComposer = std::unique_ptr<HWComposer>(); 785 mFlinger->mCompositionEngine->setHwComposer(mFlinger->mHWComposer.get()); 786 mFlinger->mRenderEngine = std::unique_ptr<renderengine::RenderEngine>(); 787 mFlinger->mCompositionEngine->setRenderEngine(mFlinger->mRenderEngine.get()); 788 mFlinger->mTransactionTracing.reset(); 789 } 790 791 /* ------------------------------------------------------------------------ 792 * Wrapper classes for Read-write access to private data to set up 793 * preconditions and assert post-conditions. 794 */ 795 struct HWC2Display : public HWC2::impl::Display { HWC2DisplayHWC2Display796 HWC2Display( 797 Hwc2::Composer& composer, 798 const std::unordered_set<aidl::android::hardware::graphics::composer3::Capability>& 799 capabilities, 800 hal::HWDisplayId id, hal::DisplayType type) 801 : HWC2::impl::Display(composer, capabilities, id, type) {} ~HWC2DisplayHWC2Display802 ~HWC2Display() { 803 // Prevents a call to disable vsyncs. 804 mType = hal::DisplayType::INVALID; 805 } 806 mutableIsConnectedHWC2Display807 auto& mutableIsConnected() { return this->mIsConnected; } mutableLayersHWC2Display808 auto& mutableLayers() { return this->mLayers; } 809 }; 810 811 class FakeHwcDisplayInjector { 812 public: 813 static constexpr hal::HWDisplayId DEFAULT_HWC_DISPLAY_ID = 1000; 814 static constexpr ui::Size DEFAULT_RESOLUTION{1920, 1280}; 815 static constexpr int32_t DEFAULT_VSYNC_PERIOD = 16'666'667; 816 static constexpr int32_t DEFAULT_CONFIG_GROUP = 7; 817 static constexpr int32_t DEFAULT_DPI = 320; 818 static constexpr hal::HWConfigId DEFAULT_ACTIVE_CONFIG = 0; 819 FakeHwcDisplayInjector(DisplayIdVariant displayIdVariant,hal::DisplayType hwcDisplayType,bool isPrimary)820 FakeHwcDisplayInjector(DisplayIdVariant displayIdVariant, hal::DisplayType hwcDisplayType, 821 bool isPrimary) 822 : mDisplayIdVariant(displayIdVariant), 823 mHwcDisplayType(hwcDisplayType), 824 mIsPrimary(isPrimary) {} 825 setHwcDisplayId(hal::HWDisplayId displayId)826 auto& setHwcDisplayId(hal::HWDisplayId displayId) { 827 mHwcDisplayId = displayId; 828 return *this; 829 } 830 setResolution(ui::Size resolution)831 auto& setResolution(ui::Size resolution) { 832 mResolution = resolution; 833 return *this; 834 } 835 setVsyncPeriod(nsecs_t vsyncPeriod)836 auto& setVsyncPeriod(nsecs_t vsyncPeriod) { 837 mVsyncPeriod = vsyncPeriod; 838 return *this; 839 } 840 setDpiX(int32_t dpi)841 auto& setDpiX(int32_t dpi) { 842 mDpiX = dpi; 843 return *this; 844 } 845 setDpiY(int32_t dpi)846 auto& setDpiY(int32_t dpi) { 847 mDpiY = dpi; 848 return *this; 849 } 850 setActiveConfig(hal::HWConfigId config)851 auto& setActiveConfig(hal::HWConfigId config) { 852 mActiveConfig = config; 853 return *this; 854 } 855 setCapabilities(const std::unordered_set<aidl::android::hardware::graphics::composer3::Capability> * capabilities)856 auto& setCapabilities( 857 const std::unordered_set<aidl::android::hardware::graphics::composer3::Capability>* 858 capabilities) { 859 mCapabilities = capabilities; 860 return *this; 861 } 862 setPowerMode(hal::PowerMode mode)863 auto& setPowerMode(hal::PowerMode mode) { 864 mPowerMode = mode; 865 return *this; 866 } 867 inject(TestableSurfaceFlinger * flinger,Hwc2::mock::Composer * composer)868 void inject(TestableSurfaceFlinger* flinger, Hwc2::mock::Composer* composer) { 869 using ::testing::_; 870 using ::testing::DoAll; 871 using ::testing::Return; 872 using ::testing::SetArgPointee; 873 874 static const std::unordered_set< 875 aidl::android::hardware::graphics::composer3::Capability> 876 defaultCapabilities; 877 if (mCapabilities == nullptr) mCapabilities = &defaultCapabilities; 878 879 // Caution - Make sure that any values passed by reference here do 880 // not refer to an instance owned by FakeHwcDisplayInjector. This 881 // class has temporary lifetime, while the constructed HWC2::Display 882 // is much longer lived. 883 auto display = std::make_unique<HWC2Display>(*composer, *mCapabilities, mHwcDisplayId, 884 mHwcDisplayType); 885 display->mutableIsConnected() = true; 886 887 display->setPowerMode(mPowerMode); 888 889 const auto halDisplayId = asHalDisplayId(mDisplayIdVariant); 890 ASSERT_TRUE(halDisplayId); 891 flinger->mutableHwcDisplayData()[*halDisplayId].hwcDisplay = std::move(display); 892 893 EXPECT_CALL(*composer, getDisplayConfigs(mHwcDisplayId, _)) 894 .WillRepeatedly( 895 DoAll(SetArgPointee<1>(std::vector<hal::HWConfigId>{mActiveConfig}), 896 Return(hal::Error::NONE))); 897 EXPECT_CALL(*composer, 898 getDisplayAttribute(mHwcDisplayId, mActiveConfig, hal::Attribute::WIDTH, _)) 899 .WillRepeatedly(DoAll(SetArgPointee<3>(mResolution.getWidth()), 900 Return(hal::Error::NONE))); 901 902 EXPECT_CALL(*composer, 903 getDisplayAttribute(mHwcDisplayId, mActiveConfig, hal::Attribute::HEIGHT, 904 _)) 905 .WillRepeatedly(DoAll(SetArgPointee<3>(mResolution.getHeight()), 906 Return(hal::Error::NONE))); 907 908 EXPECT_CALL(*composer, 909 getDisplayAttribute(mHwcDisplayId, mActiveConfig, 910 hal::Attribute::VSYNC_PERIOD, _)) 911 .WillRepeatedly(DoAll(SetArgPointee<3>(static_cast<int32_t>(mVsyncPeriod)), 912 Return(hal::Error::NONE))); 913 914 EXPECT_CALL(*composer, 915 getDisplayAttribute(mHwcDisplayId, mActiveConfig, hal::Attribute::DPI_X, _)) 916 .WillRepeatedly(DoAll(SetArgPointee<3>(mDpiX), Return(hal::Error::NONE))); 917 918 EXPECT_CALL(*composer, 919 getDisplayAttribute(mHwcDisplayId, mActiveConfig, hal::Attribute::DPI_Y, _)) 920 .WillRepeatedly(DoAll(SetArgPointee<3>(mDpiY), Return(hal::Error::NONE))); 921 922 EXPECT_CALL(*composer, 923 getDisplayAttribute(mHwcDisplayId, mActiveConfig, 924 hal::Attribute::CONFIG_GROUP, _)) 925 .WillRepeatedly( 926 DoAll(SetArgPointee<3>(mConfigGroup), Return(hal::Error::NONE))); 927 928 if (mHwcDisplayType == hal::DisplayType::PHYSICAL) { 929 const auto physicalDisplayId = asPhysicalDisplayId(mDisplayIdVariant); 930 ASSERT_TRUE(physicalDisplayId); 931 flinger->mutableHwcPhysicalDisplayIdMap().emplace(mHwcDisplayId, 932 *physicalDisplayId); 933 if (mIsPrimary) { 934 flinger->mutablePrimaryHwcDisplayId() = mHwcDisplayId; 935 } else { 936 // If there is an external HWC display, there should always be a primary ID 937 // as well. Set it to some arbitrary value. 938 auto& primaryId = flinger->mutablePrimaryHwcDisplayId(); 939 if (!primaryId) primaryId = mHwcDisplayId - 1; 940 } 941 } 942 } 943 944 private: 945 const DisplayIdVariant mDisplayIdVariant; 946 const hal::DisplayType mHwcDisplayType; 947 const bool mIsPrimary; 948 949 hal::HWDisplayId mHwcDisplayId = DEFAULT_HWC_DISPLAY_ID; 950 ui::Size mResolution = DEFAULT_RESOLUTION; 951 nsecs_t mVsyncPeriod = DEFAULT_VSYNC_PERIOD; 952 int32_t mDpiX = DEFAULT_DPI; 953 int32_t mDpiY = DEFAULT_DPI; 954 int32_t mConfigGroup = DEFAULT_CONFIG_GROUP; 955 hal::HWConfigId mActiveConfig = DEFAULT_ACTIVE_CONFIG; 956 hal::PowerMode mPowerMode = hal::PowerMode::ON; 957 const std::unordered_set<aidl::android::hardware::graphics::composer3::Capability>* 958 mCapabilities = nullptr; 959 }; 960 961 class FakeDisplayDeviceInjector { 962 public: FakeDisplayDeviceInjector(TestableSurfaceFlinger & flinger,std::shared_ptr<compositionengine::Display> display,std::optional<ui::DisplayConnectionType> connectionType,std::optional<uint8_t> port,std::optional<hal::HWDisplayId> hwcDisplayId,bool isPrimary)963 FakeDisplayDeviceInjector(TestableSurfaceFlinger& flinger, 964 std::shared_ptr<compositionengine::Display> display, 965 std::optional<ui::DisplayConnectionType> connectionType, 966 std::optional<uint8_t> port, 967 std::optional<hal::HWDisplayId> hwcDisplayId, bool isPrimary) 968 : mFlinger(flinger), 969 mCreationArgs(flinger.mFlinger, flinger.mFlinger->getHwComposer(), mDisplayToken, 970 display), 971 mConnectionType(connectionType), 972 mPort(port), 973 mHwcDisplayId(hwcDisplayId) { 974 mCreationArgs.isPrimary = isPrimary; 975 mCreationArgs.initialPowerMode = hal::PowerMode::ON; 976 } 977 token()978 sp<IBinder> token() const { return mDisplayToken; } 979 physicalDisplay()980 auto physicalDisplay() const { 981 return mCreationArgs.compositionDisplay->getDisplayIdVariant() 982 .and_then(asPhysicalDisplayId) 983 .and_then(display::getPhysicalDisplay(mFlinger.physicalDisplays())); 984 } 985 mutableDrawingDisplayState()986 DisplayDeviceState& mutableDrawingDisplayState() { 987 return mFlinger.mutableDrawingState().displays.editValueFor(mDisplayToken); 988 } 989 mutableCurrentDisplayState()990 DisplayDeviceState& mutableCurrentDisplayState() { 991 return mFlinger.mutableCurrentState().displays.editValueFor(mDisplayToken); 992 } 993 getDrawingDisplayState()994 const auto& getDrawingDisplayState() { 995 return mFlinger.mutableDrawingState().displays.valueFor(mDisplayToken); 996 } 997 getCurrentDisplayState()998 const auto& getCurrentDisplayState() { 999 return mFlinger.mutableCurrentState().displays.valueFor(mDisplayToken); 1000 } 1001 mutableDisplayDevice()1002 const sp<DisplayDevice>& mutableDisplayDevice() { 1003 return mFlinger.mutableDisplays().get(mDisplayToken)->get(); 1004 } 1005 setDisplayModes(DisplayModes modes,DisplayModeId activeModeId)1006 auto& setDisplayModes(DisplayModes modes, DisplayModeId activeModeId) { 1007 mDisplayModes = std::move(modes); 1008 mActiveModeId = activeModeId; 1009 mCreationArgs.refreshRateSelector = nullptr; 1010 return *this; 1011 } 1012 setRefreshRateSelector(RefreshRateSelectorPtr selectorPtr)1013 auto& setRefreshRateSelector(RefreshRateSelectorPtr selectorPtr) { 1014 mDisplayModes = selectorPtr->displayModes(); 1015 mActiveModeId = selectorPtr->getActiveMode().modePtr->getId(); 1016 mCreationArgs.refreshRateSelector = std::move(selectorPtr); 1017 return *this; 1018 } 1019 setNativeWindow(const sp<ANativeWindow> & nativeWindow)1020 auto& setNativeWindow(const sp<ANativeWindow>& nativeWindow) { 1021 mCreationArgs.nativeWindow = nativeWindow; 1022 return *this; 1023 } 1024 setDisplaySurface(const sp<compositionengine::DisplaySurface> & displaySurface)1025 auto& setDisplaySurface(const sp<compositionengine::DisplaySurface>& displaySurface) { 1026 mCreationArgs.displaySurface = displaySurface; 1027 return *this; 1028 } 1029 setSecure(bool secure)1030 auto& setSecure(bool secure) { 1031 mCreationArgs.isSecure = secure; 1032 return *this; 1033 } 1034 setPowerMode(hal::PowerMode mode)1035 auto& setPowerMode(hal::PowerMode mode) { 1036 mCreationArgs.initialPowerMode = mode; 1037 return *this; 1038 } 1039 setHwcColorModes(const std::unordered_map<ui::ColorMode,std::vector<ui::RenderIntent>> hwcColorModes)1040 auto& setHwcColorModes( 1041 const std::unordered_map<ui::ColorMode, std::vector<ui::RenderIntent>> 1042 hwcColorModes) { 1043 mCreationArgs.hwcColorModes = hwcColorModes; 1044 return *this; 1045 } 1046 setHasWideColorGamut(bool hasWideColorGamut)1047 auto& setHasWideColorGamut(bool hasWideColorGamut) { 1048 mCreationArgs.hasWideColorGamut = hasWideColorGamut; 1049 return *this; 1050 } 1051 setPhysicalOrientation(ui::Rotation orientation)1052 auto& setPhysicalOrientation(ui::Rotation orientation) { 1053 mCreationArgs.physicalOrientation = orientation; 1054 return *this; 1055 } 1056 1057 // Used to avoid overwriting mocks injected by TestableSurfaceFlinger::setupMockScheduler. skipSchedulerRegistration()1058 auto& skipSchedulerRegistration() { 1059 mSchedulerRegistration = false; 1060 return *this; 1061 } 1062 inject()1063 sp<DisplayDevice> inject() NO_THREAD_SAFETY_ANALYSIS { 1064 return inject(std::make_unique<mock::VsyncController>(), 1065 std::make_shared<mock::VSyncTracker>()); 1066 } 1067 inject(std::unique_ptr<android::scheduler::VsyncController> controller,std::shared_ptr<android::scheduler::VSyncTracker> tracker)1068 sp<DisplayDevice> inject(std::unique_ptr<android::scheduler::VsyncController> controller, 1069 std::shared_ptr<android::scheduler::VSyncTracker> tracker) 1070 NO_THREAD_SAFETY_ANALYSIS { 1071 const auto displayId = mCreationArgs.compositionDisplay->getDisplayId(); 1072 LOG_ALWAYS_FATAL_IF(!displayId); 1073 1074 auto& modes = mDisplayModes; 1075 auto& activeModeId = mActiveModeId; 1076 1077 DisplayDeviceState state; 1078 state.isSecure = mCreationArgs.isSecure; 1079 1080 if (const auto physicalId = 1081 mCreationArgs.compositionDisplay->getDisplayIdVariant().and_then( 1082 asPhysicalDisplayId)) { 1083 LOG_ALWAYS_FATAL_IF(!mConnectionType); 1084 LOG_ALWAYS_FATAL_IF(!mHwcDisplayId); 1085 1086 if (mCreationArgs.isPrimary) { 1087 mFlinger.mutableActiveDisplayId() = *physicalId; 1088 } 1089 1090 if (!mCreationArgs.refreshRateSelector) { 1091 if (modes.empty()) { 1092 constexpr DisplayModeId kModeId{0}; 1093 DisplayModePtr mode = 1094 DisplayMode::Builder(FakeHwcDisplayInjector::DEFAULT_ACTIVE_CONFIG) 1095 .setId(kModeId) 1096 .setPhysicalDisplayId(*physicalId) 1097 .setResolution(FakeHwcDisplayInjector::DEFAULT_RESOLUTION) 1098 .setVsyncPeriod( 1099 FakeHwcDisplayInjector::DEFAULT_VSYNC_PERIOD) 1100 .setDpiX(FakeHwcDisplayInjector::DEFAULT_DPI) 1101 .setDpiY(FakeHwcDisplayInjector::DEFAULT_DPI) 1102 .setGroup(FakeHwcDisplayInjector::DEFAULT_CONFIG_GROUP) 1103 .build(); 1104 1105 modes = ftl::init::map(kModeId, std::move(mode)); 1106 activeModeId = kModeId; 1107 } 1108 1109 mCreationArgs.refreshRateSelector = 1110 std::make_shared<scheduler::RefreshRateSelector>(modes, activeModeId); 1111 } 1112 1113 const auto activeModeOpt = modes.get(activeModeId); 1114 LOG_ALWAYS_FATAL_IF(!activeModeOpt); 1115 1116 // Save a copy for use after `modes` is consumed. 1117 const Fps refreshRate = activeModeOpt->get()->getPeakFps(); 1118 1119 state.physical = {.id = *physicalId, 1120 .hwcDisplayId = *mHwcDisplayId, 1121 .activeMode = activeModeOpt->get()}; 1122 1123 const auto it = 1124 mFlinger.mutablePhysicalDisplays() 1125 .emplace_or_replace(*physicalId, mDisplayToken, *physicalId, *mPort, 1126 *mConnectionType, std::move(modes), 1127 ui::ColorModes(), std::nullopt) 1128 .first; 1129 1130 mFlinger.mutableDisplayModeController() 1131 .registerDisplay(*physicalId, it->second.snapshot(), 1132 mCreationArgs.refreshRateSelector); 1133 1134 mFlinger.mutableDisplayModeController().setActiveMode(*physicalId, activeModeId, 1135 refreshRate, refreshRate); 1136 1137 if (mFlinger.scheduler() && mSchedulerRegistration) { 1138 mFlinger.scheduler()->registerDisplay(*physicalId, 1139 mCreationArgs.refreshRateSelector, 1140 std::move(controller), std::move(tracker), 1141 mFlinger.mutableActiveDisplayId()); 1142 } 1143 } 1144 1145 sp<DisplayDevice> display = sp<DisplayDevice>::make(mCreationArgs); 1146 mFlinger.mutableDisplays().emplace_or_replace(mDisplayToken, display); 1147 1148 mFlinger.mutableCurrentState().displays.add(mDisplayToken, state); 1149 mFlinger.mutableDrawingState().displays.add(mDisplayToken, state); 1150 1151 return display; 1152 } 1153 1154 private: 1155 TestableSurfaceFlinger& mFlinger; 1156 sp<BBinder> mDisplayToken = sp<BBinder>::make(); 1157 DisplayDeviceCreationArgs mCreationArgs; 1158 DisplayModes mDisplayModes; 1159 DisplayModeId mActiveModeId; 1160 bool mSchedulerRegistration = true; 1161 const std::optional<ui::DisplayConnectionType> mConnectionType; 1162 const std::optional<uint8_t> mPort; 1163 const std::optional<hal::HWDisplayId> mHwcDisplayId; 1164 }; 1165 1166 private: 1167 template <typename T> makeMock(bool useNiceMock)1168 static std::unique_ptr<T> makeMock(bool useNiceMock) { 1169 return useNiceMock ? std::make_unique<testing::NiceMock<T>>() : std::make_unique<T>(); 1170 } 1171 1172 template <typename T> makeSharedMock(bool useNiceMock)1173 static std::shared_ptr<T> makeSharedMock(bool useNiceMock) { 1174 return useNiceMock ? std::make_shared<testing::NiceMock<T>>() : std::make_shared<T>(); 1175 } 1176 1177 static constexpr VsyncId kVsyncId{123}; 1178 1179 surfaceflinger::test::Factory mFactory; 1180 sp<SurfaceFlinger> mFlinger; 1181 scheduler::mock::SchedulerCallback mSchedulerCallback; 1182 scheduler::mock::NoOpSchedulerCallback mNoOpSchedulerCallback; 1183 std::unique_ptr<frametimeline::impl::TokenManager> mTokenManager; 1184 scheduler::TestableScheduler* mScheduler = nullptr; 1185 adpf::mock::PowerAdvisor mPowerAdvisor; 1186 }; 1187 1188 } // namespace android 1189