cc/output/gl_renderer_unittest.cc - Issue 2399713003: cc: Replace viewport/clip rect with a viewport size for DirectRenderer

Unified Diff: cc/output/gl_renderer_unittest.cc

Issue 2399713003: cc: Replace viewport/clip rect with a viewport size for DirectRenderer (Closed)

Patch Set: Created 4 years, 2 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Index: cc/output/gl_renderer_unittest.cc

diff --git a/cc/output/gl_renderer_unittest.cc b/cc/output/gl_renderer_unittest.cc

index d687acb216cb3616eb89d0fcf00fe6c87eb66640..c42ece44855aa389b493f344804ea67029e1e928 100644

--- a/cc/output/gl_renderer_unittest.cc

+++ b/cc/output/gl_renderer_unittest.cc

@@ -64,15 +64,9 @@ class GLRendererTest : public testing::Test {

RenderPass* root_render_pass() {

return render_passes_in_draw_order_.back().get();

}

- void DrawFrame(GLRenderer* renderer, const gfx::Rect& viewport_rect) {

+ void DrawFrame(GLRenderer* renderer, const gfx::Size& viewport_size) {

renderer->DrawFrame(&render_passes_in_draw_order_, 1.f, gfx::ColorSpace(),

- viewport_rect, viewport_rect);

- }

- void DrawFrame(GLRenderer* renderer,

- const gfx::Rect& viewport_rect,

- const gfx::Rect& clip_rect) {

- renderer->DrawFrame(&render_passes_in_draw_order_, 1.f, gfx::ColorSpace(),

- viewport_rect, clip_rect);

+ viewport_size);

}

RenderPassList render_passes_in_draw_order_;

@@ -492,17 +486,17 @@ class GLRendererShaderTest : public GLRendererTest {

namespace {

TEST_F(GLRendererWithDefaultHarnessTest, ExternalStencil) {

- gfx::Rect viewport_rect(1, 1);

+ gfx::Size viewport_size(1, 1);

EXPECT_FALSE(renderer_->stencil_enabled());

output_surface_->set_has_external_stencil_test(true);

RenderPass* root_pass =

AddRenderPass(&render_passes_in_draw_order_, RenderPassId(1, 0),

- viewport_rect, gfx::Transform());

+ gfx::Rect(viewport_size), gfx::Transform());

root_pass->has_transparent_background = false;

- DrawFrame(renderer_.get(), viewport_rect);

+ DrawFrame(renderer_.get(), viewport_size);

EXPECT_TRUE(renderer_->stencil_enabled());

}

@@ -686,10 +680,10 @@ TEST_F(GLRendererTest, OpaqueBackground) {

renderer.Initialize();

renderer.SetVisible(true);

- gfx::Rect viewport_rect(1, 1);

+ gfx::Size viewport_size(1, 1);

RenderPass* root_pass =

AddRenderPass(&render_passes_in_draw_order_, RenderPassId(1, 0),

- viewport_rect, gfx::Transform());

+ gfx::Rect(viewport_size), gfx::Transform());

root_pass->has_transparent_background = false;

// On DEBUG builds, render passes with opaque background clear to blue to

@@ -702,7 +696,7 @@ TEST_F(GLRendererTest, OpaqueBackground) {

#else

EXPECT_CALL(*context, clear(_)).Times(1);

#endif

- DrawFrame(&renderer, viewport_rect);

+ DrawFrame(&renderer, viewport_size);

Mock::VerifyAndClearExpectations(context);

}

@@ -727,15 +721,15 @@ TEST_F(GLRendererTest, TransparentBackground) {

renderer.Initialize();

renderer.SetVisible(true);

- gfx::Rect viewport_rect(1, 1);

+ gfx::Size viewport_size(1, 1);

RenderPass* root_pass =

AddRenderPass(&render_passes_in_draw_order_, RenderPassId(1, 0),

- viewport_rect, gfx::Transform());

+ gfx::Rect(viewport_size), gfx::Transform());

root_pass->has_transparent_background = true;

EXPECT_CALL(*context, discardFramebufferEXT(GL_FRAMEBUFFER, 1, _)).Times(1);

EXPECT_CALL(*context, clear(_)).Times(1);

- DrawFrame(&renderer, viewport_rect);

+ DrawFrame(&renderer, viewport_size);

Mock::VerifyAndClearExpectations(context);

}

@@ -761,17 +755,15 @@ TEST_F(GLRendererTest, OffscreenOutputSurface) {

renderer.Initialize();

renderer.SetVisible(true);

- gfx::Rect viewport_rect(1, 1);

- AddRenderPass(&render_passes_in_draw_order_,

- RenderPassId(1, 0),

- viewport_rect,

- gfx::Transform());

+ gfx::Size viewport_size(1, 1);

+ AddRenderPass(&render_passes_in_draw_order_, RenderPassId(1, 0),

+ gfx::Rect(viewport_size), gfx::Transform());

EXPECT_CALL(*context, discardFramebufferEXT(GL_FRAMEBUFFER, _, _))

.With(Args<2, 1>(ElementsAre(GL_COLOR_ATTACHMENT0)))

.Times(1);

EXPECT_CALL(*context, clear(_)).Times(AnyNumber());

- DrawFrame(&renderer, viewport_rect);

+ DrawFrame(&renderer, viewport_size);

Mock::VerifyAndClearExpectations(context);

}

@@ -866,8 +858,8 @@ TEST_F(GLRendererTest, ActiveTextureState) {

EXPECT_CALL(*context, drawElements(_, _, _, _)).Times(5);

}

- gfx::Rect viewport_rect(100, 100);

- DrawFrame(&renderer, viewport_rect);

+ gfx::Size viewport_size(100, 100);

+ DrawFrame(&renderer, viewport_size);

Mock::VerifyAndClearExpectations(context);

}

