cc: Rename visible_content_rect and content stuff on quads.
This renames visible_content_rect to visible_layer_rect. And for
SharedQuadState renames the transforms and rects to no longer refer
to "content" and instead refer to the space the the DrawQuad rects.
R=enne, vmpstr
TBR=dcheng
BUG=413479
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel
Review URL: https://codereview.chromium.org/1175113010
Cr-Commit-Position: refs/heads/master@{#335172}
diff --git a/cc/debug/invalidation_benchmark.cc b/cc/debug/invalidation_benchmark.cc
index 6fd3d3e..8a9fc88 100644
--- a/cc/debug/invalidation_benchmark.cc
+++ b/cc/debug/invalidation_benchmark.cc
@@ -71,9 +71,9 @@
switch (mode_) {
case FIXED_SIZE: {
// Invalidation with a random position and fixed size.
- gfx::Rect visible_content_rect = layer->visible_content_rect();
- int x = LCGRandom() * (visible_content_rect.width() - width_);
- int y = LCGRandom() * (visible_content_rect.height() - height_);
+ gfx::Rect visible_layer_rect = layer->visible_layer_rect();
+ int x = LCGRandom() * (visible_layer_rect.width() - width_);
+ int y = LCGRandom() * (visible_layer_rect.height() - height_);
gfx::Rect invalidation_rect(x, y, width_, height_);
layer->SetNeedsDisplayRect(invalidation_rect);
break;
@@ -85,11 +85,11 @@
}
case RANDOM: {
// Random invalidation inside the viewport.
- gfx::Rect visible_content_rect = layer->visible_content_rect();
- int x_min = LCGRandom() * visible_content_rect.width();
- int x_max = LCGRandom() * visible_content_rect.width();
- int y_min = LCGRandom() * visible_content_rect.height();
- int y_max = LCGRandom() * visible_content_rect.height();
+ gfx::Rect visible_layer_rect = layer->visible_layer_rect();
+ int x_min = LCGRandom() * visible_layer_rect.width();
+ int x_max = LCGRandom() * visible_layer_rect.width();
+ int y_min = LCGRandom() * visible_layer_rect.height();
+ int y_max = LCGRandom() * visible_layer_rect.height();
if (x_min > x_max)
std::swap(x_min, x_max);
if (y_min > y_max)
@@ -100,7 +100,7 @@
}
case VIEWPORT: {
// Invalidate entire viewport.
- layer->SetNeedsDisplayRect(layer->visible_content_rect());
+ layer->SetNeedsDisplayRect(layer->visible_layer_rect());
break;
}
}
diff --git a/cc/debug/rasterize_and_record_benchmark.cc b/cc/debug/rasterize_and_record_benchmark.cc
index 4f335d7..bed367d 100644
--- a/cc/debug/rasterize_and_record_benchmark.cc
+++ b/cc/debug/rasterize_and_record_benchmark.cc
@@ -109,7 +109,7 @@
void RasterizeAndRecordBenchmark::RunOnLayer(PictureLayer* layer) {
DCHECK(host_);
- gfx::Rect visible_layer_rect = layer->visible_content_rect();
+ gfx::Rect visible_layer_rect = layer->visible_layer_rect();
if (visible_layer_rect.IsEmpty())
return;
diff --git a/cc/debug/rasterize_and_record_benchmark_impl.cc b/cc/debug/rasterize_and_record_benchmark_impl.cc
index 25032dc..51e20ee 100644
--- a/cc/debug/rasterize_and_record_benchmark_impl.cc
+++ b/cc/debug/rasterize_and_record_benchmark_impl.cc
@@ -158,7 +158,7 @@
rasterize_results_.total_picture_layers_with_no_content++;
return;
}
- if (layer->visible_content_rect().IsEmpty()) {
+ if (layer->visible_layer_rect().IsEmpty()) {
rasterize_results_.total_picture_layers_off_screen++;
return;
}
@@ -181,7 +181,7 @@
tiling->CreateAllTilesForTesting();
RasterSource* raster_source = tiling->raster_source();
for (PictureLayerTiling::CoverageIterator it(tiling, 1.f,
- layer->visible_content_rect());
+ layer->visible_layer_rect());
it; ++it) {
DCHECK(*it);
diff --git a/cc/layers/append_quads_data.h b/cc/layers/append_quads_data.h
index 50f58775..45b0c17 100644
--- a/cc/layers/append_quads_data.h
+++ b/cc/layers/append_quads_data.h
@@ -14,7 +14,7 @@
AppendQuadsData()
: num_incomplete_tiles(0),
num_missing_tiles(0),
- visible_content_area(0),
+ visible_layer_area(0),
approximated_visible_content_area(0),
checkerboarded_visible_content_area(0) {}
@@ -23,7 +23,7 @@
// Set by the layer appending quads.
int64 num_missing_tiles;
// Set by the layer appending quads.
- int64 visible_content_area;
+ int64 visible_layer_area;
// Set by the layer appending quads.
int64 approximated_visible_content_area;
// Set by the layer appending quads.
diff --git a/cc/layers/delegated_renderer_layer_impl.cc b/cc/layers/delegated_renderer_layer_impl.cc
index 01ae74f..9235af5 100644
--- a/cc/layers/delegated_renderer_layer_impl.cc
+++ b/cc/layers/delegated_renderer_layer_impl.cc
@@ -429,7 +429,7 @@
output_shared_quad_state->CopyFrom(delegated_shared_quad_state);
if (is_root_delegated_render_pass) {
- output_shared_quad_state->content_to_target_transform.ConcatTransform(
+ output_shared_quad_state->quad_to_target_transform.ConcatTransform(
delegated_frame_to_target_transform);
if (render_target() == this) {
@@ -457,7 +457,7 @@
DCHECK(output_shared_quad_state);
gfx::Transform quad_content_to_delegated_target_space =
- output_shared_quad_state->content_to_target_transform;
+ output_shared_quad_state->quad_to_target_transform;
if (!is_root_delegated_render_pass) {
quad_content_to_delegated_target_space.ConcatTransform(
delegated_render_pass->transform_to_root_target);
diff --git a/cc/layers/delegated_renderer_layer_impl_unittest.cc b/cc/layers/delegated_renderer_layer_impl_unittest.cc
index 7fe6249..a2e8d70 100644
--- a/cc/layers/delegated_renderer_layer_impl_unittest.cc
+++ b/cc/layers/delegated_renderer_layer_impl_unittest.cc
@@ -404,7 +404,7 @@
EXPECT_TRANSFORMATION_MATRIX_EQ(
transform, frame.render_passes[3]
->quad_list.front()
- ->shared_quad_state->content_to_target_transform);
+ ->shared_quad_state->quad_to_target_transform);
// Quads from non-root RenderPasses should not be shifted though.
ASSERT_EQ(2u, frame.render_passes[2]->quad_list.size());
@@ -412,16 +412,16 @@
EXPECT_TRANSFORMATION_MATRIX_EQ(
gfx::Transform(), frame.render_passes[2]
->quad_list.front()
- ->shared_quad_state->content_to_target_transform);
+ ->shared_quad_state->quad_to_target_transform);
EXPECT_TRANSFORMATION_MATRIX_EQ(
gfx::Transform(), frame.render_passes[2]
->quad_list.ElementAt(1)
- ->shared_quad_state->content_to_target_transform);
+ ->shared_quad_state->quad_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()
- ->shared_quad_state->content_to_target_transform);
+ ->shared_quad_state->quad_to_target_transform);
host_impl_->DrawLayers(&frame);
host_impl_->DidDrawAllLayers(frame);
@@ -584,7 +584,7 @@
EXPECT_TRANSFORMATION_MATRIX_EQ(
gfx::Transform(), frame.render_passes[3]
->quad_list.front()
- ->shared_quad_state->content_to_target_transform);
+ ->shared_quad_state->quad_to_target_transform);
// Quads from non-root RenderPasses should not be shifted either.
ASSERT_EQ(2u, frame.render_passes[2]->quad_list.size());
@@ -592,16 +592,16 @@
EXPECT_TRANSFORMATION_MATRIX_EQ(
gfx::Transform(), frame.render_passes[2]
->quad_list.front()
- ->shared_quad_state->content_to_target_transform);
+ ->shared_quad_state->quad_to_target_transform);
EXPECT_TRANSFORMATION_MATRIX_EQ(
gfx::Transform(), frame.render_passes[2]
->quad_list.ElementAt(1)
- ->shared_quad_state->content_to_target_transform);
+ ->shared_quad_state->quad_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()
- ->shared_quad_state->content_to_target_transform);
+ ->shared_quad_state->quad_to_target_transform);
host_impl_->DrawLayers(&frame);
host_impl_->DidDrawAllLayers(frame);
@@ -829,7 +829,7 @@
expected.Scale(1.5, 1.5);
expected.Translate(7.0, 7.0);
EXPECT_TRANSFORMATION_MATRIX_EQ(
- expected, root_delegated_shared_quad_state->content_to_target_transform);
+ expected, root_delegated_shared_quad_state->quad_to_target_transform);
// The contributing render pass should not be transformed from its input.
EXPECT_EQ(gfx::Rect(21, 21, 3, 3).ToString(),
@@ -839,8 +839,7 @@
expected.Scale(0.8f, 0.8f);
expected.Translate(9.0, 9.0);
EXPECT_TRANSFORMATION_MATRIX_EQ(
- expected,
- contrib_delegated_shared_quad_state->content_to_target_transform);
+ expected, contrib_delegated_shared_quad_state->quad_to_target_transform);
host_impl_->DrawLayers(&frame);
host_impl_->DidDrawAllLayers(frame);
@@ -888,7 +887,7 @@
expected.Scale(1.5, 1.5);
expected.Translate(7.0, 7.0);
EXPECT_TRANSFORMATION_MATRIX_EQ(
- expected, root_delegated_shared_quad_state->content_to_target_transform);
+ expected, root_delegated_shared_quad_state->quad_to_target_transform);
// The contributing render pass should not be transformed from its input.
EXPECT_EQ(gfx::Rect(21, 21, 3, 3).ToString(),
@@ -898,8 +897,7 @@
expected.Scale(0.8f, 0.8f);
expected.Translate(9.0, 9.0);
EXPECT_TRANSFORMATION_MATRIX_EQ(
- expected,
- contrib_delegated_shared_quad_state->content_to_target_transform);
+ expected, contrib_delegated_shared_quad_state->quad_to_target_transform);
host_impl_->DrawLayers(&frame);
host_impl_->DidDrawAllLayers(frame);
@@ -937,7 +935,7 @@
expected.Scale(3.0, 3.0);
expected.Translate(7.0, 7.0);
EXPECT_TRANSFORMATION_MATRIX_EQ(
- expected, root_delegated_shared_quad_state->content_to_target_transform);
+ expected, root_delegated_shared_quad_state->quad_to_target_transform);
// The contributing render pass should not be transformed from its input.
EXPECT_EQ(gfx::Rect(21, 21, 3, 3).ToString(),
@@ -947,8 +945,7 @@
expected.Scale(0.8f, 0.8f);
expected.Translate(9.0, 9.0);
EXPECT_TRANSFORMATION_MATRIX_EQ(
- expected,
- contrib_delegated_shared_quad_state->content_to_target_transform);
+ expected, contrib_delegated_shared_quad_state->quad_to_target_transform);
host_impl_->DrawLayers(&frame);
host_impl_->DidDrawAllLayers(frame);
@@ -985,7 +982,7 @@
expected.Scale(3.0, 3.0);
expected.Translate(7.0, 7.0);
EXPECT_TRANSFORMATION_MATRIX_EQ(
- expected, root_delegated_shared_quad_state->content_to_target_transform);
+ expected, root_delegated_shared_quad_state->quad_to_target_transform);
// The contributing render pass should not be transformed from its input.
EXPECT_EQ(gfx::Rect(21, 21, 3, 3).ToString(),
@@ -995,8 +992,7 @@
expected.Scale(0.8f, 0.8f);
expected.Translate(9.0, 9.0);
EXPECT_TRANSFORMATION_MATRIX_EQ(
- expected,
- contrib_delegated_shared_quad_state->content_to_target_transform);
+ expected, contrib_delegated_shared_quad_state->quad_to_target_transform);
host_impl_->DrawLayers(&frame);
host_impl_->DidDrawAllLayers(frame);
@@ -1035,7 +1031,7 @@
expected.Scale(1.5, 1.5);
expected.Translate(7.0, 7.0);
EXPECT_TRANSFORMATION_MATRIX_EQ(
- expected, root_delegated_shared_quad_state->content_to_target_transform);
+ expected, root_delegated_shared_quad_state->quad_to_target_transform);
host_impl_->DrawLayers(&frame);
host_impl_->DidDrawAllLayers(frame);
@@ -1496,7 +1492,7 @@
{
SCOPED_TRACE("Full occlusion");
{
- gfx::Rect occluded(delegated_renderer_layer_impl->visible_content_rect());
+ gfx::Rect occluded(delegated_renderer_layer_impl->visible_layer_rect());
SCOPED_TRACE("Root render pass");
impl.AppendQuadsForPassWithOcclusion(delegated_renderer_layer_impl, pass1,
@@ -1506,7 +1502,7 @@
EXPECT_EQ(pass1->quad_list.size(), 0u);
}
{
- gfx::Rect occluded(delegated_renderer_layer_impl->visible_content_rect());
+ gfx::Rect occluded(delegated_renderer_layer_impl->visible_layer_rect());
SCOPED_TRACE("Contributing render pass");
impl.AppendQuadsForPassWithOcclusion(delegated_renderer_layer_impl, pass2,
diff --git a/cc/layers/draw_properties.h b/cc/layers/draw_properties.h
index 8a37179..b5ac389 100644
--- a/cc/layers/draw_properties.h
+++ b/cc/layers/draw_properties.h
@@ -81,8 +81,9 @@
// ancestor of this layer.
LayerType* render_target;
- // This rect is in the layer's content space.
- gfx::Rect visible_content_rect;
+ // This rect is a bounding box around what part of the layer is visible, in
+ // the layer's coordinate space.
+ gfx::Rect visible_layer_rect;
// In target surface space, the rect that encloses the clipped, drawable
// content of the layer.
diff --git a/cc/layers/io_surface_layer_impl_unittest.cc b/cc/layers/io_surface_layer_impl_unittest.cc
index 0ef2ec8e8..75c2cf77 100644
--- a/cc/layers/io_surface_layer_impl_unittest.cc
+++ b/cc/layers/io_surface_layer_impl_unittest.cc
@@ -39,7 +39,7 @@
{
SCOPED_TRACE("Full occlusion");
- gfx::Rect occluded(io_surface_layer_impl->visible_content_rect());
+ gfx::Rect occluded(io_surface_layer_impl->visible_layer_rect());
impl.AppendQuadsWithOcclusion(io_surface_layer_impl, occluded);
LayerTestCommon::VerifyQuadsExactlyCoverRect(impl.quad_list(), gfx::Rect());
diff --git a/cc/layers/layer.cc b/cc/layers/layer.cc
index a74c75f..45c9839 100644
--- a/cc/layers/layer.cc
+++ b/cc/layers/layer.cc
@@ -1520,12 +1520,6 @@
layer_animation_controller_->RemoveEventObserver(animation_observer);
}
-SimpleEnclosedRegion Layer::VisibleContentOpaqueRegion() const {
- if (contents_opaque())
- return SimpleEnclosedRegion(visible_content_rect());
- return SimpleEnclosedRegion();
-}
-
ScrollbarLayerInterface* Layer::ToScrollbarLayer() {
return nullptr;
}
diff --git a/cc/layers/layer.h b/cc/layers/layer.h
index 211ea7c..6a35ec7 100644
--- a/cc/layers/layer.h
+++ b/cc/layers/layer.h
@@ -254,8 +254,8 @@
gfx::Rect drawable_content_rect() const {
return draw_properties_.drawable_content_rect;
}
- gfx::Rect visible_content_rect() const {
- return draw_properties_.visible_content_rect;
+ gfx::Rect visible_layer_rect() const {
+ return draw_properties_.visible_layer_rect;
}
Layer* render_target() {
DCHECK(!draw_properties_.render_target ||
@@ -424,8 +424,6 @@
void RemoveLayerAnimationEventObserver(
LayerAnimationEventObserver* animation_observer);
- virtual SimpleEnclosedRegion VisibleContentOpaqueRegion() const;
-
virtual ScrollbarLayerInterface* ToScrollbarLayer();
virtual skia::RefPtr<SkPicture> GetPicture() const;
diff --git a/cc/layers/layer_impl.cc b/cc/layers/layer_impl.cc
index c07244d..3144472 100644
--- a/cc/layers/layer_impl.cc
+++ b/cc/layers/layer_impl.cc
@@ -283,10 +283,9 @@
void LayerImpl::PopulateSharedQuadState(SharedQuadState* state) const {
state->SetAll(draw_properties_.target_space_transform, bounds(),
- draw_properties_.visible_content_rect,
- draw_properties_.clip_rect, draw_properties_.is_clipped,
- draw_properties_.opacity, draw_properties_.blend_mode,
- sorting_context_id_);
+ draw_properties_.visible_layer_rect, draw_properties_.clip_rect,
+ draw_properties_.is_clipped, draw_properties_.opacity,
+ draw_properties_.blend_mode, sorting_context_id_);
}
void LayerImpl::PopulateScaledSharedQuadState(SharedQuadState* state,
@@ -295,14 +294,14 @@
draw_properties_.target_space_transform;
scaled_draw_transform.Scale(SK_MScalar1 / scale, SK_MScalar1 / scale);
gfx::Size scaled_bounds = gfx::ToCeiledSize(gfx::ScaleSize(bounds(), scale));
- gfx::Rect scaled_visible_content_rect =
- gfx::ScaleToEnclosingRect(visible_content_rect(), scale);
- scaled_visible_content_rect.Intersect(gfx::Rect(scaled_bounds));
+ gfx::Rect scaled_visible_layer_rect =
+ gfx::ScaleToEnclosingRect(visible_layer_rect(), scale);
+ scaled_visible_layer_rect.Intersect(gfx::Rect(scaled_bounds));
- state->SetAll(scaled_draw_transform, scaled_bounds,
- scaled_visible_content_rect, draw_properties().clip_rect,
- draw_properties().is_clipped, draw_properties().opacity,
- draw_properties().blend_mode, sorting_context_id_);
+ state->SetAll(scaled_draw_transform, scaled_bounds, scaled_visible_layer_rect,
+ draw_properties().clip_rect, draw_properties().is_clipped,
+ draw_properties().opacity, draw_properties().blend_mode,
+ sorting_context_id_);
}
bool LayerImpl::WillDraw(DrawMode draw_mode,
@@ -1259,9 +1258,9 @@
NoteLayerPropertyChangedForSubtree();
}
-SimpleEnclosedRegion LayerImpl::VisibleContentOpaqueRegion() const {
+SimpleEnclosedRegion LayerImpl::VisibleOpaqueRegion() const {
if (contents_opaque())
- return SimpleEnclosedRegion(visible_content_rect());
+ return SimpleEnclosedRegion(visible_layer_rect());
return SimpleEnclosedRegion();
}
diff --git a/cc/layers/layer_impl.h b/cc/layers/layer_impl.h
index 5c25887..90fb694 100644
--- a/cc/layers/layer_impl.h
+++ b/cc/layers/layer_impl.h
@@ -391,8 +391,8 @@
gfx::Rect drawable_content_rect() const {
return draw_properties_.drawable_content_rect;
}
- gfx::Rect visible_content_rect() const {
- return draw_properties_.visible_content_rect;
+ gfx::Rect visible_layer_rect() const {
+ return draw_properties_.visible_layer_rect;
}
LayerImpl* render_target() {
DCHECK(!draw_properties_.render_target ||
@@ -558,7 +558,7 @@
return layer_animation_controller_.get();
}
- virtual SimpleEnclosedRegion VisibleContentOpaqueRegion() const;
+ virtual SimpleEnclosedRegion VisibleOpaqueRegion() const;
virtual void DidBecomeActive();
diff --git a/cc/layers/nine_patch_layer_impl_unittest.cc b/cc/layers/nine_patch_layer_impl_unittest.cc
index 2e230ee..3535c98 100644
--- a/cc/layers/nine_patch_layer_impl_unittest.cc
+++ b/cc/layers/nine_patch_layer_impl_unittest.cc
@@ -37,7 +37,7 @@
bool fill_center,
size_t expected_quad_size) {
scoped_ptr<RenderPass> render_pass = RenderPass::Create();
- gfx::Rect visible_content_rect(layer_size);
+ gfx::Rect visible_layer_rect(layer_size);
gfx::Rect expected_remaining(border.x(),
border.y(),
layer_size.width() - border.width(),
@@ -52,7 +52,7 @@
scoped_ptr<NinePatchLayerImpl> layer =
NinePatchLayerImpl::Create(host_impl.active_tree(), 1);
- layer->draw_properties().visible_content_rect = visible_content_rect;
+ layer->draw_properties().visible_layer_rect = visible_layer_rect;
layer->SetBounds(layer_size);
layer->SetHasRenderSurface(true);
layer->draw_properties().render_target = layer.get();
@@ -72,11 +72,11 @@
const QuadList& quads = render_pass->quad_list;
EXPECT_EQ(expected_quad_size, quads.size());
- Region remaining(visible_content_rect);
+ Region remaining(visible_layer_rect);
for (auto iter = quads.cbegin(); iter != quads.cend(); ++iter) {
gfx::Rect quad_rect = iter->rect;
- EXPECT_TRUE(visible_content_rect.Contains(quad_rect)) << iter.index();
+ EXPECT_TRUE(visible_layer_rect.Contains(quad_rect)) << iter.index();
EXPECT_TRUE(remaining.Contains(quad_rect)) << iter.index();
remaining.Subtract(Region(quad_rect));
}
@@ -252,7 +252,7 @@
{
SCOPED_TRACE("Full occlusion");
- gfx::Rect occluded(nine_patch_layer_impl->visible_content_rect());
+ gfx::Rect occluded(nine_patch_layer_impl->visible_layer_rect());
impl.AppendQuadsWithOcclusion(nine_patch_layer_impl, occluded);
LayerTestCommon::VerifyQuadsExactlyCoverRect(impl.quad_list(), gfx::Rect());
diff --git a/cc/layers/painted_scrollbar_layer_impl_unittest.cc b/cc/layers/painted_scrollbar_layer_impl_unittest.cc
index 5a7229f..eac32b6 100644
--- a/cc/layers/painted_scrollbar_layer_impl_unittest.cc
+++ b/cc/layers/painted_scrollbar_layer_impl_unittest.cc
@@ -88,7 +88,7 @@
{
SCOPED_TRACE("Full occlusion");
- gfx::Rect occluded(scrollbar_layer_impl->visible_content_rect());
+ gfx::Rect occluded(scrollbar_layer_impl->visible_layer_rect());
impl.AppendQuadsWithOcclusion(scrollbar_layer_impl, occluded);
LayerTestCommon::VerifyQuadsExactlyCoverRect(impl.quad_list(), gfx::Rect());
diff --git a/cc/layers/picture_image_layer_impl_unittest.cc b/cc/layers/picture_image_layer_impl_unittest.cc
index 12c70175..ff7e9ace 100644
--- a/cc/layers/picture_image_layer_impl_unittest.cc
+++ b/cc/layers/picture_image_layer_impl_unittest.cc
@@ -76,7 +76,7 @@
maximum_animation_contents_scale;
layer->draw_properties().screen_space_transform_is_animating =
animating_transform_to_screen;
- layer->draw_properties().visible_content_rect = viewport_rect;
+ layer->draw_properties().visible_layer_rect = viewport_rect;
bool resourceless_software_draw = false;
layer->UpdateTiles(resourceless_software_draw);
}
diff --git a/cc/layers/picture_layer.cc b/cc/layers/picture_layer.cc
index aa366d5..53d5d97d4 100644
--- a/cc/layers/picture_layer.cc
+++ b/cc/layers/picture_layer.cc
@@ -117,10 +117,10 @@
update_source_frame_number_ = layer_tree_host()->source_frame_number();
bool updated = Layer::Update();
- gfx::Rect visible_layer_rect = visible_content_rect();
+ gfx::Rect update_rect = visible_layer_rect();
gfx::Size layer_size = paint_properties().bounds;
- if (last_updated_visible_content_rect_ == visible_content_rect() &&
+ if (last_updated_visible_layer_rect_ == update_rect &&
recording_source_->GetSize() == layer_size &&
pending_invalidation_.IsEmpty()) {
// Only early out if the visible content rect of this layer hasn't changed.
@@ -145,7 +145,7 @@
if (layer_tree_host()->settings().record_full_layer) {
// Workaround for http://crbug.com/235910 - to retain backwards compat
// the full page content must always be provided in the picture layer.
- visible_layer_rect = gfx::Rect(layer_size);
+ update_rect = gfx::Rect(layer_size);
}
// UpdateAndExpandInvalidation will give us an invalidation that covers
@@ -154,9 +154,9 @@
// for them.
DCHECK(client_);
updated |= recording_source_->UpdateAndExpandInvalidation(
- client_, &recording_invalidation_, layer_size, visible_layer_rect,
+ client_, &recording_invalidation_, layer_size, update_rect,
update_source_frame_number_, RecordingSource::RECORD_NORMALLY);
- last_updated_visible_content_rect_ = visible_content_rect();
+ last_updated_visible_layer_rect_ = visible_layer_rect();
if (updated) {
SetNeedsPushProperties();
diff --git a/cc/layers/picture_layer.h b/cc/layers/picture_layer.h
index 4a94d9d..771484c 100644
--- a/cc/layers/picture_layer.h
+++ b/cc/layers/picture_layer.h
@@ -64,7 +64,7 @@
InvalidationRegion pending_invalidation_;
// Invalidation from the last time update was called.
Region recording_invalidation_;
- gfx::Rect last_updated_visible_content_rect_;
+ gfx::Rect last_updated_visible_layer_rect_;
int update_source_frame_number_;
bool is_mask_;
diff --git a/cc/layers/picture_layer_impl.cc b/cc/layers/picture_layer_impl.cc
index f98dac0..82ae6fc 100644
--- a/cc/layers/picture_layer_impl.cc
+++ b/cc/layers/picture_layer_impl.cc
@@ -161,7 +161,7 @@
SolidColorLayerImpl::AppendSolidQuads(
render_pass, draw_properties().occlusion_in_content_space,
- shared_quad_state, visible_content_rect(),
+ shared_quad_state, visible_layer_rect(),
raster_source_->GetSolidColor(), append_quads_data);
return;
}
@@ -171,22 +171,22 @@
Occlusion scaled_occlusion =
draw_properties()
.occlusion_in_content_space.GetOcclusionWithGivenDrawTransform(
- shared_quad_state->content_to_target_transform);
+ shared_quad_state->quad_to_target_transform);
if (current_draw_mode_ == DRAW_MODE_RESOURCELESS_SOFTWARE) {
AppendDebugBorderQuad(
- render_pass, shared_quad_state->content_bounds, shared_quad_state,
+ render_pass, shared_quad_state->quad_layer_bounds, shared_quad_state,
append_quads_data, DebugColors::DirectPictureBorderColor(),
DebugColors::DirectPictureBorderWidth(layer_tree_impl()));
- gfx::Rect geometry_rect = shared_quad_state->visible_content_rect;
+ gfx::Rect geometry_rect = shared_quad_state->visible_quad_layer_rect;
gfx::Rect opaque_rect = contents_opaque() ? geometry_rect : gfx::Rect();
gfx::Rect visible_geometry_rect =
scaled_occlusion.GetUnoccludedContentRect(geometry_rect);
if (visible_geometry_rect.IsEmpty())
return;
- gfx::Rect quad_content_rect = shared_quad_state->visible_content_rect;
+ gfx::Rect quad_content_rect = shared_quad_state->visible_quad_layer_rect;
gfx::Size texture_size = quad_content_rect.size();
gfx::RectF texture_rect = gfx::RectF(texture_size);
@@ -200,13 +200,13 @@
return;
}
- AppendDebugBorderQuad(render_pass, shared_quad_state->content_bounds,
+ AppendDebugBorderQuad(render_pass, shared_quad_state->quad_layer_bounds,
shared_quad_state, append_quads_data);
if (ShowDebugBorders()) {
for (PictureLayerTilingSet::CoverageIterator iter(
tilings_.get(), max_contents_scale,
- shared_quad_state->visible_content_rect, ideal_contents_scale_);
+ shared_quad_state->visible_quad_layer_rect, ideal_contents_scale_);
iter; ++iter) {
SkColor color;
float width;
@@ -263,7 +263,7 @@
only_used_low_res_last_append_quads_ = true;
for (PictureLayerTilingSet::CoverageIterator iter(
tilings_.get(), max_contents_scale,
- shared_quad_state->visible_content_rect, ideal_contents_scale_);
+ shared_quad_state->visible_quad_layer_rect, ideal_contents_scale_);
iter; ++iter) {
gfx::Rect geometry_rect = iter.geometry_rect();
gfx::Rect opaque_rect = contents_opaque() ? geometry_rect : gfx::Rect();
@@ -272,7 +272,7 @@
if (visible_geometry_rect.IsEmpty())
continue;
- append_quads_data->visible_content_area +=
+ append_quads_data->visible_layer_area +=
visible_geometry_rect.width() * visible_geometry_rect.height();
bool has_draw_quad = false;
@@ -376,14 +376,14 @@
// Aggressively remove any tilings that are not seen to save memory. Note
// that this is at the expense of doing cause more frequent re-painting. A
- // better scheme would be to maintain a tighter visible_content_rect for the
+ // better scheme would be to maintain a tighter visible_layer_rect for the
// finer tilings.
CleanUpTilingsOnActiveLayer(last_append_quads_tilings_);
}
bool PictureLayerImpl::UpdateTiles(bool resourceless_software_draw) {
if (!resourceless_software_draw) {
- visible_rect_for_tile_priority_ = visible_content_rect();
+ visible_rect_for_tile_priority_ = visible_layer_rect();
}
if (!CanHaveTilings()) {
@@ -1192,7 +1192,7 @@
MathUtil::AddToTracedValue("tile_priority_rect",
viewport_rect_for_tile_priority_in_content_space_,
state);
- MathUtil::AddToTracedValue("visible_rect", visible_content_rect(), state);
+ MathUtil::AddToTracedValue("visible_rect", visible_layer_rect(), state);
state->BeginArray("pictures");
raster_source_->AsValueInto(state);
diff --git a/cc/layers/picture_layer_impl_unittest.cc b/cc/layers/picture_layer_impl_unittest.cc
index 640cbbd..83e37a0 100644
--- a/cc/layers/picture_layer_impl_unittest.cc
+++ b/cc/layers/picture_layer_impl_unittest.cc
@@ -543,7 +543,7 @@
viewport,
transform,
resourceless_software_draw);
- active_layer_->draw_properties().visible_content_rect = viewport;
+ active_layer_->draw_properties().visible_layer_rect = viewport;
active_layer_->draw_properties().screen_space_transform = transform;
active_layer_->UpdateTiles(resourceless_software_draw);
@@ -559,7 +559,7 @@
resourceless_software_draw = true;
viewport = gfx::ScaleToEnclosingRect(viewport, 2);
transform.Translate(1.f, 1.f);
- active_layer_->draw_properties().visible_content_rect = viewport;
+ active_layer_->draw_properties().visible_layer_rect = viewport;
active_layer_->draw_properties().screen_space_transform = transform;
host_impl_.SetExternalDrawConstraints(transform,
viewport,
@@ -1621,8 +1621,7 @@
gfx::Rect layer_invalidation(150, 200, 30, 180);
SetupTreesWithInvalidation(pending_pile, active_pile, layer_invalidation);
- active_layer_->draw_properties().visible_content_rect =
- gfx::Rect(layer_bounds);
+ active_layer_->draw_properties().visible_layer_rect = gfx::Rect(layer_bounds);
AppendQuadsData data;
active_layer_->WillDraw(DRAW_MODE_RESOURCELESS_SOFTWARE, nullptr);
@@ -1652,7 +1651,7 @@
SetupTrees(pending_pile, active_pile);
- active_layer_->draw_properties().visible_content_rect = visible_rect;
+ active_layer_->draw_properties().visible_layer_rect = visible_rect;
AppendQuadsData data;
active_layer_->WillDraw(DRAW_MODE_SOFTWARE, nullptr);
@@ -1744,7 +1743,7 @@
gfx::Size tile_size(100, 100);
gfx::Size layer_bounds(400, 400);
gfx::Rect external_viewport_for_tile_priority(400, 200);
- gfx::Rect visible_content_rect(200, 400);
+ gfx::Rect visible_layer_rect(200, 400);
scoped_refptr<FakePicturePileImpl> active_pile =
FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
@@ -1772,7 +1771,7 @@
// Set visible content rect that is different from
// external_viewport_for_tile_priority.
- pending_layer_->draw_properties().visible_content_rect = visible_content_rect;
+ pending_layer_->draw_properties().visible_layer_rect = visible_layer_rect;
host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(200));
pending_layer_->UpdateTiles(resourceless_software_draw);
@@ -1780,7 +1779,7 @@
// activation.
gfx::Rect viewport_for_tile_priority =
pending_layer_->viewport_rect_for_tile_priority_in_content_space();
- viewport_for_tile_priority.Intersect(pending_layer_->visible_content_rect());
+ viewport_for_tile_priority.Intersect(pending_layer_->visible_layer_rect());
EXPECT_TRUE(pending_layer_->HighResTiling()->AllTilesForTesting().empty());
@@ -1809,7 +1808,7 @@
// Activate and draw active layer.
host_impl_.ActivateSyncTree();
host_impl_.active_tree()->UpdateDrawProperties(update_lcd_text);
- active_layer_->draw_properties().visible_content_rect = visible_content_rect;
+ active_layer_->draw_properties().visible_layer_rect = visible_layer_rect;
scoped_ptr<RenderPass> render_pass = RenderPass::Create();
AppendQuadsData data;
@@ -2915,7 +2914,7 @@
// No NOW tiles.
host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(200));
- pending_layer_->draw_properties().visible_content_rect =
+ pending_layer_->draw_properties().visible_layer_rect =
gfx::Rect(1100, 1100, 500, 500);
bool resourceless_software_draw = false;
pending_layer_->UpdateTiles(resourceless_software_draw);
@@ -2945,7 +2944,7 @@
host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(200));
- pending_layer_->draw_properties().visible_content_rect =
+ pending_layer_->draw_properties().visible_layer_rect =
gfx::Rect(0, 0, 500, 500);
pending_layer_->UpdateTiles(resourceless_software_draw);
@@ -3065,7 +3064,7 @@
for (size_t i = 0; i < pending_layer_->num_tilings(); ++i) {
PictureLayerTiling* tiling = pending_layer_->tilings()->tiling_at(i);
for (PictureLayerTiling::CoverageIterator iter(
- tiling, 1.f, pending_layer_->visible_content_rect());
+ tiling, 1.f, pending_layer_->visible_layer_rect());
iter; ++iter) {
if (mark_required) {
number_of_marked_tiles++;
@@ -3208,7 +3207,7 @@
{
SCOPED_TRACE("Full occlusion");
- gfx::Rect occluded(active_layer_->visible_content_rect());
+ gfx::Rect occluded(active_layer_->visible_layer_rect());
impl.AppendQuadsWithOcclusion(active_layer_, occluded);
LayerTestCommon::VerifyQuadsExactlyCoverRect(impl.quad_list(), gfx::Rect());
@@ -3567,7 +3566,7 @@
viewport,
transform,
resourceless_software_draw);
- active_layer_->draw_properties().visible_content_rect = viewport;
+ active_layer_->draw_properties().visible_layer_rect = viewport;
active_layer_->draw_properties().screen_space_transform = transform;
active_layer_->UpdateTiles(resourceless_software_draw);
@@ -3583,7 +3582,7 @@
resourceless_software_draw = true;
viewport = gfx::ScaleToEnclosingRect(viewport, 2);
transform.Translate(1.f, 1.f);
- active_layer_->draw_properties().visible_content_rect = viewport;
+ active_layer_->draw_properties().visible_layer_rect = viewport;
active_layer_->draw_properties().screen_space_transform = transform;
host_impl_.SetExternalDrawConstraints(transform,
viewport,
@@ -3798,21 +3797,21 @@
// SharedQuadState should have be of size 1, as we are doing AppenQuad once.
EXPECT_EQ(1u, render_pass->shared_quad_state_list.size());
- // The content_to_target_transform should be scaled by the
+ // The quad_to_target_transform should be scaled by the
// MaximumTilingContentsScale on the layer.
EXPECT_EQ(scaled_draw_transform.ToString(),
render_pass->shared_quad_state_list.front()
- ->content_to_target_transform.ToString());
+ ->quad_to_target_transform.ToString());
// The content_bounds should be scaled by the
// MaximumTilingContentsScale on the layer.
- EXPECT_EQ(
- gfx::Size(2500u, 5000u).ToString(),
- render_pass->shared_quad_state_list.front()->content_bounds.ToString());
- // The visible_content_rect should be scaled by the
+ EXPECT_EQ(gfx::Size(2500u, 5000u).ToString(),
+ render_pass->shared_quad_state_list.front()
+ ->quad_layer_bounds.ToString());
+ // The visible_layer_rect should be scaled by the
// MaximumTilingContentsScale on the layer.
EXPECT_EQ(gfx::Rect(0u, 0u, 2500u, 5000u).ToString(),
render_pass->shared_quad_state_list.front()
- ->visible_content_rect.ToString());
+ ->visible_quad_layer_rect.ToString());
}
class PictureLayerImplTestWithDelegatingRenderer : public PictureLayerImplTest {
@@ -3956,7 +3955,7 @@
// Some tiles may not be visible (i.e. outside the viewport). The rest are
// visible and at least partially unoccluded, verified by the above expect.
bool tile_is_visible =
- tile->content_rect().Intersects(pending_layer_->visible_content_rect());
+ tile->content_rect().Intersects(pending_layer_->visible_layer_rect());
if (tile_is_visible)
unoccluded_tile_count++;
queue->Pop();
@@ -3985,7 +3984,7 @@
EXPECT_FALSE(prioritized_tile.is_occluded());
bool tile_is_visible =
- tile->content_rect().Intersects(pending_layer_->visible_content_rect());
+ tile->content_rect().Intersects(pending_layer_->visible_layer_rect());
if (tile_is_visible)
unoccluded_tile_count++;
queue->Pop();
@@ -4008,7 +4007,7 @@
EXPECT_FALSE(prioritized_tile.is_occluded());
bool tile_is_visible =
- tile->content_rect().Intersects(pending_layer_->visible_content_rect());
+ tile->content_rect().Intersects(pending_layer_->visible_layer_rect());
if (tile_is_visible)
unoccluded_tile_count++;
queue->Pop();
@@ -4606,7 +4605,7 @@
host_impl_.SetRequiresHighResToDraw();
// Update tiles.
- pending_layer_->draw_properties().visible_content_rect = viewport;
+ pending_layer_->draw_properties().visible_layer_rect = viewport;
pending_layer_->draw_properties().screen_space_transform = transform;
SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, 1.f, 1.f, 1.f, 0.f,
false);
@@ -4620,7 +4619,7 @@
viewport = gfx::Rect(0, 2000, 100, 100);
// Update tiles.
- pending_layer_->draw_properties().visible_content_rect = viewport;
+ pending_layer_->draw_properties().visible_layer_rect = viewport;
pending_layer_->draw_properties().screen_space_transform = transform;
SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, 1.f, 1.f, 1.f, 0.f,
false);
diff --git a/cc/layers/render_surface_impl.cc b/cc/layers/render_surface_impl.cc
index a583d7f..ebb3016 100644
--- a/cc/layers/render_surface_impl.cc
+++ b/cc/layers/render_surface_impl.cc
@@ -157,9 +157,9 @@
LayerImpl* mask_layer,
AppendQuadsData* append_quads_data,
RenderPassId render_pass_id) {
- gfx::Rect visible_content_rect =
+ gfx::Rect visible_layer_rect =
occlusion_in_content_space.GetUnoccludedContentRect(content_rect_);
- if (visible_content_rect.IsEmpty())
+ if (visible_layer_rect.IsEmpty())
return;
SharedQuadState* shared_quad_state =
@@ -173,7 +173,7 @@
DebugBorderDrawQuad* debug_border_quad =
render_pass->CreateAndAppendDrawQuad<DebugBorderDrawQuad>();
debug_border_quad->SetNew(shared_quad_state, content_rect_,
- visible_content_rect, debug_border_color,
+ visible_layer_rect, debug_border_color,
debug_border_width);
}
@@ -200,14 +200,9 @@
RenderPassDrawQuad* quad =
render_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
- quad->SetNew(shared_quad_state,
- content_rect_,
- visible_content_rect,
- render_pass_id,
- mask_resource_id,
- mask_uv_scale,
- mask_texture_size,
- owning_layer_->filters(),
+ quad->SetNew(shared_quad_state, content_rect_, visible_layer_rect,
+ render_pass_id, mask_resource_id, mask_uv_scale,
+ mask_texture_size, owning_layer_->filters(),
owning_layer_to_target_scale,
owning_layer_->background_filters());
}
diff --git a/cc/layers/render_surface_impl_unittest.cc b/cc/layers/render_surface_impl_unittest.cc
index e5db867c..ac406758 100644
--- a/cc/layers/render_surface_impl_unittest.cc
+++ b/cc/layers/render_surface_impl_unittest.cc
@@ -38,7 +38,7 @@
{
SCOPED_TRACE("Full occlusion");
- gfx::Rect occluded(owning_layer_impl->visible_content_rect());
+ gfx::Rect occluded(owning_layer_impl->visible_layer_rect());
impl.AppendSurfaceQuadsWithOcclusion(render_surface_impl, occluded);
LayerTestCommon::VerifyQuadsExactlyCoverRect(impl.quad_list(), gfx::Rect());
diff --git a/cc/layers/render_surface_unittest.cc b/cc/layers/render_surface_unittest.cc
index 96f8532..5ecf2f7b 100644
--- a/cc/layers/render_surface_unittest.cc
+++ b/cc/layers/render_surface_unittest.cc
@@ -126,11 +126,12 @@
EXPECT_EQ(
30.0,
- shared_quad_state->content_to_target_transform.matrix().getDouble(0, 3));
+ shared_quad_state->quad_to_target_transform.matrix().getDouble(0, 3));
EXPECT_EQ(
40.0,
- shared_quad_state->content_to_target_transform.matrix().getDouble(1, 3));
- EXPECT_EQ(content_rect, gfx::Rect(shared_quad_state->visible_content_rect));
+ shared_quad_state->quad_to_target_transform.matrix().getDouble(1, 3));
+ EXPECT_EQ(content_rect,
+ gfx::Rect(shared_quad_state->visible_quad_layer_rect));
EXPECT_EQ(1.f, shared_quad_state->opacity);
EXPECT_EQ(blend_mode, shared_quad_state->blend_mode);
}
diff --git a/cc/layers/scrollbar_layer_unittest.cc b/cc/layers/scrollbar_layer_unittest.cc
index d6c86cc..0042204 100644
--- a/cc/layers/scrollbar_layer_unittest.cc
+++ b/cc/layers/scrollbar_layer_unittest.cc
@@ -713,7 +713,7 @@
layer_tree_root->SetScrollOffset(gfx::ScrollOffset(10, 20));
layer_tree_root->SetBounds(gfx::Size(100, 200));
content_layer->SetBounds(gfx::Size(100, 200));
- scrollbar_layer->draw_properties().visible_content_rect =
+ scrollbar_layer->draw_properties().visible_layer_rect =
gfx::Rect(0, 0, 100, 200);
scrollbar_layer->CreateRenderSurface();
scrollbar_layer->draw_properties().render_target = scrollbar_layer.get();
@@ -776,7 +776,7 @@
layer_tree_root->SetBounds(gfx::Size(100, 200));
content_layer->SetBounds(gfx::Size(100, 200));
- scrollbar_layer->draw_properties().visible_content_rect =
+ scrollbar_layer->draw_properties().visible_layer_rect =
gfx::Rect(0, 0, 100, 200);
scrollbar_layer->CreateRenderSurface();
@@ -909,7 +909,7 @@
scrollbar_layer->SetPosition(scrollbar_location);
layer_tree_root->SetBounds(gfx::Size(100, 200));
content_layer->SetBounds(gfx::Size(100, 200));
- scrollbar_layer->draw_properties().visible_content_rect =
+ scrollbar_layer->draw_properties().visible_layer_rect =
gfx::Rect(scrollbar_location, scrollbar_layer->bounds());
scrollbar_layer->CreateRenderSurface();
scrollbar_layer->draw_properties().render_target = scrollbar_layer.get();
@@ -971,7 +971,7 @@
scrollbar_layer->SetPosition(scrollbar_rect.origin());
scrollbar_layer->fake_scrollbar()->set_location(scrollbar_rect.origin());
scrollbar_layer->fake_scrollbar()->set_track_rect(scrollbar_rect);
- scrollbar_layer->draw_properties().visible_content_rect = scrollbar_rect;
+ scrollbar_layer->draw_properties().visible_layer_rect = scrollbar_rect;
layer_tree_host_->SetDeviceScaleFactor(test_scale);
diff --git a/cc/layers/solid_color_layer_impl.cc b/cc/layers/solid_color_layer_impl.cc
index b85012a..76cd3fc4 100644
--- a/cc/layers/solid_color_layer_impl.cc
+++ b/cc/layers/solid_color_layer_impl.cc
@@ -29,29 +29,29 @@
void SolidColorLayerImpl::AppendSolidQuads(
RenderPass* render_pass,
- const Occlusion& occlusion_in_content_space,
+ const Occlusion& occlusion_in_layer_space,
SharedQuadState* shared_quad_state,
- const gfx::Rect& visible_content_rect,
+ const gfx::Rect& visible_layer_rect,
SkColor color,
AppendQuadsData* append_quads_data) {
// We create a series of smaller quads instead of just one large one so that
// the culler can reduce the total pixels drawn.
- int right = visible_content_rect.right();
- int bottom = visible_content_rect.bottom();
- for (int x = visible_content_rect.x(); x < visible_content_rect.right();
+ int right = visible_layer_rect.right();
+ int bottom = visible_layer_rect.bottom();
+ for (int x = visible_layer_rect.x(); x < visible_layer_rect.right();
x += kSolidQuadTileSize) {
- for (int y = visible_content_rect.y(); y < visible_content_rect.bottom();
+ for (int y = visible_layer_rect.y(); y < visible_layer_rect.bottom();
y += kSolidQuadTileSize) {
gfx::Rect quad_rect(x,
y,
std::min(right - x, kSolidQuadTileSize),
std::min(bottom - y, kSolidQuadTileSize));
gfx::Rect visible_quad_rect =
- occlusion_in_content_space.GetUnoccludedContentRect(quad_rect);
+ occlusion_in_layer_space.GetUnoccludedContentRect(quad_rect);
if (visible_quad_rect.IsEmpty())
continue;
- append_quads_data->visible_content_area +=
+ append_quads_data->visible_layer_area +=
visible_quad_rect.width() * visible_quad_rect.height();
SolidColorDrawQuad* quad =
diff --git a/cc/layers/solid_color_layer_impl.h b/cc/layers/solid_color_layer_impl.h
index 213e3f13..2068ac5d 100644
--- a/cc/layers/solid_color_layer_impl.h
+++ b/cc/layers/solid_color_layer_impl.h
@@ -19,9 +19,9 @@
}
static void AppendSolidQuads(RenderPass* render_pass,
- const Occlusion& occlusion_in_content_space,
+ const Occlusion& occlusion_in_layer_space,
SharedQuadState* shared_quad_state,
- const gfx::Rect& visible_content_rect,
+ const gfx::Rect& visible_layer_rect,
SkColor color,
AppendQuadsData* append_quads_data);
diff --git a/cc/layers/solid_color_layer_impl_unittest.cc b/cc/layers/solid_color_layer_impl_unittest.cc
index ed33026..59ef6ba7 100644
--- a/cc/layers/solid_color_layer_impl_unittest.cc
+++ b/cc/layers/solid_color_layer_impl_unittest.cc
@@ -24,14 +24,14 @@
scoped_ptr<RenderPass> render_pass = RenderPass::Create();
gfx::Size layer_size = gfx::Size(800, 600);
- gfx::Rect visible_content_rect = gfx::Rect(layer_size);
+ gfx::Rect visible_layer_rect = gfx::Rect(layer_size);
FakeImplProxy proxy;
TestTaskGraphRunner task_graph_runner;
FakeLayerTreeHostImpl host_impl(&proxy, nullptr, &task_graph_runner);
scoped_ptr<SolidColorLayerImpl> layer =
SolidColorLayerImpl::Create(host_impl.active_tree(), 1);
- layer->draw_properties().visible_content_rect = visible_content_rect;
+ layer->draw_properties().visible_layer_rect = visible_layer_rect;
layer->SetBounds(layer_size);
layer->SetHasRenderSurface(true);
layer->draw_properties().render_target = layer.get();
@@ -40,7 +40,7 @@
layer->AppendQuads(render_pass.get(), &data);
LayerTestCommon::VerifyQuadsExactlyCoverRect(render_pass->quad_list,
- visible_content_rect);
+ visible_layer_rect);
}
TEST(SolidColorLayerImplTest, VerifyCorrectBackgroundColorInQuad) {
@@ -49,14 +49,14 @@
scoped_ptr<RenderPass> render_pass = RenderPass::Create();
gfx::Size layer_size = gfx::Size(100, 100);
- gfx::Rect visible_content_rect = gfx::Rect(layer_size);
+ gfx::Rect visible_layer_rect = gfx::Rect(layer_size);
FakeImplProxy proxy;
TestTaskGraphRunner task_graph_runner;
FakeLayerTreeHostImpl host_impl(&proxy, nullptr, &task_graph_runner);
scoped_ptr<SolidColorLayerImpl> layer =
SolidColorLayerImpl::Create(host_impl.active_tree(), 1);
- layer->draw_properties().visible_content_rect = visible_content_rect;
+ layer->draw_properties().visible_layer_rect = visible_layer_rect;
layer->SetBounds(layer_size);
layer->SetBackgroundColor(test_color);
layer->SetHasRenderSurface(true);
@@ -77,14 +77,14 @@
scoped_ptr<RenderPass> render_pass = RenderPass::Create();
gfx::Size layer_size = gfx::Size(100, 100);
- gfx::Rect visible_content_rect = gfx::Rect(layer_size);
+ gfx::Rect visible_layer_rect = gfx::Rect(layer_size);
FakeImplProxy proxy;
TestTaskGraphRunner task_graph_runner;
FakeLayerTreeHostImpl host_impl(&proxy, nullptr, &task_graph_runner);
scoped_ptr<SolidColorLayerImpl> layer =
SolidColorLayerImpl::Create(host_impl.active_tree(), 1);
- layer->draw_properties().visible_content_rect = visible_content_rect;
+ layer->draw_properties().visible_layer_rect = visible_layer_rect;
layer->SetBounds(layer_size);
layer->draw_properties().opacity = opacity;
layer->SetHasRenderSurface(true);
@@ -105,7 +105,7 @@
scoped_ptr<RenderPass> render_pass = RenderPass::Create();
gfx::Size layer_size = gfx::Size(100, 100);
- gfx::Rect visible_content_rect = gfx::Rect(layer_size);
+ gfx::Rect visible_layer_rect = gfx::Rect(layer_size);
FakeImplProxy proxy;
TestTaskGraphRunner task_graph_runner;
@@ -125,7 +125,7 @@
TEST(SolidColorLayerImplTest, VerifyOpaqueRect) {
gfx::Size layer_size = gfx::Size(100, 100);
- gfx::Rect visible_content_rect = gfx::Rect(layer_size);
+ gfx::Rect visible_layer_rect = gfx::Rect(layer_size);
LayerSettings layer_settings;
@@ -170,7 +170,7 @@
layer_impl->AppendQuads(render_pass.get(), &data);
ASSERT_EQ(render_pass->quad_list.size(), 1U);
- EXPECT_EQ(visible_content_rect.ToString(),
+ EXPECT_EQ(visible_layer_rect.ToString(),
render_pass->quad_list.front()->opaque_rect.ToString());
}
@@ -227,7 +227,7 @@
{
SCOPED_TRACE("Full occlusion");
- gfx::Rect occluded(solid_color_layer_impl->visible_content_rect());
+ gfx::Rect occluded(solid_color_layer_impl->visible_layer_rect());
impl.AppendQuadsWithOcclusion(solid_color_layer_impl, occluded);
LayerTestCommon::VerifyQuadsExactlyCoverRect(impl.quad_list(), gfx::Rect());
diff --git a/cc/layers/solid_color_scrollbar_layer_impl_unittest.cc b/cc/layers/solid_color_scrollbar_layer_impl_unittest.cc
index a8d59e5..c758497 100644
--- a/cc/layers/solid_color_scrollbar_layer_impl_unittest.cc
+++ b/cc/layers/solid_color_scrollbar_layer_impl_unittest.cc
@@ -54,7 +54,7 @@
{
SCOPED_TRACE("Full occlusion");
- gfx::Rect occluded(scrollbar_layer_impl->visible_content_rect());
+ gfx::Rect occluded(scrollbar_layer_impl->visible_layer_rect());
impl.AppendQuadsWithOcclusion(scrollbar_layer_impl, occluded);
LayerTestCommon::VerifyQuadsExactlyCoverRect(impl.quad_list(), gfx::Rect());
diff --git a/cc/layers/surface_layer_impl_unittest.cc b/cc/layers/surface_layer_impl_unittest.cc
index ab0db38..3ff8255 100644
--- a/cc/layers/surface_layer_impl_unittest.cc
+++ b/cc/layers/surface_layer_impl_unittest.cc
@@ -39,7 +39,7 @@
{
SCOPED_TRACE("Full occlusion");
- gfx::Rect occluded(surface_layer_impl->visible_content_rect());
+ gfx::Rect occluded(surface_layer_impl->visible_layer_rect());
impl.AppendQuadsWithOcclusion(surface_layer_impl, occluded);
LayerTestCommon::VerifyQuadsExactlyCoverRect(impl.quad_list(), gfx::Rect());
diff --git a/cc/layers/texture_layer.cc b/cc/layers/texture_layer.cc
index 2704cf8..20741fdd 100644
--- a/cc/layers/texture_layer.cc
+++ b/cc/layers/texture_layer.cc
@@ -267,16 +267,6 @@
}
}
-SimpleEnclosedRegion TextureLayer::VisibleContentOpaqueRegion() const {
- if (contents_opaque())
- return SimpleEnclosedRegion(visible_content_rect());
-
- if (blend_background_color_ && (SkColorGetA(background_color()) == 0xFF))
- return SimpleEnclosedRegion(visible_content_rect());
-
- return SimpleEnclosedRegion();
-}
-
TextureLayer::TextureMailboxHolder::MainThreadReference::MainThreadReference(
TextureMailboxHolder* holder)
: holder_(holder) {
diff --git a/cc/layers/texture_layer.h b/cc/layers/texture_layer.h
index 09d703b..53f2d8d 100644
--- a/cc/layers/texture_layer.h
+++ b/cc/layers/texture_layer.h
@@ -144,7 +144,6 @@
void SetLayerTreeHost(LayerTreeHost* layer_tree_host) override;
bool Update() override;
void PushPropertiesTo(LayerImpl* layer) override;
- SimpleEnclosedRegion VisibleContentOpaqueRegion() const override;
protected:
TextureLayer(const LayerSettings& settings, TextureLayerClient* client);
diff --git a/cc/layers/texture_layer_impl.cc b/cc/layers/texture_layer_impl.cc
index ba31c6d..08617dbe 100644
--- a/cc/layers/texture_layer_impl.cc
+++ b/cc/layers/texture_layer_impl.cc
@@ -184,12 +184,12 @@
ValidateQuadResources(quad);
}
-SimpleEnclosedRegion TextureLayerImpl::VisibleContentOpaqueRegion() const {
+SimpleEnclosedRegion TextureLayerImpl::VisibleOpaqueRegion() const {
if (contents_opaque())
- return SimpleEnclosedRegion(visible_content_rect());
+ return SimpleEnclosedRegion(visible_layer_rect());
if (blend_background_color_ && (SkColorGetA(background_color()) == 0xFF))
- return SimpleEnclosedRegion(visible_content_rect());
+ return SimpleEnclosedRegion(visible_layer_rect());
return SimpleEnclosedRegion();
}
diff --git a/cc/layers/texture_layer_impl.h b/cc/layers/texture_layer_impl.h
index acbfbce..680aaf0a 100644
--- a/cc/layers/texture_layer_impl.h
+++ b/cc/layers/texture_layer_impl.h
@@ -30,7 +30,7 @@
ResourceProvider* resource_provider) override;
void AppendQuads(RenderPass* render_pass,
AppendQuadsData* append_quads_data) override;
- SimpleEnclosedRegion VisibleContentOpaqueRegion() const override;
+ SimpleEnclosedRegion VisibleOpaqueRegion() const override;
void ReleaseResources() override;
// These setter methods don't cause any implicit damage, so the texture client
diff --git a/cc/layers/texture_layer_impl_unittest.cc b/cc/layers/texture_layer_impl_unittest.cc
index d3f660e..27efd97 100644
--- a/cc/layers/texture_layer_impl_unittest.cc
+++ b/cc/layers/texture_layer_impl_unittest.cc
@@ -17,6 +17,32 @@
BlockingTaskRunner* main_thread_task_runner) {
}
+TEST(TextureLayerImplTest, VisibleOpaqueRegion) {
+ const gfx::Size layer_bounds(100, 100);
+ const gfx::Rect layer_rect(layer_bounds);
+ const Region layer_region(layer_rect);
+
+ LayerTestCommon::LayerImplTest impl;
+
+ TextureLayerImpl* layer = impl.AddChildToRoot<TextureLayerImpl>();
+ layer->SetBounds(layer_bounds);
+ layer->draw_properties().visible_layer_rect = layer_rect;
+ layer->SetBlendBackgroundColor(true);
+
+ // Verify initial conditions.
+ EXPECT_FALSE(layer->contents_opaque());
+ EXPECT_EQ(0u, layer->background_color());
+ EXPECT_EQ(Region().ToString(), layer->VisibleOpaqueRegion().ToString());
+
+ // Opaque background.
+ layer->SetBackgroundColor(SK_ColorWHITE);
+ EXPECT_EQ(layer_region.ToString(), layer->VisibleOpaqueRegion().ToString());
+
+ // Transparent background.
+ layer->SetBackgroundColor(SkColorSetARGB(100, 255, 255, 255));
+ EXPECT_EQ(Region().ToString(), layer->VisibleOpaqueRegion().ToString());
+}
+
TEST(TextureLayerImplTest, Occlusion) {
gfx::Size layer_size(1000, 1000);
gfx::Size viewport_size(1000, 1000);
@@ -50,7 +76,7 @@
{
SCOPED_TRACE("Full occlusion");
- gfx::Rect occluded(texture_layer_impl->visible_content_rect());
+ gfx::Rect occluded(texture_layer_impl->visible_layer_rect());
impl.AppendQuadsWithOcclusion(texture_layer_impl, occluded);
LayerTestCommon::VerifyQuadsExactlyCoverRect(impl.quad_list(), gfx::Rect());
diff --git a/cc/layers/texture_layer_unittest.cc b/cc/layers/texture_layer_unittest.cc
index 0a68d23..97bb7a1 100644
--- a/cc/layers/texture_layer_unittest.cc
+++ b/cc/layers/texture_layer_unittest.cc
@@ -235,34 +235,6 @@
EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetBlendBackgroundColor(true));
}
-TEST_F(TextureLayerTest, VisibleContentOpaqueRegion) {
- const gfx::Size layer_bounds(100, 100);
- const gfx::Rect layer_rect(layer_bounds);
- const Region layer_region(layer_rect);
-
- scoped_refptr<TextureLayer> layer =
- TextureLayer::CreateForMailbox(layer_settings_, nullptr);
- layer->SetBounds(layer_bounds);
- layer->draw_properties().visible_content_rect = layer_rect;
- layer->SetBlendBackgroundColor(true);
-
- // Verify initial conditions.
- EXPECT_FALSE(layer->contents_opaque());
- EXPECT_EQ(0u, layer->background_color());
- EXPECT_EQ(Region().ToString(),
- layer->VisibleContentOpaqueRegion().ToString());
-
- // Opaque background.
- layer->SetBackgroundColor(SK_ColorWHITE);
- EXPECT_EQ(layer_region.ToString(),
- layer->VisibleContentOpaqueRegion().ToString());
-
- // Transparent background.
- layer->SetBackgroundColor(SkColorSetARGB(100, 255, 255, 255));
- EXPECT_EQ(Region().ToString(),
- layer->VisibleContentOpaqueRegion().ToString());
-}
-
TEST_F(TextureLayerTest, RateLimiter) {
FakeTextureLayerClient client;
scoped_refptr<TextureLayer> test_layer =
diff --git a/cc/layers/ui_resource_layer_impl_unittest.cc b/cc/layers/ui_resource_layer_impl_unittest.cc
index dfb17eb..e31d68a 100644
--- a/cc/layers/ui_resource_layer_impl_unittest.cc
+++ b/cc/layers/ui_resource_layer_impl_unittest.cc
@@ -28,10 +28,10 @@
const gfx::Size& layer_size,
bool opaque,
UIResourceId uid) {
- gfx::Rect visible_content_rect(layer_size);
+ gfx::Rect visible_layer_rect(layer_size);
scoped_ptr<UIResourceLayerImpl> layer =
UIResourceLayerImpl::Create(host_impl->active_tree(), 1);
- layer->draw_properties().visible_content_rect = visible_content_rect;
+ layer->draw_properties().visible_layer_rect = visible_layer_rect;
layer->SetBounds(layer_size);
layer->SetHasRenderSurface(true);
layer->draw_properties().render_target = layer.get();
@@ -190,7 +190,7 @@
{
SCOPED_TRACE("Full occlusion");
- gfx::Rect occluded(ui_resource_layer_impl->visible_content_rect());
+ gfx::Rect occluded(ui_resource_layer_impl->visible_layer_rect());
impl.AppendQuadsWithOcclusion(ui_resource_layer_impl, occluded);
LayerTestCommon::VerifyQuadsExactlyCoverRect(impl.quad_list(), gfx::Rect());
diff --git a/cc/layers/video_layer_impl.cc b/cc/layers/video_layer_impl.cc
index 665541e..2233583 100644
--- a/cc/layers/video_layer_impl.cc
+++ b/cc/layers/video_layer_impl.cc
@@ -161,7 +161,7 @@
SharedQuadState* shared_quad_state =
render_pass->CreateAndAppendSharedQuadState();
- shared_quad_state->SetAll(transform, rotated_size, visible_content_rect(),
+ shared_quad_state->SetAll(transform, rotated_size, visible_layer_rect(),
clip_rect(), is_clipped(), draw_opacity(),
draw_blend_mode(), sorting_context_id());
@@ -389,11 +389,11 @@
provider_client_impl_->ReleaseLock();
}
-SimpleEnclosedRegion VideoLayerImpl::VisibleContentOpaqueRegion() const {
+SimpleEnclosedRegion VideoLayerImpl::VisibleOpaqueRegion() const {
// If we don't have a frame yet, then we don't have an opaque region.
if (!provider_client_impl_->HasCurrentFrame())
return SimpleEnclosedRegion();
- return LayerImpl::VisibleContentOpaqueRegion();
+ return LayerImpl::VisibleOpaqueRegion();
}
void VideoLayerImpl::ReleaseResources() {
diff --git a/cc/layers/video_layer_impl.h b/cc/layers/video_layer_impl.h
index 58c0e12..6fab7f5 100644
--- a/cc/layers/video_layer_impl.h
+++ b/cc/layers/video_layer_impl.h
@@ -38,7 +38,7 @@
void AppendQuads(RenderPass* render_pass,
AppendQuadsData* append_quads_data) override;
void DidDraw(ResourceProvider* resource_provider) override;
- SimpleEnclosedRegion VisibleContentOpaqueRegion() const override;
+ SimpleEnclosedRegion VisibleOpaqueRegion() const override;
void DidBecomeActive() override;
void ReleaseResources() override;
diff --git a/cc/layers/video_layer_impl_unittest.cc b/cc/layers/video_layer_impl_unittest.cc
index 5f580d1..da2de85 100644
--- a/cc/layers/video_layer_impl_unittest.cc
+++ b/cc/layers/video_layer_impl_unittest.cc
@@ -63,7 +63,7 @@
{
SCOPED_TRACE("Full occlusion");
- gfx::Rect occluded(video_layer_impl->visible_content_rect());
+ gfx::Rect occluded(video_layer_impl->visible_layer_rect());
impl.AppendQuadsWithOcclusion(video_layer_impl, occluded);
LayerTestCommon::VerifyQuadsExactlyCoverRect(impl.quad_list(), gfx::Rect());
@@ -176,10 +176,10 @@
gfx::Point3F p2(impl.quad_list().front()->rect.width(), 0, 0);
impl.quad_list()
.front()
- ->shared_quad_state->content_to_target_transform.TransformPoint(&p1);
+ ->shared_quad_state->quad_to_target_transform.TransformPoint(&p1);
impl.quad_list()
.front()
- ->shared_quad_state->content_to_target_transform.TransformPoint(&p2);
+ ->shared_quad_state->quad_to_target_transform.TransformPoint(&p2);
EXPECT_EQ(gfx::Point3F(0, 50, 0), p1);
EXPECT_EQ(gfx::Point3F(100, 0, 0), p2);
}
@@ -215,10 +215,10 @@
gfx::Point3F p2(impl.quad_list().front()->rect.width(), 0, 0);
impl.quad_list()
.front()
- ->shared_quad_state->content_to_target_transform.TransformPoint(&p1);
+ ->shared_quad_state->quad_to_target_transform.TransformPoint(&p1);
impl.quad_list()
.front()
- ->shared_quad_state->content_to_target_transform.TransformPoint(&p2);
+ ->shared_quad_state->quad_to_target_transform.TransformPoint(&p2);
EXPECT_EQ(gfx::Point3F(0, 0, 0), p1);
EXPECT_EQ(gfx::Point3F(100, 50, 0), p2);
}
@@ -254,10 +254,10 @@
gfx::Point3F p2(impl.quad_list().front()->rect.width(), 0, 0);
impl.quad_list()
.front()
- ->shared_quad_state->content_to_target_transform.TransformPoint(&p1);
+ ->shared_quad_state->quad_to_target_transform.TransformPoint(&p1);
impl.quad_list()
.front()
- ->shared_quad_state->content_to_target_transform.TransformPoint(&p2);
+ ->shared_quad_state->quad_to_target_transform.TransformPoint(&p2);
EXPECT_EQ(gfx::Point3F(100, 0, 0), p1);
EXPECT_EQ(gfx::Point3F(0, 50, 0), p2);
}
@@ -293,10 +293,10 @@
gfx::Point3F p2(impl.quad_list().front()->rect.width(), 0, 0);
impl.quad_list()
.front()
- ->shared_quad_state->content_to_target_transform.TransformPoint(&p1);
+ ->shared_quad_state->quad_to_target_transform.TransformPoint(&p1);
impl.quad_list()
.front()
- ->shared_quad_state->content_to_target_transform.TransformPoint(&p2);
+ ->shared_quad_state->quad_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 ddf39f3b..8a336941 100644
--- a/cc/output/bsp_walk_action.cc
+++ b/cc/output/bsp_walk_action.cc
@@ -28,7 +28,7 @@
gfx::Transform inverse_transform;
bool invertible =
item->original_ref()
- ->shared_quad_state->content_to_target_transform.GetInverse(
+ ->shared_quad_state->quad_to_target_transform.GetInverse(
&inverse_transform);
DCHECK(invertible);
item->TransformToLayerSpace(inverse_transform);
diff --git a/cc/output/direct_renderer.cc b/cc/output/direct_renderer.cc
index 058c53b..7ceaa00 100644
--- a/cc/output/direct_renderer.cc
+++ b/cc/output/direct_renderer.cc
@@ -461,10 +461,9 @@
// 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.shared_quad_state->content_to_target_transform,
- next_polygon_id++));
+ scoped_ptr<DrawPolygon> new_polygon(new DrawPolygon(
+ *it, quad.visible_rect,
+ quad.shared_quad_state->quad_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 473e164a..761123e 100644
--- a/cc/output/gl_renderer.cc
+++ b/cc/output/gl_renderer.cc
@@ -599,7 +599,7 @@
SetShaderOpacity(quad->shared_quad_state->opacity,
program->fragment_shader().alpha_location());
- DrawQuadGeometry(frame, quad->shared_quad_state->content_to_target_transform,
+ DrawQuadGeometry(frame, quad->shared_quad_state->quad_to_target_transform,
quad->rect, program->vertex_shader().matrix_location());
}
@@ -620,7 +620,7 @@
gfx::Rect layer_rect = quad->rect;
gfx::Transform render_matrix;
QuadRectTransform(&render_matrix,
- quad->shared_quad_state->content_to_target_transform,
+ quad->shared_quad_state->quad_to_target_transform,
layer_rect);
GLRenderer::ToGLMatrix(&gl_matrix[0],
frame->projection_matrix * render_matrix);
@@ -927,7 +927,7 @@
gfx::Transform quad_rect_matrix;
QuadRectTransform(&quad_rect_matrix,
- quad->shared_quad_state->content_to_target_transform,
+ quad->shared_quad_state->quad_to_target_transform,
quad->rect);
gfx::Transform contents_device_transform =
frame->window_matrix * frame->projection_matrix * quad_rect_matrix;
@@ -1081,10 +1081,8 @@
}
TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
- gl_,
- &highp_threshold_cache_,
- highp_threshold_min_,
- quad->shared_quad_state->visible_content_rect.bottom_right());
+ gl_, &highp_threshold_cache_, highp_threshold_min_,
+ quad->shared_quad_state->visible_quad_layer_rect.bottom_right());
ShaderLocations locations;
@@ -1258,7 +1256,7 @@
SetShaderOpacity(quad->shared_quad_state->opacity, locations.alpha);
SetShaderQuadF(surface_quad, locations.quad);
- DrawQuadGeometry(frame, quad->shared_quad_state->content_to_target_transform,
+ DrawQuadGeometry(frame, quad->shared_quad_state->quad_to_target_transform,
quad->rect, locations.matrix);
// Flush the compositor context before the filter bitmap goes out of
@@ -1310,10 +1308,10 @@
return true;
return std::abs(clip_region->p3().y() -
- quad->shared_quad_state->content_bounds.height()) <
+ quad->shared_quad_state->quad_layer_bounds.height()) <
kAntiAliasingEpsilon &&
std::abs(clip_region->p4().y() -
- quad->shared_quad_state->content_bounds.height()) <
+ quad->shared_quad_state->quad_layer_bounds.height()) <
kAntiAliasingEpsilon;
}
@@ -1334,10 +1332,10 @@
return true;
return std::abs(clip_region->p2().x() -
- quad->shared_quad_state->content_bounds.width()) <
+ quad->shared_quad_state->quad_layer_bounds.width()) <
kAntiAliasingEpsilon &&
std::abs(clip_region->p3().x() -
- quad->shared_quad_state->content_bounds.width()) <
+ quad->shared_quad_state->quad_layer_bounds.width()) <
kAntiAliasingEpsilon;
}
} // anonymous namespace
@@ -1584,7 +1582,7 @@
gfx::Transform device_transform =
frame->window_matrix * frame->projection_matrix *
- quad->shared_quad_state->content_to_target_transform;
+ quad->shared_quad_state->quad_to_target_transform;
device_transform.FlattenTo2d();
if (!device_transform.IsInvertible())
return;
@@ -1601,7 +1599,7 @@
bool force_aa = false;
device_layer_quad = MathUtil::MapQuad(
device_transform,
- gfx::QuadF(quad->shared_quad_state->visible_content_rect), &clipped);
+ gfx::QuadF(quad->shared_quad_state->visible_quad_layer_rect), &clipped);
use_aa = ShouldAntialiasQuad(device_layer_quad, clipped, force_aa);
}
@@ -1649,7 +1647,7 @@
gfx::RectF centered_rect(
gfx::PointF(-0.5f * tile_rect.width(), -0.5f * tile_rect.height()),
tile_rect.size());
- DrawQuadGeometry(frame, quad->shared_quad_state->content_to_target_transform,
+ DrawQuadGeometry(frame, quad->shared_quad_state->quad_to_target_transform,
centered_rect, uniforms.matrix_location);
}
@@ -1693,7 +1691,7 @@
const gfx::QuadF* clip_region) {
gfx::Transform device_transform =
frame->window_matrix * frame->projection_matrix *
- quad->shared_quad_state->content_to_target_transform;
+ quad->shared_quad_state->quad_to_target_transform;
device_transform.FlattenTo2d();
gfx::QuadF device_layer_quad;
@@ -1704,7 +1702,7 @@
bool force_aa = false;
device_layer_quad = MathUtil::MapQuad(
device_transform,
- gfx::QuadF(quad->shared_quad_state->visible_content_rect), &clipped);
+ gfx::QuadF(quad->shared_quad_state->visible_quad_layer_rect), &clipped);
use_aa = ShouldAntialiasQuad(device_layer_quad, clipped, force_aa);
}
@@ -1835,7 +1833,7 @@
gfx::RectF centered_rect(
gfx::PointF(-0.5f * tile_rect.width(), -0.5f * tile_rect.height()),
tile_rect.size());
- DrawQuadGeometry(frame, quad->shared_quad_state->content_to_target_transform,
+ DrawQuadGeometry(frame, quad->shared_quad_state->quad_to_target_transform,
centered_rect, uniforms.matrix_location);
}
@@ -1851,7 +1849,7 @@
bool scaled = (tex_to_geom_scale_x != 1.f || tex_to_geom_scale_y != 1.f);
GLenum filter = (scaled ||
- !quad->shared_quad_state->content_to_target_transform
+ !quad->shared_quad_state->quad_to_target_transform
.IsIdentityOrIntegerTranslation()) &&
!quad->nearest_neighbor
? GL_LINEAR
@@ -1951,7 +1949,7 @@
static float gl_matrix[16];
ToGLMatrix(&gl_matrix[0],
frame->projection_matrix *
- quad->shared_quad_state->content_to_target_transform);
+ quad->shared_quad_state->quad_to_target_transform);
gl_->UniformMatrix4fv(uniforms.matrix_location, 1, false, &gl_matrix[0]);
gl_->DrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);
@@ -1963,10 +1961,8 @@
SetBlendEnabled(quad->ShouldDrawWithBlending());
TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
- gl_,
- &highp_threshold_cache_,
- highp_threshold_min_,
- quad->shared_quad_state->visible_content_rect.bottom_right());
+ gl_, &highp_threshold_cache_, highp_threshold_min_,
+ quad->shared_quad_state->visible_quad_layer_rect.bottom_right());
bool use_alpha_plane = quad->a_plane_resource_id() != 0;
@@ -2159,8 +2155,7 @@
SetShaderOpacity(quad->shared_quad_state->opacity, alpha_location);
if (!clip_region) {
- DrawQuadGeometry(frame,
- quad->shared_quad_state->content_to_target_transform,
+ DrawQuadGeometry(frame, quad->shared_quad_state->quad_to_target_transform,
tile_rect, matrix_location);
} else {
float uvs[8] = {0};
@@ -2169,7 +2164,7 @@
region_quad.Scale(1.0f / tile_rect.width(), 1.0f / tile_rect.height());
region_quad -= gfx::Vector2dF(0.5f, 0.5f);
DrawQuadGeometryClippedByQuadF(
- frame, quad->shared_quad_state->content_to_target_transform, tile_rect,
+ frame, quad->shared_quad_state->quad_to_target_transform, tile_rect,
region_quad, matrix_location, uvs);
}
}
@@ -2184,10 +2179,8 @@
DCHECK(capabilities_.using_egl_image);
TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
- gl_,
- &highp_threshold_cache_,
- highp_threshold_min_,
- quad->shared_quad_state->visible_content_rect.bottom_right());
+ gl_, &highp_threshold_cache_, highp_threshold_min_,
+ quad->shared_quad_state->visible_quad_layer_rect.bottom_right());
const VideoStreamTextureProgram* program =
GetVideoStreamTextureProgram(tex_coord_precision);
@@ -2207,8 +2200,7 @@
SetShaderOpacity(quad->shared_quad_state->opacity,
program->fragment_shader().alpha_location());
if (!clip_region) {
- DrawQuadGeometry(frame,
- quad->shared_quad_state->content_to_target_transform,
+ DrawQuadGeometry(frame, quad->shared_quad_state->quad_to_target_transform,
quad->rect, program->vertex_shader().matrix_location());
} else {
gfx::QuadF region_quad(*clip_region);
@@ -2217,7 +2209,7 @@
float uvs[8] = {0};
GetScaledUVs(quad->visible_rect, clip_region, uvs);
DrawQuadGeometryClippedByQuadF(
- frame, quad->shared_quad_state->content_to_target_transform, quad->rect,
+ frame, quad->shared_quad_state->quad_to_target_transform, quad->rect,
region_quad, program->vertex_shader().matrix_location(), uvs);
}
}
@@ -2333,10 +2325,8 @@
}
TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
- gl_,
- &highp_threshold_cache_,
- highp_threshold_min_,
- quad->shared_quad_state->visible_content_rect.bottom_right());
+ gl_, &highp_threshold_cache_, highp_threshold_min_,
+ quad->shared_quad_state->visible_quad_layer_rect.bottom_right());
ResourceProvider::ScopedReadLockGL lock(resource_provider_,
quad->resource_id());
@@ -2399,7 +2389,7 @@
// Generate the transform matrix
gfx::Transform quad_rect_matrix;
QuadRectTransform(&quad_rect_matrix,
- quad->shared_quad_state->content_to_target_transform,
+ quad->shared_quad_state->quad_to_target_transform,
quad->rect);
quad_rect_matrix = frame->projection_matrix * quad_rect_matrix;
@@ -2435,10 +2425,8 @@
SetBlendEnabled(quad->ShouldDrawWithBlending());
TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
- gl_,
- &highp_threshold_cache_,
- highp_threshold_min_,
- quad->shared_quad_state->visible_content_rect.bottom_right());
+ gl_, &highp_threshold_cache_, highp_threshold_min_,
+ quad->shared_quad_state->visible_quad_layer_rect.bottom_right());
TexTransformTextureProgramBinding binding;
binding.Set(GetTextureIOSurfaceProgram(tex_coord_precision));
@@ -2467,14 +2455,13 @@
gl_->BindTexture(GL_TEXTURE_RECTANGLE_ARB, lock.texture_id());
if (!clip_region) {
- DrawQuadGeometry(frame,
- quad->shared_quad_state->content_to_target_transform,
+ DrawQuadGeometry(frame, quad->shared_quad_state->quad_to_target_transform,
quad->rect, binding.matrix_location);
} else {
float uvs[8] = {0};
GetScaledUVs(quad->visible_rect, clip_region, uvs);
DrawQuadGeometryClippedByQuadF(
- frame, quad->shared_quad_state->content_to_target_transform, quad->rect,
+ frame, quad->shared_quad_state->quad_to_target_transform, quad->rect,
*clip_region, binding.matrix_location, uvs);
}
diff --git a/cc/output/overlay_strategy_common.cc b/cc/output/overlay_strategy_common.cc
index f95b373..9c3a2342 100644
--- a/cc/output/overlay_strategy_common.cc
+++ b/cc/output/overlay_strategy_common.cc
@@ -50,7 +50,7 @@
OverlayCandidate* quad_info) {
gfx::OverlayTransform overlay_transform =
OverlayCandidate::GetOverlayTransform(
- quad.shared_quad_state->content_to_target_transform, quad.y_flipped);
+ quad.shared_quad_state->quad_to_target_transform, quad.y_flipped);
if (quad.background_color != SK_ColorTRANSPARENT ||
quad.premultiplied_alpha ||
overlay_transform == gfx::OVERLAY_TRANSFORM_INVALID)
@@ -66,7 +66,7 @@
OverlayCandidate* quad_info) {
gfx::OverlayTransform overlay_transform =
OverlayCandidate::GetOverlayTransform(
- quad.shared_quad_state->content_to_target_transform, false);
+ quad.shared_quad_state->quad_to_target_transform, false);
if (overlay_transform == gfx::OVERLAY_TRANSFORM_INVALID)
return false;
if (!quad.matrix.IsScaleOrTranslation()) {
@@ -125,7 +125,7 @@
quad_info->format = RGBA_8888;
quad_info->display_rect = OverlayCandidate::GetOverlayRect(
- draw_quad.shared_quad_state->content_to_target_transform, draw_quad.rect);
+ draw_quad.shared_quad_state->quad_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 e188916..956aa54 100644
--- a/cc/output/overlay_strategy_single_on_top.cc
+++ b/cc/output/overlay_strategy_single_on_top.cc
@@ -35,13 +35,13 @@
// Check that no prior quads overlap it.
bool intersects = false;
gfx::RectF rect = draw_quad->rect;
- draw_quad->shared_quad_state->content_to_target_transform.TransformRect(
+ draw_quad->shared_quad_state->quad_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->shared_quad_state->content_to_target_transform
- .TransformRect(&overlap_rect);
+ overlap_iter->shared_quad_state->quad_to_target_transform.TransformRect(
+ &overlap_rect);
if (rect.Intersects(overlap_rect) && !IsInvisibleQuad(*overlap_iter)) {
intersects = true;
break;
diff --git a/cc/output/overlay_unittest.cc b/cc/output/overlay_unittest.cc
index 448d04d..6ac9b1c64 100644
--- a/cc/output/overlay_unittest.cc
+++ b/cc/output/overlay_unittest.cc
@@ -278,8 +278,8 @@
exp_iter != expected->quad_list.cend();
++exp_iter, ++act_iter) {
EXPECT_EQ(exp_iter->rect.ToString(), act_iter->rect.ToString());
- EXPECT_EQ(exp_iter->shared_quad_state->content_bounds.ToString(),
- act_iter->shared_quad_state->content_bounds.ToString());
+ EXPECT_EQ(exp_iter->shared_quad_state->quad_layer_bounds.ToString(),
+ act_iter->shared_quad_state->quad_layer_bounds.ToString());
}
}
}
@@ -546,7 +546,7 @@
pass->shared_quad_state_list.back(),
pass.get());
pass->shared_quad_state_list.back()
- ->content_to_target_transform.RotateAboutXAxis(45.f);
+ ->quad_to_target_transform.RotateAboutXAxis(45.f);
RenderPassList pass_list;
pass_list.push_back(pass.Pass());
@@ -563,8 +563,8 @@
scoped_ptr<RenderPass> pass = CreateRenderPass();
CreateCandidateQuadAt(resource_provider_.get(),
pass->shared_quad_state_list.back(), pass.get(), rect);
- pass->shared_quad_state_list.back()->content_to_target_transform.Scale(2.0f,
- -1.0f);
+ pass->shared_quad_state_list.back()->quad_to_target_transform.Scale(2.0f,
+ -1.0f);
RenderPassList pass_list;
pass_list.push_back(pass.Pass());
@@ -583,8 +583,8 @@
scoped_ptr<RenderPass> pass = CreateRenderPass();
CreateCandidateQuadAt(resource_provider_.get(),
pass->shared_quad_state_list.back(), pass.get(), rect);
- pass->shared_quad_state_list.back()->content_to_target_transform.Scale(-1.0f,
- 2.0f);
+ pass->shared_quad_state_list.back()->quad_to_target_transform.Scale(-1.0f,
+ 2.0f);
RenderPassList pass_list;
pass_list.push_back(pass.Pass());
@@ -602,8 +602,8 @@
scoped_ptr<RenderPass> pass = CreateRenderPass();
CreateCandidateQuadAt(resource_provider_.get(),
pass->shared_quad_state_list.back(), pass.get(), rect);
- pass->shared_quad_state_list.back()->content_to_target_transform.Scale(2.0f,
- 1.0f);
+ pass->shared_quad_state_list.back()->quad_to_target_transform.Scale(2.0f,
+ 1.0f);
RenderPassList pass_list;
pass_list.push_back(pass.Pass());
@@ -620,7 +620,7 @@
CreateCandidateQuadAt(resource_provider_.get(),
pass->shared_quad_state_list.back(), pass.get(), rect);
pass->shared_quad_state_list.back()
- ->content_to_target_transform.RotateAboutZAxis(90.f);
+ ->quad_to_target_transform.RotateAboutZAxis(90.f);
RenderPassList pass_list;
pass_list.push_back(pass.Pass());
@@ -638,7 +638,7 @@
CreateCandidateQuadAt(resource_provider_.get(),
pass->shared_quad_state_list.back(), pass.get(), rect);
pass->shared_quad_state_list.back()
- ->content_to_target_transform.RotateAboutZAxis(180.f);
+ ->quad_to_target_transform.RotateAboutZAxis(180.f);
RenderPassList pass_list;
pass_list.push_back(pass.Pass());
@@ -656,7 +656,7 @@
CreateCandidateQuadAt(resource_provider_.get(),
pass->shared_quad_state_list.back(), pass.get(), rect);
pass->shared_quad_state_list.back()
- ->content_to_target_transform.RotateAboutZAxis(270.f);
+ ->quad_to_target_transform.RotateAboutZAxis(270.f);
RenderPassList pass_list;
pass_list.push_back(pass.Pass());
diff --git a/cc/output/renderer_pixeltest.cc b/cc/output/renderer_pixeltest.cc
index 136550c..d6a8e5d 100644
--- a/cc/output/renderer_pixeltest.cc
+++ b/cc/output/renderer_pixeltest.cc
@@ -47,48 +47,38 @@
}
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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,
0,
@@ -1601,9 +1591,9 @@
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,
0,
@@ -1758,41 +1748,32 @@
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_,
- 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_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 @@
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 @@
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 @@
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 @@
}
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 @@
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 @@
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 @@
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,
0,
@@ -2036,26 +2016,26 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
// 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 @@
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 @@
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 @@
// 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 @@
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 @@
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,
0,
@@ -2828,9 +2800,9 @@
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,
0,
@@ -2877,9 +2849,9 @@
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,
diff --git a/cc/output/software_renderer.cc b/cc/output/software_renderer.cc
index aa55a5b..a8110ef 100644
--- a/cc/output/software_renderer.cc
+++ b/cc/output/software_renderer.cc
@@ -251,7 +251,7 @@
TRACE_EVENT0("cc", "SoftwareRenderer::DoDrawQuad");
gfx::Transform quad_rect_matrix;
QuadRectTransform(&quad_rect_matrix,
- quad->shared_quad_state->content_to_target_transform,
+ quad->shared_quad_state->quad_to_target_transform,
quad->rect);
gfx::Transform contents_device_transform =
frame->window_matrix * frame->projection_matrix * quad_rect_matrix;
diff --git a/cc/quads/draw_polygon.cc b/cc/quads/draw_polygon.cc
index 6544b64..cdb94d0 100644
--- a/cc/quads/draw_polygon.cc
+++ b/cc/quads/draw_polygon.cc
@@ -52,7 +52,7 @@
// a visible content rect to make the 4 corner points from, and a transformation
// to move it and its normal into screen space.
DrawPolygon::DrawPolygon(const DrawQuad* original_ref,
- const gfx::RectF& visible_content_rect,
+ const gfx::RectF& visible_layer_rect,
const gfx::Transform& transform,
int draw_order_index)
: normal_(0.0f, 0.0f, 1.0f),
@@ -61,7 +61,7 @@
is_split_(false) {
gfx::Point3F points[8];
int num_vertices_in_clipped_quad;
- gfx::QuadF send_quad(visible_content_rect);
+ gfx::QuadF send_quad(visible_layer_rect);
// Doing this mapping here is very important, since we can't just transform
// the points without clipping and not run into strange geometry issues when
diff --git a/cc/quads/draw_polygon.h b/cc/quads/draw_polygon.h
index b94ff1e..93c3602 100644
--- a/cc/quads/draw_polygon.h
+++ b/cc/quads/draw_polygon.h
@@ -29,7 +29,7 @@
const gfx::Vector3dF& normal,
int draw_order_index = 0);
DrawPolygon(const DrawQuad* original_ref,
- const gfx::RectF& visible_content_rect,
+ const gfx::RectF& visible_layer_rect,
const gfx::Transform& transform,
int draw_order_index = 0);
diff --git a/cc/quads/draw_quad.cc b/cc/quads/draw_quad.cc
index 1142cc10..606d7ab 100644
--- a/cc/quads/draw_quad.cc
+++ b/cc/quads/draw_quad.cc
@@ -62,10 +62,9 @@
MathUtil::AddToTracedValue("content_space_rect", rect, value);
bool rect_is_clipped;
- gfx::QuadF rect_as_target_space_quad = MathUtil::MapQuad(
- shared_quad_state->content_to_target_transform,
- gfx::QuadF(rect),
- &rect_is_clipped);
+ gfx::QuadF rect_as_target_space_quad =
+ MathUtil::MapQuad(shared_quad_state->quad_to_target_transform,
+ gfx::QuadF(rect), &rect_is_clipped);
MathUtil::AddToTracedValue("rect_as_target_space_quad",
rect_as_target_space_quad, value);
@@ -74,10 +73,9 @@
MathUtil::AddToTracedValue("content_space_opaque_rect", opaque_rect, value);
bool opaque_rect_is_clipped;
- gfx::QuadF opaque_rect_as_target_space_quad = MathUtil::MapQuad(
- shared_quad_state->content_to_target_transform,
- gfx::QuadF(opaque_rect),
- &opaque_rect_is_clipped);
+ gfx::QuadF opaque_rect_as_target_space_quad =
+ MathUtil::MapQuad(shared_quad_state->quad_to_target_transform,
+ gfx::QuadF(opaque_rect), &opaque_rect_is_clipped);
MathUtil::AddToTracedValue("opaque_rect_as_target_space_quad",
opaque_rect_as_target_space_quad, value);
@@ -86,10 +84,9 @@
MathUtil::AddToTracedValue("content_space_visible_rect", visible_rect, value);
bool visible_rect_is_clipped;
- gfx::QuadF visible_rect_as_target_space_quad = MathUtil::MapQuad(
- shared_quad_state->content_to_target_transform,
- gfx::QuadF(visible_rect),
- &visible_rect_is_clipped);
+ gfx::QuadF visible_rect_as_target_space_quad =
+ MathUtil::MapQuad(shared_quad_state->quad_to_target_transform,
+ gfx::QuadF(visible_rect), &visible_rect_is_clipped);
MathUtil::AddToTracedValue("visible_rect_as_target_space_quad",
visible_rect_as_target_space_quad, value);
diff --git a/cc/quads/draw_quad.h b/cc/quads/draw_quad.h
index d5d431e..df3bc12 100644
--- a/cc/quads/draw_quad.h
+++ b/cc/quads/draw_quad.h
@@ -96,13 +96,13 @@
// Is the right edge of this tile aligned with the originating layer's
// right edge?
bool IsRightEdge() const {
- return rect.right() == shared_quad_state->content_bounds.width();
+ return rect.right() == shared_quad_state->quad_layer_bounds.width();
}
// Is the bottom edge of this tile aligned with the originating layer's
// bottom edge?
bool IsBottomEdge() const {
- return rect.bottom() == shared_quad_state->content_bounds.height();
+ return rect.bottom() == shared_quad_state->quad_layer_bounds.height();
}
// Is any edge of this tile aligned with the originating layer's
diff --git a/cc/quads/draw_quad_perftest.cc b/cc/quads/draw_quad_perftest.cc
index 0473238..08ce6d0 100644
--- a/cc/quads/draw_quad_perftest.cc
+++ b/cc/quads/draw_quad_perftest.cc
@@ -23,7 +23,7 @@
SharedQuadState* CreateSharedQuadState(RenderPass* render_pass) {
gfx::Transform quad_transform = gfx::Transform(1.0, 0.0, 0.5, 1.0, 0.5, 0.0);
gfx::Size content_bounds(26, 28);
- gfx::Rect visible_content_rect(10, 12, 14, 16);
+ gfx::Rect visible_layer_rect(10, 12, 14, 16);
gfx::Rect clip_rect(19, 21, 23, 25);
bool is_clipped = false;
float opacity = 1.f;
@@ -31,7 +31,7 @@
SkXfermode::Mode blend_mode = SkXfermode::kSrcOver_Mode;
SharedQuadState* state = render_pass->CreateAndAppendSharedQuadState();
- state->SetAll(quad_transform, content_bounds, visible_content_rect, clip_rect,
+ state->SetAll(quad_transform, content_bounds, visible_layer_rect, clip_rect,
is_clipped, opacity, blend_mode, sorting_context_id);
return state;
}
diff --git a/cc/quads/draw_quad_unittest.cc b/cc/quads/draw_quad_unittest.cc
index 5bce42e..833f388 100644
--- a/cc/quads/draw_quad_unittest.cc
+++ b/cc/quads/draw_quad_unittest.cc
@@ -34,8 +34,8 @@
TEST(DrawQuadTest, CopySharedQuadState) {
gfx::Transform quad_transform = gfx::Transform(1.0, 0.0, 0.5, 1.0, 0.5, 0.0);
- gfx::Size content_bounds(26, 28);
- gfx::Rect visible_content_rect(10, 12, 14, 16);
+ gfx::Size layer_bounds(26, 28);
+ gfx::Rect visible_layer_rect(10, 12, 14, 16);
gfx::Rect clip_rect(19, 21, 23, 25);
bool is_clipped = true;
float opacity = 0.25f;
@@ -43,19 +43,13 @@
int sorting_context_id = 65536;
scoped_ptr<SharedQuadState> state(new SharedQuadState);
- state->SetAll(quad_transform,
- content_bounds,
- visible_content_rect,
- clip_rect,
- is_clipped,
- opacity,
- blend_mode,
- sorting_context_id);
+ state->SetAll(quad_transform, layer_bounds, visible_layer_rect, clip_rect,
+ is_clipped, opacity, blend_mode, sorting_context_id);
scoped_ptr<SharedQuadState> copy(new SharedQuadState);
copy->CopyFrom(state.get());
- EXPECT_EQ(quad_transform, copy->content_to_target_transform);
- EXPECT_EQ(visible_content_rect, copy->visible_content_rect);
+ EXPECT_EQ(quad_transform, copy->quad_to_target_transform);
+ EXPECT_EQ(visible_layer_rect, copy->visible_quad_layer_rect);
EXPECT_EQ(opacity, copy->opacity);
EXPECT_EQ(clip_rect, copy->clip_rect);
EXPECT_EQ(is_clipped, copy->is_clipped);
@@ -64,8 +58,8 @@
SharedQuadState* CreateSharedQuadState(RenderPass* render_pass) {
gfx::Transform quad_transform = gfx::Transform(1.0, 0.0, 0.5, 1.0, 0.5, 0.0);
- gfx::Size content_bounds(26, 28);
- gfx::Rect visible_content_rect(10, 12, 14, 16);
+ gfx::Size layer_bounds(26, 28);
+ gfx::Rect visible_layer_rect(10, 12, 14, 16);
gfx::Rect clip_rect(19, 21, 23, 25);
bool is_clipped = false;
float opacity = 1.f;
@@ -73,14 +67,8 @@
SkXfermode::Mode blend_mode = SkXfermode::kSrcOver_Mode;
SharedQuadState* state = render_pass->CreateAndAppendSharedQuadState();
- state->SetAll(quad_transform,
- content_bounds,
- visible_content_rect,
- clip_rect,
- is_clipped,
- opacity,
- blend_mode,
- sorting_context_id);
+ state->SetAll(quad_transform, layer_bounds, visible_layer_rect, clip_rect,
+ is_clipped, opacity, blend_mode, sorting_context_id);
return state;
}
diff --git a/cc/quads/render_pass_unittest.cc b/cc/quads/render_pass_unittest.cc
index e6f39bca..65183af 100644
--- a/cc/quads/render_pass_unittest.cc
+++ b/cc/quads/render_pass_unittest.cc
@@ -57,8 +57,8 @@
exp_iter != expected->quad_list.cend();
++exp_iter, ++act_iter) {
EXPECT_EQ(exp_iter->rect.ToString(), act_iter->rect.ToString());
- EXPECT_EQ(exp_iter->shared_quad_state->content_bounds.ToString(),
- act_iter->shared_quad_state->content_bounds.ToString());
+ EXPECT_EQ(exp_iter->shared_quad_state->quad_layer_bounds.ToString(),
+ act_iter->shared_quad_state->quad_layer_bounds.ToString());
}
}
}
diff --git a/cc/quads/shared_quad_state.cc b/cc/quads/shared_quad_state.cc
index 5e46fcc..e09cdaf 100644
--- a/cc/quads/shared_quad_state.cc
+++ b/cc/quads/shared_quad_state.cc
@@ -28,17 +28,17 @@
*this = *other;
}
-void SharedQuadState::SetAll(const gfx::Transform& content_to_target_transform,
- const gfx::Size& content_bounds,
- const gfx::Rect& visible_content_rect,
+void SharedQuadState::SetAll(const gfx::Transform& quad_to_target_transform,
+ const gfx::Size& quad_layer_bounds,
+ const gfx::Rect& visible_quad_layer_rect,
const gfx::Rect& clip_rect,
bool is_clipped,
float opacity,
SkXfermode::Mode blend_mode,
int sorting_context_id) {
- this->content_to_target_transform = content_to_target_transform;
- this->content_bounds = content_bounds;
- this->visible_content_rect = visible_content_rect;
+ this->quad_to_target_transform = quad_to_target_transform;
+ this->quad_layer_bounds = quad_layer_bounds;
+ this->visible_quad_layer_rect = visible_quad_layer_rect;
this->clip_rect = clip_rect;
this->is_clipped = is_clipped;
this->opacity = opacity;
@@ -47,10 +47,10 @@
}
void SharedQuadState::AsValueInto(base::trace_event::TracedValue* value) const {
- MathUtil::AddToTracedValue("transform", content_to_target_transform, value);
- MathUtil::AddToTracedValue("layer_content_bounds", content_bounds, value);
- MathUtil::AddToTracedValue("layer_visible_content_rect", visible_content_rect,
- value);
+ MathUtil::AddToTracedValue("transform", quad_to_target_transform, value);
+ MathUtil::AddToTracedValue("layer_content_bounds", quad_layer_bounds, value);
+ MathUtil::AddToTracedValue("layer_visible_content_rect",
+ visible_quad_layer_rect, value);
value->SetBoolean("is_clipped", is_clipped);
diff --git a/cc/quads/shared_quad_state.h b/cc/quads/shared_quad_state.h
index 6f0ef929..a66c7bc 100644
--- a/cc/quads/shared_quad_state.h
+++ b/cc/quads/shared_quad_state.h
@@ -32,9 +32,9 @@
void CopyFrom(const SharedQuadState* other);
- void SetAll(const gfx::Transform& content_to_target_transform,
- const gfx::Size& content_bounds,
- const gfx::Rect& visible_content_rect,
+ void SetAll(const gfx::Transform& quad_to_target_transform,
+ const gfx::Size& layer_bounds,
+ const gfx::Rect& visible_layer_rect,
const gfx::Rect& clip_rect,
bool is_clipped,
float opacity,
@@ -42,12 +42,13 @@
int sorting_context_id);
void AsValueInto(base::trace_event::TracedValue* dict) const;
- // Transforms from quad's original content space to its target content space.
- gfx::Transform content_to_target_transform;
- // This size lives in the content space for the quad's originating layer.
- gfx::Size content_bounds;
- // This rect lives in the content space for the quad's originating layer.
- gfx::Rect visible_content_rect;
+ // Transforms quad rects into the target content space.
+ gfx::Transform quad_to_target_transform;
+ // The size of the quads' originating layer in the space of the quad rects.
+ gfx::Size quad_layer_bounds;
+ // The size of the visible area in the quads' originating layer, in the space
+ // of the quad rects.
+ gfx::Rect visible_quad_layer_rect;
// This rect lives in the target content space.
gfx::Rect clip_rect;
bool is_clipped;
diff --git a/cc/surfaces/surface_aggregator.cc b/cc/surfaces/surface_aggregator.cc
index a6af98ea..e1ee987a 100644
--- a/cc/surfaces/surface_aggregator.cc
+++ b/cc/surfaces/surface_aggregator.cc
@@ -259,7 +259,7 @@
// transform of the surface quad into account to update their transform to
// the root surface.
copy_pass->transform_to_root_target.ConcatTransform(
- surface_quad->shared_quad_state->content_to_target_transform);
+ surface_quad->shared_quad_state->quad_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);
@@ -280,14 +280,14 @@
const QuadList& quads = last_pass.quad_list;
gfx::Transform surface_transform =
- surface_quad->shared_quad_state->content_to_target_transform;
+ surface_quad->shared_quad_state->quad_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->shared_quad_state->content_to_target_transform,
+ surface_quad->shared_quad_state->quad_to_target_transform,
surface_quad->visible_rect));
if (surface_quad->shared_quad_state->is_clipped) {
surface_quad_clip_rect.rect.Intersect(
@@ -324,7 +324,7 @@
dest_pass->damage_rect = gfx::UnionRects(
dest_pass->damage_rect,
MathUtil::MapEnclosingClippedRect(
- surface_quad->shared_quad_state->content_to_target_transform,
+ surface_quad->shared_quad_state->quad_to_target_transform,
surface_damage));
referenced_surfaces_.erase(it);
@@ -344,7 +344,7 @@
// target space of the pass. This will be identity except when copying the
// root draw pass from a surface into a pass when the surface draw quad's
// transform is not identity.
- copy_shared_quad_state->content_to_target_transform.ConcatTransform(
+ copy_shared_quad_state->quad_to_target_transform.ConcatTransform(
target_transform);
ClipData new_clip_rect = CalculateClipRect(
@@ -404,7 +404,7 @@
dest_pass->damage_rect = gfx::UnionRects(
dest_pass->damage_rect,
MathUtil::MapEnclosingClippedRect(
- dest_quad->shared_quad_state->content_to_target_transform,
+ dest_quad->shared_quad_state->quad_to_target_transform,
pass_damage));
} else {
dest_quad = dest_pass->CopyFromAndAppendDrawQuad(
diff --git a/cc/surfaces/surface_aggregator_test_helpers.cc b/cc/surfaces/surface_aggregator_test_helpers.cc
index b21b37e..f7da1a2 100644
--- a/cc/surfaces/surface_aggregator_test_helpers.cc
+++ b/cc/surfaces/surface_aggregator_test_helpers.cc
@@ -26,22 +26,17 @@
const gfx::Size& surface_size,
float opacity,
SurfaceId surface_id) {
- gfx::Transform content_to_target_transform;
- gfx::Size content_bounds = surface_size;
- gfx::Rect visible_content_rect = gfx::Rect(surface_size);
+ gfx::Transform layer_to_target_transform;
+ gfx::Size layer_bounds = surface_size;
+ gfx::Rect visible_layer_rect = gfx::Rect(surface_size);
gfx::Rect clip_rect = gfx::Rect(surface_size);
bool is_clipped = false;
SkXfermode::Mode blend_mode = SkXfermode::kSrcOver_Mode;
SharedQuadState* shared_quad_state = pass->CreateAndAppendSharedQuadState();
- shared_quad_state->SetAll(content_to_target_transform,
- content_bounds,
- visible_content_rect,
- clip_rect,
- is_clipped,
- opacity,
- blend_mode,
- 0);
+ shared_quad_state->SetAll(layer_to_target_transform, layer_bounds,
+ visible_layer_rect, clip_rect, is_clipped, opacity,
+ blend_mode, 0);
SurfaceDrawQuad* surface_quad =
pass->CreateAndAppendDrawQuad<SurfaceDrawQuad>();
diff --git a/cc/surfaces/surface_aggregator_unittest.cc b/cc/surfaces/surface_aggregator_unittest.cc
index 981a573..b657efa 100644
--- a/cc/surfaces/surface_aggregator_unittest.cc
+++ b/cc/surfaces/surface_aggregator_unittest.cc
@@ -690,9 +690,9 @@
void AddSolidColorQuadWithBlendMode(const gfx::Size& size,
RenderPass* pass,
const SkXfermode::Mode blend_mode) {
- const gfx::Transform content_to_target_transform;
- const gfx::Size content_bounds(size);
- const gfx::Rect visible_content_rect(size);
+ const gfx::Transform layer_to_target_transform;
+ const gfx::Size layer_bounds(size);
+ const gfx::Rect visible_layer_rect(size);
const gfx::Rect clip_rect(size);
bool is_clipped = false;
@@ -700,21 +700,13 @@
bool force_anti_aliasing_off = false;
SharedQuadState* sqs = pass->CreateAndAppendSharedQuadState();
- sqs->SetAll(content_to_target_transform,
- content_bounds,
- visible_content_rect,
- clip_rect,
- is_clipped,
- opacity,
- blend_mode,
- 0);
+ sqs->SetAll(layer_to_target_transform, layer_bounds, visible_layer_rect,
+ clip_rect, is_clipped, opacity, blend_mode, 0);
SolidColorDrawQuad* color_quad =
pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
- color_quad->SetNew(pass->shared_quad_state_list.back(),
- visible_content_rect,
- visible_content_rect,
- SK_ColorGREEN,
+ color_quad->SetNew(pass->shared_quad_state_list.back(), visible_layer_rect,
+ visible_layer_rect, SK_ColorGREEN,
force_anti_aliasing_off);
}
@@ -889,12 +881,12 @@
child_nonroot_pass->transform_to_root_target.Translate(8, 0);
SharedQuadState* child_nonroot_pass_sqs =
child_nonroot_pass->shared_quad_state_list.front();
- child_nonroot_pass_sqs->content_to_target_transform.Translate(5, 0);
+ child_nonroot_pass_sqs->quad_to_target_transform.Translate(5, 0);
RenderPass* child_root_pass = child_pass_list.at(1u);
SharedQuadState* child_root_pass_sqs =
child_root_pass->shared_quad_state_list.front();
- child_root_pass_sqs->content_to_target_transform.Translate(8, 0);
+ child_root_pass_sqs->quad_to_target_transform.Translate(8, 0);
child_root_pass_sqs->is_clipped = true;
child_root_pass_sqs->clip_rect = gfx::Rect(0, 0, 5, 5);
@@ -927,7 +919,7 @@
gfx::Rect(0, 1, 100, 7);
SharedQuadState* middle_root_pass_sqs =
middle_root_pass->shared_quad_state_list.front();
- middle_root_pass_sqs->content_to_target_transform.Scale(2, 3);
+ middle_root_pass_sqs->quad_to_target_transform.Scale(2, 3);
scoped_ptr<DelegatedFrameData> middle_frame_data(new DelegatedFrameData);
middle_pass_list.swap(middle_frame_data->render_pass_list);
@@ -956,10 +948,10 @@
root_pass_list.at(0)
->shared_quad_state_list.front()
- ->content_to_target_transform.Translate(0, 7);
+ ->quad_to_target_transform.Translate(0, 7);
root_pass_list.at(0)
->shared_quad_state_list.ElementAt(1)
- ->content_to_target_transform.Translate(0, 10);
+ ->quad_to_target_transform.Translate(0, 10);
root_pass_list.at(0)->quad_list.ElementAt(1)->visible_rect =
gfx::Rect(0, 0, 8, 100);
@@ -1005,7 +997,7 @@
gfx::Transform expected_aggregated_first_pass_sqs_transform;
expected_aggregated_first_pass_sqs_transform.Translate(5, 0);
EXPECT_EQ(expected_aggregated_first_pass_sqs_transform.ToString(),
- aggregated_first_pass_sqs->content_to_target_transform.ToString());
+ aggregated_first_pass_sqs->quad_to_target_transform.ToString());
// The first pass's transform to the root target should include the aggregated
// transform, including the transform from the child pass to the root.
@@ -1036,7 +1028,7 @@
iter != aggregated_pass_list[1]->quad_list.cend();
++iter) {
EXPECT_EQ(expected_root_pass_quad_transforms[iter.index()].ToString(),
- iter->shared_quad_state->content_to_target_transform.ToString())
+ iter->shared_quad_state->quad_to_target_transform.ToString())
<< iter.index();
}
@@ -1073,7 +1065,7 @@
RenderPass* child_root_pass = child_pass_list.at(0u);
SharedQuadState* child_root_pass_sqs =
child_root_pass->shared_quad_state_list.front();
- child_root_pass_sqs->content_to_target_transform.Translate(8, 0);
+ child_root_pass_sqs->quad_to_target_transform.Translate(8, 0);
scoped_ptr<DelegatedFrameData> child_frame_data(new DelegatedFrameData);
child_pass_list.swap(child_frame_data->render_pass_list);
@@ -1100,7 +1092,7 @@
root_pass_list.at(0)
->shared_quad_state_list.front()
- ->content_to_target_transform.Translate(0, 10);
+ ->quad_to_target_transform.Translate(0, 10);
root_pass_list.at(0)->damage_rect = gfx::Rect(5, 5, 10, 10);
root_pass_list.at(1)->damage_rect = gfx::Rect(5, 5, 100, 100);
@@ -1138,7 +1130,7 @@
RenderPass* child_root_pass = child_pass_list.at(0u);
SharedQuadState* child_root_pass_sqs =
child_root_pass->shared_quad_state_list.front();
- child_root_pass_sqs->content_to_target_transform.Translate(8, 0);
+ child_root_pass_sqs->quad_to_target_transform.Translate(8, 0);
child_root_pass->damage_rect = gfx::Rect(10, 10, 10, 10);
scoped_ptr<DelegatedFrameData> child_frame_data(new DelegatedFrameData);
@@ -1178,7 +1170,7 @@
root_pass_list.at(0)
->shared_quad_state_list.front()
- ->content_to_target_transform.Translate(0, 10);
+ ->quad_to_target_transform.Translate(0, 10);
root_pass_list.at(0)->damage_rect = gfx::Rect(0, 0, 1, 1);
scoped_ptr<DelegatedFrameData> root_frame_data(new DelegatedFrameData);
@@ -1200,7 +1192,7 @@
root_pass_list.at(0)
->shared_quad_state_list.front()
- ->content_to_target_transform.Translate(0, 10);
+ ->quad_to_target_transform.Translate(0, 10);
root_pass_list.at(0)->damage_rect = gfx::Rect(1, 1, 1, 1);
scoped_ptr<DelegatedFrameData> root_frame_data(new DelegatedFrameData);
diff --git a/cc/surfaces/surfaces_pixeltest.cc b/cc/surfaces/surfaces_pixeltest.cc
index 528684b..bf8ad57 100644
--- a/cc/surfaces/surfaces_pixeltest.cc
+++ b/cc/surfaces/surfaces_pixeltest.cc
@@ -41,21 +41,15 @@
RenderPass* render_pass,
const gfx::Transform& transform,
const gfx::Size& size) {
- const gfx::Size content_bounds = size;
- const gfx::Rect visible_content_rect = gfx::Rect(size);
+ const gfx::Size layer_bounds = size;
+ const gfx::Rect visible_layer_rect = gfx::Rect(size);
const gfx::Rect clip_rect = gfx::Rect(size);
bool is_clipped = false;
float opacity = 1.f;
const SkXfermode::Mode blend_mode = SkXfermode::kSrcOver_Mode;
SharedQuadState* shared_state = render_pass->CreateAndAppendSharedQuadState();
- shared_state->SetAll(transform,
- content_bounds,
- visible_content_rect,
- clip_rect,
- is_clipped,
- opacity,
- blend_mode,
- 0);
+ shared_state->SetAll(transform, layer_bounds, visible_layer_rect, clip_rect,
+ is_clipped, opacity, blend_mode, 0);
return shared_state;
}
diff --git a/cc/test/layer_test_common.cc b/cc/test/layer_test_common.cc
index 2f975af..abc1eb0 100644
--- a/cc/test/layer_test_common.cc
+++ b/cc/test/layer_test_common.cc
@@ -42,7 +42,7 @@
for (auto iter = quads.cbegin(); iter != quads.cend(); ++iter) {
gfx::RectF quad_rectf = MathUtil::MapClippedRect(
- iter->shared_quad_state->content_to_target_transform,
+ iter->shared_quad_state->quad_to_target_transform,
gfx::RectF(iter->rect));
// Before testing for exact coverage in the integer world, assert that
@@ -70,29 +70,27 @@
// No quad should exist if it's fully occluded.
for (const auto& quad : quads) {
gfx::Rect target_visible_rect = MathUtil::MapEnclosingClippedRect(
- quad->shared_quad_state->content_to_target_transform,
- quad->visible_rect);
+ quad->shared_quad_state->quad_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->shared_quad_state->content_to_target_transform, quad->rect);
- if (!quad->shared_quad_state->content_to_target_transform
+ quad->shared_quad_state->quad_to_target_transform, quad->rect);
+ if (!quad->shared_quad_state->quad_to_target_transform
.IsIdentityOrIntegerTranslation()) {
- DCHECK(quad->shared_quad_state->content_to_target_transform
+ DCHECK(quad->shared_quad_state->quad_to_target_transform
.IsPositiveScaleOrTranslation())
- << quad->shared_quad_state->content_to_target_transform.ToString();
+ << quad->shared_quad_state->quad_to_target_transform.ToString();
gfx::RectF target_rectf = MathUtil::MapClippedRect(
- quad->shared_quad_state->content_to_target_transform, quad->rect);
+ quad->shared_quad_state->quad_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->shared_quad_state->content_to_target_transform,
- quad->visible_rect);
+ quad->shared_quad_state->quad_to_target_transform, quad->visible_rect);
bool fully_occluded_horizontal = target_rect.x() >= occluded.x() &&
target_rect.right() <= occluded.right();
diff --git a/cc/test/render_pass_test_common.cc b/cc/test/render_pass_test_common.cc
index b2242f7e..6fda53660 100644
--- a/cc/test/render_pass_test_common.cc
+++ b/cc/test/render_pass_test_common.cc
@@ -193,8 +193,8 @@
transformed_state->CopyFrom(shared_state);
gfx::Transform rotation;
rotation.Rotate(45);
- transformed_state->content_to_target_transform =
- transformed_state->content_to_target_transform * rotation;
+ transformed_state->quad_to_target_transform =
+ transformed_state->quad_to_target_transform * rotation;
TileDrawQuad* transformed_tile_quad =
this->CreateAndAppendDrawQuad<TileDrawQuad>();
transformed_tile_quad->SetNew(transformed_state,
diff --git a/cc/trees/draw_property_utils.cc b/cc/trees/draw_property_utils.cc
index b1b4de1..e2a7fd69 100644
--- a/cc/trees/draw_property_utils.cc
+++ b/cc/trees/draw_property_utils.cc
@@ -270,7 +270,7 @@
// Some additional conditions need to be computed at a later point after the
// recursion is finished.
// - the intersection of render_surface content and layer clip_rect is empty
- // - the visible_content_rect is empty
+ // - the visible_layer_rect is empty
//
// Note, if the layer should not have been drawn due to being fully
// transparent, we would have skipped the entire subtree and never made it
diff --git a/cc/trees/layer_tree_host.cc b/cc/trees/layer_tree_host.cc
index 46ed4fa..b143b519 100644
--- a/cc/trees/layer_tree_host.cc
+++ b/cc/trees/layer_tree_host.cc
@@ -814,7 +814,7 @@
bool did_paint_content = false;
for (const auto& layer : update_layer_list) {
// TODO(enne): temporarily clobber draw properties visible rect.
- layer->draw_properties().visible_content_rect =
+ layer->draw_properties().visible_layer_rect =
layer->visible_rect_from_property_trees();
did_paint_content |= layer->Update();
content_is_suitable_for_gpu_rasterization_ &=
diff --git a/cc/trees/layer_tree_host_common.cc b/cc/trees/layer_tree_host_common.cc
index 9d34ad3..ce268de 100644
--- a/cc/trees/layer_tree_host_common.cc
+++ b/cc/trees/layer_tree_host_common.cc
@@ -370,7 +370,7 @@
}
template <typename LayerType>
-static gfx::Rect CalculateVisibleContentRect(
+static gfx::Rect CalculateVisibleLayerRect(
LayerType* layer,
const gfx::Rect& clip_rect_of_target_surface_in_target_space,
const gfx::Rect& layer_rect_in_target_space) {
@@ -432,7 +432,7 @@
// Some additional conditions need to be computed at a later point after the
// recursion is finished.
// - the intersection of render_surface content and layer clip_rect is empty
- // - the visible_content_rect is empty
+ // - the visible_layer_rect is empty
//
// Note, if the layer should not have been drawn due to being fully
// transparent, we would have skipped the entire subtree and never made it
@@ -1917,7 +1917,7 @@
DrawProperties<LayerType>& mask_layer_draw_properties =
layer->mask_layer()->draw_properties();
mask_layer_draw_properties.render_target = layer;
- mask_layer_draw_properties.visible_content_rect =
+ mask_layer_draw_properties.visible_layer_rect =
gfx::Rect(layer->bounds());
}
@@ -1925,7 +1925,7 @@
DrawProperties<LayerType>& replica_mask_draw_properties =
layer->replica_layer()->mask_layer()->draw_properties();
replica_mask_draw_properties.render_target = layer;
- replica_mask_draw_properties.visible_content_rect =
+ replica_mask_draw_properties.visible_layer_rect =
gfx::Rect(layer->bounds());
}
@@ -2222,7 +2222,7 @@
}
// Compute the layer's visible content rect (the rect is in content space).
- layer_draw_properties.visible_content_rect = CalculateVisibleContentRect(
+ layer_draw_properties.visible_layer_rect = CalculateVisibleLayerRect(
layer, clip_rect_of_target_surface_in_target_space, rect_in_target_space);
// Compute the remaining properties for the render surface, if the layer has
@@ -2481,10 +2481,10 @@
void VerifyPropertyTreeValuesForLayer(LayerType* current_layer,
PropertyTrees* property_trees) {
const bool visible_rects_match =
- ApproximatelyEqual(current_layer->visible_content_rect(),
+ ApproximatelyEqual(current_layer->visible_layer_rect(),
current_layer->visible_rect_from_property_trees());
CHECK(visible_rects_match)
- << "expected: " << current_layer->visible_content_rect().ToString()
+ << "expected: " << current_layer->visible_layer_rect().ToString()
<< " actual: "
<< current_layer->visible_rect_from_property_trees().ToString();
diff --git a/cc/trees/layer_tree_host_common_unittest.cc b/cc/trees/layer_tree_host_common_unittest.cc
index 20561da..abb687c 100644
--- a/cc/trees/layer_tree_host_common_unittest.cc
+++ b/cc/trees/layer_tree_host_common_unittest.cc
@@ -2656,7 +2656,7 @@
// In target space, not clipped.
EXPECT_EQ(gfx::Rect(60, 70, 100, 100), root->drawable_content_rect());
// In layer space, clipped.
- EXPECT_EQ(gfx::Rect(0, 0, 40, 30), root->visible_content_rect());
+ EXPECT_EQ(gfx::Rect(0, 0, 40, 30), root->visible_layer_rect());
}
TEST_F(LayerTreeHostCommonTest, DrawableAndVisibleContentRectsForSimpleLayers) {
@@ -2709,13 +2709,13 @@
root->render_surface()->DrawableContentRect());
EXPECT_EQ(gfx::Rect(0, 0, 100, 100), root->drawable_content_rect());
- // Layers that do not draw content should have empty visible_content_rects.
- EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_content_rect());
+ // Layers that do not draw content should have empty visible_layer_rects.
+ EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_layer_rect());
- // layer visible_content_rects are clipped by their target surface.
- EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1->visible_content_rect());
- EXPECT_EQ(gfx::Rect(0, 0, 25, 25), child2->visible_content_rect());
- EXPECT_TRUE(child3->visible_content_rect().IsEmpty());
+ // layer visible_layer_rects are clipped by their target surface.
+ EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1->visible_layer_rect());
+ EXPECT_EQ(gfx::Rect(0, 0, 25, 25), child2->visible_layer_rect());
+ EXPECT_TRUE(child3->visible_layer_rect().IsEmpty());
// layer drawable_content_rects are not clipped.
EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1->drawable_content_rect());
@@ -2787,13 +2787,13 @@
EXPECT_EQ(gfx::Rect(0, 0, 100, 100), root->drawable_content_rect());
// Layers that do not draw content should have empty visible content rects.
- EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_content_rect());
- EXPECT_EQ(gfx::Rect(0, 0, 0, 0), child->visible_content_rect());
+ EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_layer_rect());
+ EXPECT_EQ(gfx::Rect(0, 0, 0, 0), child->visible_layer_rect());
// All grandchild visible content rects should be clipped by child.
- EXPECT_EQ(gfx::Rect(0, 0, 50, 50), grand_child1->visible_content_rect());
- EXPECT_EQ(gfx::Rect(0, 0, 25, 25), grand_child2->visible_content_rect());
- EXPECT_TRUE(grand_child3->visible_content_rect().IsEmpty());
+ EXPECT_EQ(gfx::Rect(0, 0, 50, 50), grand_child1->visible_layer_rect());
+ EXPECT_EQ(gfx::Rect(0, 0, 25, 25), grand_child2->visible_layer_rect());
+ EXPECT_TRUE(grand_child3->visible_layer_rect().IsEmpty());
// All grandchild DrawableContentRects should also be clipped by child.
EXPECT_EQ(gfx::Rect(5, 5, 50, 50), grand_child1->drawable_content_rect());
@@ -2897,8 +2897,8 @@
EXPECT_EQ(gfx::Rect(0, 0, 100, 100), root->drawable_content_rect());
// Layers that do not draw content should have empty visible content rects.
- EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_content_rect());
- EXPECT_EQ(gfx::Rect(0, 0, 0, 0), render_surface1->visible_content_rect());
+ EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_layer_rect());
+ EXPECT_EQ(gfx::Rect(0, 0, 0, 0), render_surface1->visible_layer_rect());
// An unclipped surface grows its DrawableContentRect to include all drawable
// regions of the subtree.
@@ -2906,9 +2906,9 @@
render_surface1->render_surface()->DrawableContentRect());
// All layers that draw content into the unclipped surface are also unclipped.
- EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1->visible_content_rect());
- EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child2->visible_content_rect());
- EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child3->visible_content_rect());
+ EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1->visible_layer_rect());
+ EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child2->visible_layer_rect());
+ EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child3->visible_layer_rect());
EXPECT_EQ(gfx::Rect(5, 5, 50, 50), child1->drawable_content_rect());
EXPECT_EQ(gfx::Rect(75, 75, 50, 50), child2->drawable_content_rect());
@@ -2959,9 +2959,9 @@
// Visible content rect calculation will check if the target surface is
// clipped or not. An empty clip rect does not indicate the render surface
// is unclipped.
- EXPECT_EQ(empty, child1->visible_content_rect());
- EXPECT_EQ(empty, child2->visible_content_rect());
- EXPECT_EQ(empty, child3->visible_content_rect());
+ EXPECT_EQ(empty, child1->visible_layer_rect());
+ EXPECT_EQ(empty, child2->visible_layer_rect());
+ EXPECT_EQ(empty, child3->visible_layer_rect());
}
TEST_F(LayerTreeHostCommonTest,
@@ -2995,7 +2995,7 @@
ExecuteCalculateDrawProperties(root.get());
- EXPECT_TRUE(child->visible_content_rect().IsEmpty());
+ EXPECT_TRUE(child->visible_layer_rect().IsEmpty());
EXPECT_TRUE(child->drawable_content_rect().IsEmpty());
// Case 2: a matrix with flattened z, uninvertible and not visible according
@@ -3014,7 +3014,7 @@
ExecuteCalculateDrawProperties(root.get());
- EXPECT_TRUE(child->visible_content_rect().IsEmpty());
+ EXPECT_TRUE(child->visible_layer_rect().IsEmpty());
EXPECT_TRUE(child->drawable_content_rect().IsEmpty());
// Case 3: a matrix with flattened z, also uninvertible and not visible.
@@ -3033,7 +3033,7 @@
ExecuteCalculateDrawProperties(root.get());
- EXPECT_TRUE(child->visible_content_rect().IsEmpty());
+ EXPECT_TRUE(child->visible_layer_rect().IsEmpty());
EXPECT_TRUE(child->drawable_content_rect().IsEmpty());
}
@@ -3175,8 +3175,8 @@
EXPECT_EQ(gfx::Rect(0, 0, 100, 100), root->drawable_content_rect());
// Layers that do not draw content should have empty visible content rects.
- EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_content_rect());
- EXPECT_EQ(gfx::Rect(0, 0, 0, 0), render_surface1->visible_content_rect());
+ EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_layer_rect());
+ EXPECT_EQ(gfx::Rect(0, 0, 0, 0), render_surface1->visible_layer_rect());
// A clipped surface grows its DrawableContentRect to include all drawable
// regions of the subtree, but also gets clamped by the ancestor's clip.
@@ -3185,9 +3185,9 @@
// All layers that draw content into the surface have their visible content
// rect clipped by the surface clip rect.
- EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1->visible_content_rect());
- EXPECT_EQ(gfx::Rect(0, 0, 25, 25), child2->visible_content_rect());
- EXPECT_TRUE(child3->visible_content_rect().IsEmpty());
+ EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1->visible_layer_rect());
+ EXPECT_EQ(gfx::Rect(0, 0, 25, 25), child2->visible_layer_rect());
+ EXPECT_TRUE(child3->visible_layer_rect().IsEmpty());
// But the DrawableContentRects are unclipped.
EXPECT_EQ(gfx::Rect(5, 5, 50, 50), child1->drawable_content_rect());
@@ -3272,9 +3272,9 @@
EXPECT_EQ(gfx::Rect(0, 0, 100, 100), root->drawable_content_rect());
// Layers that do not draw content should have empty visible content rects.
- EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_content_rect());
- EXPECT_EQ(gfx::Rect(0, 0, 0, 0), render_surface1->visible_content_rect());
- EXPECT_EQ(gfx::Rect(0, 0, 0, 0), render_surface2->visible_content_rect());
+ EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_layer_rect());
+ EXPECT_EQ(gfx::Rect(0, 0, 0, 0), render_surface1->visible_layer_rect());
+ EXPECT_EQ(gfx::Rect(0, 0, 0, 0), render_surface2->visible_layer_rect());
// A clipped surface grows its DrawableContentRect to include all drawable
// regions of the subtree, but also gets clamped by the ancestor's clip.
@@ -3288,9 +3288,9 @@
render_surface2->render_surface()->DrawableContentRect());
// All layers that draw content into render_surface2 think they are unclipped.
- EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1->visible_content_rect());
- EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child2->visible_content_rect());
- EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child3->visible_content_rect());
+ EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1->visible_layer_rect());
+ EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child2->visible_layer_rect());
+ EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child3->visible_layer_rect());
// DrawableContentRects are also unclipped.
EXPECT_EQ(gfx::Rect(5, 5, 50, 50), child1->drawable_content_rect());
@@ -3347,8 +3347,8 @@
EXPECT_EQ(gfx::Rect(0, 0, 100, 100), root->drawable_content_rect());
// Layers that do not draw content should have empty visible content rects.
- EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_content_rect());
- EXPECT_EQ(gfx::Rect(0, 0, 0, 0), render_surface1->visible_content_rect());
+ EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_layer_rect());
+ EXPECT_EQ(gfx::Rect(0, 0, 0, 0), render_surface1->visible_layer_rect());
// The unclipped surface grows its DrawableContentRect to include all drawable
// regions of the subtree.
@@ -3362,7 +3362,7 @@
render_surface1->render_surface()->DrawableContentRect());
// All layers that draw content into the unclipped surface are also unclipped.
- EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1->visible_content_rect());
+ EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1->visible_layer_rect());
EXPECT_EQ(expected_surface_drawable_content, child1->drawable_content_rect());
}
@@ -3429,7 +3429,7 @@
// up covering the full left half of child1.
//
// Given the floating point math, this number is a little bit fuzzy.
- EXPECT_EQ(gfx::Rect(0, 0, 26, 50), child1->visible_content_rect());
+ EXPECT_EQ(gfx::Rect(0, 0, 26, 50), child1->visible_layer_rect());
// The child's DrawableContentRect is unclipped.
EXPECT_EQ(unclipped_surface_content, child1->drawable_content_rect());
@@ -3529,15 +3529,15 @@
EXPECT_EQ(gfx::Rect(250, 250, 100, 100), child3->drawable_content_rect());
// The root layer does not actually draw content of its own.
- EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_content_rect());
+ EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_layer_rect());
// All layer visible content rects are not expressed in content space of each
// layer, so they are not scaled by the device_scale_factor.
- EXPECT_EQ(gfx::Rect(0, 0, 3, 4), render_surface1->visible_content_rect());
- EXPECT_EQ(gfx::Rect(0, 0, 7, 13), render_surface2->visible_content_rect());
- EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1->visible_content_rect());
- EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child2->visible_content_rect());
- EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child3->visible_content_rect());
+ EXPECT_EQ(gfx::Rect(0, 0, 3, 4), render_surface1->visible_layer_rect());
+ EXPECT_EQ(gfx::Rect(0, 0, 7, 13), render_surface2->visible_layer_rect());
+ EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1->visible_layer_rect());
+ EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child2->visible_layer_rect());
+ EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child3->visible_layer_rect());
}
TEST_F(LayerTreeHostCommonTest, BackFaceCullingWithoutPreserves3d) {
@@ -4059,17 +4059,17 @@
render_surface_layer_list.at(1)
->render_surface()->layer_list().at(1)->id());
- EXPECT_FALSE(child2->visible_content_rect().IsEmpty());
+ EXPECT_FALSE(child2->visible_layer_rect().IsEmpty());
// The animating layers should have a visible content rect that represents the
// area of the front face that is within the viewport.
- EXPECT_EQ(animating_child->visible_content_rect(),
+ EXPECT_EQ(animating_child->visible_layer_rect(),
gfx::Rect(animating_child->bounds()));
- EXPECT_EQ(animating_surface->visible_content_rect(),
+ EXPECT_EQ(animating_surface->visible_layer_rect(),
gfx::Rect(animating_surface->bounds()));
// And layers in the subtree of the animating layer should have valid visible
// content rects also.
- EXPECT_EQ(child_of_animating_surface->visible_content_rect(),
+ EXPECT_EQ(child_of_animating_surface->visible_layer_rect(),
gfx::Rect(child_of_animating_surface->bounds()));
}
@@ -5570,10 +5570,10 @@
inputs.can_adjust_raster_scales = true;
LayerTreeHostCommon::CalculateDrawProperties(&inputs);
- // The visible_content_rect for the |surface_child| should not be clipped by
+ // The visible_layer_rect for the |surface_child| should not be clipped by
// the viewport.
EXPECT_EQ(gfx::Rect(50, 50).ToString(),
- surface_child->visible_content_rect().ToString());
+ surface_child->visible_layer_rect().ToString());
}
TEST_F(LayerTreeHostCommonTest, TransformedClipParent) {
@@ -5799,7 +5799,7 @@
EXPECT_EQ(gfx::Rect(-1, -1, 40, 40).ToString(),
clip_child->clip_rect().ToString());
EXPECT_EQ(gfx::Rect(9, 9, 40, 40).ToString(),
- clip_child->visible_content_rect().ToString());
+ clip_child->visible_layer_rect().ToString());
EXPECT_TRUE(clip_child->is_clipped());
}
@@ -5927,7 +5927,7 @@
EXPECT_EQ(gfx::Rect(2, 2, 40, 40).ToString(),
clip_child->clip_rect().ToString());
EXPECT_EQ(gfx::Rect(12, 12, 40, 40).ToString(),
- clip_child->visible_content_rect().ToString());
+ clip_child->visible_layer_rect().ToString());
EXPECT_TRUE(clip_child->is_clipped());
}
@@ -6006,7 +6006,7 @@
clip_child->clip_rect().ToString());
EXPECT_TRUE(clip_child->is_clipped());
EXPECT_EQ(gfx::Rect(0, 0, 40, 40).ToString(),
- child->visible_content_rect().ToString());
+ child->visible_layer_rect().ToString());
EXPECT_TRUE(child->is_clipped());
}
@@ -7692,11 +7692,11 @@
// Layers in the root render surface have their visible content rect clipped
// by the viewport.
- EXPECT_EQ(gfx::Rect(768 / 2, 582 / 2), root->visible_content_rect());
+ EXPECT_EQ(gfx::Rect(768 / 2, 582 / 2), root->visible_layer_rect());
// Layers drawing to a child render surface should still have their visible
// content rect clipped by the viewport.
- EXPECT_EQ(gfx::Rect(768 / 2, 582 / 2), content->visible_content_rect());
+ EXPECT_EQ(gfx::Rect(768 / 2, 582 / 2), content->visible_layer_rect());
}
TEST_F(LayerTreeHostCommonTest, BoundsDeltaAffectVisibleContentRect) {
@@ -7752,7 +7752,7 @@
LayerTreeHostCommon::CalculateDrawProperties(&inputs);
- EXPECT_EQ(gfx::Rect(root_size), sublayer->visible_content_rect());
+ EXPECT_EQ(gfx::Rect(root_size), sublayer->visible_layer_rect());
root->SetBoundsDelta(gfx::Vector2dF(0.0, 50.0));
@@ -7760,7 +7760,7 @@
gfx::Rect affected_by_delta(0, 0, root_size.width(),
root_size.height() + 50);
- EXPECT_EQ(affected_by_delta, sublayer->visible_content_rect());
+ EXPECT_EQ(affected_by_delta, sublayer->visible_layer_rect());
}
TEST_F(LayerTreeHostCommonTest, VisibleContentRectForAnimatedLayer) {
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index 51b4198c3..3109c006 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -850,11 +850,10 @@
*it,
contributing_render_pass,
&append_quads_data);
- } else if (it.represents_itself() &&
- !it->visible_content_rect().IsEmpty()) {
+ } else if (it.represents_itself() && !it->visible_layer_rect().IsEmpty()) {
bool occluded =
it->draw_properties().occlusion_in_content_space.IsOccluded(
- it->visible_content_rect());
+ it->visible_layer_rect());
if (!occluded && it->WillDraw(draw_mode, resource_provider_.get())) {
DCHECK_EQ(active_tree_, it->layer_tree_impl());
@@ -880,7 +879,7 @@
// For layers that represent themselves, add composite frame timing
// requests if the visible rect intersects the requested rect.
for (const auto& request : it->frame_timing_requests()) {
- if (request.rect().Intersects(it->visible_content_rect())) {
+ if (request.rect().Intersects(it->visible_layer_rect())) {
frame->composite_events.push_back(
FrameTimingTracker::FrameAndRectIds(
active_tree_->source_frame_number(), request.id()));
@@ -892,7 +891,7 @@
}
rendering_stats_instrumentation_->AddVisibleContentArea(
- append_quads_data.visible_content_area);
+ append_quads_data.visible_layer_area);
rendering_stats_instrumentation_->AddApproximatedVisibleContentArea(
append_quads_data.approximated_visible_content_area);
rendering_stats_instrumentation_->AddCheckerboardedVisibleContentArea(
diff --git a/cc/trees/layer_tree_host_impl_unittest.cc b/cc/trees/layer_tree_host_impl_unittest.cc
index 20ad677..b69f9e4 100644
--- a/cc/trees/layer_tree_host_impl_unittest.cc
+++ b/cc/trees/layer_tree_host_impl_unittest.cc
@@ -188,7 +188,7 @@
root->SetPosition(gfx::PointF());
root->SetBounds(gfx::Size(10, 10));
root->SetDrawsContent(true);
- root->draw_properties().visible_content_rect = gfx::Rect(0, 0, 10, 10);
+ root->draw_properties().visible_layer_rect = gfx::Rect(0, 0, 10, 10);
root->SetHasRenderSurface(true);
host_impl_->active_tree()->SetRootLayer(root.Pass());
}
@@ -2152,7 +2152,7 @@
did_draw_called_(false) {
SetBounds(gfx::Size(10, 10));
SetDrawsContent(true);
- draw_properties().visible_content_rect = gfx::Rect(0, 0, 10, 10);
+ draw_properties().visible_layer_rect = gfx::Rect(0, 0, 10, 10);
}
private:
@@ -2216,7 +2216,7 @@
root->AddChild(DidDrawCheckLayer::Create(host_impl_->active_tree(), 2));
DidDrawCheckLayer* layer =
static_cast<DidDrawCheckLayer*>(root->children()[0]);
- // Ensure visible_content_rect for layer is empty.
+ // Ensure visible_layer_rect for layer is empty.
layer->SetPosition(gfx::PointF(100.f, 100.f));
layer->SetBounds(gfx::Size(10, 10));
@@ -2232,9 +2232,9 @@
EXPECT_FALSE(layer->will_draw_called());
EXPECT_FALSE(layer->did_draw_called());
- EXPECT_TRUE(layer->visible_content_rect().IsEmpty());
+ EXPECT_TRUE(layer->visible_layer_rect().IsEmpty());
- // Ensure visible_content_rect for layer is not empty
+ // Ensure visible_layer_rect for layer is not empty
layer->SetPosition(gfx::PointF());
EXPECT_FALSE(layer->will_draw_called());
@@ -2247,7 +2247,7 @@
EXPECT_TRUE(layer->will_draw_called());
EXPECT_TRUE(layer->did_draw_called());
- EXPECT_FALSE(layer->visible_content_rect().IsEmpty());
+ EXPECT_FALSE(layer->visible_layer_rect().IsEmpty());
}
TEST_F(LayerTreeHostImplTest, WillDrawNotCalledOnOccludedLayer) {
@@ -5529,20 +5529,20 @@
root->SetHasRenderSurface(true);
root->SetPosition(root_rect.origin());
root->SetBounds(root_rect.size());
- root->draw_properties().visible_content_rect = root_rect;
+ root->draw_properties().visible_layer_rect = root_rect;
root->SetDrawsContent(false);
root->render_surface()->SetContentRect(gfx::Rect(root_rect.size()));
child->SetPosition(gfx::PointF(child_rect.x(), child_rect.y()));
child->SetOpacity(0.5f);
child->SetBounds(gfx::Size(child_rect.width(), child_rect.height()));
- child->draw_properties().visible_content_rect = child_rect;
+ child->draw_properties().visible_layer_rect = child_rect;
child->SetDrawsContent(false);
child->SetHasRenderSurface(true);
grand_child->SetPosition(grand_child_rect.origin());
grand_child->SetBounds(grand_child_rect.size());
- grand_child->draw_properties().visible_content_rect = grand_child_rect;
+ grand_child->draw_properties().visible_layer_rect = grand_child_rect;
grand_child->SetDrawsContent(true);
child->AddChild(grand_child.Pass());
@@ -5900,8 +5900,8 @@
bool clipped = false, force_aa = false;
gfx::QuadF device_layer_quad = MathUtil::MapQuad(
- quad->shared_quad_state->content_to_target_transform,
- gfx::QuadF(quad->shared_quad_state->visible_content_rect), &clipped);
+ quad->shared_quad_state->quad_to_target_transform,
+ gfx::QuadF(quad->shared_quad_state->visible_quad_layer_rect), &clipped);
EXPECT_FALSE(clipped);
bool antialiased =
GLRendererWithSetupQuadForAntialiasing::ShouldAntialiasQuad(
diff --git a/cc/trees/layer_tree_host_unittest.cc b/cc/trees/layer_tree_host_unittest.cc
index f181e3c..759f86a 100644
--- a/cc/trees/layer_tree_host_unittest.cc
+++ b/cc/trees/layer_tree_host_unittest.cc
@@ -4804,8 +4804,7 @@
float quad_scale =
quad->tex_coord_rect.width() / static_cast<float>(quad->rect.width());
float transform_scale = SkMScalarToFloat(
- quad->shared_quad_state->content_to_target_transform.matrix().get(0,
- 0));
+ quad->shared_quad_state->quad_to_target_transform.matrix().get(0, 0));
float scale = quad_scale / transform_scale;
if (frame_scale != 0.f && frame_scale != scale)
return 0.f;
@@ -5106,8 +5105,7 @@
float quad_scale =
quad->tex_coord_rect.width() / static_cast<float>(quad->rect.width());
float transform_scale = SkMScalarToFloat(
- quad->shared_quad_state->content_to_target_transform.matrix().get(0,
- 0));
+ quad->shared_quad_state->quad_to_target_transform.matrix().get(0, 0));
float scale = quad_scale / transform_scale;
if (frame_scale != 0.f && frame_scale != scale)
return 0.f;
diff --git a/cc/trees/layer_tree_impl_unittest.cc b/cc/trees/layer_tree_impl_unittest.cc
index 4811893..81a566f 100644
--- a/cc/trees/layer_tree_impl_unittest.cc
+++ b/cc/trees/layer_tree_impl_unittest.cc
@@ -1470,8 +1470,7 @@
ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
// Check whether the child layer fits into the root after scaled.
- EXPECT_EQ(gfx::Rect(test_layer->bounds()),
- test_layer->visible_content_rect());
+ EXPECT_EQ(gfx::Rect(test_layer->bounds()), test_layer->visible_layer_rect());
// Hit checking for a point outside the layer should return a null pointer
// (the root layer does not draw content, so it will not be tested either).
diff --git a/cc/trees/occlusion_tracker.cc b/cc/trees/occlusion_tracker.cc
index 02af3be..996adc89 100644
--- a/cc/trees/occlusion_tracker.cc
+++ b/cc/trees/occlusion_tracker.cc
@@ -356,11 +356,11 @@
if (layer->Is3dSorted())
return;
- SimpleEnclosedRegion opaque_contents = layer->VisibleContentOpaqueRegion();
- if (opaque_contents.IsEmpty())
+ SimpleEnclosedRegion opaque_layer_region = layer->VisibleOpaqueRegion();
+ if (opaque_layer_region.IsEmpty())
return;
- DCHECK(layer->visible_content_rect().Contains(opaque_contents.bounds()));
+ DCHECK(layer->visible_layer_rect().Contains(opaque_layer_region.bounds()));
// TODO(danakj): Find a rect interior to each transformed quad.
if (!layer->draw_transform().Preserves2dAxisAlignment())
@@ -375,10 +375,10 @@
layer->render_target()->render_surface()->content_rect());
}
- for (size_t i = 0; i < opaque_contents.GetRegionComplexity(); ++i) {
+ for (size_t i = 0; i < opaque_layer_region.GetRegionComplexity(); ++i) {
gfx::Rect transformed_rect =
MathUtil::MapEnclosedRectWith2dAxisAlignedTransform(
- layer->draw_transform(), opaque_contents.GetRect(i));
+ layer->draw_transform(), opaque_layer_region.GetRect(i));
transformed_rect.Intersect(clip_rect_in_target);
if (transformed_rect.width() < minimum_tracking_size_.width() &&
transformed_rect.height() < minimum_tracking_size_.height())
diff --git a/cc/trees/occlusion_tracker_unittest.cc b/cc/trees/occlusion_tracker_unittest.cc
index 2cbd2e56..08cfcf7 100644
--- a/cc/trees/occlusion_tracker_unittest.cc
+++ b/cc/trees/occlusion_tracker_unittest.cc
@@ -35,12 +35,12 @@
SetDrawsContent(true);
}
- SimpleEnclosedRegion VisibleContentOpaqueRegion() const override {
+ SimpleEnclosedRegion VisibleOpaqueRegion() const override {
if (override_opaque_contents_rect_) {
return SimpleEnclosedRegion(
- gfx::IntersectRects(opaque_contents_rect_, visible_content_rect()));
+ gfx::IntersectRects(opaque_contents_rect_, visible_layer_rect()));
}
- return LayerImpl::VisibleContentOpaqueRegion();
+ return LayerImpl::VisibleOpaqueRegion();
}
void SetOpaqueContentsRect(const gfx::Rect& opaque_contents_rect) {
override_opaque_contents_rect_ = true;
@@ -59,7 +59,7 @@
bool OccludedLayer(const LayerImpl* layer,
const gfx::Rect& content_rect) const {
- DCHECK(layer->visible_content_rect().Contains(content_rect));
+ DCHECK(layer->visible_layer_rect().Contains(content_rect));
return this->GetCurrentOcclusionForLayer(layer->draw_transform())
.IsOccluded(content_rect);
}
@@ -68,7 +68,7 @@
// layer. Simple wrapper around GetUnoccludedContentRect.
gfx::Rect UnoccludedLayerContentRect(const LayerImpl* layer,
const gfx::Rect& content_rect) const {
- DCHECK(layer->visible_content_rect().Contains(content_rect));
+ DCHECK(layer->visible_layer_rect().Contains(content_rect));
return this->GetCurrentOcclusionForLayer(layer->draw_transform())
.GetUnoccludedContentRect(content_rect);
}
@@ -644,7 +644,7 @@
TestOcclusionTrackerWithClip occlusion(gfx::Rect(0, 0, 1000, 1000));
gfx::Rect clipped_layer_in_child = MathUtil::MapEnclosingClippedRect(
- layer_transform, layer->visible_content_rect());
+ layer_transform, layer->visible_layer_rect());
this->VisitLayer(layer, &occlusion);
this->EnterContributingSurface(child, &occlusion);
