cc/output/renderer_pixeltest.cc - Issue 1175113010: cc: Rename visible_content_rect and content stuff on quads.

Unified Diff: cc/output/renderer_pixeltest.cc

Issue 1175113010: cc: Rename visible_content_rect and content stuff on quads. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master

Patch Set: rename-visible-content-rect: moreandroid Created 5 years, 6 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

Download patch

Index: cc/output/renderer_pixeltest.cc

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

index 136550c528e229f70b867c9ebf0cbe2a8d9b6415..d6a8e5dc4b477b04f5baada88f323437609ebdf7 100644

--- a/cc/output/renderer_pixeltest.cc

+++ b/cc/output/renderer_pixeltest.cc

@@ -47,48 +47,38 @@ scoped_ptr<RenderPass> CreateTestRenderPass(

}

SharedQuadState* CreateTestSharedQuadState(

- gfx::Transform content_to_target_transform,

+ gfx::Transform quad_to_target_transform,

const gfx::Rect& rect,

RenderPass* render_pass) {

- const gfx::Size content_bounds = rect.size();

- const gfx::Rect visible_content_rect = rect;

+ const gfx::Size layer_bounds = rect.size();

+ const gfx::Rect visible_layer_rect = rect;

const gfx::Rect clip_rect = rect;

const bool is_clipped = false;

const float opacity = 1.0f;

const SkXfermode::Mode blend_mode = SkXfermode::kSrcOver_Mode;

int sorting_context_id = 0;

SharedQuadState* shared_state = render_pass->CreateAndAppendSharedQuadState();

- shared_state->SetAll(content_to_target_transform,

- content_bounds,

- visible_content_rect,

- clip_rect,

- is_clipped,

- opacity,

- blend_mode,

- sorting_context_id);

+ shared_state->SetAll(quad_to_target_transform, layer_bounds,

+ visible_layer_rect, clip_rect, is_clipped, opacity,

+ blend_mode, sorting_context_id);

return shared_state;

}

SharedQuadState* CreateTestSharedQuadStateClipped(

- gfx::Transform content_to_target_transform,

+ gfx::Transform quad_to_target_transform,

const gfx::Rect& rect,

const gfx::Rect& clip_rect,

RenderPass* render_pass) {

- const gfx::Size content_bounds = rect.size();

- const gfx::Rect visible_content_rect = clip_rect;

+ const gfx::Size layer_bounds = rect.size();

+ const gfx::Rect visible_layer_rect = clip_rect;

const bool is_clipped = true;

const float opacity = 1.0f;

const SkXfermode::Mode blend_mode = SkXfermode::kSrcOver_Mode;

int sorting_context_id = 0;

SharedQuadState* shared_state = render_pass->CreateAndAppendSharedQuadState();

- shared_state->SetAll(content_to_target_transform,

- content_bounds,

- visible_content_rect,

- clip_rect,

- is_clipped,

- opacity,

- blend_mode,

- sorting_context_id);

+ shared_state->SetAll(quad_to_target_transform, layer_bounds,

+ visible_layer_rect, clip_rect, is_clipped, opacity,

+ blend_mode, sorting_context_id);

return shared_state;

}

@@ -1220,9 +1210,9 @@ TYPED_TEST(RendererPixelTest, FastPassColorFilterAlpha) {

scoped_ptr<RenderPass> child_pass =

CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root);

- gfx::Transform content_to_target_transform;

+ gfx::Transform quad_to_target_transform;

SharedQuadState* shared_state = CreateTestSharedQuadState(

- content_to_target_transform, viewport_rect, child_pass.get());

+ quad_to_target_transform, viewport_rect, child_pass.get());

shared_state->opacity = 0.5f;

gfx::Rect blue_rect(0,

@@ -1241,7 +1231,7 @@ TYPED_TEST(RendererPixelTest, FastPassColorFilterAlpha) {

yellow->SetNew(shared_state, yellow_rect, yellow_rect, SK_ColorYELLOW, false);

SharedQuadState* blank_state = CreateTestSharedQuadState(

- content_to_target_transform, viewport_rect, child_pass.get());

+ quad_to_target_transform, viewport_rect, child_pass.get());

SolidColorDrawQuad* white =

child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();

@@ -1312,9 +1302,9 @@ TYPED_TEST(RendererPixelTest, FastPassSaturateFilter) {

scoped_ptr<RenderPass> child_pass =

CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root);

- gfx::Transform content_to_target_transform;

+ gfx::Transform quad_to_target_transform;

SharedQuadState* shared_state = CreateTestSharedQuadState(

- content_to_target_transform, viewport_rect, child_pass.get());

+ quad_to_target_transform, viewport_rect, child_pass.get());