@@ -902,20 +894,19 @@ TEST_F(GLRendererTest, ShouldClearRootRenderPass) {

renderer.Initialize();

renderer.SetVisible(true);

- gfx::Rect viewport_rect(10, 10);

+ gfx::Size viewport_size(10, 10);

RenderPassId child_pass_id(2, 0);

RenderPass* child_pass =

- AddRenderPass(&render_passes_in_draw_order_, child_pass_id, viewport_rect,

- gfx::Transform());

- AddQuad(child_pass, viewport_rect, SK_ColorBLUE);

+ AddRenderPass(&render_passes_in_draw_order_, child_pass_id,

+ gfx::Rect(viewport_size), gfx::Transform());

+ AddQuad(child_pass, gfx::Rect(viewport_size), SK_ColorBLUE);

RenderPassId root_pass_id(1, 0);

RenderPass* root_pass =

- AddRenderPass(&render_passes_in_draw_order_, root_pass_id, viewport_rect,

- gfx::Transform());

- AddQuad(root_pass, viewport_rect, SK_ColorGREEN);

+ AddRenderPass(&render_passes_in_draw_order_, root_pass_id,

+ gfx::Rect(viewport_size), gfx::Transform());

+ AddQuad(root_pass, gfx::Rect(viewport_size), SK_ColorGREEN);

AddRenderPassQuad(root_pass, child_pass);

@@ -939,7 +930,7 @@ TEST_F(GLRendererTest, ShouldClearRootRenderPass) {

first_render_pass);

renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);

- DrawFrame(&renderer, viewport_rect);

+ DrawFrame(&renderer, viewport_size);

// In multiple render passes all but the root pass should clear the

// framebuffer.

@@ -987,7 +978,7 @@ TEST_F(GLRendererTest, ScissorTestWhenClearing) {

EXPECT_FALSE(renderer.use_partial_swap());

renderer.SetVisible(true);

- gfx::Rect viewport_rect(1, 1);

+ gfx::Size viewport_size(1, 1);

gfx::Rect grand_child_rect(25, 25);

RenderPassId grand_child_pass_id(3, 0);

@@ -1005,15 +996,15 @@ TEST_F(GLRendererTest, ScissorTestWhenClearing) {

RenderPassId root_pass_id(1, 0);

RenderPass* root_pass =

- AddRenderPass(&render_passes_in_draw_order_, root_pass_id, viewport_rect,

- gfx::Transform());

- AddQuad(root_pass, viewport_rect, SK_ColorGREEN);

+ AddRenderPass(&render_passes_in_draw_order_, root_pass_id,

+ gfx::Rect(viewport_size), gfx::Transform());

+ AddQuad(root_pass, gfx::Rect(viewport_size), SK_ColorGREEN);

AddRenderPassQuad(root_pass, child_pass);

AddRenderPassQuad(child_pass, grand_child_pass);

renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);

- DrawFrame(&renderer, viewport_rect);

+ DrawFrame(&renderer, viewport_size);

}

