Commit ea959b13 authored by dcastagna's avatar dcastagna Committed by Commit bot

cc: Add OverlayStrategyFullscreen strategy.

Add an overlay strategy that promotes a single quad to an
overlay iff the buffer that backs the quad can be directly used
as main framebuffer.

BUG=b/29430506
CQ_INCLUDE_TRYBOTS=master.tryserver.blink:linux_blink_rel

Review-Url: https://codereview.chromium.org/2168693002
Cr-Commit-Position: refs/heads/master@{#406676}
parent 2677c697
......@@ -244,6 +244,8 @@ component("cc") {
"output/overlay_candidate_validator.h",
"output/overlay_processor.cc",
"output/overlay_processor.h",
"output/overlay_strategy_fullscreen.cc",
"output/overlay_strategy_fullscreen.h",
"output/overlay_strategy_single_on_top.cc",
"output/overlay_strategy_single_on_top.h",
"output/overlay_strategy_underlay.cc",
......
......@@ -305,6 +305,8 @@
'output/overlay_candidate_validator.h',
'output/overlay_processor.cc',
'output/overlay_processor.h',
'output/overlay_strategy_fullscreen.cc',
'output/overlay_strategy_fullscreen.h',
'output/overlay_strategy_single_on_top.cc',
'output/overlay_strategy_single_on_top.h',
'output/overlay_strategy_underlay.cc',
......
......@@ -217,9 +217,11 @@ bool OverlayCandidate::FromDrawQuad(ResourceProvider* resource_provider,
// static
bool OverlayCandidate::IsInvisibleQuad(const DrawQuad* quad) {
float opacity = quad->shared_quad_state->opacity;
if (opacity < std::numeric_limits<float>::epsilon())
return true;
if (quad->material == DrawQuad::SOLID_COLOR) {
SkColor color = SolidColorDrawQuad::MaterialCast(quad)->color;
float opacity = quad->shared_quad_state->opacity;
float alpha = (SkColorGetA(color) * (1.0f / 255.0f)) * opacity;
return quad->ShouldDrawWithBlending() &&
alpha < std::numeric_limits<float>::epsilon();
......
// Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "cc/output/overlay_strategy_fullscreen.h"
#include "cc/base/math_util.h"
#include "cc/output/overlay_candidate_validator.h"
#include "cc/quads/draw_quad.h"
#include "cc/quads/solid_color_draw_quad.h"
#include "ui/gfx/geometry/rect_conversions.h"
#include "ui/gfx/geometry/size_conversions.h"
namespace cc {
OverlayStrategyFullscreen::OverlayStrategyFullscreen() {}
OverlayStrategyFullscreen::~OverlayStrategyFullscreen() {}
bool OverlayStrategyFullscreen::Attempt(ResourceProvider* resource_provider,
RenderPass* render_pass,
OverlayCandidateList* candidate_list) {
QuadList* quad_list = &render_pass->quad_list;
// First quad of quad_list is the top most quad.
auto front = quad_list->begin();
while (front != quad_list->end()) {
if (!OverlayCandidate::IsInvisibleQuad(*front))
break;
front++;
}
if (front == quad_list->end())
return false;
OverlayCandidate candidate;
if (!OverlayCandidate::FromDrawQuad(resource_provider, *front, &candidate)) {
return false;
}
if (candidate.transform != gfx::OVERLAY_TRANSFORM_NONE) {
return false;
}
if (!candidate.display_rect.origin().IsOrigin() ||
gfx::ToRoundedSize(candidate.display_rect.size()) !=
render_pass->output_rect.size() ||
render_pass->output_rect.size() != candidate.resource_size_in_pixels) {
return false;
}
candidate.plane_z_order = 1;
candidate.overlay_handled = true;
candidate_list->push_back(candidate);
quad_list->EraseAndInvalidateAllPointers(quad_list->begin());
return true;
}
} // namespace cc
// Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CC_OUTPUT_OVERLAY_STRATEGY_FULLSCREEN_H_
#define CC_OUTPUT_OVERLAY_STRATEGY_FULLSCREEN_H_
#include "base/macros.h"
#include "cc/output/overlay_processor.h"
namespace cc {
class OverlayCandidateValidator;
// Overlay strategy to promote a single full screen quad to an overlay.
// The promoted quad should have all the property of the framebuffer and it
// should be possible to use it as such.
class CC_EXPORT OverlayStrategyFullscreen : public OverlayProcessor::Strategy {
public:
OverlayStrategyFullscreen();
~OverlayStrategyFullscreen() override;
bool Attempt(ResourceProvider* resource_provider,
RenderPass* render_pass,
OverlayCandidateList* candidate_list) override;
private:
DISALLOW_COPY_AND_ASSIGN(OverlayStrategyFullscreen);
};
} // namespace cc
#endif // CC_OUTPUT_OVERLAY_STRATEGY_FULLSCREEN_H_
......@@ -15,6 +15,7 @@
#include "cc/output/output_surface_client.h"
#include "cc/output/overlay_candidate_validator.h"
#include "cc/output/overlay_processor.h"
#include "cc/output/overlay_strategy_fullscreen.h"
#include "cc/output/overlay_strategy_single_on_top.h"
#include "cc/output/overlay_strategy_underlay.h"
#include "cc/quads/render_pass.h"
......@@ -61,6 +62,18 @@ void MailboxReleased(const gpu::SyncToken& sync_token,
bool lost_resource,
BlockingTaskRunner* main_thread_task_runner) {}
class FullscreenOverlayValidator : public OverlayCandidateValidator {
public:
void GetStrategies(OverlayProcessor::StrategyList* strategies) override {
strategies->push_back(base::WrapUnique(new OverlayStrategyFullscreen()));
}
bool AllowCALayerOverlays() override { return false; }
void CheckOverlaySupport(OverlayCandidateList* surfaces) override {
// We're not checking for support.
ASSERT_TRUE(false);
}
};
class SingleOverlayValidator : public OverlayCandidateValidator {
public:
void GetStrategies(OverlayProcessor::StrategyList* strategies) override {
......@@ -231,7 +244,7 @@ TextureDrawQuad* CreateCandidateQuadAt(ResourceProvider* resource_provider,
bool flipped = false;
bool nearest_neighbor = false;
float vertex_opacity[4] = {1.0f, 1.0f, 1.0f, 1.0f};
gfx::Size resource_size_in_pixels = gfx::Size(64, 64);
gfx::Size resource_size_in_pixels = rect.size();
bool is_overlay_candidate = true;
ResourceId resource_id = CreateResource(
resource_provider, resource_size_in_pixels, is_overlay_candidate);
......@@ -253,7 +266,7 @@ StreamVideoDrawQuad* CreateCandidateVideoQuadAt(
RenderPass* render_pass,
const gfx::Rect& rect,
const gfx::Transform& transform) {
gfx::Size resource_size_in_pixels = gfx::Size(64, 64);
gfx::Size resource_size_in_pixels = rect.size();
bool is_overlay_candidate = true;
ResourceId resource_id = CreateResource(
resource_provider, resource_size_in_pixels, is_overlay_candidate);
......@@ -357,6 +370,7 @@ class OverlayTest : public testing::Test {
gfx::Rect damage_rect_;
};
typedef OverlayTest<FullscreenOverlayValidator> FullscreenOverlayTest;
typedef OverlayTest<SingleOnTopOverlayValidator> SingleOverlayOnTopTest;
typedef OverlayTest<UnderlayOverlayValidator> UnderlayTest;
typedef OverlayTest<CALayerValidator> CALayerOverlayTest;
......@@ -389,6 +403,94 @@ TEST(OverlayTest, OverlaysProcessorHasStrategy) {
EXPECT_GE(2U, overlay_processor->GetStrategyCount());
}
TEST_F(FullscreenOverlayTest, SuccessfulOverlay) {
std::unique_ptr<RenderPass> pass = CreateRenderPass();
TextureDrawQuad* original_quad = CreateFullscreenCandidateQuad(
resource_provider_.get(), pass->shared_quad_state_list.back(),
pass.get());
unsigned original_resource_id = original_quad->resource_id();
// Add something behind it.
CreateFullscreenOpaqueQuad(resource_provider_.get(),
pass->shared_quad_state_list.back(), pass.get());
// Check for potential candidates.
OverlayCandidateList candidate_list;
overlay_processor_->ProcessForOverlays(resource_provider_.get(), pass.get(),
&candidate_list, nullptr,
&damage_rect_);
ASSERT_EQ(1U, candidate_list.size());
RenderPass* main_pass = pass.get();
// Check that the quad is gone.
EXPECT_EQ(1U, main_pass->quad_list.size());
// Check that the right resource id got extracted.
EXPECT_EQ(original_resource_id, candidate_list.back().resource_id);
}
TEST_F(FullscreenOverlayTest, ResourceSizeInPixelsFail) {
std::unique_ptr<RenderPass> pass = CreateRenderPass();
TextureDrawQuad* original_quad = CreateFullscreenCandidateQuad(
resource_provider_.get(), pass->shared_quad_state_list.back(),
pass.get());
original_quad->set_resource_size_in_pixels(gfx::Size(64, 64));
// Check for potential candidates.
OverlayCandidateList candidate_list;
overlay_processor_->ProcessForOverlays(resource_provider_.get(), pass.get(),
&candidate_list, nullptr,
&damage_rect_);
ASSERT_EQ(0U, candidate_list.size());
RenderPass* main_pass = pass.get();
// Check that the quad is not gone.
EXPECT_EQ(1U, main_pass->quad_list.size());
}
TEST_F(FullscreenOverlayTest, OnTopFail) {
std::unique_ptr<RenderPass> pass = CreateRenderPass();
// Add something in front of it.
CreateOpaqueQuadAt(resource_provider_.get(),
pass->shared_quad_state_list.back(), pass.get(),
kOverlayTopLeftRect);
CreateFullscreenCandidateQuad(resource_provider_.get(),
pass->shared_quad_state_list.back(),
pass.get());
// Check for potential candidates.
OverlayCandidateList candidate_list;
overlay_processor_->ProcessForOverlays(resource_provider_.get(), pass.get(),
&candidate_list, nullptr,
&damage_rect_);
ASSERT_EQ(0U, candidate_list.size());
RenderPass* main_pass = pass.get();
// Check that the 2 quads are not gone.
EXPECT_EQ(2U, main_pass->quad_list.size());
}
TEST_F(FullscreenOverlayTest, NotCoveringFullscreenFail) {
std::unique_ptr<RenderPass> pass = CreateRenderPass();
gfx::Rect inset_rect = pass->output_rect;
inset_rect.Inset(0, 1, 0, 1);
CreateCandidateQuadAt(resource_provider_.get(),
pass->shared_quad_state_list.back(), pass.get(),
inset_rect);
// Check for potential candidates.
OverlayCandidateList candidate_list;
overlay_processor_->ProcessForOverlays(resource_provider_.get(), pass.get(),
&candidate_list, nullptr,
&damage_rect_);
ASSERT_EQ(0U, candidate_list.size());
RenderPass* main_pass = pass.get();
// Check that the quad is not gone.
EXPECT_EQ(1U, main_pass->quad_list.size());
}
TEST_F(SingleOverlayOnTopTest, SuccessfulOverlay) {
std::unique_ptr<RenderPass> pass = CreateRenderPass();
TextureDrawQuad* original_quad =
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment