summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--cc/layers/delegated_renderer_layer_impl_unittest.cc39
-rw-r--r--cc/layers/solid_color_layer_impl_unittest.cc2
-rw-r--r--cc/layers/video_layer_impl_unittest.cc32
-rw-r--r--cc/output/bsp_walk_action.cc4
-rw-r--r--cc/output/direct_renderer.cc18
-rw-r--r--cc/output/gl_renderer.cc113
-rw-r--r--cc/output/overlay_strategy_common.cc11
-rw-r--r--cc/output/overlay_strategy_single_on_top.cc6
-rw-r--r--cc/output/software_renderer.cc24
-rw-r--r--cc/quads/draw_quad.h11
-rw-r--r--cc/surfaces/surface_aggregator.cc37
-rw-r--r--cc/surfaces/surface_aggregator_unittest.cc2
-rw-r--r--cc/test/layer_test_common.cc27
-rw-r--r--cc/trees/layer_tree_host_impl_unittest.cc2
-rw-r--r--cc/trees/layer_tree_host_unittest.cc10
15 files changed, 198 insertions, 140 deletions
diff --git a/cc/layers/delegated_renderer_layer_impl_unittest.cc b/cc/layers/delegated_renderer_layer_impl_unittest.cc
index d5ab06b..cc5f03d 100644
--- a/cc/layers/delegated_renderer_layer_impl_unittest.cc
+++ b/cc/layers/delegated_renderer_layer_impl_unittest.cc
@@ -407,21 +407,26 @@ TEST_F(DelegatedRendererLayerImplTestSimple,
gfx::Transform transform;
transform.Translate(4.0, 4.0);
EXPECT_TRANSFORMATION_MATRIX_EQ(
- transform, frame.render_passes[3]->quad_list.front()->quadTransform());
+ transform, frame.render_passes[3]
+ ->quad_list.front()
+ ->shared_quad_state->content_to_target_transform);
// Quads from non-root RenderPasses should not be shifted though.
ASSERT_EQ(2u, frame.render_passes[2]->quad_list.size());
EXPECT_TRANSFORMATION_MATRIX_EQ(
- gfx::Transform(),
- frame.render_passes[2]->quad_list.front()->quadTransform());
+ gfx::Transform(), frame.render_passes[2]
+ ->quad_list.front()
+ ->shared_quad_state->content_to_target_transform);
EXPECT_TRANSFORMATION_MATRIX_EQ(
- gfx::Transform(),
- frame.render_passes[2]->quad_list.ElementAt(1)->quadTransform());
+ gfx::Transform(), frame.render_passes[2]
+ ->quad_list.ElementAt(1)
+ ->shared_quad_state->content_to_target_transform);
ASSERT_EQ(1u, frame.render_passes[1]->quad_list.size());
EXPECT_TRANSFORMATION_MATRIX_EQ(
- gfx::Transform(),
- frame.render_passes[1]->quad_list.front()->quadTransform());
+ gfx::Transform(), frame.render_passes[1]
+ ->quad_list.front()
+ ->shared_quad_state->content_to_target_transform);
host_impl_->DrawLayers(&frame);
host_impl_->DidDrawAllLayers(frame);
@@ -582,22 +587,26 @@ TEST_F(DelegatedRendererLayerImplTestOwnSurface,
// Because the DelegatedRendererLayer owns a RenderSurfaceImpl, its root
// RenderPass' quads do not need to be translated at all.
EXPECT_TRANSFORMATION_MATRIX_EQ(
- gfx::Transform(),
- frame.render_passes[3]->quad_list.front()->quadTransform());
+ gfx::Transform(), frame.render_passes[3]
+ ->quad_list.front()
+ ->shared_quad_state->content_to_target_transform);
// Quads from non-root RenderPasses should not be shifted either.
ASSERT_EQ(2u, frame.render_passes[2]->quad_list.size());
EXPECT_TRANSFORMATION_MATRIX_EQ(
- gfx::Transform(),
- frame.render_passes[2]->quad_list.front()->quadTransform());
+ gfx::Transform(), frame.render_passes[2]
+ ->quad_list.front()
+ ->shared_quad_state->content_to_target_transform);
EXPECT_TRANSFORMATION_MATRIX_EQ(
- gfx::Transform(),
- frame.render_passes[2]->quad_list.ElementAt(1)->quadTransform());
+ gfx::Transform(), frame.render_passes[2]
+ ->quad_list.ElementAt(1)
+ ->shared_quad_state->content_to_target_transform);
ASSERT_EQ(1u, frame.render_passes[1]->quad_list.size());
EXPECT_TRANSFORMATION_MATRIX_EQ(
- gfx::Transform(),
- frame.render_passes[1]->quad_list.front()->quadTransform());
+ gfx::Transform(), frame.render_passes[1]
+ ->quad_list.front()
+ ->shared_quad_state->content_to_target_transform);
host_impl_->DrawLayers(&frame);
host_impl_->DidDrawAllLayers(frame);
diff --git a/cc/layers/solid_color_layer_impl_unittest.cc b/cc/layers/solid_color_layer_impl_unittest.cc
index 5035ec7..9cfd2ef 100644
--- a/cc/layers/solid_color_layer_impl_unittest.cc
+++ b/cc/layers/solid_color_layer_impl_unittest.cc
@@ -99,7 +99,7 @@ TEST(SolidColorLayerImplTest, VerifyCorrectOpacityInQuad) {
ASSERT_EQ(render_pass->quad_list.size(), 1U);
EXPECT_EQ(opacity,
SolidColorDrawQuad::MaterialCast(render_pass->quad_list.front())
- ->opacity());
+ ->shared_quad_state->opacity);
}
TEST(SolidColorLayerImplTest, VerifyCorrectBlendModeInQuad) {
diff --git a/cc/layers/video_layer_impl_unittest.cc b/cc/layers/video_layer_impl_unittest.cc
index 088560c..56d43a7 100644
--- a/cc/layers/video_layer_impl_unittest.cc
+++ b/cc/layers/video_layer_impl_unittest.cc
@@ -178,8 +178,12 @@ TEST(VideoLayerImplTest, Rotated0) {
gfx::Point3F p1(0, impl.quad_list().front()->rect.height(), 0);
gfx::Point3F p2(impl.quad_list().front()->rect.width(), 0, 0);
- impl.quad_list().front()->quadTransform().TransformPoint(&p1);
- impl.quad_list().front()->quadTransform().TransformPoint(&p2);
+ impl.quad_list()
+ .front()
+ ->shared_quad_state->content_to_target_transform.TransformPoint(&p1);
+ impl.quad_list()
+ .front()
+ ->shared_quad_state->content_to_target_transform.TransformPoint(&p2);
EXPECT_EQ(gfx::Point3F(0, 50, 0), p1);
EXPECT_EQ(gfx::Point3F(100, 0, 0), p2);
}
@@ -214,8 +218,12 @@ TEST(VideoLayerImplTest, Rotated90) {
gfx::Point3F p1(0, impl.quad_list().front()->rect.height(), 0);
gfx::Point3F p2(impl.quad_list().front()->rect.width(), 0, 0);
- impl.quad_list().front()->quadTransform().TransformPoint(&p1);
- impl.quad_list().front()->quadTransform().TransformPoint(&p2);
+ impl.quad_list()
+ .front()
+ ->shared_quad_state->content_to_target_transform.TransformPoint(&p1);
+ impl.quad_list()
+ .front()
+ ->shared_quad_state->content_to_target_transform.TransformPoint(&p2);
EXPECT_EQ(gfx::Point3F(0, 0, 0), p1);
EXPECT_EQ(gfx::Point3F(100, 50, 0), p2);
}
@@ -250,8 +258,12 @@ TEST(VideoLayerImplTest, Rotated180) {
gfx::Point3F p1(0, impl.quad_list().front()->rect.height(), 0);
gfx::Point3F p2(impl.quad_list().front()->rect.width(), 0, 0);
- impl.quad_list().front()->quadTransform().TransformPoint(&p1);
- impl.quad_list().front()->quadTransform().TransformPoint(&p2);
+ impl.quad_list()
+ .front()
+ ->shared_quad_state->content_to_target_transform.TransformPoint(&p1);
+ impl.quad_list()
+ .front()
+ ->shared_quad_state->content_to_target_transform.TransformPoint(&p2);
EXPECT_EQ(gfx::Point3F(100, 0, 0), p1);
EXPECT_EQ(gfx::Point3F(0, 50, 0), p2);
}
@@ -286,8 +298,12 @@ TEST(VideoLayerImplTest, Rotated270) {
gfx::Point3F p1(0, impl.quad_list().front()->rect.height(), 0);
gfx::Point3F p2(impl.quad_list().front()->rect.width(), 0, 0);
- impl.quad_list().front()->quadTransform().TransformPoint(&p1);
- impl.quad_list().front()->quadTransform().TransformPoint(&p2);
+ impl.quad_list()
+ .front()
+ ->shared_quad_state->content_to_target_transform.TransformPoint(&p1);
+ impl.quad_list()
+ .front()
+ ->shared_quad_state->content_to_target_transform.TransformPoint(&p2);
EXPECT_EQ(gfx::Point3F(100, 50, 0), p1);
EXPECT_EQ(gfx::Point3F(0, 0, 0), p2);
}
diff --git a/cc/output/bsp_walk_action.cc b/cc/output/bsp_walk_action.cc
index 9ffc299..ddf39f3 100644
--- a/cc/output/bsp_walk_action.cc
+++ b/cc/output/bsp_walk_action.cc
@@ -27,7 +27,9 @@ BspWalkActionDrawPolygon::BspWalkActionDrawPolygon(
void BspWalkActionDrawPolygon::operator()(DrawPolygon* item) {
gfx::Transform inverse_transform;
bool invertible =
- item->original_ref()->quadTransform().GetInverse(&inverse_transform);
+ item->original_ref()
+ ->shared_quad_state->content_to_target_transform.GetInverse(
+ &inverse_transform);
DCHECK(invertible);
item->TransformToLayerSpace(inverse_transform);
renderer_->DoDrawPolygon(*item, frame_, render_pass_scissor_,
diff --git a/cc/output/direct_renderer.cc b/cc/output/direct_renderer.cc
index 10bba29..3915816 100644
--- a/cc/output/direct_renderer.cc
+++ b/cc/output/direct_renderer.cc
@@ -309,8 +309,8 @@ bool DirectRenderer::ShouldSkipQuad(const DrawQuad& quad,
if (render_pass_scissor.IsEmpty())
return true;
- if (quad.isClipped()) {
- gfx::Rect r = quad.clipRect();
+ if (quad.shared_quad_state->is_clipped) {
+ gfx::Rect r = quad.shared_quad_state->clip_rect;
r.Intersect(render_pass_scissor);
return r.IsEmpty();
}
@@ -325,12 +325,12 @@ void DirectRenderer::SetScissorStateForQuad(
bool use_render_pass_scissor) {
if (use_render_pass_scissor) {
gfx::Rect quad_scissor_rect = render_pass_scissor;
- if (quad.isClipped())
- quad_scissor_rect.Intersect(quad.clipRect());
+ if (quad.shared_quad_state->is_clipped)
+ quad_scissor_rect.Intersect(quad.shared_quad_state->clip_rect);
SetScissorTestRectInDrawSpace(frame, quad_scissor_rect);
return;
- } else if (quad.isClipped()) {
- SetScissorTestRectInDrawSpace(frame, quad.clipRect());
+ } else if (quad.shared_quad_state->is_clipped) {
+ SetScissorTestRectInDrawSpace(frame, quad.shared_quad_state->clip_rect);
return;
}
@@ -460,8 +460,10 @@ void DirectRenderer::DrawRenderPass(DrawingFrame* frame,
// This layer is in a 3D sorting context so we add it to the list of
// polygons to go into the BSP tree.
if (quad.shared_quad_state->sorting_context_id != 0) {
- scoped_ptr<DrawPolygon> new_polygon(new DrawPolygon(
- *it, quad.visible_rect, quad.quadTransform(), next_polygon_id++));
+ scoped_ptr<DrawPolygon> new_polygon(
+ new DrawPolygon(*it, quad.visible_rect,
+ quad.shared_quad_state->content_to_target_transform,
+ next_polygon_id++));
if (new_polygon->points().size() > 2u) {
poly_list.push_back(new_polygon.Pass());
}
diff --git a/cc/output/gl_renderer.cc b/cc/output/gl_renderer.cc
index 50dac6c..faf6bbb 100644
--- a/cc/output/gl_renderer.cc
+++ b/cc/output/gl_renderer.cc
@@ -597,12 +597,10 @@ void GLRenderer::DrawCheckerboardQuad(const DrawingFrame* frame,
gl_->Uniform1f(program->fragment_shader().frequency_location(), frequency);
- SetShaderOpacity(quad->opacity(),
+ SetShaderOpacity(quad->shared_quad_state->opacity,
program->fragment_shader().alpha_location());
- DrawQuadGeometry(frame,
- quad->quadTransform(),
- quad->rect,
- program->vertex_shader().matrix_location());
+ DrawQuadGeometry(frame, quad->shared_quad_state->content_to_target_transform,
+ quad->rect, program->vertex_shader().matrix_location());
}
// This function does not handle 3D sorting right now, since the debug border
@@ -621,7 +619,9 @@ void GLRenderer::DrawDebugBorderQuad(const DrawingFrame* frame,
// partial swaps.
gfx::Rect layer_rect = quad->rect;
gfx::Transform render_matrix;
- QuadRectTransform(&render_matrix, quad->quadTransform(), layer_rect);
+ QuadRectTransform(&render_matrix,
+ quad->shared_quad_state->content_to_target_transform,
+ layer_rect);
GLRenderer::ToGLMatrix(&gl_matrix[0],
frame->projection_matrix * render_matrix);
gl_->UniformMatrix4fv(program->vertex_shader().matrix_location(), 1, false,
@@ -931,7 +931,9 @@ void GLRenderer::DrawRenderPassQuad(DrawingFrame* frame,
DCHECK(contents_texture->id());
gfx::Transform quad_rect_matrix;
- QuadRectTransform(&quad_rect_matrix, quad->quadTransform(), quad->rect);
+ QuadRectTransform(&quad_rect_matrix,
+ quad->shared_quad_state->content_to_target_transform,
+ quad->rect);
gfx::Transform contents_device_transform =
frame->window_matrix * frame->projection_matrix * quad_rect_matrix;
contents_device_transform.FlattenTo2d();
@@ -1242,10 +1244,10 @@ void GLRenderer::DrawRenderPassQuad(DrawingFrame* frame,
}
}
- SetShaderOpacity(quad->opacity(), locations.alpha);
+ SetShaderOpacity(quad->shared_quad_state->opacity, locations.alpha);
SetShaderQuadF(surface_quad, locations.quad);
- DrawQuadGeometry(
- frame, quad->quadTransform(), quad->rect, locations.matrix);
+ DrawQuadGeometry(frame, quad->shared_quad_state->content_to_target_transform,
+ quad->rect, locations.matrix);
// Flush the compositor context before the filter bitmap goes out of
// scope, so the draw gets processed before the filter texture gets deleted.
@@ -1429,8 +1431,9 @@ bool GLRenderer::ShouldAntialiasQuad(const gfx::Transform& device_transform,
// crbug.com/429702
if (!is_render_pass_quad && !quad->IsEdge())
return false;
- gfx::RectF content_rect =
- is_render_pass_quad ? QuadVertexRect() : quad->visibleContentRect();
+ gfx::RectF content_rect = is_render_pass_quad
+ ? QuadVertexRect()
+ : quad->shared_quad_state->visible_content_rect;
bool clipped = false;
gfx::QuadF device_layer_quad =
@@ -1466,9 +1469,10 @@ void GLRenderer::SetupQuadForClippingAndAntialiasing(
local_clip_region = &rotated_clip;
}
- gfx::QuadF content_rect = is_render_pass_quad
- ? gfx::QuadF(QuadVertexRect())
- : gfx::QuadF(quad->visibleContentRect());
+ gfx::QuadF content_rect =
+ is_render_pass_quad
+ ? gfx::QuadF(QuadVertexRect())
+ : gfx::QuadF(quad->shared_quad_state->visible_content_rect);
if (!use_aa) {
if (local_clip_region) {
if (!is_render_pass_quad) {
@@ -1532,7 +1536,7 @@ void GLRenderer::DrawSolidColorQuad(const DrawingFrame* frame,
gfx::Rect tile_rect = quad->visible_rect;
SkColor color = quad->color;
- float opacity = quad->opacity();
+ float opacity = quad->shared_quad_state->opacity;
float alpha = (SkColorGetA(color) * (1.0f / 255.0f)) * opacity;
// Early out if alpha is small enough that quad doesn't contribute to output.
@@ -1541,7 +1545,8 @@ void GLRenderer::DrawSolidColorQuad(const DrawingFrame* frame,
return;
gfx::Transform device_transform =
- frame->window_matrix * frame->projection_matrix * quad->quadTransform();
+ frame->window_matrix * frame->projection_matrix *
+ quad->shared_quad_state->content_to_target_transform;
device_transform.FlattenTo2d();
if (!device_transform.IsInvertible())
return;
@@ -1594,8 +1599,8 @@ void GLRenderer::DrawSolidColorQuad(const DrawingFrame* frame,
gfx::RectF centered_rect(
gfx::PointF(-0.5f * tile_rect.width(), -0.5f * tile_rect.height()),
tile_rect.size());
- DrawQuadGeometry(
- frame, quad->quadTransform(), centered_rect, uniforms.matrix_location);
+ DrawQuadGeometry(frame, quad->shared_quad_state->content_to_target_transform,
+ centered_rect, uniforms.matrix_location);
}
struct TileProgramUniforms {
@@ -1637,7 +1642,8 @@ void GLRenderer::DrawContentQuad(const DrawingFrame* frame,
ResourceId resource_id,
const gfx::QuadF* clip_region) {
gfx::Transform device_transform =
- frame->window_matrix * frame->projection_matrix * quad->quadTransform();
+ frame->window_matrix * frame->projection_matrix *
+ quad->shared_quad_state->content_to_target_transform;
device_transform.FlattenTo2d();
bool use_aa = settings_->allow_antialiasing &&
@@ -1758,7 +1764,7 @@ void GLRenderer::DrawContentQuadAA(const DrawingFrame* frame,
// Normalize to tile_rect.
local_quad.Scale(1.0f / tile_rect.width(), 1.0f / tile_rect.height());
- SetShaderOpacity(quad->opacity(), uniforms.alpha_location);
+ SetShaderOpacity(quad->shared_quad_state->opacity, uniforms.alpha_location);
SetShaderQuadF(local_quad, uniforms.quad_location);
// The transform and vertex data are used to figure out the extents that the
@@ -1768,8 +1774,8 @@ void GLRenderer::DrawContentQuadAA(const DrawingFrame* frame,
gfx::RectF centered_rect(
gfx::PointF(-0.5f * tile_rect.width(), -0.5f * tile_rect.height()),
tile_rect.size());
- DrawQuadGeometry(
- frame, quad->quadTransform(), centered_rect, uniforms.matrix_location);
+ DrawQuadGeometry(frame, quad->shared_quad_state->content_to_target_transform,
+ centered_rect, uniforms.matrix_location);
}
void GLRenderer::DrawContentQuadNoAA(const DrawingFrame* frame,
@@ -1783,11 +1789,12 @@ void GLRenderer::DrawContentQuadNoAA(const DrawingFrame* frame,
quad->rect.height() / quad->tex_coord_rect.height();
bool scaled = (tex_to_geom_scale_x != 1.f || tex_to_geom_scale_y != 1.f);
- GLenum filter =
- (scaled || !quad->quadTransform().IsIdentityOrIntegerTranslation()) &&
- !quad->nearest_neighbor
- ? GL_LINEAR
- : GL_NEAREST;
+ GLenum filter = (scaled ||
+ !quad->shared_quad_state->content_to_target_transform
+ .IsIdentityOrIntegerTranslation()) &&
+ !quad->nearest_neighbor
+ ? GL_LINEAR
+ : GL_NEAREST;
ResourceProvider::ScopedSamplerGL quad_resource_lock(
resource_provider_, resource_id, filter);
@@ -1840,7 +1847,7 @@ void GLRenderer::DrawContentQuadNoAA(const DrawingFrame* frame,
SetBlendEnabled(quad->ShouldDrawWithBlending());
- SetShaderOpacity(quad->opacity(), uniforms.alpha_location);
+ SetShaderOpacity(quad->shared_quad_state->opacity, uniforms.alpha_location);
// Pass quad coordinates to the uniform in the same order as GeometryBinding
// does, then vertices will match the texture mapping in the vertex buffer.
@@ -1881,7 +1888,9 @@ void GLRenderer::DrawContentQuadNoAA(const DrawingFrame* frame,
gl_->Uniform2fv(uniforms.quad_location, 4, gl_quad);
static float gl_matrix[16];
- ToGLMatrix(&gl_matrix[0], frame->projection_matrix * quad->quadTransform());
+ ToGLMatrix(&gl_matrix[0],
+ frame->projection_matrix *
+ quad->shared_quad_state->content_to_target_transform);
gl_->UniformMatrix4fv(uniforms.matrix_location, 1, false, &gl_matrix[0]);
gl_->DrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);
@@ -2087,17 +2096,20 @@ void GLRenderer::DrawYUVVideoQuad(const DrawingFrame* frame,
gl_->UniformMatrix3fv(yuv_matrix_location, 1, 0, yuv_to_rgb);
gl_->Uniform3fv(yuv_adj_location, 1, yuv_adjust);
- SetShaderOpacity(quad->opacity(), alpha_location);
+ SetShaderOpacity(quad->shared_quad_state->opacity, alpha_location);
if (!clip_region) {
- DrawQuadGeometry(frame, quad->quadTransform(), tile_rect, matrix_location);
+ DrawQuadGeometry(frame,
+ quad->shared_quad_state->content_to_target_transform,
+ tile_rect, matrix_location);
} else {
float uvs[8] = {0};
GetScaledUVs(quad->visible_rect, clip_region, uvs);
gfx::QuadF region_quad = *clip_region;
region_quad.Scale(1.0f / tile_rect.width(), 1.0f / tile_rect.height());
region_quad -= gfx::Vector2dF(0.5f, 0.5f);
- DrawQuadGeometryClippedByQuadF(frame, quad->quadTransform(), tile_rect,
- region_quad, matrix_location, uvs);
+ DrawQuadGeometryClippedByQuadF(
+ frame, quad->shared_quad_state->content_to_target_transform, tile_rect,
+ region_quad, matrix_location, uvs);
}
}
@@ -2131,11 +2143,12 @@ void GLRenderer::DrawStreamVideoQuad(const DrawingFrame* frame,
gl_->Uniform1i(program->fragment_shader().sampler_location(), 0);
- SetShaderOpacity(quad->opacity(),
+ SetShaderOpacity(quad->shared_quad_state->opacity,
program->fragment_shader().alpha_location());
if (!clip_region) {
- DrawQuadGeometry(frame, quad->quadTransform(), quad->rect,
- program->vertex_shader().matrix_location());
+ DrawQuadGeometry(frame,
+ quad->shared_quad_state->content_to_target_transform,
+ quad->rect, program->vertex_shader().matrix_location());
} else {
gfx::QuadF region_quad(*clip_region);
region_quad.Scale(1.0f / quad->rect.width(), 1.0f / quad->rect.height());
@@ -2143,8 +2156,8 @@ void GLRenderer::DrawStreamVideoQuad(const DrawingFrame* frame,
float uvs[8] = {0};
GetScaledUVs(quad->visible_rect, clip_region, uvs);
DrawQuadGeometryClippedByQuadF(
- frame, quad->quadTransform(), quad->rect, region_quad,
- program->vertex_shader().matrix_location(), uvs);
+ frame, quad->shared_quad_state->content_to_target_transform, quad->rect,
+ region_quad, program->vertex_shader().matrix_location(), uvs);
}
}
@@ -2313,7 +2326,7 @@ void GLRenderer::EnqueueTextureQuad(const DrawingFrame* frame,
}
// Generate the vertex opacity
- const float opacity = quad->opacity();
+ const float opacity = quad->shared_quad_state->opacity;
draw_cache_.vertex_opacity_data.push_back(quad->vertex_opacity[0] * opacity);
draw_cache_.vertex_opacity_data.push_back(quad->vertex_opacity[1] * opacity);
draw_cache_.vertex_opacity_data.push_back(quad->vertex_opacity[2] * opacity);
@@ -2321,7 +2334,9 @@ void GLRenderer::EnqueueTextureQuad(const DrawingFrame* frame,
// Generate the transform matrix
gfx::Transform quad_rect_matrix;
- QuadRectTransform(&quad_rect_matrix, quad->quadTransform(), quad->rect);
+ QuadRectTransform(&quad_rect_matrix,
+ quad->shared_quad_state->content_to_target_transform,
+ quad->rect);
quad_rect_matrix = frame->projection_matrix * quad_rect_matrix;
Float16 m;
@@ -2376,8 +2391,10 @@ void GLRenderer::DrawIOSurfaceQuad(const DrawingFrame* frame,
quad->io_surface_size.height());
}
- const float vertex_opacity[] = {quad->opacity(), quad->opacity(),
- quad->opacity(), quad->opacity()};
+ const float vertex_opacity[] = {quad->shared_quad_state->opacity,
+ quad->shared_quad_state->opacity,
+ quad->shared_quad_state->opacity,
+ quad->shared_quad_state->opacity};
gl_->Uniform1fv(binding.vertex_opacity_location, 4, vertex_opacity);
ResourceProvider::ScopedReadLockGL lock(resource_provider_,
@@ -2386,13 +2403,15 @@ void GLRenderer::DrawIOSurfaceQuad(const DrawingFrame* frame,
gl_->BindTexture(GL_TEXTURE_RECTANGLE_ARB, lock.texture_id());
if (!clip_region) {
- DrawQuadGeometry(frame, quad->quadTransform(), quad->rect,
- binding.matrix_location);
+ DrawQuadGeometry(frame,
+ quad->shared_quad_state->content_to_target_transform,
+ quad->rect, binding.matrix_location);
} else {
float uvs[8] = {0};
GetScaledUVs(quad->visible_rect, clip_region, uvs);
- DrawQuadGeometryClippedByQuadF(frame, quad->quadTransform(), quad->rect,
- *clip_region, binding.matrix_location, uvs);
+ DrawQuadGeometryClippedByQuadF(
+ frame, quad->shared_quad_state->content_to_target_transform, quad->rect,
+ *clip_region, binding.matrix_location, uvs);
}
gl_->BindTexture(GL_TEXTURE_RECTANGLE_ARB, 0);
diff --git a/cc/output/overlay_strategy_common.cc b/cc/output/overlay_strategy_common.cc
index 93bd15c..6fa778a 100644
--- a/cc/output/overlay_strategy_common.cc
+++ b/cc/output/overlay_strategy_common.cc
@@ -46,7 +46,7 @@ bool OverlayStrategyCommon::IsInvisibleQuad(const DrawQuad* draw_quad) {
const SolidColorDrawQuad* solid_quad =
SolidColorDrawQuad::MaterialCast(draw_quad);
SkColor color = solid_quad->color;
- float opacity = solid_quad->opacity();
+ float opacity = solid_quad->shared_quad_state->opacity;
float alpha = (SkColorGetA(color) * (1.0f / 255.0f)) * opacity;
return solid_quad->ShouldDrawWithBlending() &&
alpha < std::numeric_limits<float>::epsilon();
@@ -57,8 +57,8 @@ bool OverlayStrategyCommon::IsInvisibleQuad(const DrawQuad* draw_quad) {
bool OverlayStrategyCommon::GetTextureQuadInfo(const TextureDrawQuad& quad,
OverlayCandidate* quad_info) {
gfx::OverlayTransform overlay_transform =
- OverlayCandidate::GetOverlayTransform(quad.quadTransform(),
- quad.y_flipped);
+ OverlayCandidate::GetOverlayTransform(
+ quad.shared_quad_state->content_to_target_transform, quad.y_flipped);
if (quad.background_color != SK_ColorTRANSPARENT ||
quad.premultiplied_alpha ||
overlay_transform == gfx::OVERLAY_TRANSFORM_INVALID)
@@ -72,7 +72,8 @@ bool OverlayStrategyCommon::GetTextureQuadInfo(const TextureDrawQuad& quad,
bool OverlayStrategyCommon::GetVideoQuadInfo(const StreamVideoDrawQuad& quad,
OverlayCandidate* quad_info) {
gfx::OverlayTransform overlay_transform =
- OverlayCandidate::GetOverlayTransform(quad.quadTransform(), false);
+ OverlayCandidate::GetOverlayTransform(
+ quad.shared_quad_state->content_to_target_transform, false);
if (overlay_transform == gfx::OVERLAY_TRANSFORM_INVALID)
return false;
if (!quad.matrix.IsScaleOrTranslation()) {
@@ -130,7 +131,7 @@ bool OverlayStrategyCommon::GetCandidateQuadInfo(const DrawQuad& draw_quad,
quad_info->format = RGBA_8888;
quad_info->display_rect = OverlayCandidate::GetOverlayRect(
- draw_quad.quadTransform(), draw_quad.rect);
+ draw_quad.shared_quad_state->content_to_target_transform, draw_quad.rect);
return true;
}
diff --git a/cc/output/overlay_strategy_single_on_top.cc b/cc/output/overlay_strategy_single_on_top.cc
index 7cb0dca..921dba7 100644
--- a/cc/output/overlay_strategy_single_on_top.cc
+++ b/cc/output/overlay_strategy_single_on_top.cc
@@ -36,11 +36,13 @@ bool OverlayStrategySingleOnTop::Attempt(
// Check that no prior quads overlap it.
bool intersects = false;
gfx::RectF rect = draw_quad->rect;
- draw_quad->quadTransform().TransformRect(&rect);
+ draw_quad->shared_quad_state->content_to_target_transform.TransformRect(
+ &rect);
for (auto overlap_iter = quad_list.cbegin(); overlap_iter != it;
++overlap_iter) {
gfx::RectF overlap_rect = overlap_iter->rect;
- overlap_iter->quadTransform().TransformRect(&overlap_rect);
+ overlap_iter->shared_quad_state->content_to_target_transform
+ .TransformRect(&overlap_rect);
if (rect.Intersects(overlap_rect) && !IsInvisibleQuad(*overlap_iter)) {
intersects = true;
break;
diff --git a/cc/output/software_renderer.cc b/cc/output/software_renderer.cc
index 992dbc9..e7540ccb 100644
--- a/cc/output/software_renderer.cc
+++ b/cc/output/software_renderer.cc
@@ -250,7 +250,9 @@ void SoftwareRenderer::DoDrawQuad(DrawingFrame* frame,
TRACE_EVENT0("cc", "SoftwareRenderer::DoDrawQuad");
gfx::Transform quad_rect_matrix;
- QuadRectTransform(&quad_rect_matrix, quad->quadTransform(), quad->rect);
+ QuadRectTransform(&quad_rect_matrix,
+ quad->shared_quad_state->content_to_target_transform,
+ quad->rect);
gfx::Transform contents_device_transform =
frame->window_matrix * frame->projection_matrix * quad_rect_matrix;
contents_device_transform.FlattenTo2d();
@@ -276,7 +278,7 @@ void SoftwareRenderer::DoDrawQuad(DrawingFrame* frame,
if (quad->ShouldDrawWithBlending() ||
quad->shared_quad_state->blend_mode != SkXfermode::kSrcOver_Mode) {
- current_paint_.setAlpha(quad->opacity() * 255);
+ current_paint_.setAlpha(quad->shared_quad_state->opacity * 255);
current_paint_.setXfermodeMode(quad->shared_quad_state->blend_mode);
} else {
current_paint_.setXfermodeMode(SkXfermode::kSrc_Mode);
@@ -351,7 +353,7 @@ void SoftwareRenderer::DrawCheckerboardQuad(const DrawingFrame* frame,
gfx::RectF visible_quad_vertex_rect = MathUtil::ScaleRectProportional(
QuadVertexRect(), quad->rect, quad->visible_rect);
current_paint_.setColor(quad->color);
- current_paint_.setAlpha(quad->opacity());
+ current_paint_.setAlpha(quad->shared_quad_state->opacity);
current_canvas_->drawRect(gfx::RectFToSkRect(visible_quad_vertex_rect),
current_paint_);
}
@@ -368,7 +370,8 @@ void SoftwareRenderer::DrawDebugBorderQuad(const DrawingFrame* frame,
current_canvas_->resetMatrix();
current_paint_.setColor(quad->color);
- current_paint_.setAlpha(quad->opacity() * SkColorGetA(quad->color));
+ current_paint_.setAlpha(quad->shared_quad_state->opacity *
+ SkColorGetA(quad->color));
current_paint_.setStyle(SkPaint::kStroke_Style);
current_paint_.setStrokeWidth(quad->width);
current_canvas_->drawPoints(SkCanvas::kPolygon_PointMode,
@@ -387,10 +390,10 @@ void SoftwareRenderer::DrawPictureQuad(const DrawingFrame* frame,
// TODO(aelias): This isn't correct in all cases. We should detect these
// cases and fall back to a persistent bitmap backing
// (http://crbug.com/280374).
- skia::RefPtr<SkDrawFilter> opacity_filter =
- skia::AdoptRef(new skia::OpacityDrawFilter(
- quad->opacity(), frame->disable_picture_quad_image_filtering ||
- quad->nearest_neighbor));
+ skia::RefPtr<SkDrawFilter> opacity_filter = skia::AdoptRef(
+ new skia::OpacityDrawFilter(quad->shared_quad_state->opacity,
+ frame->disable_picture_quad_image_filtering ||
+ quad->nearest_neighbor));
DCHECK(!current_canvas_->getDrawFilter());
current_canvas_->setDrawFilter(opacity_filter.get());
@@ -408,7 +411,8 @@ void SoftwareRenderer::DrawSolidColorQuad(const DrawingFrame* frame,
gfx::RectF visible_quad_vertex_rect = MathUtil::ScaleRectProportional(
QuadVertexRect(), quad->rect, quad->visible_rect);
current_paint_.setColor(quad->color);
- current_paint_.setAlpha(quad->opacity() * SkColorGetA(quad->color));
+ current_paint_.setAlpha(quad->shared_quad_state->opacity *
+ SkColorGetA(quad->color));
current_canvas_->drawRect(gfx::RectFToSkRect(visible_quad_vertex_rect),
current_paint_);
}
@@ -607,7 +611,7 @@ void SoftwareRenderer::DrawUnsupportedQuad(const DrawingFrame* frame,
#else
current_paint_.setColor(SK_ColorMAGENTA);
#endif
- current_paint_.setAlpha(quad->opacity() * 255);
+ current_paint_.setAlpha(quad->shared_quad_state->opacity * 255);
current_canvas_->drawRect(gfx::RectFToSkRect(QuadVertexRect()),
current_paint_);
}
diff --git a/cc/quads/draw_quad.h b/cc/quads/draw_quad.h
index fa1959b..07bf177 100644
--- a/cc/quads/draw_quad.h
+++ b/cc/quads/draw_quad.h
@@ -51,17 +51,6 @@ class CC_EXPORT DrawQuad {
virtual ~DrawQuad();
- // TODO(danakj): Chromify or remove these SharedQuadState helpers.
- const gfx::Transform& quadTransform() const {
- return shared_quad_state->content_to_target_transform;
- }
- gfx::Rect visibleContentRect() const {
- return shared_quad_state->visible_content_rect;
- }
- gfx::Rect clipRect() const { return shared_quad_state->clip_rect; }
- bool isClipped() const { return shared_quad_state->is_clipped; }
- float opacity() const { return shared_quad_state->opacity; }
-
Material material;
// This rect, after applying the quad_transform(), gives the geometry that
diff --git a/cc/surfaces/surface_aggregator.cc b/cc/surfaces/surface_aggregator.cc
index 531e2d2..16f91da 100644
--- a/cc/surfaces/surface_aggregator.cc
+++ b/cc/surfaces/surface_aggregator.cc
@@ -231,7 +231,8 @@ void SurfaceAggregator::HandleSurfaceQuad(
const ResourceProvider::ResourceIdMap& child_to_parent_map =
provider_ ? provider_->GetChildToParentMap(ChildIdForSurface(surface))
: ResourceProvider::ResourceIdMap();
- bool merge_pass = surface_quad->opacity() == 1.f && copy_requests.empty();
+ bool merge_pass =
+ surface_quad->shared_quad_state->opacity == 1.f && copy_requests.empty();
gfx::Rect surface_damage = DamageRectForSurface(
surface, *render_pass_list.back(), surface_quad->visible_rect);
@@ -257,7 +258,7 @@ void SurfaceAggregator::HandleSurfaceQuad(
// transform of the surface quad into account to update their transform to
// the root surface.
copy_pass->transform_to_root_target.ConcatTransform(
- surface_quad->quadTransform());
+ surface_quad->shared_quad_state->content_to_target_transform);
copy_pass->transform_to_root_target.ConcatTransform(target_transform);
copy_pass->transform_to_root_target.ConcatTransform(
dest_pass->transform_to_root_target);
@@ -277,16 +278,20 @@ void SurfaceAggregator::HandleSurfaceQuad(
// TODO(jamesr): Clean up last pass special casing.
const QuadList& quads = last_pass.quad_list;
- gfx::Transform surface_transform = surface_quad->quadTransform();
+ gfx::Transform surface_transform =
+ surface_quad->shared_quad_state->content_to_target_transform;
surface_transform.ConcatTransform(target_transform);
// Intersect the transformed visible rect and the clip rect to create a
// smaller cliprect for the quad.
ClipData surface_quad_clip_rect(
- true, MathUtil::MapEnclosingClippedRect(surface_quad->quadTransform(),
- surface_quad->visible_rect));
- if (surface_quad->isClipped())
- surface_quad_clip_rect.rect.Intersect(surface_quad->clipRect());
+ true, MathUtil::MapEnclosingClippedRect(
+ surface_quad->shared_quad_state->content_to_target_transform,
+ surface_quad->visible_rect));
+ if (surface_quad->shared_quad_state->is_clipped) {
+ surface_quad_clip_rect.rect.Intersect(
+ surface_quad->shared_quad_state->clip_rect);
+ }
ClipData quads_clip =
CalculateClipRect(clip_rect, surface_quad_clip_rect, target_transform);
@@ -315,10 +320,11 @@ void SurfaceAggregator::HandleSurfaceQuad(
gfx::Vector2dF(),
FilterOperations());
}
- dest_pass->damage_rect =
- gfx::UnionRects(dest_pass->damage_rect,
- MathUtil::MapEnclosingClippedRect(
- surface_quad->quadTransform(), surface_damage));
+ dest_pass->damage_rect = gfx::UnionRects(
+ dest_pass->damage_rect,
+ MathUtil::MapEnclosingClippedRect(
+ surface_quad->shared_quad_state->content_to_target_transform,
+ surface_damage));
referenced_surfaces_.erase(it);
}
@@ -394,10 +400,11 @@ void SurfaceAggregator::CopyQuadsToPass(
dest_quad = dest_pass->CopyFromAndAppendRenderPassDrawQuad(
pass_quad, dest_pass->shared_quad_state_list.back(),
remapped_pass_id);
- dest_pass->damage_rect =
- gfx::UnionRects(dest_pass->damage_rect,
- MathUtil::MapEnclosingClippedRect(
- dest_quad->quadTransform(), pass_damage));
+ dest_pass->damage_rect = gfx::UnionRects(
+ dest_pass->damage_rect,
+ MathUtil::MapEnclosingClippedRect(
+ dest_quad->shared_quad_state->content_to_target_transform,
+ pass_damage));
} else {
dest_quad = dest_pass->CopyFromAndAppendDrawQuad(
quad, dest_pass->shared_quad_state_list.back());
diff --git a/cc/surfaces/surface_aggregator_unittest.cc b/cc/surfaces/surface_aggregator_unittest.cc
index 1fb5163..ac81b3b 100644
--- a/cc/surfaces/surface_aggregator_unittest.cc
+++ b/cc/surfaces/surface_aggregator_unittest.cc
@@ -1036,7 +1036,7 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateMultiplePassWithTransform) {
iter != aggregated_pass_list[1]->quad_list.cend();
++iter) {
EXPECT_EQ(expected_root_pass_quad_transforms[iter.index()].ToString(),
- iter->quadTransform().ToString())
+ iter->shared_quad_state->content_to_target_transform.ToString())
<< iter.index();
}
diff --git a/cc/test/layer_test_common.cc b/cc/test/layer_test_common.cc
index 83f756d..8ae9aef 100644
--- a/cc/test/layer_test_common.cc
+++ b/cc/test/layer_test_common.cc
@@ -41,8 +41,9 @@ void LayerTestCommon::VerifyQuadsExactlyCoverRect(const QuadList& quads,
Region remaining = rect;
for (auto iter = quads.cbegin(); iter != quads.cend(); ++iter) {
- gfx::RectF quad_rectf =
- MathUtil::MapClippedRect(iter->quadTransform(), gfx::RectF(iter->rect));
+ gfx::RectF quad_rectf = MathUtil::MapClippedRect(
+ iter->shared_quad_state->content_to_target_transform,
+ gfx::RectF(iter->rect));
// Before testing for exact coverage in the integer world, assert that
// rounding will not round the rect incorrectly.
@@ -69,25 +70,29 @@ void LayerTestCommon::VerifyQuadsAreOccluded(const QuadList& quads,
// No quad should exist if it's fully occluded.
for (const auto& quad : quads) {
gfx::Rect target_visible_rect = MathUtil::MapEnclosingClippedRect(
- quad->quadTransform(), quad->visible_rect);
+ quad->shared_quad_state->content_to_target_transform,
+ quad->visible_rect);
EXPECT_FALSE(occluded.Contains(target_visible_rect));
}
// Quads that are fully occluded on one axis only should be shrunken.
for (const auto& quad : quads) {
- gfx::Rect target_rect =
- MathUtil::MapEnclosingClippedRect(quad->quadTransform(), quad->rect);
- if (!quad->quadTransform().IsIdentityOrIntegerTranslation()) {
- DCHECK(quad->quadTransform().IsPositiveScaleOrTranslation())
- << quad->quadTransform().ToString();
- gfx::RectF target_rectf =
- MathUtil::MapClippedRect(quad->quadTransform(), quad->rect);
+ gfx::Rect target_rect = MathUtil::MapEnclosingClippedRect(
+ quad->shared_quad_state->content_to_target_transform, quad->rect);
+ if (!quad->shared_quad_state->content_to_target_transform
+ .IsIdentityOrIntegerTranslation()) {
+ DCHECK(quad->shared_quad_state->content_to_target_transform
+ .IsPositiveScaleOrTranslation())
+ << quad->shared_quad_state->content_to_target_transform.ToString();
+ gfx::RectF target_rectf = MathUtil::MapClippedRect(
+ quad->shared_quad_state->content_to_target_transform, quad->rect);
// Scale transforms allowed, as long as the final transformed rect
// ends up on integer boundaries for ease of testing.
DCHECK_EQ(target_rectf.ToString(), gfx::RectF(target_rect).ToString());
}
gfx::Rect target_visible_rect = MathUtil::MapEnclosingClippedRect(
- quad->quadTransform(), quad->visible_rect);
+ quad->shared_quad_state->content_to_target_transform,
+ quad->visible_rect);
bool fully_occluded_horizontal = target_rect.x() >= occluded.x() &&
target_rect.right() <= occluded.right();
diff --git a/cc/trees/layer_tree_host_impl_unittest.cc b/cc/trees/layer_tree_host_impl_unittest.cc
index cd3d58c..912d1c0 100644
--- a/cc/trees/layer_tree_host_impl_unittest.cc
+++ b/cc/trees/layer_tree_host_impl_unittest.cc
@@ -5829,7 +5829,7 @@ TEST_F(LayerTreeHostImplTest, FarAwayQuadsDontNeedAA) {
bool antialiased =
GLRendererWithSetupQuadForAntialiasing::ShouldAntialiasQuad(
- quad->quadTransform(), quad, false);
+ quad->shared_quad_state->content_to_target_transform, quad, false);
EXPECT_FALSE(antialiased);
host_impl_->DrawLayers(&frame);
diff --git a/cc/trees/layer_tree_host_unittest.cc b/cc/trees/layer_tree_host_unittest.cc
index 715165d..427b649 100644
--- a/cc/trees/layer_tree_host_unittest.cc
+++ b/cc/trees/layer_tree_host_unittest.cc
@@ -6040,8 +6040,9 @@ class LayerTreeHostTestCrispUpAfterPinchEnds : public LayerTreeHostTest {
const TileDrawQuad* quad = TileDrawQuad::MaterialCast(draw_quad);
float quad_scale =
quad->tex_coord_rect.width() / static_cast<float>(quad->rect.width());
- float transform_scale =
- SkMScalarToFloat(quad->quadTransform().matrix().get(0, 0));
+ float transform_scale = SkMScalarToFloat(
+ quad->shared_quad_state->content_to_target_transform.matrix().get(0,
+ 0));
float scale = quad_scale / transform_scale;
if (frame_scale != 0.f && frame_scale != scale)
return 0.f;
@@ -6343,8 +6344,9 @@ class LayerTreeHostTestContinuousDrawWhenCreatingVisibleTiles
const TileDrawQuad* quad = TileDrawQuad::MaterialCast(draw_quad);
float quad_scale =
quad->tex_coord_rect.width() / static_cast<float>(quad->rect.width());
- float transform_scale =
- SkMScalarToFloat(quad->quadTransform().matrix().get(0, 0));
+ float transform_scale = SkMScalarToFloat(
+ quad->shared_quad_state->content_to_target_transform.matrix().get(0,
+ 0));
float scale = quad_scale / transform_scale;
if (frame_scale != 0.f && frame_scale != scale)
return 0.f;
generated by cgit v1.1 at 2025-03-01 09:31:52 +0000