class DiscardCheckingGLES2Interface : public TestGLES2Interface {

@@ -1075,20 +1066,19 @@ TEST_F(GLRendererTest, NoDiscardOnPartialUpdates) {

EXPECT_TRUE(renderer.use_partial_swap());

renderer.SetVisible(true);

- gfx::Rect viewport_rect(100, 100);

- gfx::Rect clip_rect(100, 100);

+ gfx::Size viewport_size(100, 100);

{

// Partial frame, should not discard.

RenderPassId root_pass_id(1, 0);

RenderPass* root_pass =

AddRenderPass(&render_passes_in_draw_order_, root_pass_id,

- viewport_rect, gfx::Transform());

- AddQuad(root_pass, viewport_rect, SK_ColorGREEN);

+ gfx::Rect(viewport_size), gfx::Transform());

+ AddQuad(root_pass, gfx::Rect(viewport_size), SK_ColorGREEN);

root_pass->damage_rect = gfx::Rect(2, 2, 3, 3);

renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);

- DrawFrame(&renderer, viewport_rect, clip_rect);

+ DrawFrame(&renderer, viewport_size);

EXPECT_EQ(0, gl->discarded());

gl->reset_discarded();

}

@@ -1097,12 +1087,12 @@ TEST_F(GLRendererTest, NoDiscardOnPartialUpdates) {

RenderPassId root_pass_id(1, 0);

RenderPass* root_pass =

AddRenderPass(&render_passes_in_draw_order_, root_pass_id,

- viewport_rect, gfx::Transform());

- AddQuad(root_pass, viewport_rect, SK_ColorGREEN);

+ gfx::Rect(viewport_size), gfx::Transform());

+ AddQuad(root_pass, gfx::Rect(viewport_size), SK_ColorGREEN);

root_pass->damage_rect = root_pass->output_rect;

renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);

- DrawFrame(&renderer, viewport_rect, clip_rect);

+ DrawFrame(&renderer, viewport_size);

EXPECT_EQ(1, gl->discarded());

gl->reset_discarded();

}

@@ -1112,13 +1102,13 @@ TEST_F(GLRendererTest, NoDiscardOnPartialUpdates) {

RenderPassId root_pass_id(1, 0);

RenderPass* root_pass =

AddRenderPass(&render_passes_in_draw_order_, root_pass_id,

- viewport_rect, gfx::Transform());

- AddQuad(root_pass, viewport_rect, SK_ColorGREEN);

+ gfx::Rect(viewport_size), gfx::Transform());

+ AddQuad(root_pass, gfx::Rect(viewport_size), SK_ColorGREEN);

root_pass->damage_rect = root_pass->output_rect;

root_pass->has_transparent_background = false;

renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);

- DrawFrame(&renderer, viewport_rect, clip_rect);

+ DrawFrame(&renderer, viewport_size);

EXPECT_EQ(0, gl->discarded());

gl->reset_discarded();

output_surface->set_has_external_stencil_test(false);

