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}

android_webview/browser/hardware_renderer.cc

@@ -150,15 +150,15 @@ void HardwareRenderer::DrawGL(bool stencil_enabled,
 
   cc::SharedQuadState* quad_state =
       render_pass->CreateAndAppendSharedQuadState();
-  quad_state->content_to_target_transform = transform;
-  quad_state->content_bounds = frame_size_;
-  quad_state->visible_content_rect = gfx::Rect(frame_size_);
+  quad_state->quad_to_target_transform = transform;
+  quad_state->quad_layer_bounds = frame_size_;
+  quad_state->visible_quad_layer_rect = gfx::Rect(frame_size_);
   quad_state->opacity = 1.f;
 
   cc::SurfaceDrawQuad* surface_quad =
       render_pass->CreateAndAppendDrawQuad<cc::SurfaceDrawQuad>();
-  surface_quad->SetNew(quad_state, gfx::Rect(quad_state->content_bounds),
-                       gfx::Rect(quad_state->content_bounds), child_id_);
+  surface_quad->SetNew(quad_state, gfx::Rect(quad_state->quad_layer_bounds),
+                       gfx::Rect(quad_state->quad_layer_bounds), child_id_);
 
   scoped_ptr<cc::DelegatedFrameData> delegated_frame(
       new cc::DelegatedFrameData);

cc/debug/invalidation_benchmark.cc

@@ -71,9 +71,9 @@ void InvalidationBenchmark::RunOnLayer(PictureLayer* layer) {
   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 @@ void InvalidationBenchmark::RunOnLayer(PictureLayer* layer) {
     }
     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 @@ void InvalidationBenchmark::RunOnLayer(PictureLayer* layer) {
     }
     case VIEWPORT: {
       // Invalidate entire viewport.
-      layer->SetNeedsDisplayRect(layer->visible_content_rect());
+      layer->SetNeedsDisplayRect(layer->visible_layer_rect());
       break;
     }
   }

cc/debug/rasterize_and_record_benchmark.cc

@@ -109,7 +109,7 @@ scoped_ptr<MicroBenchmarkImpl> RasterizeAndRecordBenchmark::CreateBenchmarkImpl(
 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;
 

cc/debug/rasterize_and_record_benchmark_impl.cc

@@ -158,7 +158,7 @@ void RasterizeAndRecordBenchmarkImpl::RunOnLayer(PictureLayerImpl* layer) {
     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 @@ void RasterizeAndRecordBenchmarkImpl::RunOnLayer(PictureLayerImpl* layer) {
   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);
 

cc/layers/append_quads_data.h

@@ -14,7 +14,7 @@ struct AppendQuadsData {
   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 @@ struct AppendQuadsData {
   // 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.

cc/layers/delegated_renderer_layer_impl.cc

@@ -429,7 +429,7 @@ void DelegatedRendererLayerImpl::AppendRenderPassQuads(
       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 @@ void DelegatedRendererLayerImpl::AppendRenderPassQuads(
     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);

cc/layers/delegated_renderer_layer_impl_unittest.cc

@@ -404,24 +404,24 @@ TEST_F(DelegatedRendererLayerImplTestSimple,
   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());
 
   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,24 +584,24 @@ TEST_F(DelegatedRendererLayerImplTestOwnSurface,
   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());
 
   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 @@ TEST_F(DelegatedRendererLayerImplTestTransform, QuadsUnclipped_NoSurface) {
   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 @@ TEST_F(DelegatedRendererLayerImplTestTransform, QuadsUnclipped_NoSurface) {
   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 @@ TEST_F(DelegatedRendererLayerImplTestTransform, QuadsClipped_NoSurface) {
   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 @@ TEST_F(DelegatedRendererLayerImplTestTransform, QuadsClipped_NoSurface) {
   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 @@ TEST_F(DelegatedRendererLayerImplTestTransform, QuadsUnclipped_Surface) {
   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 @@ TEST_F(DelegatedRendererLayerImplTestTransform, QuadsUnclipped_Surface) {
   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 @@ TEST_F(DelegatedRendererLayerImplTestTransform, QuadsClipped_Surface) {
   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 @@ TEST_F(DelegatedRendererLayerImplTestTransform, QuadsClipped_Surface) {
   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 @@ TEST_F(DelegatedRendererLayerImplTestTransform, MismatchedDeviceScaleFactor) {
   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 @@ TEST_F(DelegatedRendererLayerImplTest, Occlusion) {
   {
     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 @@ TEST_F(DelegatedRendererLayerImplTest, Occlusion) {
       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,

cc/layers/draw_properties.h

@@ -81,8 +81,9 @@ struct CC_EXPORT DrawProperties {
   // 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.

cc/layers/io_surface_layer_impl_unittest.cc

@@ -39,7 +39,7 @@ TEST(IOSurfaceLayerImplTest, Occlusion) {
 
   {
     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());

cc/layers/layer.cc

@@ -1520,12 +1520,6 @@ void Layer::RemoveLayerAnimationEventObserver(
   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;
 }

cc/layers/layer.h

@@ -254,8 +254,8 @@ class CC_EXPORT Layer : public base::RefCounted<Layer>,
   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 @@ class CC_EXPORT Layer : public base::RefCounted<Layer>,
   void RemoveLayerAnimationEventObserver(
       LayerAnimationEventObserver* animation_observer);
 
-  virtual SimpleEnclosedRegion VisibleContentOpaqueRegion() const;
-
   virtual ScrollbarLayerInterface* ToScrollbarLayer();
 
   virtual skia::RefPtr<SkPicture> GetPicture() const;

cc/layers/layer_impl.cc

@@ -283,10 +283,9 @@ void LayerImpl::ClearRenderSurfaceLayerList() {
 
 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 @@ void LayerImpl::PopulateScaledSharedQuadState(SharedQuadState* state,
       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 @@ void LayerImpl::SetDoubleSided(bool double_sided) {
   NoteLayerPropertyChangedForSubtree();
 }
 
-SimpleEnclosedRegion LayerImpl::VisibleContentOpaqueRegion() const {
+SimpleEnclosedRegion LayerImpl::VisibleOpaqueRegion() const {
   if (contents_opaque())
-    return SimpleEnclosedRegion(visible_content_rect());
+    return SimpleEnclosedRegion(visible_layer_rect());
   return SimpleEnclosedRegion();
 }