shared_state->opacity = 0.5f;

gfx::Rect blue_rect(0,

@@ -1333,7 +1323,7 @@ TYPED_TEST(RendererPixelTest, FastPassSaturateFilter) {

yellow->SetNew(shared_state, yellow_rect, yellow_rect, SK_ColorYELLOW, false);

SharedQuadState* blank_state = CreateTestSharedQuadState(

- content_to_target_transform, viewport_rect, child_pass.get());

+ quad_to_target_transform, viewport_rect, child_pass.get());

SolidColorDrawQuad* white =

child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();

@@ -1383,9 +1373,9 @@ TYPED_TEST(RendererPixelTest, FastPassFilterChain) {

scoped_ptr<RenderPass> child_pass =

CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root);

- gfx::Transform content_to_target_transform;

+ gfx::Transform quad_to_target_transform;

SharedQuadState* shared_state = CreateTestSharedQuadState(

- content_to_target_transform, viewport_rect, child_pass.get());

+ quad_to_target_transform, viewport_rect, child_pass.get());

shared_state->opacity = 0.5f;

gfx::Rect blue_rect(0,

@@ -1404,7 +1394,7 @@ TYPED_TEST(RendererPixelTest, FastPassFilterChain) {

yellow->SetNew(shared_state, yellow_rect, yellow_rect, SK_ColorYELLOW, false);

SharedQuadState* blank_state = CreateTestSharedQuadState(

- content_to_target_transform, viewport_rect, child_pass.get());

+ quad_to_target_transform, viewport_rect, child_pass.get());

SolidColorDrawQuad* white =

child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();

@@ -1456,9 +1446,9 @@ TYPED_TEST(RendererPixelTest, FastPassColorFilterAlphaTranslation) {

scoped_ptr<RenderPass> child_pass =

CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root);

- gfx::Transform content_to_target_transform;

+ gfx::Transform quad_to_target_transform;

SharedQuadState* shared_state = CreateTestSharedQuadState(

- content_to_target_transform, viewport_rect, child_pass.get());

+ quad_to_target_transform, viewport_rect, child_pass.get());

shared_state->opacity = 0.5f;

gfx::Rect blue_rect(0,

@@ -1477,7 +1467,7 @@ TYPED_TEST(RendererPixelTest, FastPassColorFilterAlphaTranslation) {

yellow->SetNew(shared_state, yellow_rect, yellow_rect, SK_ColorYELLOW, false);

SharedQuadState* blank_state = CreateTestSharedQuadState(

- content_to_target_transform, viewport_rect, child_pass.get());

+ quad_to_target_transform, viewport_rect, child_pass.get());

SolidColorDrawQuad* white =

child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();

@@ -1552,9 +1542,9 @@ TYPED_TEST(RendererPixelTest, EnlargedRenderPassTexture) {

scoped_ptr<RenderPass> child_pass =

CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root);

- gfx::Transform content_to_target_transform;

+ gfx::Transform quad_to_target_transform;

SharedQuadState* shared_state = CreateTestSharedQuadState(

- content_to_target_transform, viewport_rect, child_pass.get());

+ quad_to_target_transform, viewport_rect, child_pass.get());

gfx::Rect blue_rect(0,

@@ -1601,9 +1591,9 @@ TYPED_TEST(RendererPixelTest, EnlargedRenderPassTextureWithAntiAliasing) {

scoped_ptr<RenderPass> child_pass =

CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root);

- gfx::Transform content_to_target_transform;

+ gfx::Transform quad_to_target_transform;

SharedQuadState* shared_state = CreateTestSharedQuadState(

- content_to_target_transform, viewport_rect, child_pass.get());

+ quad_to_target_transform, viewport_rect, child_pass.get());