@@ -1155,14 +1145,13 @@ TEST_F(GLRendererTest, DrawFramePreservesFramebuffer) {

EXPECT_FALSE(renderer.use_partial_swap());

renderer.SetVisible(true);

- gfx::Rect device_viewport_rect(0, 0, 100, 100);

- gfx::Rect viewport_rect(device_viewport_rect.size());

+ gfx::Size viewport_size(100, 100);

gfx::Rect quad_rect = gfx::Rect(20, 20, 20, 20);

RenderPassId root_pass_id(1, 0);

RenderPass* root_pass =

- AddRenderPass(&render_passes_in_draw_order_, root_pass_id, viewport_rect,

- gfx::Transform());

+ AddRenderPass(&render_passes_in_draw_order_, root_pass_id,

+ gfx::Rect(viewport_size), gfx::Transform());

AddClippedQuad(root_pass, quad_rect, SK_ColorGREEN);

unsigned fbo;

@@ -1172,7 +1161,7 @@ TEST_F(GLRendererTest, DrawFramePreservesFramebuffer) {

output_surface->set_framebuffer(fbo, GL_RGB);

renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);

- DrawFrame(&renderer, device_viewport_rect);

+ DrawFrame(&renderer, viewport_size);

int bound_fbo;

gl->GetIntegerv(GL_FRAMEBUFFER_BINDING, &bound_fbo);

@@ -1180,7 +1169,7 @@ TEST_F(GLRendererTest, DrawFramePreservesFramebuffer) {

}

TEST_F(GLRendererShaderTest, DrawRenderPassQuadShaderPermutations) {

- gfx::Rect viewport_rect(1, 1);

+ gfx::Size viewport_size(1, 1);

gfx::Rect child_rect(50, 50);

RenderPassId child_pass_id(2, 0);

@@ -1229,10 +1218,8 @@ TEST_F(GLRendererShaderTest, DrawRenderPassQuadShaderPermutations) {

child_rect,

gfx::Transform());

- root_pass = AddRenderPass(&render_passes_in_draw_order_,

- root_pass_id,

- viewport_rect,

- gfx::Transform());

+ root_pass = AddRenderPass(&render_passes_in_draw_order_, root_pass_id,

+ gfx::Rect(viewport_size), gfx::Transform());

AddRenderPassQuad(root_pass,

child_pass,

@@ -1243,7 +1230,7 @@ TEST_F(GLRendererShaderTest, DrawRenderPassQuadShaderPermutations) {

renderer_->DecideRenderPassAllocationsForFrame(

render_passes_in_draw_order_);

- DrawFrame(renderer_.get(), viewport_rect);

+ DrawFrame(renderer_.get(), viewport_size);

TestRenderPassProgram(TEX_COORD_PRECISION_MEDIUM, blend_mode);

// RenderPassColorMatrixProgram

@@ -1254,17 +1241,15 @@ TEST_F(GLRendererShaderTest, DrawRenderPassQuadShaderPermutations) {

child_rect,

transform_causing_aa);

- root_pass = AddRenderPass(&render_passes_in_draw_order_,

- root_pass_id,

- viewport_rect,

- gfx::Transform());

+ root_pass = AddRenderPass(&render_passes_in_draw_order_, root_pass_id,

+ gfx::Rect(viewport_size), gfx::Transform());

AddRenderPassQuad(

root_pass, child_pass, 0, filters, gfx::Transform(), xfer_mode);

renderer_->DecideRenderPassAllocationsForFrame(

render_passes_in_draw_order_);

- DrawFrame(renderer_.get(), viewport_rect);

+ DrawFrame(renderer_.get(), viewport_size);

TestRenderPassColorMatrixProgram(TEX_COORD_PRECISION_MEDIUM, blend_mode);

// RenderPassMaskProgram

@@ -1275,10 +1260,8 @@ TEST_F(GLRendererShaderTest, DrawRenderPassQuadShaderPermutations) {

child_rect,

gfx::Transform());

- root_pass = AddRenderPass(&render_passes_in_draw_order_,

- root_pass_id,

- viewport_rect,

- gfx::Transform());

+ root_pass = AddRenderPass(&render_passes_in_draw_order_, root_pass_id,

+ gfx::Rect(viewport_size), gfx::Transform());

AddRenderPassQuad(root_pass,

child_pass,

@@ -1289,7 +1272,7 @@ TEST_F(GLRendererShaderTest, DrawRenderPassQuadShaderPermutations) {

renderer_->DecideRenderPassAllocationsForFrame(

render_passes_in_draw_order_);

- DrawFrame(renderer_.get(), viewport_rect);

+ DrawFrame(renderer_.get(), viewport_size);

TestRenderPassMaskProgram(TEX_COORD_PRECISION_MEDIUM, SAMPLER_TYPE_2D,

blend_mode);

@@ -1301,17 +1284,15 @@ TEST_F(GLRendererShaderTest, DrawRenderPassQuadShaderPermutations) {

child_rect,

gfx::Transform());

- root_pass = AddRenderPass(&render_passes_in_draw_order_,

- root_pass_id,

- viewport_rect,

- gfx::Transform());

+ root_pass = AddRenderPass(&render_passes_in_draw_order_, root_pass_id,

+ gfx::Rect(viewport_size), gfx::Transform());

AddRenderPassQuad(

root_pass, child_pass, mask, filters, gfx::Transform(), xfer_mode);

renderer_->DecideRenderPassAllocationsForFrame(

render_passes_in_draw_order_);

- DrawFrame(renderer_.get(), viewport_rect);

+ DrawFrame(renderer_.get(), viewport_size);

TestRenderPassMaskColorMatrixProgram(TEX_COORD_PRECISION_MEDIUM,

SAMPLER_TYPE_2D, blend_mode);

@@ -1323,10 +1304,8 @@ TEST_F(GLRendererShaderTest, DrawRenderPassQuadShaderPermutations) {

child_rect,

transform_causing_aa);

- root_pass = AddRenderPass(&render_passes_in_draw_order_,

- root_pass_id,

- viewport_rect,

- gfx::Transform());

+ root_pass = AddRenderPass(&render_passes_in_draw_order_, root_pass_id,

+ gfx::Rect(viewport_size), gfx::Transform());

AddRenderPassQuad(root_pass,

child_pass,

@@ -1337,7 +1316,7 @@ TEST_F(GLRendererShaderTest, DrawRenderPassQuadShaderPermutations) {

renderer_->DecideRenderPassAllocationsForFrame(

render_passes_in_draw_order_);

- DrawFrame(renderer_.get(), viewport_rect);

+ DrawFrame(renderer_.get(), viewport_size);

TestRenderPassProgramAA(TEX_COORD_PRECISION_MEDIUM, blend_mode);

// RenderPassColorMatrixProgramAA

@@ -1348,17 +1327,15 @@ TEST_F(GLRendererShaderTest, DrawRenderPassQuadShaderPermutations) {

child_rect,

transform_causing_aa);

- root_pass = AddRenderPass(&render_passes_in_draw_order_,

- root_pass_id,

- viewport_rect,

- gfx::Transform());

+ root_pass = AddRenderPass(&render_passes_in_draw_order_, root_pass_id,

+ gfx::Rect(viewport_size), gfx::Transform());

AddRenderPassQuad(

root_pass, child_pass, 0, filters, transform_causing_aa, xfer_mode);

renderer_->DecideRenderPassAllocationsForFrame(

render_passes_in_draw_order_);

- DrawFrame(renderer_.get(), viewport_rect);

+ DrawFrame(renderer_.get(), viewport_size);

TestRenderPassColorMatrixProgramAA(TEX_COORD_PRECISION_MEDIUM, blend_mode);

// RenderPassMaskProgramAA

@@ -1369,10 +1346,8 @@ TEST_F(GLRendererShaderTest, DrawRenderPassQuadShaderPermutations) {

child_rect,

transform_causing_aa);

- root_pass = AddRenderPass(&render_passes_in_draw_order_,

- root_pass_id,

- viewport_rect,

- gfx::Transform());

+ root_pass = AddRenderPass(&render_passes_in_draw_order_, root_pass_id,

+ gfx::Rect(viewport_size), gfx::Transform());

AddRenderPassQuad(root_pass,

child_pass,

@@ -1383,7 +1358,7 @@ TEST_F(GLRendererShaderTest, DrawRenderPassQuadShaderPermutations) {

renderer_->DecideRenderPassAllocationsForFrame(

render_passes_in_draw_order_);

- DrawFrame(renderer_.get(), viewport_rect);

+ DrawFrame(renderer_.get(), viewport_size);

TestRenderPassMaskProgramAA(TEX_COORD_PRECISION_MEDIUM, SAMPLER_TYPE_2D,

blend_mode);

@@ -1395,17 +1370,15 @@ TEST_F(GLRendererShaderTest, DrawRenderPassQuadShaderPermutations) {

child_rect,

transform_causing_aa);

- root_pass = AddRenderPass(&render_passes_in_draw_order_,

- root_pass_id,

- viewport_rect,

- transform_causing_aa);

+ root_pass = AddRenderPass(&render_passes_in_draw_order_, root_pass_id,

+ gfx::Rect(viewport_size), transform_causing_aa);

AddRenderPassQuad(

root_pass, child_pass, mask, filters, transform_causing_aa, xfer_mode);

renderer_->DecideRenderPassAllocationsForFrame(

render_passes_in_draw_order_);

- DrawFrame(renderer_.get(), viewport_rect);

+ DrawFrame(renderer_.get(), viewport_size);

TestRenderPassMaskColorMatrixProgramAA(TEX_COORD_PRECISION_MEDIUM,

SAMPLER_TYPE_2D, blend_mode);

}

@@ -1418,7 +1391,7 @@ TEST_F(GLRendererShaderTest, DrawRenderPassQuadSkipsAAForClippingTransform) {

RenderPassId child_pass_id(2, 0);

RenderPass* child_pass;

- gfx::Rect viewport_rect(1, 1);

+ gfx::Size viewport_size(1, 1);

RenderPassId root_pass_id(1, 0);

RenderPass* root_pass;

@@ -1439,10 +1412,8 @@ TEST_F(GLRendererShaderTest, DrawRenderPassQuadSkipsAAForClippingTransform) {

child_rect,

transform_preventing_aa);

- root_pass = AddRenderPass(&render_passes_in_draw_order_,

- root_pass_id,

- viewport_rect,

- gfx::Transform());

+ root_pass = AddRenderPass(&render_passes_in_draw_order_, root_pass_id,

+ gfx::Rect(viewport_size), gfx::Transform());

AddRenderPassQuad(root_pass,

child_pass,

@@ -1452,7 +1423,7 @@ TEST_F(GLRendererShaderTest, DrawRenderPassQuadSkipsAAForClippingTransform) {

SkXfermode::kSrcOver_Mode);

renderer_->DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);

- DrawFrame(renderer_.get(), viewport_rect);

+ DrawFrame(renderer_.get(), viewport_size);

// If use_aa incorrectly ignores clipping, it will use the

// RenderPassProgramAA shader instead of the RenderPassProgram.

@@ -1460,7 +1431,7 @@ TEST_F(GLRendererShaderTest, DrawRenderPassQuadSkipsAAForClippingTransform) {

}

TEST_F(GLRendererShaderTest, DrawSolidColorShader) {

- gfx::Rect viewport_rect(1, 1);

+ gfx::Size viewport_size(1, 1);

RenderPassId root_pass_id(1, 0);

RenderPass* root_pass;

@@ -1468,17 +1439,13 @@ TEST_F(GLRendererShaderTest, DrawSolidColorShader) {

pixel_aligned_transform_causing_aa.Translate(25.5f, 25.5f);

pixel_aligned_transform_causing_aa.Scale(0.5f, 0.5f);

- root_pass = AddRenderPass(&render_passes_in_draw_order_,

- root_pass_id,

- viewport_rect,

- gfx::Transform());

- AddTransformedQuad(root_pass,

- viewport_rect,

- SK_ColorYELLOW,

+ root_pass = AddRenderPass(&render_passes_in_draw_order_, root_pass_id,

+ gfx::Rect(viewport_size), gfx::Transform());

+ AddTransformedQuad(root_pass, gfx::Rect(viewport_size), SK_ColorYELLOW,

pixel_aligned_transform_causing_aa);

renderer_->DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);

- DrawFrame(renderer_.get(), viewport_rect);

+ DrawFrame(renderer_.get(), viewport_size);

TestSolidColorProgramAA();

}

@@ -1550,19 +1517,19 @@ class MockOutputSurfaceTest : public GLRendererTest {

void SwapBuffers() { renderer_->SwapBuffers(CompositorFrameMetadata()); }

void DrawFrame(float device_scale_factor,

- const gfx::Rect& device_viewport_rect,

+ const gfx::Size& viewport_size,

bool transparent) {

RenderPassId render_pass_id(1, 0);

RenderPass* render_pass =

AddRenderPass(&render_passes_in_draw_order_, render_pass_id,

- device_viewport_rect, gfx::Transform());

- AddQuad(render_pass, device_viewport_rect, SK_ColorGREEN);

+ gfx::Rect(viewport_size), gfx::Transform());

+ AddQuad(render_pass, gfx::Rect(viewport_size), SK_ColorGREEN);

render_pass->has_transparent_background = transparent;

EXPECT_CALL(output_surface_, EnsureBackbuffer()).WillRepeatedly(Return());

- EXPECT_CALL(output_surface_, Reshape(device_viewport_rect.size(),

- device_scale_factor, _, transparent))

+ EXPECT_CALL(output_surface_,

+ Reshape(viewport_size, device_scale_factor, _, transparent))

.Times(1);

EXPECT_CALL(output_surface_, BindFramebuffer()).Times(1);

@@ -1572,8 +1539,7 @@ class MockOutputSurfaceTest : public GLRendererTest {

renderer_->DecideRenderPassAllocationsForFrame(

render_passes_in_draw_order_);

renderer_->DrawFrame(&render_passes_in_draw_order_, device_scale_factor,

- gfx::ColorSpace(), device_viewport_rect,

- device_viewport_rect);

+ gfx::ColorSpace(), viewport_size);

}

OutputSurfaceMockContext* Context() {

@@ -1675,10 +1641,10 @@ TEST_F(GLRendererTest, DontOverlayWithCopyRequests) {

new TestOverlayProcessor::Validator);

output_surface->SetOverlayCandidateValidator(validator.get());

- gfx::Rect viewport_rect(1, 1);

+ gfx::Size viewport_size(1, 1);

RenderPass* root_pass =

AddRenderPass(&render_passes_in_draw_order_, RenderPassId(1, 0),

- viewport_rect, gfx::Transform());

+ gfx::Rect(viewport_size), gfx::Transform());

root_pass->has_transparent_background = false;

root_pass->copy_requests.push_back(

CopyOutputRequest::CreateRequest(base::Bind(&IgnoreCopyResult)));

@@ -1697,11 +1663,11 @@ TEST_F(GLRendererTest, DontOverlayWithCopyRequests) {

TextureDrawQuad* overlay_quad =

root_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();

- overlay_quad->SetNew(root_pass->CreateAndAppendSharedQuadState(),

- viewport_rect, viewport_rect, viewport_rect, resource_id,

- premultiplied_alpha, gfx::PointF(0, 0),

- gfx::PointF(1, 1), SK_ColorTRANSPARENT, vertex_opacity,

- flipped, nearest_neighbor, false);

+ overlay_quad->SetNew(

+ root_pass->CreateAndAppendSharedQuadState(), gfx::Rect(viewport_size),

+ gfx::Rect(viewport_size), gfx::Rect(viewport_size), resource_id,

+ premultiplied_alpha, gfx::PointF(0, 0), gfx::PointF(1, 1),

+ SK_ColorTRANSPARENT, vertex_opacity, flipped, nearest_neighbor, false);

// DirectRenderer::DrawFrame calls into OverlayProcessor::ProcessForOverlays.

// Attempt will be called for each strategy in OverlayProcessor. We have

@@ -1710,44 +1676,44 @@ TEST_F(GLRendererTest, DontOverlayWithCopyRequests) {

// list because the render pass is cleaned up by DrawFrame.

EXPECT_CALL(*processor->strategy_, Attempt(_, _, _)).Times(0);

EXPECT_CALL(*validator, AllowCALayerOverlays()).Times(0);

- DrawFrame(&renderer, viewport_rect);

+ DrawFrame(&renderer, viewport_size);

Mock::VerifyAndClearExpectations(processor->strategy_);

Mock::VerifyAndClearExpectations(validator.get());

// Without a copy request Attempt() should be called once.

root_pass = AddRenderPass(&render_passes_in_draw_order_, RenderPassId(1, 0),

- viewport_rect, gfx::Transform());

+ gfx::Rect(viewport_size), gfx::Transform());

root_pass->has_transparent_background = false;

overlay_quad = root_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();

- overlay_quad->SetNew(root_pass->CreateAndAppendSharedQuadState(),

- viewport_rect, viewport_rect, viewport_rect, resource_id,

- premultiplied_alpha, gfx::PointF(0, 0),

- gfx::PointF(1, 1), SK_ColorTRANSPARENT, vertex_opacity,

- flipped, nearest_neighbor, false);

+ overlay_quad->SetNew(

+ root_pass->CreateAndAppendSharedQuadState(), gfx::Rect(viewport_size),

+ gfx::Rect(viewport_size), gfx::Rect(viewport_size), resource_id,

+ premultiplied_alpha, gfx::PointF(0, 0), gfx::PointF(1, 1),

+ SK_ColorTRANSPARENT, vertex_opacity, flipped, nearest_neighbor, false);

EXPECT_CALL(*validator, AllowCALayerOverlays())

.Times(1)

.WillOnce(::testing::Return(false));

EXPECT_CALL(*processor->strategy_, Attempt(_, _, _)).Times(1);

- DrawFrame(&renderer, viewport_rect);

+ DrawFrame(&renderer, viewport_size);

// If the CALayerOverlay path is taken, then the ordinary overlay path should

// not be called.

root_pass = AddRenderPass(&render_passes_in_draw_order_, RenderPassId(1, 0),

- viewport_rect, gfx::Transform());

+ gfx::Rect(viewport_size), gfx::Transform());

root_pass->has_transparent_background = false;

overlay_quad = root_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();

- overlay_quad->SetNew(root_pass->CreateAndAppendSharedQuadState(),

- viewport_rect, viewport_rect, viewport_rect, resource_id,

- premultiplied_alpha, gfx::PointF(0, 0),

- gfx::PointF(1, 1), SK_ColorTRANSPARENT, vertex_opacity,

- flipped, nearest_neighbor, false);

+ overlay_quad->SetNew(

+ root_pass->CreateAndAppendSharedQuadState(), gfx::Rect(viewport_size),

+ gfx::Rect(viewport_size), gfx::Rect(viewport_size), resource_id,

+ premultiplied_alpha, gfx::PointF(0, 0), gfx::PointF(1, 1),

+ SK_ColorTRANSPARENT, vertex_opacity, flipped, nearest_neighbor, false);

EXPECT_CALL(*validator, AllowCALayerOverlays())

.Times(1)

.WillOnce(::testing::Return(true));

EXPECT_CALL(*processor->strategy_, Attempt(_, _, _)).Times(0);

- DrawFrame(&renderer, viewport_rect);

+ DrawFrame(&renderer, viewport_size);

}

class SingleOverlayOnTopProcessor : public OverlayProcessor {

@@ -1829,10 +1795,10 @@ TEST_F(GLRendererTest, OverlaySyncTokensAreProcessed) {

processor->Initialize();

renderer.SetOverlayProcessor(processor);

- gfx::Rect viewport_rect(1, 1);

+ gfx::Size viewport_size(1, 1);

RenderPass* root_pass =

AddRenderPass(&render_passes_in_draw_order_, RenderPassId(1, 0),

- viewport_rect, gfx::Transform());

+ gfx::Rect(viewport_size), gfx::Transform());

root_pass->has_transparent_background = false;

gpu::SyncToken sync_token(gpu::CommandBufferNamespace::GPU_IO, 0,

@@ -1854,21 +1820,25 @@ TEST_F(GLRendererTest, OverlaySyncTokensAreProcessed) {

TextureDrawQuad* overlay_quad =

root_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();

SharedQuadState* shared_state = root_pass->CreateAndAppendSharedQuadState();

- shared_state->SetAll(gfx::Transform(), viewport_rect.size(), viewport_rect,

- viewport_rect, false, 1, SkXfermode::kSrcOver_Mode, 0);

- overlay_quad->SetNew(shared_state, viewport_rect, viewport_rect,

- viewport_rect, resource_id, premultiplied_alpha,

- uv_top_left, uv_bottom_right, SK_ColorTRANSPARENT,

- vertex_opacity, flipped, nearest_neighbor, false);

+ shared_state->SetAll(gfx::Transform(), viewport_size,

+ gfx::Rect(viewport_size), gfx::Rect(viewport_size),

+ false, 1, SkXfermode::kSrcOver_Mode, 0);

+ overlay_quad->SetNew(shared_state, gfx::Rect(viewport_size),

+ gfx::Rect(viewport_size), gfx::Rect(viewport_size),

+ resource_id, premultiplied_alpha, uv_top_left,

+ uv_bottom_right, SK_ColorTRANSPARENT, vertex_opacity,

+ flipped, nearest_neighbor, false);

// Verify that overlay_quad actually gets turned into an overlay, and even

// though it's not drawn, that its sync point is waited on.

EXPECT_CALL(*context, waitSyncToken(MatchesSyncToken(sync_token))).Times(1);

- EXPECT_CALL(overlay_scheduler,

- Schedule(1, gfx::OVERLAY_TRANSFORM_NONE, _, viewport_rect,

- BoundingRect(uv_top_left, uv_bottom_right))).Times(1);

+ EXPECT_CALL(

+ overlay_scheduler,

+ Schedule(1, gfx::OVERLAY_TRANSFORM_NONE, _, gfx::Rect(viewport_size),

+ BoundingRect(uv_top_left, uv_bottom_right)))

+ .Times(1);

- DrawFrame(&renderer, viewport_rect);

+ DrawFrame(&renderer, viewport_size);

}

class PartialSwapMockGLES2Interface : public TestGLES2Interface {

@@ -1905,15 +1875,14 @@ class GLRendererPartialSwapTest : public GLRendererTest {

EXPECT_EQ(partial_swap, renderer.use_partial_swap());

renderer.SetVisible(true);

- gfx::Rect viewport_rect(100, 100);

- gfx::Rect clip_rect(100, 100);

+ gfx::Size viewport_size(100, 100);

{

RenderPassId root_pass_id(1, 0);

RenderPass* root_pass =

AddRenderPass(&render_passes_in_draw_order_, root_pass_id,

- viewport_rect, gfx::Transform());

- AddQuad(root_pass, viewport_rect, SK_ColorGREEN);

+ gfx::Rect(viewport_size), gfx::Transform());

+ AddQuad(root_pass, gfx::Rect(viewport_size), SK_ColorGREEN);

testing::Sequence seq;

// A bunch of initialization that happens.

@@ -1931,7 +1900,7 @@ class GLRendererPartialSwapTest : public GLRendererTest {

EXPECT_CALL(*gl, Enable(GL_SCISSOR_TEST)).InSequence(seq);

// The scissor is flipped, so subtract the y coord and height from the

// bottom of the GL viewport.

- EXPECT_CALL(*gl, Scissor(2, viewport_rect.bottom() - 3 - 2, 3, 3))

+ EXPECT_CALL(*gl, Scissor(2, viewport_size.height() - 3 - 2, 3, 3))

.InSequence(seq);

}

@@ -1943,7 +1912,7 @@ class GLRendererPartialSwapTest : public GLRendererTest {

renderer.DecideRenderPassAllocationsForFrame(

render_passes_in_draw_order_);

- DrawFrame(&renderer, viewport_rect, clip_rect);

+ DrawFrame(&renderer, viewport_size);

}

};

« no previous file with comments | « cc/output/gl_renderer.cc ('k') | cc/output/overlay_unittest.cc » ('j') | no next file with comments »