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 351 static void injectPendingHotplugEvent(DisplayTransactionTest* test, Connection connection) { 352 test->mFlinger.mutablePendingHotplugEvents().emplace_back( 353 TestableSurfaceFlinger::HotplugEvent{HWC_DISPLAY_ID, connection}); 354 } 355 356 // Called by tests to inject a HWC display setup 357 template <hal::PowerMode kPowerMode = hal::PowerMode::ON> 358 static void injectHwcDisplayWithNoDefaultCapabilities(DisplayTransactionTest* test) { 359 const auto displayId = DisplayVariant::DISPLAY_ID::get(); 360 ASSERT_FALSE(GpuVirtualDisplayId::tryCast(displayId)); 361 TestableSurfaceFlinger::FakeHwcDisplayInjector(displayId, HWC_DISPLAY_TYPE, 362 static_cast<bool>(DisplayVariant::PRIMARY)) 363 .setHwcDisplayId(HWC_DISPLAY_ID) 364 .setResolution(DisplayVariant::RESOLUTION) 365 .setActiveConfig(HWC_ACTIVE_CONFIG_ID) 366 .setPowerMode(kPowerMode) 367 .inject(&test->mFlinger, test->mComposer); 368 } 369 370 // Called by tests to inject a HWC display setup 371 // 372 // TODO(b/241285876): The `kExpectSetPowerModeOnce` argument is set to `false` by tests that 373 // power on/off displays several times. Replace those catch-all expectations with `InSequence` 374 // and `RetiresOnSaturation`. 375 // 376 template <hal::PowerMode kPowerMode = hal::PowerMode::ON, bool kExpectSetPowerModeOnce = true> 377 static void injectHwcDisplay(DisplayTransactionTest* test) { 378 if constexpr (kExpectSetPowerModeOnce) { 379 if constexpr (kPowerMode == hal::PowerMode::ON) { 380 EXPECT_CALL(*test->mComposer, getDisplayCapabilities(HWC_DISPLAY_ID, _)) 381 .WillOnce(DoAll(SetArgPointee<1>(std::vector<DisplayCapability>({})), 382 Return(Error::NONE))); 383 } 384 385 EXPECT_CALL(*test->mComposer, setPowerMode(HWC_DISPLAY_ID, kPowerMode)) 386 .WillOnce(Return(Error::NONE)); 387 } else { 388 EXPECT_CALL(*test->mComposer, getDisplayCapabilities(HWC_DISPLAY_ID, _)) 389 .WillRepeatedly(DoAll(SetArgPointee<1>(std::vector<DisplayCapability>({})), 390 Return(Error::NONE))); 391 392 EXPECT_CALL(*test->mComposer, setPowerMode(HWC_DISPLAY_ID, _)) 393 .WillRepeatedly(Return(Error::NONE)); 394 } 395 396 injectHwcDisplayWithNoDefaultCapabilities<kPowerMode>(test); 397 } 398 399 static std::shared_ptr<compositionengine::Display> injectCompositionDisplay( 400 DisplayTransactionTest* test) { 401 const ::testing::TestInfo* const test_info = 402 ::testing::UnitTest::GetInstance()->current_test_info(); 403 404 auto ceDisplayArgs = compositionengine::DisplayCreationArgsBuilder() 405 .setId(DisplayVariant::DISPLAY_ID::get()) 406 .setPixels(DisplayVariant::RESOLUTION) 407 .setIsSecure(static_cast<bool>(DisplayVariant::SECURE)) 408 .setPowerAdvisor(&test->mPowerAdvisor) 409 .setName(std::string("Injected display for ") + 410 test_info->test_case_name() + "." + test_info->name()) 411 .build(); 412 413 return compositionengine::impl::createDisplay(test->mFlinger.getCompositionEngine(), 414 ceDisplayArgs); 415 } 416 417 static void setupHwcGetConfigsCallExpectations(DisplayTransactionTest* test) { 418 if (HWC_DISPLAY_TYPE == DisplayType::PHYSICAL) { 419 EXPECT_CALL(*test->mComposer, getDisplayConfigs(HWC_DISPLAY_ID, _)) 420 .WillRepeatedly(DoAll(SetArgPointee<1>(std::vector<hal::HWConfigId>{ 421 HWC_ACTIVE_CONFIG_ID}), 422 Return(Error::NONE))); 423 EXPECT_CALL(*test->mComposer, 424 getDisplayAttribute(HWC_DISPLAY_ID, HWC_ACTIVE_CONFIG_ID, 425 IComposerClient::Attribute::WIDTH, _)) 426 .WillRepeatedly( 427 DoAll(SetArgPointee<3>(DisplayVariant::WIDTH), Return(Error::NONE))); 428 EXPECT_CALL(*test->mComposer, 429 getDisplayAttribute(HWC_DISPLAY_ID, HWC_ACTIVE_CONFIG_ID, 430 IComposerClient::Attribute::HEIGHT, _)) 431 .WillRepeatedly( 432 DoAll(SetArgPointee<3>(DisplayVariant::HEIGHT), Return(Error::NONE))); 433 EXPECT_CALL(*test->mComposer, 434 getDisplayAttribute(HWC_DISPLAY_ID, HWC_ACTIVE_CONFIG_ID, 435 IComposerClient::Attribute::VSYNC_PERIOD, _)) 436 .WillRepeatedly( 437 DoAll(SetArgPointee<3>(DEFAULT_VSYNC_PERIOD), Return(Error::NONE))); 438 EXPECT_CALL(*test->mComposer, 439 getDisplayAttribute(HWC_DISPLAY_ID, HWC_ACTIVE_CONFIG_ID, 440 IComposerClient::Attribute::DPI_X, _)) 441 .WillRepeatedly(DoAll(SetArgPointee<3>(DEFAULT_DPI), Return(Error::NONE))); 442 EXPECT_CALL(*test->mComposer, 443 getDisplayAttribute(HWC_DISPLAY_ID, HWC_ACTIVE_CONFIG_ID, 444 IComposerClient::Attribute::DPI_Y, _)) 445 .WillRepeatedly(DoAll(SetArgPointee<3>(DEFAULT_DPI), Return(Error::NONE))); 446 EXPECT_CALL(*test->mComposer, 447 getDisplayAttribute(HWC_DISPLAY_ID, HWC_ACTIVE_CONFIG_ID, 448 IComposerClient::Attribute::CONFIG_GROUP, _)) 449 .WillRepeatedly(DoAll(SetArgPointee<3>(-1), Return(Error::NONE))); 450 } else { 451 EXPECT_CALL(*test->mComposer, getDisplayConfigs(_, _)).Times(0); 452 EXPECT_CALL(*test->mComposer, getDisplayAttribute(_, _, _, _)).Times(0); 453 } 454 } 455 456 template <bool kFailedHotplug = false> 457 static void setupHwcHotplugCallExpectations(DisplayTransactionTest* test) { 458 if constexpr (!kFailedHotplug) { 459 constexpr auto CONNECTION_TYPE = 460 PhysicalDisplay::CONNECTION_TYPE == ui::DisplayConnectionType::Internal 461 ? IComposerClient::DisplayConnectionType::INTERNAL 462 : IComposerClient::DisplayConnectionType::EXTERNAL; 463 464 using ::testing::AtLeast; 465 EXPECT_CALL(*test->mComposer, getDisplayConnectionType(HWC_DISPLAY_ID, _)) 466 .Times(AtLeast(1)) 467 .WillRepeatedly(DoAll(SetArgPointee<1>(CONNECTION_TYPE), 468 Return(hal::V2_4::Error::NONE))); 469 } 470 471 EXPECT_CALL(*test->mComposer, setClientTargetSlotCount(_)) 472 .WillOnce(Return(hal::Error::NONE)); 473 474 setupHwcGetConfigsCallExpectations(test); 475 476 if (PhysicalDisplay::HAS_IDENTIFICATION_DATA) { 477 EXPECT_CALL(*test->mComposer, getDisplayIdentificationData(HWC_DISPLAY_ID, _, _)) 478 .WillOnce(DoAll(SetArgPointee<1>(PhysicalDisplay::PORT), 479 SetArgPointee<2>(PhysicalDisplay::GET_IDENTIFICATION_DATA()), 480 Return(Error::NONE))); 481 } else { 482 EXPECT_CALL(*test->mComposer, getDisplayIdentificationData(HWC_DISPLAY_ID, _, _)) 483 .WillOnce(Return(Error::UNSUPPORTED)); 484 } 485 } 486 487 // Called by tests to set up HWC call expectations 488 static void setupHwcGetActiveConfigCallExpectations(DisplayTransactionTest* test) { 489 EXPECT_CALL(*test->mComposer, getActiveConfig(HWC_DISPLAY_ID, _)) 490 .WillRepeatedly(DoAll(SetArgPointee<1>(HWC_ACTIVE_CONFIG_ID), Return(Error::NONE))); 491 } 492 }; 493 494 // Physical displays are expected to be synchronous, secure, and have a HWC display for output. 495 constexpr uint32_t GRALLOC_USAGE_PHYSICAL_DISPLAY = 496 GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_COMPOSER | GRALLOC_USAGE_HW_FB; 497 498 constexpr int PHYSICAL_DISPLAY_FLAGS = 0x1; 499 500 template <typename PhysicalDisplay, int width, int height, 501 Secure secure = (PhysicalDisplay::CONNECTION_TYPE == ui::DisplayConnectionType::Internal) 502 ? Secure::TRUE 503 : Secure::FALSE> 504 struct PhysicalDisplayVariant 505 : DisplayVariant<PhysicalDisplayIdType<PhysicalDisplay>, width, height, Async::FALSE, secure, 506 PhysicalDisplay::PRIMARY, GRALLOC_USAGE_PHYSICAL_DISPLAY, 507 PHYSICAL_DISPLAY_FLAGS>, 508 HwcDisplayVariant<PhysicalDisplay::HWC_DISPLAY_ID, DisplayType::PHYSICAL, 509 DisplayVariant<PhysicalDisplayIdType<PhysicalDisplay>, width, height, 510 Async::FALSE, secure, PhysicalDisplay::PRIMARY, 511 GRALLOC_USAGE_PHYSICAL_DISPLAY, PHYSICAL_DISPLAY_FLAGS>, 512 PhysicalDisplay> {}; 513 514 template <bool hasIdentificationData> 515 struct PrimaryDisplay { 516 static constexpr auto CONNECTION_TYPE = ui::DisplayConnectionType::Internal; 517 static constexpr Primary PRIMARY = Primary::TRUE; 518 static constexpr uint8_t PORT = 255; 519 static constexpr HWDisplayId HWC_DISPLAY_ID = 1001; 520 static constexpr bool HAS_IDENTIFICATION_DATA = hasIdentificationData; 521 static constexpr auto GET_IDENTIFICATION_DATA = getInternalEdid; 522 }; 523 524 template <ui::DisplayConnectionType connectionType, bool hasIdentificationData> 525 struct SecondaryDisplay { 526 static constexpr auto CONNECTION_TYPE = connectionType; 527 static constexpr Primary PRIMARY = Primary::FALSE; 528 static constexpr uint8_t PORT = 254; 529 static constexpr HWDisplayId HWC_DISPLAY_ID = 1002; 530 static constexpr bool HAS_IDENTIFICATION_DATA = hasIdentificationData; 531 static constexpr auto GET_IDENTIFICATION_DATA = 532 connectionType == ui::DisplayConnectionType::Internal ? getInternalEdid 533 : getExternalEdid; 534 }; 535 536 struct TertiaryDisplay { 537 static constexpr auto CONNECTION_TYPE = ui::DisplayConnectionType::External; 538 static constexpr Primary PRIMARY = Primary::FALSE; 539 static constexpr uint8_t PORT = 253; 540 static constexpr HWDisplayId HWC_DISPLAY_ID = 1003; 541 static constexpr auto GET_IDENTIFICATION_DATA = getExternalEdid; 542 }; 543 544 using PrimaryDisplayVariant = PhysicalDisplayVariant<PrimaryDisplay<false>, 3840, 2160>; 545 546 using InnerDisplayVariant = PhysicalDisplayVariant<PrimaryDisplay<true>, 1840, 2208>; 547 using OuterDisplayVariant = 548 PhysicalDisplayVariant<SecondaryDisplay<ui::DisplayConnectionType::Internal, true>, 1080, 549 2092>; 550 551 using ExternalDisplayVariant = 552 PhysicalDisplayVariant<SecondaryDisplay<ui::DisplayConnectionType::External, false>, 1920, 553 1280>; 554 555 using TertiaryDisplayVariant = PhysicalDisplayVariant<TertiaryDisplay, 1600, 1200>; 556 557 // A virtual display not supported by the HWC. 558 constexpr uint32_t GRALLOC_USAGE_NONHWC_VIRTUAL_DISPLAY = 0; 559 560 constexpr int VIRTUAL_DISPLAY_FLAGS = 0x0; 561 562 template <int width, int height, Secure secure> 563 struct NonHwcVirtualDisplayVariant 564 : DisplayVariant<GpuVirtualDisplayIdType, width, height, Async::TRUE, secure, Primary::FALSE, 565 GRALLOC_USAGE_NONHWC_VIRTUAL_DISPLAY, VIRTUAL_DISPLAY_FLAGS> { 566 using Base = DisplayVariant<GpuVirtualDisplayIdType, width, height, Async::TRUE, secure, 567 Primary::FALSE, GRALLOC_USAGE_NONHWC_VIRTUAL_DISPLAY, 568 VIRTUAL_DISPLAY_FLAGS>; 569 570 static void injectHwcDisplay(DisplayTransactionTest*) {} 571 572 static std::shared_ptr<compositionengine::Display> injectCompositionDisplay( 573 DisplayTransactionTest* test) { 574 const ::testing::TestInfo* const test_info = 575 ::testing::UnitTest::GetInstance()->current_test_info(); 576 577 auto ceDisplayArgs = compositionengine::DisplayCreationArgsBuilder() 578 .setId(Base::DISPLAY_ID::get()) 579 .setPixels(Base::RESOLUTION) 580 .setIsSecure(static_cast<bool>(Base::SECURE)) 581 .setPowerAdvisor(&test->mPowerAdvisor) 582 .setName(std::string("Injected display for ") + 583 test_info->test_case_name() + "." + test_info->name()) 584 .build(); 585 586 return compositionengine::impl::createDisplay(test->mFlinger.getCompositionEngine(), 587 ceDisplayArgs); 588 } 589 590 static void setupHwcGetConfigsCallExpectations(DisplayTransactionTest* test) { 591 EXPECT_CALL(*test->mComposer, getDisplayConfigs(_, _)).Times(0); 592 EXPECT_CALL(*test->mComposer, getDisplayAttribute(_, _, _, _)).Times(0); 593 } 594 595 static void setupHwcGetActiveConfigCallExpectations(DisplayTransactionTest* test) { 596 EXPECT_CALL(*test->mComposer, getActiveConfig(_, _)).Times(0); 597 } 598 599 static void setupNativeWindowSurfaceCreationCallExpectations(DisplayTransactionTest* test) { 600 Base::setupNativeWindowSurfaceCreationCallExpectations(test); 601 EXPECT_CALL(*test->mNativeWindow, setSwapInterval(0)).Times(1); 602 } 603 }; 604 605 // A virtual display supported by the HWC. 606 constexpr uint32_t GRALLOC_USAGE_HWC_VIRTUAL_DISPLAY = GRALLOC_USAGE_HW_COMPOSER; 607 608 template <int width, int height, Secure secure> 609 struct HwcVirtualDisplayVariant 610 : DisplayVariant<HalVirtualDisplayIdType<42>, width, height, Async::TRUE, secure, 611 Primary::FALSE, GRALLOC_USAGE_HWC_VIRTUAL_DISPLAY, VIRTUAL_DISPLAY_FLAGS>, 612 HwcDisplayVariant<HWC_VIRTUAL_DISPLAY_HWC_DISPLAY_ID, DisplayType::VIRTUAL, 613 DisplayVariant<HalVirtualDisplayIdType<42>, width, height, Async::TRUE, 614 secure, Primary::FALSE, GRALLOC_USAGE_HWC_VIRTUAL_DISPLAY, 615 VIRTUAL_DISPLAY_FLAGS>> { 616 using Base = DisplayVariant<HalVirtualDisplayIdType<42>, width, height, Async::TRUE, secure, 617 Primary::FALSE, GRALLOC_USAGE_HW_COMPOSER, VIRTUAL_DISPLAY_FLAGS>; 618 using Self = HwcVirtualDisplayVariant<width, height, secure>; 619 620 static std::shared_ptr<compositionengine::Display> injectCompositionDisplay( 621 DisplayTransactionTest* test) { 622 const ::testing::TestInfo* const test_info = 623 ::testing::UnitTest::GetInstance()->current_test_info(); 624 625 const auto displayId = Base::DISPLAY_ID::get(); 626 auto ceDisplayArgs = compositionengine::DisplayCreationArgsBuilder() 627 .setId(displayId) 628 .setPixels(Base::RESOLUTION) 629 .setIsSecure(static_cast<bool>(Base::SECURE)) 630 .setPowerAdvisor(&test->mPowerAdvisor) 631 .setName(std::string("Injected display for ") + 632 test_info->test_case_name() + "." + test_info->name()) 633 .build(); 634 635 auto compositionDisplay = 636 compositionengine::impl::createDisplay(test->mFlinger.getCompositionEngine(), 637 ceDisplayArgs); 638 639 // Insert display data so that the HWC thinks it created the virtual display. 640 test->mFlinger.mutableHwcDisplayData().try_emplace(displayId); 641 642 return compositionDisplay; 643 } 644 645 static void setupNativeWindowSurfaceCreationCallExpectations(DisplayTransactionTest* test) { 646 Base::setupNativeWindowSurfaceCreationCallExpectations(test); 647 EXPECT_CALL(*test->mNativeWindow, setSwapInterval(0)).Times(1); 648 } 649 650 static void setupHwcVirtualDisplayCreationCallExpectations(DisplayTransactionTest* test) { 651 EXPECT_CALL(*test->mComposer, createVirtualDisplay(Base::WIDTH, Base::HEIGHT, _, _)) 652 .WillOnce(DoAll(SetArgPointee<3>(Self::HWC_DISPLAY_ID), Return(Error::NONE))); 653 EXPECT_CALL(*test->mComposer, setClientTargetSlotCount(_)).WillOnce(Return(Error::NONE)); 654 } 655 }; 656 657 // For this variant, the display is not a HWC display, so no HDR support should 658 // be configured. 659 struct NonHwcDisplayHdrSupportVariant { 660 static constexpr bool HDR10_PLUS_SUPPORTED = false; 661 static constexpr bool HDR10_SUPPORTED = false; 662 static constexpr bool HDR_HLG_SUPPORTED = false; 663 static constexpr bool HDR_DOLBY_VISION_SUPPORTED = false; 664 static void setupComposerCallExpectations(DisplayTransactionTest* test) { 665 EXPECT_CALL(*test->mComposer, getHdrCapabilities(_, _, _, _, _)).Times(0); 666 } 667 }; 668 669 // For this variant, the composer should respond with am empty list of HDR 670 // modes, so no HDR support should be configured. 671 template <typename Display> 672 struct HdrNotSupportedVariant { 673 static constexpr bool HDR10_PLUS_SUPPORTED = false; 674 static constexpr bool HDR10_SUPPORTED = false; 675 static constexpr bool HDR_HLG_SUPPORTED = false; 676 static constexpr bool HDR_DOLBY_VISION_SUPPORTED = false; 677 static void setupComposerCallExpectations(DisplayTransactionTest* test) { 678 EXPECT_CALL(*test->mComposer, getHdrCapabilities(Display::HWC_DISPLAY_ID, _, _, _, _)) 679 .WillOnce(DoAll(SetArgPointee<1>(std::vector<Hdr>()), Return(Error::NONE))); 680 } 681 }; 682 683 struct NonHwcPerFrameMetadataSupportVariant { 684 static constexpr int PER_FRAME_METADATA_KEYS = 0; 685 static void setupComposerCallExpectations(DisplayTransactionTest* test) { 686 EXPECT_CALL(*test->mComposer, getPerFrameMetadataKeys(_)).Times(0); 687 } 688 }; 689 690 template <typename Display> 691 struct NoPerFrameMetadataSupportVariant { 692 static constexpr int PER_FRAME_METADATA_KEYS = 0; 693 static void setupComposerCallExpectations(DisplayTransactionTest* test) { 694 EXPECT_CALL(*test->mComposer, getPerFrameMetadataKeys(Display::HWC_DISPLAY_ID)) 695 .WillOnce(Return(std::vector<PerFrameMetadataKey>())); 696 } 697 }; 698 699 // For this variant, SurfaceFlinger should configure itself with wide display 700 // support, but the display should respond with an empty list of supported color 701 // modes. Wide-color support for the display should not be configured. 702 template <typename Display> 703 struct WideColorNotSupportedVariant { 704 static constexpr bool WIDE_COLOR_SUPPORTED = false; 705 706 static void injectConfigChange(DisplayTransactionTest* test) { 707 test->mFlinger.mutableSupportsWideColor() = true; 708 } 709 710 static void setupComposerCallExpectations(DisplayTransactionTest* test) { 711 EXPECT_CALL(*test->mComposer, setColorMode(_, _, _)).Times(0); 712 } 713 }; 714 715 // For this variant, SurfaceFlinger should not configure itself with wide 716 // display support, so the display should not be configured for wide-color 717 // support. 718 struct WideColorSupportNotConfiguredVariant { 719 static constexpr bool WIDE_COLOR_SUPPORTED = false; 720 721 static void injectConfigChange(DisplayTransactionTest* test) { 722 test->mFlinger.mutableSupportsWideColor() = false; 723 test->mFlinger.mutableDisplayColorSetting() = DisplayColorSetting::kUnmanaged; 724 } 725 726 static void setupComposerCallExpectations(DisplayTransactionTest* test) { 727 EXPECT_CALL(*test->mComposer, getRenderIntents(_, _, _)).Times(0); 728 EXPECT_CALL(*test->mComposer, setColorMode(_, _, _)).Times(0); 729 } 730 }; 731 732 /* ------------------------------------------------------------------------ 733 * Typical display configurations to test 734 */ 735 736 template <typename DisplayPolicy, typename WideColorSupportPolicy, typename HdrSupportPolicy, 737 typename PerFrameMetadataSupportPolicy> 738 struct Case { 739 using Display = DisplayPolicy; 740 using WideColorSupport = WideColorSupportPolicy; 741 using HdrSupport = HdrSupportPolicy; 742 using PerFrameMetadataSupport = PerFrameMetadataSupportPolicy; 743 }; 744 745 using SimplePrimaryDisplayCase = 746 Case<PrimaryDisplayVariant, WideColorNotSupportedVariant<PrimaryDisplayVariant>, 747 HdrNotSupportedVariant<PrimaryDisplayVariant>, 748 NoPerFrameMetadataSupportVariant<PrimaryDisplayVariant>>; 749 using SimpleExternalDisplayCase = 750 Case<ExternalDisplayVariant, WideColorNotSupportedVariant<ExternalDisplayVariant>, 751 HdrNotSupportedVariant<ExternalDisplayVariant>, 752 NoPerFrameMetadataSupportVariant<ExternalDisplayVariant>>; 753 using SimpleTertiaryDisplayCase = 754 Case<TertiaryDisplayVariant, WideColorNotSupportedVariant<TertiaryDisplayVariant>, 755 HdrNotSupportedVariant<TertiaryDisplayVariant>, 756 NoPerFrameMetadataSupportVariant<TertiaryDisplayVariant>>; 757 758 using NonHwcVirtualDisplayCase = 759 Case<NonHwcVirtualDisplayVariant<1024, 768, Secure::FALSE>, 760 WideColorSupportNotConfiguredVariant, NonHwcDisplayHdrSupportVariant, 761 NonHwcPerFrameMetadataSupportVariant>; 762 using SimpleHwcVirtualDisplayVariant = HwcVirtualDisplayVariant<1024, 768, Secure::TRUE>; 763 using HwcVirtualDisplayCase = 764 Case<SimpleHwcVirtualDisplayVariant, WideColorSupportNotConfiguredVariant, 765 HdrNotSupportedVariant<SimpleHwcVirtualDisplayVariant>, 766 NoPerFrameMetadataSupportVariant<SimpleHwcVirtualDisplayVariant>>; 767 768 inline DisplayModePtr createDisplayMode(DisplayModeId modeId, Fps refreshRate, int32_t group = 0, 769 ui::Size resolution = ui::Size(1920, 1080)) { 770 return mock::createDisplayMode(modeId, refreshRate, group, resolution, 771 PrimaryDisplayVariant::DISPLAY_ID::get()); 772 } 773 774 } // namespace android 775 776 // TODO(b/129481165): remove the #pragma below and fix conversion issues 777 #pragma clang diagnostic pop // ignored "-Wconversion -Wextra" 778