1 /* 2 * Copyright 2020 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 // TODO(b/129481165): remove the #pragma below and fix conversion issues 20 #pragma clang diagnostic push 21 #pragma clang diagnostic ignored "-Wconversion" 22 #pragma clang diagnostic ignored "-Wextra" 23 24 #include <type_traits> 25 #include "DisplayIdentificationTestHelpers.h" 26 27 #include <binder/IPCThreadState.h> 28 #include <compositionengine/Display.h> 29 #include <compositionengine/DisplayColorProfile.h> 30 #include <compositionengine/impl/Display.h> 31 #include <compositionengine/impl/OutputCompositionState.h> 32 #include <compositionengine/mock/Display.h> 33 #include <compositionengine/mock/DisplayColorProfile.h> 34 #include <compositionengine/mock/DisplaySurface.h> 35 #include <compositionengine/mock/RenderSurface.h> 36 #include <gmock/gmock.h> 37 #include <gtest/gtest.h> 38 #include <gui/mock/GraphicBufferConsumer.h> 39 #include <gui/mock/GraphicBufferProducer.h> 40 #include <log/log.h> 41 #include <private/android_filesystem_config.h> 42 #include <renderengine/mock/RenderEngine.h> 43 #include <ui/DebugUtils.h> 44 45 #include "FakeDisplayInjector.h" 46 #include "TestableScheduler.h" 47 #include "TestableSurfaceFlinger.h" 48 #include "mock/DisplayHardware/MockComposer.h" 49 #include "mock/DisplayHardware/MockDisplayMode.h" 50 #include "mock/DisplayHardware/MockPowerAdvisor.h" 51 #include "mock/MockEventThread.h" 52 #include "mock/MockNativeWindowSurface.h" 53 #include "mock/MockVsyncController.h" 54 #include "mock/system/window/MockNativeWindow.h" 55 56 namespace android { 57 58 // TODO: Do not polute the android namespace 59 namespace hal = android::hardware::graphics::composer::hal; 60 61 using testing::_; 62 using testing::AnyNumber; 63 using testing::DoAll; 64 using testing::Mock; 65 using testing::ResultOf; 66 using testing::Return; 67 using testing::SetArgPointee; 68 69 using aidl::android::hardware::graphics::composer3::DisplayCapability; 70 using hal::ColorMode; 71 using hal::Connection; 72 using hal::DisplayType; 73 using hal::Error; 74 using hal::Hdr; 75 using hal::HWDisplayId; 76 using hal::IComposer; 77 using hal::IComposerClient; 78 using hal::PerFrameMetadataKey; 79 using hal::PowerMode; 80 81 class DisplayTransactionTest : public testing::Test { 82 public: 83 ~DisplayTransactionTest() override; 84 85 // -------------------------------------------------------------------- 86 // Mock/Fake injection 87 88 void injectMockScheduler(PhysicalDisplayId); 89 void injectMockComposer(int virtualDisplayCount); 90 void injectFakeBufferQueueFactory(); 91 void injectFakeNativeWindowSurfaceFactory(); 92 injectDefaultInternalDisplay(std::function<void (TestableSurfaceFlinger::FakeDisplayDeviceInjector &)> injectExtra)93 sp<DisplayDevice> injectDefaultInternalDisplay( 94 std::function<void(TestableSurfaceFlinger::FakeDisplayDeviceInjector&)> injectExtra) { 95 return mFakeDisplayInjector.injectInternalDisplay(injectExtra); 96 } 97 98 // -------------------------------------------------------------------- 99 // Postcondition helpers 100 101 bool hasPhysicalHwcDisplay(hal::HWDisplayId) const; 102 bool hasTransactionFlagSet(int32_t flag) const; 103 104 bool hasDisplayDevice(const sp<IBinder>& displayToken) const; 105 const DisplayDevice& getDisplayDevice(const sp<IBinder>& displayToken) const; 106 107 bool hasCurrentDisplayState(const sp<IBinder>& displayToken) const; 108 const DisplayDeviceState& getCurrentDisplayState(const sp<IBinder>& displayToken) const; 109 110 bool hasDrawingDisplayState(const sp<IBinder>& displayToken) const; 111 const DisplayDeviceState& getDrawingDisplayState(const sp<IBinder>& displayToken) const; 112 113 // -------------------------------------------------------------------- 114 // Test instances 115 116 TestableSurfaceFlinger mFlinger; 117 sp<mock::NativeWindow> mNativeWindow = sp<mock::NativeWindow>::make(); 118 sp<GraphicBuffer> mBuffer = 119 sp<GraphicBuffer>::make(1u, 1u, PIXEL_FORMAT_RGBA_8888, 120 GRALLOC_USAGE_SW_WRITE_OFTEN | GRALLOC_USAGE_SW_READ_OFTEN); 121 Hwc2::mock::PowerAdvisor mPowerAdvisor; 122 123 FakeDisplayInjector mFakeDisplayInjector{mFlinger, mPowerAdvisor, mNativeWindow}; 124 125 // These mocks are created by the test, but are destroyed by SurfaceFlinger 126 // by virtue of being stored into a std::unique_ptr. However we still need 127 // to keep a reference to them for use in setting up call expectations. 128 renderengine::mock::RenderEngine* mRenderEngine = new renderengine::mock::RenderEngine(); 129 Hwc2::mock::Composer* mComposer = nullptr; 130 131 mock::EventThread* mEventThread = new mock::EventThread; 132 mock::EventThread* mSFEventThread = new mock::EventThread; 133 134 // These mocks are created only when expected to be created via a factory. 135 sp<mock::GraphicBufferConsumer> mConsumer; 136 sp<mock::GraphicBufferProducer> mProducer; 137 surfaceflinger::mock::NativeWindowSurface* mNativeWindowSurface = nullptr; 138 139 protected: 140 DisplayTransactionTest(bool withMockScheduler = true); 141 }; 142 143 constexpr int32_t DEFAULT_VSYNC_PERIOD = 16'666'667; 144 constexpr int32_t DEFAULT_DPI = 320; 145 constexpr int DEFAULT_VIRTUAL_DISPLAY_SURFACE_FORMAT = HAL_PIXEL_FORMAT_RGB_565; 146 147 constexpr int POWER_MODE_LEET = 1337; // An out of range power mode value 148 149 /* ------------------------------------------------------------------------ 150 * Boolean avoidance 151 * 152 * To make calls and template instantiations more readable, we define some 153 * local enums along with an implicit bool conversion. 154 */ 155 156 #define BOOL_SUBSTITUTE(TYPENAME) enum class TYPENAME : bool { FALSE = false, TRUE = true }; 157 158 BOOL_SUBSTITUTE(Async); 159 BOOL_SUBSTITUTE(Primary); 160 BOOL_SUBSTITUTE(Secure); 161 BOOL_SUBSTITUTE(Virtual); 162 163 template <typename PhysicalDisplay> 164 struct PhysicalDisplayIdType {}; 165 166 template <uint64_t displayId> 167 using HalVirtualDisplayIdType = std::integral_constant<uint64_t, displayId>; 168 169 struct GpuVirtualDisplayIdType {}; 170 171 template <typename> 172 struct IsPhysicalDisplayId : std::bool_constant<false> {}; 173 174 template <typename PhysicalDisplay> 175 struct IsPhysicalDisplayId<PhysicalDisplayIdType<PhysicalDisplay>> : std::bool_constant<true> {}; 176 177 template <typename> 178 struct DisplayIdGetter; 179 180 template <typename PhysicalDisplay> 181 struct DisplayIdGetter<PhysicalDisplayIdType<PhysicalDisplay>> { 182 static PhysicalDisplayId get() { 183 if (!PhysicalDisplay::HAS_IDENTIFICATION_DATA) { 184 return PhysicalDisplayId::fromPort(static_cast<bool>(PhysicalDisplay::PRIMARY) 185 ? LEGACY_DISPLAY_TYPE_PRIMARY 186 : LEGACY_DISPLAY_TYPE_EXTERNAL); 187 } 188 189 const auto info = 190 parseDisplayIdentificationData(PhysicalDisplay::PORT, 191 PhysicalDisplay::GET_IDENTIFICATION_DATA()); 192 return info ? info->id : PhysicalDisplayId::fromPort(PhysicalDisplay::PORT); 193 } 194 }; 195 196 template <uint64_t displayId> 197 struct DisplayIdGetter<HalVirtualDisplayIdType<displayId>> { 198 static HalVirtualDisplayId get() { return HalVirtualDisplayId(displayId); } 199 }; 200 201 template <> 202 struct DisplayIdGetter<GpuVirtualDisplayIdType> { 203 static GpuVirtualDisplayId get() { return GpuVirtualDisplayId(0); } 204 }; 205 206 template <typename> 207 struct DisplayConnectionTypeGetter { 208 static constexpr std::optional<ui::DisplayConnectionType> value; 209 }; 210 211 template <typename PhysicalDisplay> 212 struct DisplayConnectionTypeGetter<PhysicalDisplayIdType<PhysicalDisplay>> { 213 static constexpr std::optional<ui::DisplayConnectionType> value = 214 PhysicalDisplay::CONNECTION_TYPE; 215 }; 216 217 template <typename> 218 struct HwcDisplayIdGetter { 219 static constexpr std::optional<HWDisplayId> value; 220 }; 221 222 constexpr HWDisplayId HWC_VIRTUAL_DISPLAY_HWC_DISPLAY_ID = 1010; 223 224 template <uint64_t displayId> 225 struct HwcDisplayIdGetter<HalVirtualDisplayIdType<displayId>> { 226 static constexpr std::optional<HWDisplayId> value = HWC_VIRTUAL_DISPLAY_HWC_DISPLAY_ID; 227 }; 228 229 template <typename PhysicalDisplay> 230 struct HwcDisplayIdGetter<PhysicalDisplayIdType<PhysicalDisplay>> { 231 static constexpr std::optional<HWDisplayId> value = PhysicalDisplay::HWC_DISPLAY_ID; 232 }; 233 234 // DisplayIdType can be: 235 // 1) PhysicalDisplayIdType<...> for generated ID of physical display backed by HWC. 236 // 2) HalVirtualDisplayIdType<...> for hard-coded ID of virtual display backed by HWC. 237 // 3) GpuVirtualDisplayIdType for virtual display without HWC backing. 238 template <typename DisplayIdType, int width, int height, Async async, Secure secure, 239 Primary primary, int grallocUsage, int displayFlags> 240 struct DisplayVariant { 241 using DISPLAY_ID = DisplayIdGetter<DisplayIdType>; 242 using CONNECTION_TYPE = DisplayConnectionTypeGetter<DisplayIdType>; 243 using HWC_DISPLAY_ID_OPT = HwcDisplayIdGetter<DisplayIdType>; 244 245 static constexpr int WIDTH = width; 246 static constexpr int HEIGHT = height; 247 static constexpr ui::Size RESOLUTION{WIDTH, HEIGHT}; 248 249 static constexpr int GRALLOC_USAGE = grallocUsage; 250 251 // Whether the display is virtual or physical 252 static constexpr Virtual VIRTUAL = 253 IsPhysicalDisplayId<DisplayIdType>{} ? Virtual::FALSE : Virtual::TRUE; 254 255 // When creating native window surfaces for the framebuffer, whether those should be async 256 static constexpr Async ASYNC = async; 257 258 // Whether the display should be treated as secure 259 static constexpr Secure SECURE = secure; 260 261 // Whether the display is primary 262 static constexpr Primary PRIMARY = primary; 263 264 static constexpr int DISPLAY_FLAGS = displayFlags; 265 266 static auto makeFakeExistingDisplayInjector(DisplayTransactionTest* test) { 267 auto ceDisplayArgs = compositionengine::DisplayCreationArgsBuilder(); 268 ceDisplayArgs.setId(DISPLAY_ID::get()) 269 .setPixels(RESOLUTION) 270 .setPowerAdvisor(&test->mPowerAdvisor); 271 272 auto compositionDisplay = 273 compositionengine::impl::createDisplay(test->mFlinger.getCompositionEngine(), 274 ceDisplayArgs.build()); 275 276 auto injector = 277 TestableSurfaceFlinger::FakeDisplayDeviceInjector(test->mFlinger, 278 compositionDisplay, 279 CONNECTION_TYPE::value, 280 HWC_DISPLAY_ID_OPT::value, 281 static_cast<bool>(PRIMARY)); 282 283 injector.setSecure(static_cast<bool>(SECURE)); 284 injector.setNativeWindow(test->mNativeWindow); 285 286 // Creating a DisplayDevice requires getting default dimensions from the 287 // native window along with some other initial setup. 288 EXPECT_CALL(*test->mNativeWindow, query(NATIVE_WINDOW_WIDTH, _)) 289 .WillRepeatedly(DoAll(SetArgPointee<1>(WIDTH), Return(0))); 290 EXPECT_CALL(*test->mNativeWindow, query(NATIVE_WINDOW_HEIGHT, _)) 291 .WillRepeatedly(DoAll(SetArgPointee<1>(HEIGHT), Return(0))); 292 EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_SET_BUFFERS_FORMAT)) 293 .WillRepeatedly(Return(0)); 294 EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_API_CONNECT)) 295 .WillRepeatedly(Return(0)); 296 EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_SET_USAGE64)) 297 .WillRepeatedly(Return(0)); 298 EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_API_DISCONNECT)) 299 .WillRepeatedly(Return(0)); 300 301 return injector; 302 } 303 304 // Called by tests to set up any native window creation call expectations. 305 static void setupNativeWindowSurfaceCreationCallExpectations(DisplayTransactionTest* test) { 306 EXPECT_CALL(*test->mNativeWindowSurface, getNativeWindow()) 307 .WillOnce(Return(test->mNativeWindow)); 308 309 EXPECT_CALL(*test->mNativeWindow, query(NATIVE_WINDOW_WIDTH, _)) 310 .WillRepeatedly(DoAll(SetArgPointee<1>(WIDTH), Return(0))); 311 EXPECT_CALL(*test->mNativeWindow, query(NATIVE_WINDOW_HEIGHT, _)) 312 .WillRepeatedly(DoAll(SetArgPointee<1>(HEIGHT), Return(0))); 313 EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_SET_BUFFERS_FORMAT)) 314 .WillRepeatedly(Return(0)); 315 EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_API_CONNECT)) 316 .WillRepeatedly(Return(0)); 317 EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_SET_USAGE64)) 318 .WillRepeatedly(Return(0)); 319 EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_API_DISCONNECT)) 320 .WillRepeatedly(Return(0)); 321 } 322 323 static void setupFramebufferConsumerBufferQueueCallExpectations(DisplayTransactionTest* test) { 324 EXPECT_CALL(*test->mConsumer, consumerConnect(_, false)).WillOnce(Return(NO_ERROR)); 325 EXPECT_CALL(*test->mConsumer, setConsumerName(_)).WillRepeatedly(Return(NO_ERROR)); 326 EXPECT_CALL(*test->mConsumer, setConsumerUsageBits(GRALLOC_USAGE)) 327 .WillRepeatedly(Return(NO_ERROR)); 328 EXPECT_CALL(*test->mConsumer, setDefaultBufferSize(WIDTH, HEIGHT)) 329 .WillRepeatedly(Return(NO_ERROR)); 330 EXPECT_CALL(*test->mConsumer, setMaxAcquiredBufferCount(_)) 331 .WillRepeatedly(Return(NO_ERROR)); 332 } 333 334 static void setupFramebufferProducerBufferQueueCallExpectations(DisplayTransactionTest* test) { 335 EXPECT_CALL(*test->mProducer, allocateBuffers(0, 0, 0, 0)).WillRepeatedly(Return()); 336 } 337 }; 338 339 template <HWDisplayId hwcDisplayId, DisplayType hwcDisplayType, typename DisplayVariant, 340 typename PhysicalDisplay = void> 341 struct HwcDisplayVariant { 342 // The display id supplied by the HWC 343 static constexpr HWDisplayId HWC_DISPLAY_ID = hwcDisplayId; 344 345 // The HWC display type 346 static constexpr DisplayType HWC_DISPLAY_TYPE = hwcDisplayType; 347 348 // The HWC active configuration id 349 static constexpr hal::HWConfigId HWC_ACTIVE_CONFIG_ID = 2001; 350 static constexpr PowerMode INIT_POWER_MODE = hal::PowerMode::ON; 351 352 static void injectPendingHotplugEvent(DisplayTransactionTest* test, Connection connection) { 353 test->mFlinger.mutablePendingHotplugEvents().emplace_back( 354 TestableSurfaceFlinger::HotplugEvent{HWC_DISPLAY_ID, connection}); 355 } 356 357 // Called by tests to inject a HWC display setup 358 template <bool kInitPowerMode = true> 359 static void injectHwcDisplayWithNoDefaultCapabilities(DisplayTransactionTest* test) { 360 const auto displayId = DisplayVariant::DISPLAY_ID::get(); 361 ASSERT_FALSE(GpuVirtualDisplayId::tryCast(displayId)); 362 TestableSurfaceFlinger::FakeHwcDisplayInjector(displayId, HWC_DISPLAY_TYPE, 363 static_cast<bool>(DisplayVariant::PRIMARY)) 364 .setHwcDisplayId(HWC_DISPLAY_ID) 365 .setResolution(DisplayVariant::RESOLUTION) 366 .setActiveConfig(HWC_ACTIVE_CONFIG_ID) 367 .setPowerMode(kInitPowerMode ? std::make_optional(INIT_POWER_MODE) : std::nullopt) 368 .inject(&test->mFlinger, test->mComposer); 369 } 370 371 // Called by tests to inject a HWC display setup 372 template <bool kInitPowerMode = true> 373 static void injectHwcDisplay(DisplayTransactionTest* test) { 374 if constexpr (kInitPowerMode) { 375 EXPECT_CALL(*test->mComposer, getDisplayCapabilities(HWC_DISPLAY_ID, _)) 376 .WillOnce(DoAll(SetArgPointee<1>(std::vector<DisplayCapability>({})), 377 Return(Error::NONE))); 378 379 EXPECT_CALL(*test->mComposer, setPowerMode(HWC_DISPLAY_ID, INIT_POWER_MODE)) 380 .WillOnce(Return(Error::NONE)); 381 } 382 injectHwcDisplayWithNoDefaultCapabilities<kInitPowerMode>(test); 383 } 384 385 static std::shared_ptr<compositionengine::Display> injectCompositionDisplay( 386 DisplayTransactionTest* test) { 387 const ::testing::TestInfo* const test_info = 388 ::testing::UnitTest::GetInstance()->current_test_info(); 389 390 auto ceDisplayArgs = compositionengine::DisplayCreationArgsBuilder() 391 .setId(DisplayVariant::DISPLAY_ID::get()) 392 .setPixels(DisplayVariant::RESOLUTION) 393 .setIsSecure(static_cast<bool>(DisplayVariant::SECURE)) 394 .setPowerAdvisor(&test->mPowerAdvisor) 395 .setName(std::string("Injected display for ") + 396 test_info->test_case_name() + "." + test_info->name()) 397 .build(); 398 399 return compositionengine::impl::createDisplay(test->mFlinger.getCompositionEngine(), 400 ceDisplayArgs); 401 } 402 403 static void setupHwcGetConfigsCallExpectations(DisplayTransactionTest* test) { 404 if (HWC_DISPLAY_TYPE == DisplayType::PHYSICAL) { 405 EXPECT_CALL(*test->mComposer, getDisplayConfigs(HWC_DISPLAY_ID, _)) 406 .WillRepeatedly(DoAll(SetArgPointee<1>(std::vector<hal::HWConfigId>{ 407 HWC_ACTIVE_CONFIG_ID}), 408 Return(Error::NONE))); 409 EXPECT_CALL(*test->mComposer, 410 getDisplayAttribute(HWC_DISPLAY_ID, HWC_ACTIVE_CONFIG_ID, 411 IComposerClient::Attribute::WIDTH, _)) 412 .WillRepeatedly( 413 DoAll(SetArgPointee<3>(DisplayVariant::WIDTH), Return(Error::NONE))); 414 EXPECT_CALL(*test->mComposer, 415 getDisplayAttribute(HWC_DISPLAY_ID, HWC_ACTIVE_CONFIG_ID, 416 IComposerClient::Attribute::HEIGHT, _)) 417 .WillRepeatedly( 418 DoAll(SetArgPointee<3>(DisplayVariant::HEIGHT), Return(Error::NONE))); 419 EXPECT_CALL(*test->mComposer, 420 getDisplayAttribute(HWC_DISPLAY_ID, HWC_ACTIVE_CONFIG_ID, 421 IComposerClient::Attribute::VSYNC_PERIOD, _)) 422 .WillRepeatedly( 423 DoAll(SetArgPointee<3>(DEFAULT_VSYNC_PERIOD), Return(Error::NONE))); 424 EXPECT_CALL(*test->mComposer, 425 getDisplayAttribute(HWC_DISPLAY_ID, HWC_ACTIVE_CONFIG_ID, 426 IComposerClient::Attribute::DPI_X, _)) 427 .WillRepeatedly(DoAll(SetArgPointee<3>(DEFAULT_DPI), Return(Error::NONE))); 428 EXPECT_CALL(*test->mComposer, 429 getDisplayAttribute(HWC_DISPLAY_ID, HWC_ACTIVE_CONFIG_ID, 430 IComposerClient::Attribute::DPI_Y, _)) 431 .WillRepeatedly(DoAll(SetArgPointee<3>(DEFAULT_DPI), Return(Error::NONE))); 432 EXPECT_CALL(*test->mComposer, 433 getDisplayAttribute(HWC_DISPLAY_ID, HWC_ACTIVE_CONFIG_ID, 434 IComposerClient::Attribute::CONFIG_GROUP, _)) 435 .WillRepeatedly(DoAll(SetArgPointee<3>(-1), Return(Error::NONE))); 436 } else { 437 EXPECT_CALL(*test->mComposer, getDisplayConfigs(_, _)).Times(0); 438 EXPECT_CALL(*test->mComposer, getDisplayAttribute(_, _, _, _)).Times(0); 439 } 440 } 441 442 template <bool kFailedHotplug = false> 443 static void setupHwcHotplugCallExpectations(DisplayTransactionTest* test) { 444 if constexpr (!kFailedHotplug) { 445 constexpr auto CONNECTION_TYPE = 446 PhysicalDisplay::CONNECTION_TYPE == ui::DisplayConnectionType::Internal 447 ? IComposerClient::DisplayConnectionType::INTERNAL 448 : IComposerClient::DisplayConnectionType::EXTERNAL; 449 450 EXPECT_CALL(*test->mComposer, getDisplayConnectionType(HWC_DISPLAY_ID, _)) 451 .WillOnce(DoAll(SetArgPointee<1>(CONNECTION_TYPE), 452 Return(hal::V2_4::Error::NONE))); 453 } 454 455 EXPECT_CALL(*test->mComposer, setClientTargetSlotCount(_)) 456 .WillOnce(Return(hal::Error::NONE)); 457 458 setupHwcGetConfigsCallExpectations(test); 459 460 if (PhysicalDisplay::HAS_IDENTIFICATION_DATA) { 461 EXPECT_CALL(*test->mComposer, getDisplayIdentificationData(HWC_DISPLAY_ID, _, _)) 462 .WillOnce(DoAll(SetArgPointee<1>(PhysicalDisplay::PORT), 463 SetArgPointee<2>(PhysicalDisplay::GET_IDENTIFICATION_DATA()), 464 Return(Error::NONE))); 465 } else { 466 EXPECT_CALL(*test->mComposer, getDisplayIdentificationData(HWC_DISPLAY_ID, _, _)) 467 .WillOnce(Return(Error::UNSUPPORTED)); 468 } 469 } 470 471 // Called by tests to set up HWC call expectations 472 static void setupHwcGetActiveConfigCallExpectations(DisplayTransactionTest* test) { 473 EXPECT_CALL(*test->mComposer, getActiveConfig(HWC_DISPLAY_ID, _)) 474 .WillRepeatedly(DoAll(SetArgPointee<1>(HWC_ACTIVE_CONFIG_ID), Return(Error::NONE))); 475 } 476 }; 477 478 // Physical displays are expected to be synchronous, secure, and have a HWC display for output. 479 constexpr uint32_t GRALLOC_USAGE_PHYSICAL_DISPLAY = 480 GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_COMPOSER | GRALLOC_USAGE_HW_FB; 481 482 constexpr int PHYSICAL_DISPLAY_FLAGS = 0x1; 483 484 template <typename PhysicalDisplay, int width, int height> 485 struct PhysicalDisplayVariant 486 : DisplayVariant<PhysicalDisplayIdType<PhysicalDisplay>, width, height, Async::FALSE, 487 Secure::TRUE, PhysicalDisplay::PRIMARY, GRALLOC_USAGE_PHYSICAL_DISPLAY, 488 PHYSICAL_DISPLAY_FLAGS>, 489 HwcDisplayVariant<PhysicalDisplay::HWC_DISPLAY_ID, DisplayType::PHYSICAL, 490 DisplayVariant<PhysicalDisplayIdType<PhysicalDisplay>, width, height, 491 Async::FALSE, Secure::TRUE, PhysicalDisplay::PRIMARY, 492 GRALLOC_USAGE_PHYSICAL_DISPLAY, PHYSICAL_DISPLAY_FLAGS>, 493 PhysicalDisplay> {}; 494 495 template <bool hasIdentificationData> 496 struct PrimaryDisplay { 497 static constexpr auto CONNECTION_TYPE = ui::DisplayConnectionType::Internal; 498 static constexpr Primary PRIMARY = Primary::TRUE; 499 static constexpr uint8_t PORT = 255; 500 static constexpr HWDisplayId HWC_DISPLAY_ID = 1001; 501 static constexpr bool HAS_IDENTIFICATION_DATA = hasIdentificationData; 502 static constexpr auto GET_IDENTIFICATION_DATA = getInternalEdid; 503 }; 504 505 template <ui::DisplayConnectionType connectionType, bool hasIdentificationData> 506 struct SecondaryDisplay { 507 static constexpr auto CONNECTION_TYPE = connectionType; 508 static constexpr Primary PRIMARY = Primary::FALSE; 509 static constexpr uint8_t PORT = 254; 510 static constexpr HWDisplayId HWC_DISPLAY_ID = 1002; 511 static constexpr bool HAS_IDENTIFICATION_DATA = hasIdentificationData; 512 static constexpr auto GET_IDENTIFICATION_DATA = 513 connectionType == ui::DisplayConnectionType::Internal ? getInternalEdid 514 : getExternalEdid; 515 }; 516 517 struct TertiaryDisplay { 518 static constexpr Primary PRIMARY = Primary::FALSE; 519 static constexpr uint8_t PORT = 253; 520 static constexpr HWDisplayId HWC_DISPLAY_ID = 1003; 521 static constexpr auto GET_IDENTIFICATION_DATA = getExternalEdid; 522 }; 523 524 using PrimaryDisplayVariant = PhysicalDisplayVariant<PrimaryDisplay<false>, 3840, 2160>; 525 526 using InnerDisplayVariant = PhysicalDisplayVariant<PrimaryDisplay<true>, 1840, 2208>; 527 using OuterDisplayVariant = 528 PhysicalDisplayVariant<SecondaryDisplay<ui::DisplayConnectionType::Internal, true>, 1080, 529 2092>; 530 531 using ExternalDisplayVariant = 532 PhysicalDisplayVariant<SecondaryDisplay<ui::DisplayConnectionType::External, false>, 1920, 533 1280>; 534 535 using TertiaryDisplayVariant = PhysicalDisplayVariant<TertiaryDisplay, 1600, 1200>; 536 537 // A virtual display not supported by the HWC. 538 constexpr uint32_t GRALLOC_USAGE_NONHWC_VIRTUAL_DISPLAY = 0; 539 540 constexpr int VIRTUAL_DISPLAY_FLAGS = 0x0; 541 542 template <int width, int height, Secure secure> 543 struct NonHwcVirtualDisplayVariant 544 : DisplayVariant<GpuVirtualDisplayIdType, width, height, Async::TRUE, secure, Primary::FALSE, 545 GRALLOC_USAGE_NONHWC_VIRTUAL_DISPLAY, VIRTUAL_DISPLAY_FLAGS> { 546 using Base = DisplayVariant<GpuVirtualDisplayIdType, width, height, Async::TRUE, secure, 547 Primary::FALSE, GRALLOC_USAGE_NONHWC_VIRTUAL_DISPLAY, 548 VIRTUAL_DISPLAY_FLAGS>; 549 550 static void injectHwcDisplay(DisplayTransactionTest*) {} 551 552 static std::shared_ptr<compositionengine::Display> injectCompositionDisplay( 553 DisplayTransactionTest* test) { 554 const ::testing::TestInfo* const test_info = 555 ::testing::UnitTest::GetInstance()->current_test_info(); 556 557 auto ceDisplayArgs = compositionengine::DisplayCreationArgsBuilder() 558 .setId(Base::DISPLAY_ID::get()) 559 .setPixels(Base::RESOLUTION) 560 .setIsSecure(static_cast<bool>(Base::SECURE)) 561 .setPowerAdvisor(&test->mPowerAdvisor) 562 .setName(std::string("Injected display for ") + 563 test_info->test_case_name() + "." + test_info->name()) 564 .build(); 565 566 return compositionengine::impl::createDisplay(test->mFlinger.getCompositionEngine(), 567 ceDisplayArgs); 568 } 569 570 static void setupHwcGetConfigsCallExpectations(DisplayTransactionTest* test) { 571 EXPECT_CALL(*test->mComposer, getDisplayConfigs(_, _)).Times(0); 572 EXPECT_CALL(*test->mComposer, getDisplayAttribute(_, _, _, _)).Times(0); 573 } 574 575 static void setupHwcGetActiveConfigCallExpectations(DisplayTransactionTest* test) { 576 EXPECT_CALL(*test->mComposer, getActiveConfig(_, _)).Times(0); 577 } 578 579 static void setupNativeWindowSurfaceCreationCallExpectations(DisplayTransactionTest* test) { 580 Base::setupNativeWindowSurfaceCreationCallExpectations(test); 581 EXPECT_CALL(*test->mNativeWindow, setSwapInterval(0)).Times(1); 582 } 583 }; 584 585 // A virtual display supported by the HWC. 586 constexpr uint32_t GRALLOC_USAGE_HWC_VIRTUAL_DISPLAY = GRALLOC_USAGE_HW_COMPOSER; 587 588 template <int width, int height, Secure secure> 589 struct HwcVirtualDisplayVariant 590 : DisplayVariant<HalVirtualDisplayIdType<42>, width, height, Async::TRUE, secure, 591 Primary::FALSE, GRALLOC_USAGE_HWC_VIRTUAL_DISPLAY, VIRTUAL_DISPLAY_FLAGS>, 592 HwcDisplayVariant<HWC_VIRTUAL_DISPLAY_HWC_DISPLAY_ID, DisplayType::VIRTUAL, 593 DisplayVariant<HalVirtualDisplayIdType<42>, width, height, Async::TRUE, 594 secure, Primary::FALSE, GRALLOC_USAGE_HWC_VIRTUAL_DISPLAY, 595 VIRTUAL_DISPLAY_FLAGS>> { 596 using Base = DisplayVariant<HalVirtualDisplayIdType<42>, width, height, Async::TRUE, secure, 597 Primary::FALSE, GRALLOC_USAGE_HW_COMPOSER, VIRTUAL_DISPLAY_FLAGS>; 598 using Self = HwcVirtualDisplayVariant<width, height, secure>; 599 600 static std::shared_ptr<compositionengine::Display> injectCompositionDisplay( 601 DisplayTransactionTest* test) { 602 const ::testing::TestInfo* const test_info = 603 ::testing::UnitTest::GetInstance()->current_test_info(); 604 605 const auto displayId = Base::DISPLAY_ID::get(); 606 auto ceDisplayArgs = compositionengine::DisplayCreationArgsBuilder() 607 .setId(displayId) 608 .setPixels(Base::RESOLUTION) 609 .setIsSecure(static_cast<bool>(Base::SECURE)) 610 .setPowerAdvisor(&test->mPowerAdvisor) 611 .setName(std::string("Injected display for ") + 612 test_info->test_case_name() + "." + test_info->name()) 613 .build(); 614 615 auto compositionDisplay = 616 compositionengine::impl::createDisplay(test->mFlinger.getCompositionEngine(), 617 ceDisplayArgs); 618 619 // Insert display data so that the HWC thinks it created the virtual display. 620 test->mFlinger.mutableHwcDisplayData().try_emplace(displayId); 621 622 return compositionDisplay; 623 } 624 625 static void setupNativeWindowSurfaceCreationCallExpectations(DisplayTransactionTest* test) { 626 Base::setupNativeWindowSurfaceCreationCallExpectations(test); 627 EXPECT_CALL(*test->mNativeWindow, setSwapInterval(0)).Times(1); 628 } 629 630 static void setupHwcVirtualDisplayCreationCallExpectations(DisplayTransactionTest* test) { 631 EXPECT_CALL(*test->mComposer, createVirtualDisplay(Base::WIDTH, Base::HEIGHT, _, _)) 632 .WillOnce(DoAll(SetArgPointee<3>(Self::HWC_DISPLAY_ID), Return(Error::NONE))); 633 EXPECT_CALL(*test->mComposer, setClientTargetSlotCount(_)).WillOnce(Return(Error::NONE)); 634 } 635 }; 636 637 // For this variant, the display is not a HWC display, so no HDR support should 638 // be configured. 639 struct NonHwcDisplayHdrSupportVariant { 640 static constexpr bool HDR10_PLUS_SUPPORTED = false; 641 static constexpr bool HDR10_SUPPORTED = false; 642 static constexpr bool HDR_HLG_SUPPORTED = false; 643 static constexpr bool HDR_DOLBY_VISION_SUPPORTED = false; 644 static void setupComposerCallExpectations(DisplayTransactionTest* test) { 645 EXPECT_CALL(*test->mComposer, getHdrCapabilities(_, _, _, _, _)).Times(0); 646 } 647 }; 648 649 // For this variant, the composer should respond with am empty list of HDR 650 // modes, so no HDR support should be configured. 651 template <typename Display> 652 struct HdrNotSupportedVariant { 653 static constexpr bool HDR10_PLUS_SUPPORTED = false; 654 static constexpr bool HDR10_SUPPORTED = false; 655 static constexpr bool HDR_HLG_SUPPORTED = false; 656 static constexpr bool HDR_DOLBY_VISION_SUPPORTED = false; 657 static void setupComposerCallExpectations(DisplayTransactionTest* test) { 658 EXPECT_CALL(*test->mComposer, getHdrCapabilities(Display::HWC_DISPLAY_ID, _, _, _, _)) 659 .WillOnce(DoAll(SetArgPointee<1>(std::vector<Hdr>()), Return(Error::NONE))); 660 } 661 }; 662 663 struct NonHwcPerFrameMetadataSupportVariant { 664 static constexpr int PER_FRAME_METADATA_KEYS = 0; 665 static void setupComposerCallExpectations(DisplayTransactionTest* test) { 666 EXPECT_CALL(*test->mComposer, getPerFrameMetadataKeys(_)).Times(0); 667 } 668 }; 669 670 template <typename Display> 671 struct NoPerFrameMetadataSupportVariant { 672 static constexpr int PER_FRAME_METADATA_KEYS = 0; 673 static void setupComposerCallExpectations(DisplayTransactionTest* test) { 674 EXPECT_CALL(*test->mComposer, getPerFrameMetadataKeys(Display::HWC_DISPLAY_ID)) 675 .WillOnce(Return(std::vector<PerFrameMetadataKey>())); 676 } 677 }; 678 679 // For this variant, SurfaceFlinger should configure itself with wide display 680 // support, but the display should respond with an empty list of supported color 681 // modes. Wide-color support for the display should not be configured. 682 template <typename Display> 683 struct WideColorNotSupportedVariant { 684 static constexpr bool WIDE_COLOR_SUPPORTED = false; 685 686 static void injectConfigChange(DisplayTransactionTest* test) { 687 test->mFlinger.mutableSupportsWideColor() = true; 688 } 689 690 static void setupComposerCallExpectations(DisplayTransactionTest* test) { 691 EXPECT_CALL(*test->mComposer, setColorMode(_, _, _)).Times(0); 692 } 693 }; 694 695 // For this variant, SurfaceFlinger should not configure itself with wide 696 // display support, so the display should not be configured for wide-color 697 // support. 698 struct WideColorSupportNotConfiguredVariant { 699 static constexpr bool WIDE_COLOR_SUPPORTED = false; 700 701 static void injectConfigChange(DisplayTransactionTest* test) { 702 test->mFlinger.mutableSupportsWideColor() = false; 703 test->mFlinger.mutableDisplayColorSetting() = DisplayColorSetting::kUnmanaged; 704 } 705 706 static void setupComposerCallExpectations(DisplayTransactionTest* test) { 707 EXPECT_CALL(*test->mComposer, getRenderIntents(_, _, _)).Times(0); 708 EXPECT_CALL(*test->mComposer, setColorMode(_, _, _)).Times(0); 709 } 710 }; 711 712 /* ------------------------------------------------------------------------ 713 * Typical display configurations to test 714 */ 715 716 template <typename DisplayPolicy, typename WideColorSupportPolicy, typename HdrSupportPolicy, 717 typename PerFrameMetadataSupportPolicy> 718 struct Case { 719 using Display = DisplayPolicy; 720 using WideColorSupport = WideColorSupportPolicy; 721 using HdrSupport = HdrSupportPolicy; 722 using PerFrameMetadataSupport = PerFrameMetadataSupportPolicy; 723 }; 724 725 using SimplePrimaryDisplayCase = 726 Case<PrimaryDisplayVariant, WideColorNotSupportedVariant<PrimaryDisplayVariant>, 727 HdrNotSupportedVariant<PrimaryDisplayVariant>, 728 NoPerFrameMetadataSupportVariant<PrimaryDisplayVariant>>; 729 using SimpleExternalDisplayCase = 730 Case<ExternalDisplayVariant, WideColorNotSupportedVariant<ExternalDisplayVariant>, 731 HdrNotSupportedVariant<ExternalDisplayVariant>, 732 NoPerFrameMetadataSupportVariant<ExternalDisplayVariant>>; 733 using SimpleTertiaryDisplayCase = 734 Case<TertiaryDisplayVariant, WideColorNotSupportedVariant<TertiaryDisplayVariant>, 735 HdrNotSupportedVariant<TertiaryDisplayVariant>, 736 NoPerFrameMetadataSupportVariant<TertiaryDisplayVariant>>; 737 738 using NonHwcVirtualDisplayCase = 739 Case<NonHwcVirtualDisplayVariant<1024, 768, Secure::FALSE>, 740 WideColorSupportNotConfiguredVariant, NonHwcDisplayHdrSupportVariant, 741 NonHwcPerFrameMetadataSupportVariant>; 742 using SimpleHwcVirtualDisplayVariant = HwcVirtualDisplayVariant<1024, 768, Secure::TRUE>; 743 using HwcVirtualDisplayCase = 744 Case<SimpleHwcVirtualDisplayVariant, WideColorSupportNotConfiguredVariant, 745 HdrNotSupportedVariant<SimpleHwcVirtualDisplayVariant>, 746 NoPerFrameMetadataSupportVariant<SimpleHwcVirtualDisplayVariant>>; 747 748 inline DisplayModePtr createDisplayMode(DisplayModeId modeId, Fps refreshRate, int32_t group = 0, 749 ui::Size resolution = ui::Size(1920, 1080)) { 750 return mock::createDisplayMode(modeId, refreshRate, group, resolution, 751 PrimaryDisplayVariant::DISPLAY_ID::get()); 752 } 753 754 } // namespace android 755 756 // TODO(b/129481165): remove the #pragma below and fix conversion issues 757 #pragma clang diagnostic pop // ignored "-Wconversion -Wextra" 758