// Copyright 2019 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ui/ozone/platform/drm/gpu/drm_overlay_manager.h"
#include "base/functional/bind.h"
#include "base/functional/callback.h"
#include "base/test/task_environment.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/ozone/public/overlay_surface_candidate.h"
namespace ui {
namespace {
constexpr gfx::AcceleratedWidget kPrimaryWidget = 1;
constexpr gfx::AcceleratedWidget kSecondaryWidget = 2;
class TestDrmOverlayManager : public DrmOverlayManager {
public:
explicit TestDrmOverlayManager(
bool allow_sync_and_real_buffer_page_flip_testing)
: DrmOverlayManager(/*handle_overlays_swap_failure=*/false,
allow_sync_and_real_buffer_page_flip_testing) {}
TestDrmOverlayManager(bool handle_overlays_swap_failure,
bool allow_sync_and_real_buffer_page_flip_testing)
: DrmOverlayManager(handle_overlays_swap_failure,
allow_sync_and_real_buffer_page_flip_testing) {}
TestDrmOverlayManager() : TestDrmOverlayManager(false) {}
~TestDrmOverlayManager() override = default;
using DrmOverlayManager::UpdateCacheForOverlayCandidates;
std::vector<std::vector<OverlaySurfaceCandidate>>& requests() {
return requests_;
}
// DrmOverlayManager:
void SendOverlayValidationRequest(
const std::vector<OverlaySurfaceCandidate>& candidates,
gfx::AcceleratedWidget widget) override {
requests_.push_back(candidates);
}
std::vector<OverlayStatus> SendOverlayValidationRequestSync(
const std::vector<OverlaySurfaceCandidate>& candidates,
gfx::AcceleratedWidget widget) override {
requests_.push_back(candidates);
std::vector<OverlayStatus> status;
status.reserve(candidates.size());
for (size_t i = 0; i < candidates.size(); i++) {
status.emplace_back(candidates[i].overlay_handled
? OverlayStatus::OVERLAY_STATUS_ABLE
: OverlayStatus::OVERLAY_STATUS_NOT);
}
return status;
}
void GetHardwareCapabilities(
gfx::AcceleratedWidget widget,
HardwareCapabilitiesCallback& receive_callback) override {
HardwareCapabilities hardware_capabilities;
hardware_capabilities.num_overlay_capable_planes = num_planes_response_;
// Immediately respond to the callback.
receive_callback.Run(hardware_capabilities);
}
base::TimeTicks GetDisallowFullscreenOverlaysEndTime() const {
return disallow_fullscreen_overlays_end_time();
}
int num_planes_response_ = 0;
private:
std::vector<std::vector<OverlaySurfaceCandidate>> requests_;
};
OverlaySurfaceCandidate CreateCandidate(const gfx::Rect& rect,
int plane_z_order) {
OverlaySurfaceCandidate candidate;
candidate.transform = gfx::OVERLAY_TRANSFORM_NONE;
candidate.format = gfx::BufferFormat::YUV_420_BIPLANAR;
candidate.plane_z_order = plane_z_order;
candidate.buffer_size = rect.size();
candidate.display_rect = gfx::RectF(rect);
candidate.crop_rect = gfx::RectF(rect);
return candidate;
}
class DrmOverlayManagerTest : public testing::Test {
public:
DrmOverlayManagerTest() = default;
void SetUp() override {
manager_.SetSupportedBufferFormats(kPrimaryWidget,
{gfx::BufferFormat::YUV_420_BIPLANAR});
manager_.SetSupportedBufferFormats(kSecondaryWidget,
{gfx::BufferFormat::YUV_420_BIPLANAR});
}
protected:
TestDrmOverlayManager manager_;
};
} // namespace
TEST_F(DrmOverlayManagerTest, CacheLogic) {
// Candidates for output surface and single-on-top quad.
std::vector<OverlaySurfaceCandidate> candidates = {
CreateCandidate(gfx::Rect(0, 0, 100, 100), 0),
CreateCandidate(gfx::Rect(10, 10, 20, 20), 1)};
// The first three times that CheckOverlaySupport() is called for an overlay
// configuration it won't send a validation request.
for (int i = 0; i < 3; ++i) {
manager_.CheckOverlaySupport(&candidates, kPrimaryWidget);
EXPECT_FALSE(candidates[0].overlay_handled);
EXPECT_FALSE(candidates[1].overlay_handled);
EXPECT_EQ(manager_.requests().size(), 0u);
}
// The fourth call with the same overlay configuration should trigger a
// request to validate the configuration. Still assume the overlay
// configuration won't work until we get a response.
manager_.CheckOverlaySupport(&candidates, kPrimaryWidget);
EXPECT_FALSE(candidates[0].overlay_handled);
EXPECT_FALSE(candidates[1].overlay_handled);
EXPECT_EQ(manager_.requests().size(), 1u);
// While waiting for a response we shouldn't send the same request.
manager_.CheckOverlaySupport(&candidates, kPrimaryWidget);
EXPECT_FALSE(candidates[0].overlay_handled);
EXPECT_FALSE(candidates[1].overlay_handled);
ASSERT_EQ(manager_.requests().size(), 1u);
// Receive response that the overlay configuration will work.
manager_.UpdateCacheForOverlayCandidates(
manager_.requests().front(), kPrimaryWidget,
std::vector<OverlayStatus>(candidates.size(), OVERLAY_STATUS_ABLE));
manager_.requests().clear();
// CheckOverlaySupport() should now indicate the overlay configuration will
// work.
manager_.CheckOverlaySupport(&candidates, kPrimaryWidget);
EXPECT_TRUE(candidates[0].overlay_handled);
EXPECT_TRUE(candidates[1].overlay_handled);
EXPECT_EQ(manager_.requests().size(), 0u);
}
// Tests that the crop rect changing will make a new request.
TEST_F(DrmOverlayManagerTest, CropRectCacheLogic) {
// Candidates fo single-on-top quad.
std::vector<OverlaySurfaceCandidate> candidates = {
CreateCandidate(gfx::Rect(0, 0, 100, 100), 0)};
// The first three times won't send a validation request. The fourth will send
// a request.
for (int i = 0; i < 3; ++i) {
manager_.CheckOverlaySupport(&candidates, kPrimaryWidget);
EXPECT_FALSE(candidates.back().overlay_handled);
EXPECT_EQ(manager_.requests().size(), 0u);
}
manager_.CheckOverlaySupport(&candidates, kPrimaryWidget);
EXPECT_EQ(manager_.requests().size(), 1u);
// Receive response that the overlay configuration will work.
manager_.UpdateCacheForOverlayCandidates(
manager_.requests().front(), kPrimaryWidget,
std::vector<OverlayStatus>(candidates.size(), OVERLAY_STATUS_ABLE));
manager_.requests().clear();
// Overlay configuration should work.
manager_.CheckOverlaySupport(&candidates, kPrimaryWidget);
EXPECT_TRUE(candidates.back().overlay_handled);
// Now, adjust the crop rect.
candidates.back().overlay_handled = false;
candidates.back().crop_rect = gfx::RectF(0, 0, 0.5f, 0.5f);
// The first three times won't send a validation request. The fourth will send
// a request.
for (int i = 0; i < 3; ++i) {
manager_.CheckOverlaySupport(&candidates, kPrimaryWidget);
EXPECT_FALSE(candidates.back().overlay_handled);
EXPECT_EQ(manager_.requests().size(), 0u);
}
manager_.CheckOverlaySupport(&candidates, kPrimaryWidget);
EXPECT_EQ(manager_.requests().size(), 1u);
// Receive response that the overlay configuration won't work.
manager_.UpdateCacheForOverlayCandidates(
manager_.requests().front(), kPrimaryWidget,
std::vector<OverlayStatus>(candidates.size(), OVERLAY_STATUS_NOT));
manager_.requests().clear();
// Overlay configuration should not work.
manager_.CheckOverlaySupport(&candidates, kPrimaryWidget);
EXPECT_FALSE(candidates.back().overlay_handled);
}
TEST_F(DrmOverlayManagerTest, DifferentWidgetCache) {
// Candidates for output surface and single-on-top quad.
std::vector<OverlaySurfaceCandidate> candidates = {
CreateCandidate(gfx::Rect(0, 0, 100, 100), 0),
CreateCandidate(gfx::Rect(10, 10, 20, 20), 1)};
// Call 4 Times to go beyond the Throttle Request Size
ASSERT_EQ(manager_.requests().size(), 0u);
for (int i = 0; i < 4; ++i) {
manager_.CheckOverlaySupport(&candidates, kPrimaryWidget);
EXPECT_FALSE(candidates[0].overlay_handled);
EXPECT_FALSE(candidates[1].overlay_handled);
}
ASSERT_EQ(manager_.requests().size(), 1u);
// Receive response that the overlay configuration on kPrimaryWidget will
// work.
manager_.UpdateCacheForOverlayCandidates(
manager_.requests().front(), kPrimaryWidget,
std::vector<OverlayStatus>(candidates.size(), OVERLAY_STATUS_ABLE));
manager_.requests().clear();
// Overlay should not be handled when using a different widget
manager_.CheckOverlaySupport(&candidates, kSecondaryWidget);
EXPECT_FALSE(candidates[0].overlay_handled);
EXPECT_FALSE(candidates[1].overlay_handled);
EXPECT_EQ(manager_.requests().size(), 0u);
}
TEST_F(DrmOverlayManagerTest, MultipleWidgetCacheSupport) {
// Candidates for output surface and single-on-top quad.
std::vector<OverlaySurfaceCandidate> candidates = {
CreateCandidate(gfx::Rect(0, 0, 100, 100), 0),
CreateCandidate(gfx::Rect(10, 10, 20, 20), 1)};
// Call 4 Times to go beyond the Throttle Request Size
ASSERT_EQ(manager_.requests().size(), 0u);
for (int i = 0; i < 4; ++i) {
manager_.CheckOverlaySupport(&candidates, kPrimaryWidget);
EXPECT_FALSE(candidates[0].overlay_handled);
EXPECT_FALSE(candidates[1].overlay_handled);
manager_.CheckOverlaySupport(&candidates, kSecondaryWidget);
EXPECT_FALSE(candidates[0].overlay_handled);
EXPECT_FALSE(candidates[1].overlay_handled);
}
EXPECT_EQ(manager_.requests().size(), 2u);
// Receive response that the overlay configuration on kPrimaryWidget will
// work.
manager_.UpdateCacheForOverlayCandidates(
manager_.requests().front(), kPrimaryWidget,
std::vector<OverlayStatus>(candidates.size(), OVERLAY_STATUS_ABLE));
manager_.CheckOverlaySupport(&candidates, kPrimaryWidget);
EXPECT_TRUE(candidates[0].overlay_handled);
EXPECT_TRUE(candidates[1].overlay_handled);
// Receive response that the overlay configuration on kSecondaryWidget will
// work.
manager_.UpdateCacheForOverlayCandidates(
manager_.requests().front(), kSecondaryWidget,
std::vector<OverlayStatus>(candidates.size(), OVERLAY_STATUS_ABLE));
manager_.requests().clear();
// Both Widgets should be handled
manager_.CheckOverlaySupport(&candidates, kPrimaryWidget);
EXPECT_TRUE(candidates[0].overlay_handled);
EXPECT_TRUE(candidates[1].overlay_handled);
manager_.CheckOverlaySupport(&candidates, kSecondaryWidget);
EXPECT_TRUE(candidates[0].overlay_handled);
EXPECT_TRUE(candidates[1].overlay_handled);
EXPECT_EQ(manager_.requests().size(), 0u);
}
TEST_F(DrmOverlayManagerTest, DifferentWidgetsSameCandidatesAreDistinct) {
// Candidates for output surface and single-on-top quad.
std::vector<OverlaySurfaceCandidate> candidates = {
CreateCandidate(gfx::Rect(0, 0, 100, 100), 0),
CreateCandidate(gfx::Rect(10, 10, 20, 20), 1)};
// Looping 4 times, but each widget is only checked twice, below the Throttle
// Request Size (3).
for (int i = 0; i < 4; ++i) {
manager_.CheckOverlaySupport(&candidates,
i % 2 ? kPrimaryWidget : kSecondaryWidget);
}
EXPECT_EQ(manager_.requests().size(), 0u);
}
TEST_F(DrmOverlayManagerTest, NonIntegerDisplayRect) {
// Candidates for output surface and single-on-top quad.
std::vector<OverlaySurfaceCandidate> candidates = {
CreateCandidate(gfx::Rect(0, 0, 100, 100), 0),
CreateCandidate(gfx::Rect(10, 10, 20, 20), 1)};
// Submit a set of candidates that could potentially be displayed in an
// overlay so they are stored in the cache. This ensures a comparison gets
// made adding the next value to the cache.
manager_.CheckOverlaySupport(&candidates, kPrimaryWidget);
// Modify the display_rect for the second candidate so it's non-integer. We
// will never try to promote this to an overlay but something will get stored
// in the cache. This verifies we don't try to convert the non-integer RectF
// into a Rect which DCHECKs.
candidates[1].display_rect = gfx::RectF(9.4, 10.43, 20.11, 20.99);
manager_.CheckOverlaySupport(&candidates, kPrimaryWidget);
}
TEST_F(DrmOverlayManagerTest, RequiredOverlayMultiDisplay) {
// Primary has a requirement, secondary does not, should only make a request
// on the primary.
std::vector<OverlaySurfaceCandidate> candidates1 = {
CreateCandidate(gfx::Rect(0, 0, 100, 100), 0)};
manager_.RegisterOverlayRequirement(kPrimaryWidget, true);
manager_.RegisterOverlayRequirement(kSecondaryWidget, false);
// Call 4 Times to go beyond the Throttle Request Size
for (int i = 0; i < 4; ++i)
manager_.CheckOverlaySupport(&candidates1, kPrimaryWidget);
EXPECT_EQ(manager_.requests().size(), 1u);
// Call 4 Times to go beyond the Throttle Request Size
for (int i = 0; i < 4; ++i)
manager_.CheckOverlaySupport(&candidates1, kSecondaryWidget);
EXPECT_EQ(manager_.requests().size(), 1u);
manager_.requests().clear();
// Secondary has a requirement, primary does not, should only make a request
// on the secondary.
std::vector<OverlaySurfaceCandidate> candidates2 = {
CreateCandidate(gfx::Rect(0, 0, 200, 200), 0)};
manager_.RegisterOverlayRequirement(kPrimaryWidget, false);
manager_.RegisterOverlayRequirement(kSecondaryWidget, true);
// Call 4 Times to go beyond the Throttle Request Size
for (int i = 0; i < 4; ++i)
manager_.CheckOverlaySupport(&candidates2, kPrimaryWidget);
EXPECT_TRUE(manager_.requests().empty());
// Call 4 Times to go beyond the Throttle Request Size
for (int i = 0; i < 4; ++i)
manager_.CheckOverlaySupport(&candidates2, kSecondaryWidget);
EXPECT_EQ(manager_.requests().size(), 1u);
}
TEST_F(DrmOverlayManagerTest, ObservingHardwareCapabilities) {
manager_.num_planes_response_ = 2;
int primary_calls = 0;
HardwareCapabilitiesCallback primary_callback = base::BindRepeating(
[](int* calls, HardwareCapabilities hc) {
(*calls)++;
EXPECT_EQ(hc.num_overlay_capable_planes, 2);
},
&primary_calls);
manager_.StartObservingHardwareCapabilities(kPrimaryWidget, primary_callback);
EXPECT_EQ(primary_calls, 1);
manager_.DisplaysConfigured();
EXPECT_EQ(primary_calls, 2);
int secondary_calls = 0;
HardwareCapabilitiesCallback secondary_callback = base::BindRepeating(
[](int* calls, HardwareCapabilities hc) {
(*calls)++;
EXPECT_EQ(hc.num_overlay_capable_planes, 2);
},
&secondary_calls);
manager_.StartObservingHardwareCapabilities(kSecondaryWidget,
secondary_callback);
// Only the secondary callback should be called.
EXPECT_EQ(primary_calls, 2);
EXPECT_EQ(secondary_calls, 1);
manager_.DisplaysConfigured();
// Both callbacks are called.
EXPECT_EQ(primary_calls, 3);
EXPECT_EQ(secondary_calls, 2);
manager_.StopObservingHardwareCapabilities(kPrimaryWidget);
manager_.DisplaysConfigured();
manager_.DisplaysConfigured();
// The primary callback won't be called anymore.
EXPECT_EQ(primary_calls, 3);
EXPECT_EQ(secondary_calls, 4);
}
TEST_F(DrmOverlayManagerTest, SingleClipRectUnderlaySupport) {
// Candidates for output surface and underlay quad.
std::vector<OverlaySurfaceCandidate> candidates = {
CreateCandidate(gfx::Rect(0, 0, 100, 100), 0),
CreateCandidate(gfx::Rect(10, 10, 20, 20), -1)};
// Set a clip rect that imposes a restriction on |display_rect|.
candidates[1].clip_rect = gfx::Rect(10, 10, 15, 15);
for (int i = 0; i < 4; i++)
manager_.CheckOverlaySupport(&candidates, kPrimaryWidget);
EXPECT_EQ(manager_.requests().size(), 1u);
EXPECT_TRUE(manager_.requests()[0][1].overlay_handled);
manager_.requests().clear();
// Now make the overlay candidate a single-on-top overlay. Single-on-top
// overlays with restrictive clip rects are not supported.
candidates[1].plane_z_order = 1;
for (int i = 0; i < 4; i++)
manager_.CheckOverlaySupport(&candidates, kPrimaryWidget);
EXPECT_EQ(manager_.requests().size(), 1u);
EXPECT_FALSE(manager_.requests()[0][1].overlay_handled);
}
TEST_F(DrmOverlayManagerTest, MultiClipRectUnderlaySupport) {
// Two underlay quads who's |display_rect| overlap. The order here is
// important; even though the -2 underlay comes first in the list it will be
// occluded by the -1 underlay and when -1 clipped the -2 underlay should
// fail.
std::vector<OverlaySurfaceCandidate> candidates = {
CreateCandidate(gfx::Rect(0, 0, 100, 100), 0),
CreateCandidate(gfx::Rect(10, 10, 20, 20), -2),
CreateCandidate(gfx::Rect(20, 20, 20, 20), -1)};
// Set a clip rect that imposes a restriction on |display_rect|.
candidates[1].clip_rect = gfx::Rect(10, 10, 15, 15);
candidates[2].clip_rect = gfx::Rect(20, 20, 15, 15);
for (int i = 0; i < 4; i++)
manager_.CheckOverlaySupport(&candidates, kPrimaryWidget);
EXPECT_EQ(manager_.requests().size(), 1u);
EXPECT_FALSE(manager_.requests()[0][1].overlay_handled);
EXPECT_TRUE(manager_.requests()[0][2].overlay_handled);
manager_.requests().clear();
// Now remove the clipping constraint on the -1 underlay which should allow
// the -2 underlay to be handled.
candidates[2].clip_rect = gfx::Rect(20, 20, 50, 50);
for (int i = 0; i < 4; i++)
manager_.CheckOverlaySupport(&candidates, kPrimaryWidget);
EXPECT_EQ(manager_.requests().size(), 1u);
EXPECT_TRUE(manager_.requests()[0][1].overlay_handled);
EXPECT_TRUE(manager_.requests()[0][2].overlay_handled);
}
TEST_F(DrmOverlayManagerTest, SupportedBufferFormat) {
// Make the manager to use sync testing for convenience.
TestDrmOverlayManager manager(true);
manager.SetSupportedBufferFormats(
kPrimaryWidget,
{gfx::BufferFormat::BGRA_8888, gfx::BufferFormat::RGBA_8888});
manager.SetSupportedBufferFormats(kSecondaryWidget,
{gfx::BufferFormat::YUV_420_BIPLANAR});
std::vector<OverlaySurfaceCandidate> candidates = {
CreateCandidate(gfx::Rect(0, 0, 150, 150), -1),
CreateCandidate(gfx::Rect(0, 0, 100, 100), 0),
CreateCandidate(gfx::Rect(10, 10, 20, 20), 1)};
candidates[0].format = gfx::BufferFormat::RGBA_8888;
candidates[1].format = gfx::BufferFormat::YUV_420_BIPLANAR;
candidates[2].format = gfx::BufferFormat::BGRA_8888;
// Primary widget supports BGRA/RGBA only.
manager.CheckOverlaySupport(&candidates, kPrimaryWidget);
EXPECT_TRUE(candidates[0].overlay_handled);
EXPECT_FALSE(candidates[1].overlay_handled);
EXPECT_TRUE(candidates[2].overlay_handled);
EXPECT_EQ(manager.requests().size(), 1u);
auto reset_candidates = [](std::vector<OverlaySurfaceCandidate>& candidates) {
for (auto& candidate : candidates) {
candidate.overlay_handled = false;
}
};
manager.requests().clear();
reset_candidates(candidates);
// Secondary widget supports N12 only.
manager.CheckOverlaySupport(&candidates, kSecondaryWidget);
EXPECT_FALSE(candidates[0].overlay_handled);
EXPECT_TRUE(candidates[1].overlay_handled);
EXPECT_FALSE(candidates[2].overlay_handled);
EXPECT_EQ(manager.requests().size(), 1u);
manager.requests().clear();
reset_candidates(candidates);
// Make primary widget support more buffer formats.
manager.SetSupportedBufferFormats(
kPrimaryWidget,
{gfx::BufferFormat::YUV_420_BIPLANAR, gfx::BufferFormat::BGRA_8888,
gfx::BufferFormat::RGBA_8888});
// Primary widget supports BGRA/RGBA and NV12 now.
manager.CheckOverlaySupport(&candidates, kPrimaryWidget);
EXPECT_TRUE(candidates[0].overlay_handled);
EXPECT_TRUE(candidates[1].overlay_handled);
EXPECT_TRUE(candidates[2].overlay_handled);
EXPECT_EQ(manager.requests().size(), 1u);
}
// Verifies that the |TestDrmOverlayManager| uses fast path for fullscreen
// overlays. That is, if |handle_overlays_swap_failure| is enabled, it marks
// fullscreen overlays as suitable candidates, but once it gets a swap failure
// notification, it fallbacks to drm testing.
TEST_F(DrmOverlayManagerTest, HandleFastPathFullScreenOverlays) {
base::test::SingleThreadTaskEnvironment env(
base::test::TaskEnvironment::TimeSource::MOCK_TIME);
TestDrmOverlayManager manager(
/*handle_overlays_swap_failure=*/true,
/*allow_sync_and_real_buffer_page_flip_testing=*/true);
manager.SetSupportedBufferFormats(kPrimaryWidget,
{gfx::BufferFormat::YUV_420_BIPLANAR});
// Check overlay support and expect fullscreen is handled without any requests
// for overlays' validation sent.
std::vector<OverlaySurfaceCandidate> candidates = {
CreateCandidate(gfx::Rect(0, 0, 100, 100), 0)};
candidates.front().overlay_type = gfx::OverlayType::kFullScreen;
manager.CheckOverlaySupport(&candidates, kPrimaryWidget);
EXPECT_EQ(manager.requests().size(), 0u);
EXPECT_TRUE(candidates.front().overlay_handled);
// Notify the manager that the fullscreen overlay were promoted and the
// next swap is a fullscreen one.
manager.OnPromotedOverlayTypes({gfx::OverlayType::kFullScreen});
// Store the current time and use it later to fast forward it.
const auto time_now = base::TimeTicks::Now();
// The swap has failed. The manager must stop fullscreen overlays' promotion.
manager.OnSwapBuffersComplete(
gfx::SwapResult::SWAP_NON_SIMPLE_OVERLAYS_FAILED);
EXPECT_TRUE(!manager.GetDisallowFullscreenOverlaysEndTime().is_null());
// Now that the previous fullscreen overlay's swap failed, the manager must
// fallback to drm test for these overlays as well.
std::vector<OverlaySurfaceCandidate> candidates2 = {
CreateCandidate(gfx::Rect(0, 0, 100, 100), 0)};
candidates2.front().overlay_type = gfx::OverlayType::kFullScreen;
manager.CheckOverlaySupport(&candidates, kPrimaryWidget);
// As expected, there are validation requests.
EXPECT_EQ(manager.requests().size(), 1u);
EXPECT_TRUE(candidates.front().overlay_handled);
manager.requests().clear();
// Fast forward the time as the manager waits X hours until it can promote
// the fullscreen overlays again.
size_t kFastForwardAttempts = 5;
while (!manager.GetDisallowFullscreenOverlaysEndTime().is_null()) {
env.FastForwardBy(manager.GetDisallowFullscreenOverlaysEndTime() -
time_now);
// Break in case if something goes very wrong.
if (--kFastForwardAttempts <= 0) {
break;
}
}
std::vector<OverlaySurfaceCandidate> candidates3 = {
CreateCandidate(gfx::Rect(0, 0, 100, 100), 0)};
candidates3.front().overlay_type = gfx::OverlayType::kFullScreen;
manager.CheckOverlaySupport(&candidates, kPrimaryWidget);
// Sanity check.
ASSERT_TRUE(manager.GetDisallowFullscreenOverlaysEndTime().is_null());
// As expected, there are no validation requests now and fullscreen overlays
// can be promoted without validation now.
EXPECT_EQ(manager.requests().size(), 0u);
EXPECT_TRUE(candidates.front().overlay_handled);
}
} // namespace ui
Codebase Browser
chromium