gfx::Rect blue_rect(0,

@@ -1758,41 +1748,32 @@ class RendererPixelTestWithBackgroundFilter

CreateTestRootRenderPass(root_id, device_viewport_rect);

root_pass->has_transparent_background = false;

- gfx::Transform identity_content_to_target_transform;

+ gfx::Transform identity_quad_to_target_transform;

RenderPassId filter_pass_id(2, 1);

gfx::Transform transform_to_root;

- scoped_ptr<RenderPass> filter_pass =

- CreateTestRenderPass(filter_pass_id,

- filter_pass_content_rect_,

- transform_to_root);

+ scoped_ptr<RenderPass> filter_pass = CreateTestRenderPass(

+ filter_pass_id, filter_pass_layer_rect_, transform_to_root);

// A non-visible quad in the filtering render pass.

{

SharedQuadState* shared_state =

- CreateTestSharedQuadState(identity_content_to_target_transform,

- filter_pass_content_rect_,

- filter_pass.get());

+ CreateTestSharedQuadState(identity_quad_to_target_transform,

+ filter_pass_layer_rect_, filter_pass.get());

SolidColorDrawQuad* color_quad =

filter_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();

- color_quad->SetNew(shared_state,

- filter_pass_content_rect_,

- SK_ColorTRANSPARENT,

- false);

+ color_quad->SetNew(shared_state, filter_pass_layer_rect_,

+ filter_pass_layer_rect_, SK_ColorTRANSPARENT, false);

}

{

SharedQuadState* shared_state =

CreateTestSharedQuadState(filter_pass_to_target_transform_,

- filter_pass_content_rect_,

- filter_pass.get());

+ filter_pass_layer_rect_, filter_pass.get());

RenderPassDrawQuad* filter_pass_quad =

root_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();

- filter_pass_quad->SetNew(shared_state,

- filter_pass_content_rect_,

- filter_pass_id,

+ filter_pass_quad->SetNew(shared_state, filter_pass_layer_rect_,

+ filter_pass_layer_rect_, filter_pass_id,

0, // mask_resource_id

gfx::Vector2dF(), // mask_uv_scale

gfx::Size(), // mask_texture_size

@@ -1806,7 +1787,7 @@ class RendererPixelTestWithBackgroundFilter

gfx::Rect left_rect = gfx::Rect(0, 0, kColumnWidth, 20);

for (int i = 0; left_rect.y() < device_viewport_rect.height(); ++i) {

SharedQuadState* shared_state = CreateTestSharedQuadState(

- identity_content_to_target_transform, left_rect, root_pass.get());

+ identity_quad_to_target_transform, left_rect, root_pass.get());

SolidColorDrawQuad* color_quad =

root_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();

color_quad->SetNew(

@@ -1817,7 +1798,7 @@ class RendererPixelTestWithBackgroundFilter

gfx::Rect middle_rect = gfx::Rect(kColumnWidth+1, 0, kColumnWidth, 20);

for (int i = 0; middle_rect.y() < device_viewport_rect.height(); ++i) {

SharedQuadState* shared_state = CreateTestSharedQuadState(

- identity_content_to_target_transform, middle_rect, root_pass.get());

+ identity_quad_to_target_transform, middle_rect, root_pass.get());

SolidColorDrawQuad* color_quad =

root_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();

color_quad->SetNew(

@@ -1828,7 +1809,7 @@ class RendererPixelTestWithBackgroundFilter

gfx::Rect right_rect = gfx::Rect((kColumnWidth+1)*2, 0, kColumnWidth, 20);

for (int i = 0; right_rect.y() < device_viewport_rect.height(); ++i) {

SharedQuadState* shared_state = CreateTestSharedQuadState(

- identity_content_to_target_transform, right_rect, root_pass.get());

+ identity_quad_to_target_transform, right_rect, root_pass.get());

SolidColorDrawQuad* color_quad =

root_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();

color_quad->SetNew(

@@ -1837,9 +1818,8 @@ class RendererPixelTestWithBackgroundFilter

}

SharedQuadState* shared_state =

- CreateTestSharedQuadState(identity_content_to_target_transform,

- device_viewport_rect,

- root_pass.get());

+ CreateTestSharedQuadState(identity_quad_to_target_transform,

+ device_viewport_rect, root_pass.get());

SolidColorDrawQuad* background_quad =

root_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();

background_quad->SetNew(shared_state,

@@ -1855,7 +1835,7 @@ class RendererPixelTestWithBackgroundFilter

RenderPassList pass_list_;

FilterOperations background_filters_;

gfx::Transform filter_pass_to_target_transform_;

- gfx::Rect filter_pass_content_rect_;

+ gfx::Rect filter_pass_layer_rect_;

};

typedef ::testing::Types<GLRenderer, SoftwareRenderer>

@@ -1871,8 +1851,8 @@ TEST_F(GLRendererPixelTestWithBackgroundFilter, InvertFilter) {

this->background_filters_.Append(

FilterOperation::CreateInvertFilter(1.f));

- this->filter_pass_content_rect_ = gfx::Rect(this->device_viewport_size_);

- this->filter_pass_content_rect_.Inset(12, 14, 16, 18);

+ this->filter_pass_layer_rect_ = gfx::Rect(this->device_viewport_size_);

+ this->filter_pass_layer_rect_.Inset(12, 14, 16, 18);

this->SetUpRenderPassList();

EXPECT_TRUE(this->RunPixelTest(

@@ -1979,9 +1959,9 @@ TEST_F(ExternalStencilPixelTest, RenderSurfacesIgnoreStencil) {

scoped_ptr<RenderPass> child_pass =

CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root);

- gfx::Transform content_to_target_transform;

+ gfx::Transform quad_to_target_transform;

SharedQuadState* shared_state = CreateTestSharedQuadState(

- content_to_target_transform, viewport_rect, child_pass.get());

+ quad_to_target_transform, viewport_rect, child_pass.get());

gfx::Rect blue_rect(0,

@@ -2036,26 +2016,26 @@ TEST_F(GLRendererPixelTest, AntiAliasing) {

RenderPassId id(1, 1);

scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);

- gfx::Transform red_content_to_target_transform;

- red_content_to_target_transform.Rotate(10);

- SharedQuadState* red_shared_state = CreateTestSharedQuadState(

- red_content_to_target_transform, rect, pass.get());

+ gfx::Transform red_quad_to_target_transform;

+ red_quad_to_target_transform.Rotate(10);

+ SharedQuadState* red_shared_state =

+ CreateTestSharedQuadState(red_quad_to_target_transform, rect, pass.get());

SolidColorDrawQuad* red = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();

red->SetNew(red_shared_state, rect, rect, SK_ColorRED, false);

- gfx::Transform yellow_content_to_target_transform;

- yellow_content_to_target_transform.Rotate(5);

+ gfx::Transform yellow_quad_to_target_transform;

+ yellow_quad_to_target_transform.Rotate(5);

SharedQuadState* yellow_shared_state = CreateTestSharedQuadState(

- yellow_content_to_target_transform, rect, pass.get());

+ yellow_quad_to_target_transform, rect, pass.get());

SolidColorDrawQuad* yellow =

pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();

yellow->SetNew(yellow_shared_state, rect, rect, SK_ColorYELLOW, false);

- gfx::Transform blue_content_to_target_transform;

+ gfx::Transform blue_quad_to_target_transform;

SharedQuadState* blue_shared_state = CreateTestSharedQuadState(

- blue_content_to_target_transform, rect, pass.get());

+ blue_quad_to_target_transform, rect, pass.get());

SolidColorDrawQuad* blue =

pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();

@@ -2080,30 +2060,29 @@ TEST_F(GLRendererPixelTest, AxisAligned) {

scoped_ptr<RenderPass> pass =

CreateTestRenderPass(id, rect, transform_to_root);

- gfx::Transform red_content_to_target_transform;

- red_content_to_target_transform.Translate(50, 50);

- red_content_to_target_transform.Scale(

- 0.5f + 1.0f / (rect.width() * 2.0f),

- 0.5f + 1.0f / (rect.height() * 2.0f));

- SharedQuadState* red_shared_state = CreateTestSharedQuadState(

- red_content_to_target_transform, rect, pass.get());

+ gfx::Transform red_quad_to_target_transform;

+ red_quad_to_target_transform.Translate(50, 50);

+ red_quad_to_target_transform.Scale(0.5f + 1.0f / (rect.width() * 2.0f),

+ 0.5f + 1.0f / (rect.height() * 2.0f));

+ SharedQuadState* red_shared_state =

+ CreateTestSharedQuadState(red_quad_to_target_transform, rect, pass.get());

SolidColorDrawQuad* red = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();

red->SetNew(red_shared_state, rect, rect, SK_ColorRED, false);

- gfx::Transform yellow_content_to_target_transform;

- yellow_content_to_target_transform.Translate(25.5f, 25.5f);

- yellow_content_to_target_transform.Scale(0.5f, 0.5f);

+ gfx::Transform yellow_quad_to_target_transform;

+ yellow_quad_to_target_transform.Translate(25.5f, 25.5f);

+ yellow_quad_to_target_transform.Scale(0.5f, 0.5f);

SharedQuadState* yellow_shared_state = CreateTestSharedQuadState(

- yellow_content_to_target_transform, rect, pass.get());

+ yellow_quad_to_target_transform, rect, pass.get());

SolidColorDrawQuad* yellow =

pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();

yellow->SetNew(yellow_shared_state, rect, rect, SK_ColorYELLOW, false);

- gfx::Transform blue_content_to_target_transform;

+ gfx::Transform blue_quad_to_target_transform;

SharedQuadState* blue_shared_state = CreateTestSharedQuadState(

- blue_content_to_target_transform, rect, pass.get());

+ blue_quad_to_target_transform, rect, pass.get());

SolidColorDrawQuad* blue =

pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();

@@ -2128,22 +2107,21 @@ TEST_F(GLRendererPixelTest, ForceAntiAliasingOff) {

scoped_ptr<RenderPass> pass =

CreateTestRenderPass(id, rect, transform_to_root);

- gfx::Transform hole_content_to_target_transform;

- hole_content_to_target_transform.Translate(50, 50);

- hole_content_to_target_transform.Scale(

- 0.5f + 1.0f / (rect.width() * 2.0f),

- 0.5f + 1.0f / (rect.height() * 2.0f));

+ gfx::Transform hole_quad_to_target_transform;

+ hole_quad_to_target_transform.Translate(50, 50);

+ hole_quad_to_target_transform.Scale(0.5f + 1.0f / (rect.width() * 2.0f),

+ 0.5f + 1.0f / (rect.height() * 2.0f));

SharedQuadState* hole_shared_state = CreateTestSharedQuadState(

- hole_content_to_target_transform, rect, pass.get());

+ hole_quad_to_target_transform, rect, pass.get());

SolidColorDrawQuad* hole =

pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();

hole->SetAll(

hole_shared_state, rect, rect, rect, false, SK_ColorTRANSPARENT, true);

- gfx::Transform green_content_to_target_transform;

+ gfx::Transform green_quad_to_target_transform;

SharedQuadState* green_shared_state = CreateTestSharedQuadState(

- green_content_to_target_transform, rect, pass.get());

+ green_quad_to_target_transform, rect, pass.get());

SolidColorDrawQuad* green =

pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();

@@ -2165,13 +2143,11 @@ TEST_F(GLRendererPixelTest, AntiAliasingPerspective) {

CreateTestRootRenderPass(RenderPassId(1, 1), rect);

gfx::Rect red_rect(0, 0, 180, 500);

- gfx::Transform red_content_to_target_transform(

- 1.0f, 2.4520f, 10.6206f, 19.0f,

- 0.0f, 0.3528f, 5.9737f, 9.5f,

- 0.0f, -0.2250f, -0.9744f, 0.0f,

- 0.0f, 0.0225f, 0.0974f, 1.0f);

+ gfx::Transform red_quad_to_target_transform(

+ 1.0f, 2.4520f, 10.6206f, 19.0f, 0.0f, 0.3528f, 5.9737f, 9.5f, 0.0f,

+ -0.2250f, -0.9744f, 0.0f, 0.0f, 0.0225f, 0.0974f, 1.0f);

SharedQuadState* red_shared_state = CreateTestSharedQuadState(

- red_content_to_target_transform, red_rect, pass.get());

+ red_quad_to_target_transform, red_rect, pass.get());

SolidColorDrawQuad* red = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();

red->SetNew(red_shared_state, red_rect, red_rect, SK_ColorRED, false);

@@ -2228,16 +2204,14 @@ TYPED_TEST(SoftwareRendererPixelTest, PictureDrawQuadIdentityScale) {

scoped_refptr<FakePicturePileImpl> blue_pile =

FakePicturePileImpl::CreateFromPile(blue_recording.get(), nullptr);

- gfx::Transform blue_content_to_target_transform;

+ gfx::Transform blue_quad_to_target_transform;

gfx::Vector2d offset(viewport.bottom_right() - blue_rect.bottom_right());

- blue_content_to_target_transform.Translate(offset.x(), offset.y());

+ blue_quad_to_target_transform.Translate(offset.x(), offset.y());

gfx::RectF blue_scissor_rect = blue_clip_rect;

- blue_content_to_target_transform.TransformRect(&blue_scissor_rect);

- SharedQuadState* blue_shared_state =

- CreateTestSharedQuadStateClipped(blue_content_to_target_transform,

- blue_rect,

- gfx::ToEnclosingRect(blue_scissor_rect),

- pass.get());

+ blue_quad_to_target_transform.TransformRect(&blue_scissor_rect);

+ SharedQuadState* blue_shared_state = CreateTestSharedQuadStateClipped(

+ blue_quad_to_target_transform, blue_rect,

+ gfx::ToEnclosingRect(blue_scissor_rect), pass.get());

PictureDrawQuad* blue_quad = pass->CreateAndAppendDrawQuad<PictureDrawQuad>();

@@ -2257,9 +2231,9 @@ TYPED_TEST(SoftwareRendererPixelTest, PictureDrawQuadIdentityScale) {

scoped_refptr<FakePicturePileImpl> green_pile =

FakePicturePileImpl::CreateFromPile(green_recording.get(), nullptr);

- gfx::Transform green_content_to_target_transform;

+ gfx::Transform green_quad_to_target_transform;

SharedQuadState* green_shared_state = CreateTestSharedQuadState(

- green_content_to_target_transform, viewport, pass.get());

+ green_quad_to_target_transform, viewport, pass.get());

PictureDrawQuad* green_quad =

pass->CreateAndAppendDrawQuad<PictureDrawQuad>();

@@ -2299,9 +2273,9 @@ TYPED_TEST(SoftwareRendererPixelTest, PictureDrawQuadOpacity) {

scoped_refptr<FakePicturePileImpl> green_pile =

FakePicturePileImpl::CreateFromPile(green_recording.get(), nullptr);

- gfx::Transform green_content_to_target_transform;

+ gfx::Transform green_quad_to_target_transform;

SharedQuadState* green_shared_state = CreateTestSharedQuadState(

- green_content_to_target_transform, viewport, pass.get());

+ green_quad_to_target_transform, viewport, pass.get());

green_shared_state->opacity = 0.5f;

PictureDrawQuad* green_quad =

@@ -2320,9 +2294,9 @@ TYPED_TEST(SoftwareRendererPixelTest, PictureDrawQuadOpacity) {

scoped_refptr<FakePicturePileImpl> white_pile =

FakePicturePileImpl::CreateFromPile(white_recording.get(), nullptr);

- gfx::Transform white_content_to_target_transform;

+ gfx::Transform white_quad_to_target_transform;

SharedQuadState* white_shared_state = CreateTestSharedQuadState(

- white_content_to_target_transform, viewport, pass.get());

+ white_quad_to_target_transform, viewport, pass.get());

PictureDrawQuad* white_quad =

pass->CreateAndAppendDrawQuad<PictureDrawQuad>();

@@ -2391,9 +2365,9 @@ TYPED_TEST(SoftwareRendererPixelTest, PictureDrawQuadDisableImageFiltering) {

scoped_refptr<FakePicturePileImpl> pile =

FakePicturePileImpl::CreateFromPile(recording.get(), nullptr);

- gfx::Transform content_to_target_transform;

- SharedQuadState* shared_state = CreateTestSharedQuadState(

- content_to_target_transform, viewport, pass.get());

+ gfx::Transform quad_to_target_transform;

+ SharedQuadState* shared_state =

+ CreateTestSharedQuadState(quad_to_target_transform, viewport, pass.get());

PictureDrawQuad* quad = pass->CreateAndAppendDrawQuad<PictureDrawQuad>();

quad->SetNew(shared_state, viewport, gfx::Rect(), viewport,

@@ -2443,9 +2417,9 @@ TYPED_TEST(SoftwareRendererPixelTest, PictureDrawQuadNearestNeighbor) {

scoped_refptr<FakePicturePileImpl> pile =

FakePicturePileImpl::CreateFromPile(recording.get(), nullptr);

- gfx::Transform content_to_target_transform;

- SharedQuadState* shared_state = CreateTestSharedQuadState(

- content_to_target_transform, viewport, pass.get());

+ gfx::Transform quad_to_target_transform;

+ SharedQuadState* shared_state =

+ CreateTestSharedQuadState(quad_to_target_transform, viewport, pass.get());

PictureDrawQuad* quad = pass->CreateAndAppendDrawQuad<PictureDrawQuad>();

quad->SetNew(shared_state, viewport, gfx::Rect(), viewport,

@@ -2494,9 +2468,9 @@ TYPED_TEST(RendererPixelTest, TileDrawQuadNearestNeighbor) {

scoped_ptr<RenderPass> pass =

CreateTestRenderPass(id, viewport, transform_to_root);

- gfx::Transform content_to_target_transform;

- SharedQuadState* shared_state = CreateTestSharedQuadState(

- content_to_target_transform, viewport, pass.get());

+ gfx::Transform quad_to_target_transform;

+ SharedQuadState* shared_state =

+ CreateTestSharedQuadState(quad_to_target_transform, viewport, pass.get());

TileDrawQuad* quad = pass->CreateAndAppendDrawQuad<TileDrawQuad>();

quad->SetNew(shared_state, viewport, gfx::Rect(), viewport, resource,

@@ -2545,9 +2519,9 @@ TYPED_TEST(SoftwareRendererPixelTest, TextureDrawQuadNearestNeighbor) {

scoped_ptr<RenderPass> pass =

CreateTestRenderPass(id, viewport, transform_to_root);

- gfx::Transform content_to_target_transform;

- SharedQuadState* shared_state = CreateTestSharedQuadState(

- content_to_target_transform, viewport, pass.get());

+ gfx::Transform quad_to_target_transform;

+ SharedQuadState* shared_state =

+ CreateTestSharedQuadState(quad_to_target_transform, viewport, pass.get());

float vertex_opacity[4] = {1.0f, 1.0f, 1.0f, 1.0f};

TextureDrawQuad* quad = pass->CreateAndAppendDrawQuad<TextureDrawQuad>();

@@ -2597,9 +2571,9 @@ TYPED_TEST(SoftwareRendererPixelTest, TextureDrawQuadLinear) {

scoped_ptr<RenderPass> pass =

CreateTestRenderPass(id, viewport, transform_to_root);

- gfx::Transform content_to_target_transform;

- SharedQuadState* shared_state = CreateTestSharedQuadState(

- content_to_target_transform, viewport, pass.get());

+ gfx::Transform quad_to_target_transform;

+ SharedQuadState* shared_state =

+ CreateTestSharedQuadState(quad_to_target_transform, viewport, pass.get());

float vertex_opacity[4] = {1.0f, 1.0f, 1.0f, 1.0f};

TextureDrawQuad* quad = pass->CreateAndAppendDrawQuad<TextureDrawQuad>();

@@ -2634,7 +2608,7 @@ TYPED_TEST(SoftwareRendererPixelTest, PictureDrawQuadNonIdentityScale) {

// a few extra "cleanup rects" need to be added to clobber the blending

// to make the output image more clean. This will also test subrects

// of the layer.

- gfx::Transform green_content_to_target_transform;

+ gfx::Transform green_quad_to_target_transform;

gfx::Rect green_rect1(gfx::Point(80, 0), gfx::Size(20, 100));

gfx::Rect green_rect2(gfx::Point(0, 80), gfx::Size(100, 20));

@@ -2653,8 +2627,8 @@ TYPED_TEST(SoftwareRendererPixelTest, PictureDrawQuadNonIdentityScale) {

FakePicturePileImpl::CreateFromPile(green_recording.get(), nullptr);

SharedQuadState* top_right_green_shared_quad_state =

- CreateTestSharedQuadState(

- green_content_to_target_transform, viewport, pass.get());

+ CreateTestSharedQuadState(green_quad_to_target_transform, viewport,

+ pass.get());

PictureDrawQuad* green_quad1 =

pass->CreateAndAppendDrawQuad<PictureDrawQuad>();

@@ -2676,10 +2650,8 @@ TYPED_TEST(SoftwareRendererPixelTest, PictureDrawQuadNonIdentityScale) {

gfx::Point(viewport.width() / 2, viewport.height() / 2),

gfx::Size(viewport.width() / 2, viewport.height() / 2));

SharedQuadState* bottom_right_green_shared_state =

- CreateTestSharedQuadStateClipped(green_content_to_target_transform,

- viewport,

- bottom_right_rect,

- pass.get());

+ CreateTestSharedQuadStateClipped(green_quad_to_target_transform, viewport,

+ bottom_right_rect, pass.get());

SolidColorDrawQuad* bottom_right_color_quad =

pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();

bottom_right_color_quad->SetNew(bottom_right_green_shared_state,

@@ -2729,11 +2701,11 @@ TYPED_TEST(SoftwareRendererPixelTest, PictureDrawQuadNonIdentityScale) {

// At a scale of 4x the rectangles with a width of 2.5 will take up 10 pixels,

// so scale an additional 10x to make them 100x100.

- gfx::Transform content_to_target_transform;

- content_to_target_transform.Scale(10.0, 10.0);

+ gfx::Transform quad_to_target_transform;

+ quad_to_target_transform.Scale(10.0, 10.0);

gfx::Rect quad_content_rect(gfx::Size(20, 20));

SharedQuadState* blue_shared_state = CreateTestSharedQuadState(

- content_to_target_transform, quad_content_rect, pass.get());

+ quad_to_target_transform, quad_content_rect, pass.get());

PictureDrawQuad* blue_quad = pass->CreateAndAppendDrawQuad<PictureDrawQuad>();

blue_quad->SetNew(blue_shared_state, quad_content_rect, gfx::Rect(),

@@ -2742,10 +2714,10 @@ TYPED_TEST(SoftwareRendererPixelTest, PictureDrawQuadNonIdentityScale) {

content_union_rect, contents_scale, pile.get());

// Fill left half of viewport with green.

- gfx::Transform half_green_content_to_target_transform;

+ gfx::Transform half_green_quad_to_target_transform;

gfx::Rect half_green_rect(gfx::Size(viewport.width() / 2, viewport.height()));

SharedQuadState* half_green_shared_state = CreateTestSharedQuadState(

- half_green_content_to_target_transform, half_green_rect, pass.get());

+ half_green_quad_to_target_transform, half_green_rect, pass.get());

SolidColorDrawQuad* half_color_quad =

pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();

half_color_quad->SetNew(half_green_shared_state,

@@ -2780,9 +2752,9 @@ TEST_F(GLRendererPixelTestWithFlippedOutputSurface, ExplicitFlipTest) {

scoped_ptr<RenderPass> child_pass =

CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root);

- gfx::Transform content_to_target_transform;

+ gfx::Transform quad_to_target_transform;

SharedQuadState* shared_state = CreateTestSharedQuadState(

- content_to_target_transform, viewport_rect, child_pass.get());

+ quad_to_target_transform, viewport_rect, child_pass.get());

gfx::Rect blue_rect(0,

@@ -2828,9 +2800,9 @@ TEST_F(GLRendererPixelTestWithFlippedOutputSurface, CheckChildPassUnflipped) {

scoped_ptr<RenderPass> child_pass =

CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root);

- gfx::Transform content_to_target_transform;

+ gfx::Transform quad_to_target_transform;

SharedQuadState* shared_state = CreateTestSharedQuadState(

- content_to_target_transform, viewport_rect, child_pass.get());

+ quad_to_target_transform, viewport_rect, child_pass.get());

gfx::Rect blue_rect(0,

@@ -2877,9 +2849,9 @@ TEST_F(GLRendererPixelTest, CheckReadbackSubset) {

scoped_ptr<RenderPass> child_pass =

CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root);

- gfx::Transform content_to_target_transform;

+ gfx::Transform quad_to_target_transform;

SharedQuadState* shared_state = CreateTestSharedQuadState(

- content_to_target_transform, viewport_rect, child_pass.get());

+ quad_to_target_transform, viewport_rect, child_pass.get());

// Draw a green quad full-size with a blue quad in the lower-right corner.

gfx::Rect blue_rect(this->device_viewport_size_.width() * 3 / 4,

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