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}

71 files changed, 559 insertions, 670 deletions

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 @@ 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;
     }
   }
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 @@ 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;
 
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 @@ 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);
 
diff --git a/cc/layers/append_quads_data.h b/cc/layers/append_quads_data.h
index 50f5877..45b0c17 100644
--- a/cc/layers/append_quads_data.h
+++ b/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.
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 @@ 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);
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 @@ 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());
@@ -412,16 +412,16 @@ TEST_F(DelegatedRendererLayerImplTestSimple,
   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 @@ 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());
@@ -592,16 +592,16 @@ TEST_F(DelegatedRendererLayerImplTestOwnSurface,
   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,
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 @@ 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.
diff --git a/cc/layers/io_surface_layer_impl_unittest.cc b/cc/layers/io_surface_layer_impl_unittest.cc
index 0ef2ec8..75c2cf77 100644
--- a/cc/layers/io_surface_layer_impl_unittest.cc
+++ b/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());
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 @@ 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;
 }
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 @@ 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;
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::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();
 }
 
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 @@ class CC_EXPORT LayerImpl : public LayerAnimationValueObserver,
   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 @@ class CC_EXPORT LayerImpl : public LayerAnimationValueObserver,
     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 @@ void NinePatchLayerLayoutTest(const gfx::Size& bitmap_size,
                               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 @@ void NinePatchLayerLayoutTest(const gfx::Size& bitmap_size,
 
   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 @@ void NinePatchLayerLayoutTest(const gfx::Size& bitmap_size,
   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 @@ TEST(NinePatchLayerImplTest, Occlusion) {
 
   {
     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 @@ TEST(PaintedScrollbarLayerImplTest, Occlusion) {
 
   {
     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 12c7017..ff7e9ac 100644
--- a/cc/layers/picture_image_layer_impl_unittest.cc
+++ b/cc/layers/picture_image_layer_impl_unittest.cc
@@ -76,7 +76,7 @@ class PictureImageLayerImplTest : public testing::Test {
         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..53d5d97 100644
--- a/cc/layers/picture_layer.cc
+++ b/cc/layers/picture_layer.cc
@@ -117,10 +117,10 @@ bool PictureLayer::Update() {
   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 @@ bool PictureLayer::Update() {
   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 @@ bool PictureLayer::Update() {
   // 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 @@ class CC_EXPORT PictureLayer : public Layer {
   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 @@ void PictureLayerImpl::AppendQuads(RenderPass* render_pass,
 
     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 @@ void PictureLayerImpl::AppendQuads(RenderPass* render_pass,
   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 @@ void PictureLayerImpl::AppendQuads(RenderPass* render_pass,
     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 @@ void PictureLayerImpl::AppendQuads(RenderPass* render_pass,
   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 @@ void PictureLayerImpl::AppendQuads(RenderPass* render_pass,
     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 @@ void PictureLayerImpl::AppendQuads(RenderPass* render_pass,
 
   // 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 @@ void PictureLayerImpl::AsValueInto(
   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 @@ TEST_F(PictureLayerImplTest, InvalidViewportForPrioritizingTiles) {
                                         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 @@ TEST_F(PictureLayerImplTest, InvalidViewportForPrioritizingTiles) {
   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 @@ TEST_F(PictureLayerImplTest, DisallowTileDrawQuads) {
   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 @@ TEST_F(PictureLayerImplTest, SolidColorLayerHasVisibleFullCoverage) {
 
   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 @@ TEST_F(NoLowResPictureLayerImplTest,
   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 @@ TEST_F(NoLowResPictureLayerImplTest,
 
   // 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 @@ TEST_F(NoLowResPictureLayerImplTest,
   // 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 @@ TEST_F(NoLowResPictureLayerImplTest,
   // 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 @@ TEST_F(PictureLayerImplTest, TilingSetRasterQueue) {
   // 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 @@ TEST_F(PictureLayerImplTest, TilingSetRasterQueue) {
 
   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 @@ TEST_F(PictureLayerImplTest, TilingSetEvictionQueue) {
   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 @@ TEST_F(PictureLayerImplTest, Occlusion) {
 
   {
     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 @@ TEST_F(NoLowResPictureLayerImplTest, InvalidViewportForPrioritizingTiles) {
                                         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 @@ TEST_F(NoLowResPictureLayerImplTest, InvalidViewportForPrioritizingTiles) {
   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 @@ TEST_F(PictureLayerImplTest, SharedQuadStateContainsMaxTilingScale) {
 
   // 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 @@ TEST_F(OcclusionTrackingPictureLayerImplTest,
     // 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 @@ TEST_F(OcclusionTrackingPictureLayerImplTest,
     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 @@ TEST_F(OcclusionTrackingPictureLayerImplTest,
     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 @@ TEST_F(PictureLayerImplTest, ChangeInViewportAllowsTilingUpdates) {
   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 @@ TEST_F(PictureLayerImplTest, ChangeInViewportAllowsTilingUpdates) {
   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 @@ void RenderSurfaceImpl::AppendQuads(RenderPass* render_pass,
                                     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 @@ void RenderSurfaceImpl::AppendQuads(RenderPass* render_pass,
     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 @@ void RenderSurfaceImpl::AppendQuads(RenderPass* render_pass,
 
   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 e5db867..ac40675 100644
--- a/cc/layers/render_surface_impl_unittest.cc
+++ b/cc/layers/render_surface_impl_unittest.cc
@@ -38,7 +38,7 @@ TEST(RenderSurfaceLayerImplTest, Occlusion) {
 
   {
     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..5ecf2f7 100644
--- a/cc/layers/render_surface_unittest.cc
+++ b/cc/layers/render_surface_unittest.cc
@@ -126,11 +126,12 @@ TEST(RenderSurfaceTest, SanityCheckSurfaceCreatesCorrectSharedQuadState) {
 
   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 @@ class ScrollbarLayerTestResourceCreationAndRelease : public ScrollbarLayerTest {
     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 @@ TEST_F(ScrollbarLayerTestResourceCreationAndRelease, TestResourceUpdate) {
   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 @@ class ScaledScrollbarLayerTestResourceCreation : public ScrollbarLayerTest {
     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 @@ class ScaledScrollbarLayerTestScaledRasterization : public ScrollbarLayerTest {
     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..76cd3fc 100644
--- a/cc/layers/solid_color_layer_impl.cc
+++ b/cc/layers/solid_color_layer_impl.cc
@@ -29,29 +29,29 @@ scoped_ptr<LayerImpl> SolidColorLayerImpl::CreateLayerImpl(
 
 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 213e3f1..2068ac5 100644
--- a/cc/layers/solid_color_layer_impl.h
+++ b/cc/layers/solid_color_layer_impl.h
@@ -19,9 +19,9 @@ class CC_EXPORT SolidColorLayerImpl : public LayerImpl {
   }
 
   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..59ef6ba 100644
--- a/cc/layers/solid_color_layer_impl_unittest.cc
+++ b/cc/layers/solid_color_layer_impl_unittest.cc
@@ -24,14 +24,14 @@ TEST(SolidColorLayerImplTest, VerifyTilingCompleteAndNoOverlap) {
   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 @@ TEST(SolidColorLayerImplTest, VerifyTilingCompleteAndNoOverlap) {
   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 @@ TEST(SolidColorLayerImplTest, VerifyCorrectBackgroundColorInQuad) {
   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 @@ TEST(SolidColorLayerImplTest, VerifyCorrectOpacityInQuad) {
   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 @@ TEST(SolidColorLayerImplTest, VerifyCorrectBlendModeInQuad) {
   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, VerifyCorrectBlendModeInQuad) {
 
 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 @@ TEST(SolidColorLayerImplTest, VerifyOpaqueRect) {
     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 @@ TEST(SolidColorLayerImplTest, Occlusion) {
 
   {
     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 @@ TEST(SolidColorScrollbarLayerImplTest, Occlusion) {
 
   {
     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 @@ TEST(SurfaceLayerImplTest, Occlusion) {
 
   {
     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..20741fd 100644
--- a/cc/layers/texture_layer.cc
+++ b/cc/layers/texture_layer.cc
@@ -267,16 +267,6 @@ void TextureLayer::PushPropertiesTo(LayerImpl* layer) {
   }
 }
 
-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 @@ class CC_EXPORT TextureLayer : public Layer {
   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..08617db 100644
--- a/cc/layers/texture_layer_impl.cc
+++ b/cc/layers/texture_layer_impl.cc
@@ -184,12 +184,12 @@ void TextureLayerImpl::AppendQuads(RenderPass* render_pass,
   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..680aaf0 100644
--- a/cc/layers/texture_layer_impl.h
+++ b/cc/layers/texture_layer_impl.h
@@ -30,7 +30,7 @@ class CC_EXPORT TextureLayerImpl : public LayerImpl {
                 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 @@ void IgnoreCallback(uint32 sync_point,
                     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 @@ TEST(TextureLayerImplTest, Occlusion) {
 
   {
     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 @@ TEST_F(TextureLayerTest, CheckPropertyChangeCausesCorrectBehavior) {
   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 @@ scoped_ptr<UIResourceLayerImpl> GenerateUIResourceLayer(
     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 @@ TEST(UIResourceLayerImplTest, Occlusion) {
 
   {
     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 @@ void VideoLayerImpl::AppendQuads(RenderPass* render_pass,
 
   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 @@ void VideoLayerImpl::DidDraw(ResourceProvider* resource_provider) {
   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 @@ class CC_EXPORT VideoLayerImpl : public LayerImpl {
   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 @@ TEST(VideoLayerImplTest, Occlusion) {
 
   {
     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 @@ TEST(VideoLayerImplTest, Rotated0) {
   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 @@ TEST(VideoLayerImplTest, Rotated90) {
   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 @@ TEST(VideoLayerImplTest, Rotated180) {
   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 @@ TEST(VideoLayerImplTest, Rotated270) {
   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 ddf39f3..8a33694 100644
--- a/cc/output/bsp_walk_action.cc
+++ b/cc/output/bsp_walk_action.cc
@@ -28,7 +28,7 @@ void BspWalkActionDrawPolygon::operator()(DrawPolygon* item) {
   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 @@ void DirectRenderer::DrawRenderPass(DrawingFrame* frame,
     // This layer is in a 3D sorting context so we add it to the list of
     // polygons to go into the BSP tree.
     if (quad.shared_quad_state->sorting_context_id != 0) {
-      scoped_ptr<DrawPolygon> new_polygon(
-          new DrawPolygon(*it, quad.visible_rect,
-                          quad.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 473e164..761123e 100644
--- a/cc/output/gl_renderer.cc
+++ b/cc/output/gl_renderer.cc
@@ -599,7 +599,7 @@ void GLRenderer::DrawCheckerboardQuad(const DrawingFrame* frame,
 
   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 @@ void GLRenderer::DrawDebugBorderQuad(const DrawingFrame* frame,
   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 @@ void GLRenderer::DrawRenderPassQuad(DrawingFrame* frame,
 
   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 @@ void GLRenderer::DrawRenderPassQuad(DrawingFrame* frame,
   }
 
   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 @@ void GLRenderer::DrawRenderPassQuad(DrawingFrame* frame,
 
   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 @@ bool is_bottom(const gfx::QuadF* clip_region, const DrawQuad* quad) {
     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 @@ bool is_right(const gfx::QuadF* clip_region, const DrawQuad* quad) {
     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 @@ void GLRenderer::DrawSolidColorQuad(const DrawingFrame* frame,
 
   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 @@ void GLRenderer::DrawSolidColorQuad(const DrawingFrame* frame,
     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 @@ void GLRenderer::DrawSolidColorQuad(const DrawingFrame* frame,
   gfx::RectF centered_rect(
       gfx::PointF(-0.5f * tile_rect.width(), -0.5f * tile_rect.height()),
       tile_rect.size());
-  DrawQuadGeometry(frame, quad->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 @@ void GLRenderer::DrawContentQuad(const DrawingFrame* frame,
                                  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 @@ void GLRenderer::DrawContentQuad(const DrawingFrame* frame,
     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 @@ void GLRenderer::DrawContentQuadAA(const DrawingFrame* frame,
   gfx::RectF centered_rect(
       gfx::PointF(-0.5f * tile_rect.width(), -0.5f * tile_rect.height()),
       tile_rect.size());
-  DrawQuadGeometry(frame, quad->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 @@ void GLRenderer::DrawContentQuadNoAA(const DrawingFrame* frame,
 
   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 @@ void GLRenderer::DrawContentQuadNoAA(const DrawingFrame* frame,
   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 @@ void GLRenderer::DrawYUVVideoQuad(const DrawingFrame* frame,
   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 @@ void GLRenderer::DrawYUVVideoQuad(const DrawingFrame* frame,
 
   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 @@ void GLRenderer::DrawYUVVideoQuad(const DrawingFrame* frame,
     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 @@ void GLRenderer::DrawStreamVideoQuad(const DrawingFrame* frame,
   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 @@ void GLRenderer::DrawStreamVideoQuad(const DrawingFrame* frame,
   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 @@ void GLRenderer::DrawStreamVideoQuad(const DrawingFrame* frame,
     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 @@ void GLRenderer::EnqueueTextureQuad(const DrawingFrame* frame,
   }
 
   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 @@ void GLRenderer::EnqueueTextureQuad(const DrawingFrame* frame,
   // 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 @@ void GLRenderer::DrawIOSurfaceQuad(const DrawingFrame* frame,
   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 @@ void GLRenderer::DrawIOSurfaceQuad(const DrawingFrame* frame,
   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..9c3a234 100644
--- a/cc/output/overlay_strategy_common.cc
+++ b/cc/output/overlay_strategy_common.cc
@@ -50,7 +50,7 @@ bool OverlayStrategyCommon::GetTextureQuadInfo(const TextureDrawQuad& quad,
                                                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 @@ bool OverlayStrategyCommon::GetVideoQuadInfo(const StreamVideoDrawQuad& quad,
                                              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 @@ bool OverlayStrategyCommon::GetCandidateQuadInfo(const DrawQuad& draw_quad,
 
   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 @@ bool OverlayStrategySingleOnTop::Attempt(
       // 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..6ac9b1c 100644
--- a/cc/output/overlay_unittest.cc
+++ b/cc/output/overlay_unittest.cc
@@ -278,8 +278,8 @@ static void CompareRenderPassLists(const RenderPassList& expected_list,
          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 @@ TEST_F(SingleOverlayOnTopTest, RejectNonAxisAlignedTransform) {
                                 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 @@ TEST_F(SingleOverlayOnTopTest, AllowVerticalFlip) {
   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 @@ TEST_F(SingleOverlayOnTopTest, AllowHorizontalFlip) {
   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 @@ TEST_F(SingleOverlayOnTopTest, AllowPositiveScaleTransform) {
   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 @@ TEST_F(SingleOverlayOnTopTest, Allow90DegreeRotation) {
   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 @@ TEST_F(SingleOverlayOnTopTest, Allow180DegreeRotation) {
   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 @@ TEST_F(SingleOverlayOnTopTest, Allow270DegreeRotation) {
   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 @@ scoped_ptr<RenderPass> CreateTestRenderPass(
 }
 
 SharedQuadState* CreateTestSharedQuadState(
-    gfx::Transform content_to_target_transform,
+    gfx::Transform quad_to_target_transform,
     const gfx::Rect& rect,
     RenderPass* render_pass) {
-  const gfx::Size content_bounds = rect.size();
-  const gfx::Rect visible_content_rect = rect;
+  const gfx::Size layer_bounds = rect.size();
+  const gfx::Rect visible_layer_rect = rect;
   const gfx::Rect clip_rect = rect;
   const bool is_clipped = false;
   const float opacity = 1.0f;
   const SkXfermode::Mode blend_mode = SkXfermode::kSrcOver_Mode;
   int sorting_context_id = 0;
   SharedQuadState* shared_state = render_pass->CreateAndAppendSharedQuadState();
-  shared_state->SetAll(content_to_target_transform,
-                       content_bounds,
-                       visible_content_rect,
-                       clip_rect,
-                       is_clipped,
-                       opacity,
-                       blend_mode,
-                       sorting_context_id);
+  shared_state->SetAll(quad_to_target_transform, layer_bounds,
+                       visible_layer_rect, clip_rect, is_clipped, opacity,
+                       blend_mode, sorting_context_id);
   return shared_state;
 }
 
 SharedQuadState* CreateTestSharedQuadStateClipped(
-    gfx::Transform content_to_target_transform,
+    gfx::Transform quad_to_target_transform,
     const gfx::Rect& rect,
     const gfx::Rect& clip_rect,
     RenderPass* render_pass) {
-  const gfx::Size content_bounds = rect.size();
-  const gfx::Rect visible_content_rect = clip_rect;
+  const gfx::Size layer_bounds = rect.size();
+  const gfx::Rect visible_layer_rect = clip_rect;
   const bool is_clipped = true;
   const float opacity = 1.0f;
   const SkXfermode::Mode blend_mode = SkXfermode::kSrcOver_Mode;
   int sorting_context_id = 0;
   SharedQuadState* shared_state = render_pass->CreateAndAppendSharedQuadState();
-  shared_state->SetAll(content_to_target_transform,
-                       content_bounds,
-                       visible_content_rect,
-                       clip_rect,
-                       is_clipped,
-                       opacity,
-                       blend_mode,
-                       sorting_context_id);
+  shared_state->SetAll(quad_to_target_transform, layer_bounds,
+                       visible_layer_rect, clip_rect, is_clipped, opacity,
+                       blend_mode, sorting_context_id);
   return shared_state;
 }
 
@@ -1220,9 +1210,9 @@ TYPED_TEST(RendererPixelTest, FastPassColorFilterAlpha) {
   scoped_ptr<RenderPass> child_pass =
       CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root);
 
-  gfx::Transform content_to_target_transform;
+  gfx::Transform quad_to_target_transform;
   SharedQuadState* shared_state = CreateTestSharedQuadState(
-      content_to_target_transform, viewport_rect, child_pass.get());
+      quad_to_target_transform, viewport_rect, child_pass.get());
   shared_state->opacity = 0.5f;
 
   gfx::Rect blue_rect(0,
@@ -1241,7 +1231,7 @@ TYPED_TEST(RendererPixelTest, FastPassColorFilterAlpha) {
   yellow->SetNew(shared_state, yellow_rect, yellow_rect, SK_ColorYELLOW, false);
 
   SharedQuadState* blank_state = CreateTestSharedQuadState(
-      content_to_target_transform, viewport_rect, child_pass.get());
+      quad_to_target_transform, viewport_rect, child_pass.get());
 
   SolidColorDrawQuad* white =
       child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
@@ -1312,9 +1302,9 @@ TYPED_TEST(RendererPixelTest, FastPassSaturateFilter) {
   scoped_ptr<RenderPass> child_pass =
       CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root);
 
-  gfx::Transform content_to_target_transform;
+  gfx::Transform quad_to_target_transform;
   SharedQuadState* shared_state = CreateTestSharedQuadState(
-      content_to_target_transform, viewport_rect, child_pass.get());
+      quad_to_target_transform, viewport_rect, child_pass.get());
   shared_state->opacity = 0.5f;
 
   gfx::Rect blue_rect(0,
@@ -1333,7 +1323,7 @@ TYPED_TEST(RendererPixelTest, FastPassSaturateFilter) {
   yellow->SetNew(shared_state, yellow_rect, yellow_rect, SK_ColorYELLOW, false);
 
   SharedQuadState* blank_state = CreateTestSharedQuadState(
-      content_to_target_transform, viewport_rect, child_pass.get());
+      quad_to_target_transform, viewport_rect, child_pass.get());
 
   SolidColorDrawQuad* white =
       child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
@@ -1383,9 +1373,9 @@ TYPED_TEST(RendererPixelTest, FastPassFilterChain) {
   scoped_ptr<RenderPass> child_pass =
       CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root);
 
-  gfx::Transform content_to_target_transform;
+  gfx::Transform quad_to_target_transform;
   SharedQuadState* shared_state = CreateTestSharedQuadState(
-      content_to_target_transform, viewport_rect, child_pass.get());
+      quad_to_target_transform, viewport_rect, child_pass.get());
   shared_state->opacity = 0.5f;
 
   gfx::Rect blue_rect(0,
@@ -1404,7 +1394,7 @@ TYPED_TEST(RendererPixelTest, FastPassFilterChain) {
   yellow->SetNew(shared_state, yellow_rect, yellow_rect, SK_ColorYELLOW, false);
 
   SharedQuadState* blank_state = CreateTestSharedQuadState(
-      content_to_target_transform, viewport_rect, child_pass.get());
+      quad_to_target_transform, viewport_rect, child_pass.get());
 
   SolidColorDrawQuad* white =
       child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
@@ -1456,9 +1446,9 @@ TYPED_TEST(RendererPixelTest, FastPassColorFilterAlphaTranslation) {
   scoped_ptr<RenderPass> child_pass =
       CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root);
 
-  gfx::Transform content_to_target_transform;
+  gfx::Transform quad_to_target_transform;
   SharedQuadState* shared_state = CreateTestSharedQuadState(
-      content_to_target_transform, viewport_rect, child_pass.get());
+      quad_to_target_transform, viewport_rect, child_pass.get());
   shared_state->opacity = 0.5f;
 
   gfx::Rect blue_rect(0,
@@ -1477,7 +1467,7 @@ TYPED_TEST(RendererPixelTest, FastPassColorFilterAlphaTranslation) {
   yellow->SetNew(shared_state, yellow_rect, yellow_rect, SK_ColorYELLOW, false);
 
   SharedQuadState* blank_state = CreateTestSharedQuadState(
-      content_to_target_transform, viewport_rect, child_pass.get());
+      quad_to_target_transform, viewport_rect, child_pass.get());
 
   SolidColorDrawQuad* white =
       child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
@@ -1552,9 +1542,9 @@ TYPED_TEST(RendererPixelTest, EnlargedRenderPassTexture) {
   scoped_ptr<RenderPass> child_pass =
       CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root);
 
-  gfx::Transform content_to_target_transform;
+  gfx::Transform quad_to_target_transform;
   SharedQuadState* shared_state = CreateTestSharedQuadState(
-      content_to_target_transform, viewport_rect, child_pass.get());
+      quad_to_target_transform, viewport_rect, child_pass.get());
 
   gfx::Rect blue_rect(0,
                       0,
@@ -1601,9 +1591,9 @@ TYPED_TEST(RendererPixelTest, EnlargedRenderPassTextureWithAntiAliasing) {
   scoped_ptr<RenderPass> child_pass =
       CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root);
 
-  gfx::Transform content_to_target_transform;
+  gfx::Transform quad_to_target_transform;
   SharedQuadState* shared_state = CreateTestSharedQuadState(
-      content_to_target_transform, viewport_rect, child_pass.get());
+      quad_to_target_transform, viewport_rect, child_pass.get());
 
   gfx::Rect blue_rect(0,
                       0,
@@ -1758,41 +1748,32 @@ class RendererPixelTestWithBackgroundFilter
         CreateTestRootRenderPass(root_id, device_viewport_rect);
     root_pass->has_transparent_background = false;
 
-    gfx::Transform identity_content_to_target_transform;
+    gfx::Transform identity_quad_to_target_transform;
 
     RenderPassId filter_pass_id(2, 1);
     gfx::Transform transform_to_root;
-    scoped_ptr<RenderPass> filter_pass =
-        CreateTestRenderPass(filter_pass_id,
-                             filter_pass_content_rect_,
-                             transform_to_root);
+    scoped_ptr<RenderPass> filter_pass = CreateTestRenderPass(
+        filter_pass_id, filter_pass_layer_rect_, transform_to_root);
 
     // A non-visible quad in the filtering render pass.
     {
       SharedQuadState* shared_state =
-          CreateTestSharedQuadState(identity_content_to_target_transform,
-                                    filter_pass_content_rect_,
-                                    filter_pass.get());
+          CreateTestSharedQuadState(identity_quad_to_target_transform,
+                                    filter_pass_layer_rect_, filter_pass.get());
       SolidColorDrawQuad* color_quad =
           filter_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
-      color_quad->SetNew(shared_state,
-                         filter_pass_content_rect_,
-                         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 @@ class RendererPixelTestWithBackgroundFilter
     gfx::Rect left_rect = gfx::Rect(0, 0, kColumnWidth, 20);
     for (int i = 0; left_rect.y() < device_viewport_rect.height(); ++i) {
       SharedQuadState* shared_state = CreateTestSharedQuadState(
-          identity_content_to_target_transform, left_rect, root_pass.get());
+          identity_quad_to_target_transform, left_rect, root_pass.get());
       SolidColorDrawQuad* color_quad =
           root_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
       color_quad->SetNew(
@@ -1817,7 +1798,7 @@ class RendererPixelTestWithBackgroundFilter
     gfx::Rect middle_rect = gfx::Rect(kColumnWidth+1, 0, kColumnWidth, 20);
     for (int i = 0; middle_rect.y() < device_viewport_rect.height(); ++i) {
       SharedQuadState* shared_state = CreateTestSharedQuadState(
-          identity_content_to_target_transform, middle_rect, root_pass.get());
+          identity_quad_to_target_transform, middle_rect, root_pass.get());
       SolidColorDrawQuad* color_quad =
           root_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
       color_quad->SetNew(
@@ -1828,7 +1809,7 @@ class RendererPixelTestWithBackgroundFilter
     gfx::Rect right_rect = gfx::Rect((kColumnWidth+1)*2, 0, kColumnWidth, 20);
     for (int i = 0; right_rect.y() < device_viewport_rect.height(); ++i) {
       SharedQuadState* shared_state = CreateTestSharedQuadState(
-          identity_content_to_target_transform, right_rect, root_pass.get());
+          identity_quad_to_target_transform, right_rect, root_pass.get());
       SolidColorDrawQuad* color_quad =
           root_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
       color_quad->SetNew(
@@ -1837,9 +1818,8 @@ class RendererPixelTestWithBackgroundFilter
     }
 
     SharedQuadState* shared_state =
-        CreateTestSharedQuadState(identity_content_to_target_transform,
-                                  device_viewport_rect,
-                                  root_pass.get());
+        CreateTestSharedQuadState(identity_quad_to_target_transform,
+                                  device_viewport_rect, root_pass.get());
     SolidColorDrawQuad* background_quad =
         root_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
     background_quad->SetNew(shared_state,
@@ -1855,7 +1835,7 @@ class RendererPixelTestWithBackgroundFilter
   RenderPassList pass_list_;
   FilterOperations background_filters_;
   gfx::Transform filter_pass_to_target_transform_;
-  gfx::Rect filter_pass_content_rect_;
+  gfx::Rect filter_pass_layer_rect_;
 };
 
 typedef ::testing::Types<GLRenderer, SoftwareRenderer>
@@ -1871,8 +1851,8 @@ TEST_F(GLRendererPixelTestWithBackgroundFilter, InvertFilter) {
   this->background_filters_.Append(
       FilterOperation::CreateInvertFilter(1.f));
 
-  this->filter_pass_content_rect_ = gfx::Rect(this->device_viewport_size_);
-  this->filter_pass_content_rect_.Inset(12, 14, 16, 18);
+  this->filter_pass_layer_rect_ = gfx::Rect(this->device_viewport_size_);
+  this->filter_pass_layer_rect_.Inset(12, 14, 16, 18);
 
   this->SetUpRenderPassList();
   EXPECT_TRUE(this->RunPixelTest(
@@ -1979,9 +1959,9 @@ TEST_F(ExternalStencilPixelTest, RenderSurfacesIgnoreStencil) {
   scoped_ptr<RenderPass> child_pass =
       CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root);
 
-  gfx::Transform content_to_target_transform;
+  gfx::Transform quad_to_target_transform;
   SharedQuadState* shared_state = CreateTestSharedQuadState(
-      content_to_target_transform, viewport_rect, child_pass.get());
+      quad_to_target_transform, viewport_rect, child_pass.get());
 
   gfx::Rect blue_rect(0,
                       0,
@@ -2036,26 +2016,26 @@ TEST_F(GLRendererPixelTest, AntiAliasing) {
   RenderPassId id(1, 1);
   scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
 
-  gfx::Transform red_content_to_target_transform;
-  red_content_to_target_transform.Rotate(10);
-  SharedQuadState* red_shared_state = CreateTestSharedQuadState(
-      red_content_to_target_transform, rect, pass.get());
+  gfx::Transform red_quad_to_target_transform;
+  red_quad_to_target_transform.Rotate(10);
+  SharedQuadState* red_shared_state =
+      CreateTestSharedQuadState(red_quad_to_target_transform, rect, pass.get());
 
   SolidColorDrawQuad* red = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   red->SetNew(red_shared_state, rect, rect, SK_ColorRED, false);
 
-  gfx::Transform yellow_content_to_target_transform;
-  yellow_content_to_target_transform.Rotate(5);
+  gfx::Transform yellow_quad_to_target_transform;
+  yellow_quad_to_target_transform.Rotate(5);
   SharedQuadState* yellow_shared_state = CreateTestSharedQuadState(
-      yellow_content_to_target_transform, rect, pass.get());
+      yellow_quad_to_target_transform, rect, pass.get());
 
   SolidColorDrawQuad* yellow =
       pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   yellow->SetNew(yellow_shared_state, rect, rect, SK_ColorYELLOW, false);
 
-  gfx::Transform blue_content_to_target_transform;
+  gfx::Transform blue_quad_to_target_transform;
   SharedQuadState* blue_shared_state = CreateTestSharedQuadState(
-      blue_content_to_target_transform, rect, pass.get());
+      blue_quad_to_target_transform, rect, pass.get());
 
   SolidColorDrawQuad* blue =
       pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
@@ -2080,30 +2060,29 @@ TEST_F(GLRendererPixelTest, AxisAligned) {
   scoped_ptr<RenderPass> pass =
       CreateTestRenderPass(id, rect, transform_to_root);
 
-  gfx::Transform red_content_to_target_transform;
-  red_content_to_target_transform.Translate(50, 50);
-  red_content_to_target_transform.Scale(
-      0.5f + 1.0f / (rect.width() * 2.0f),
-      0.5f + 1.0f / (rect.height() * 2.0f));
-  SharedQuadState* red_shared_state = CreateTestSharedQuadState(
-      red_content_to_target_transform, rect, pass.get());
+  gfx::Transform red_quad_to_target_transform;
+  red_quad_to_target_transform.Translate(50, 50);
+  red_quad_to_target_transform.Scale(0.5f + 1.0f / (rect.width() * 2.0f),
+                                     0.5f + 1.0f / (rect.height() * 2.0f));
+  SharedQuadState* red_shared_state =
+      CreateTestSharedQuadState(red_quad_to_target_transform, rect, pass.get());
 
   SolidColorDrawQuad* red = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   red->SetNew(red_shared_state, rect, rect, SK_ColorRED, false);
 
-  gfx::Transform yellow_content_to_target_transform;
-  yellow_content_to_target_transform.Translate(25.5f, 25.5f);
-  yellow_content_to_target_transform.Scale(0.5f, 0.5f);
+  gfx::Transform yellow_quad_to_target_transform;
+  yellow_quad_to_target_transform.Translate(25.5f, 25.5f);
+  yellow_quad_to_target_transform.Scale(0.5f, 0.5f);
   SharedQuadState* yellow_shared_state = CreateTestSharedQuadState(
-      yellow_content_to_target_transform, rect, pass.get());
+      yellow_quad_to_target_transform, rect, pass.get());
 
   SolidColorDrawQuad* yellow =
       pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   yellow->SetNew(yellow_shared_state, rect, rect, SK_ColorYELLOW, false);
 
-  gfx::Transform blue_content_to_target_transform;
+  gfx::Transform blue_quad_to_target_transform;
   SharedQuadState* blue_shared_state = CreateTestSharedQuadState(
-      blue_content_to_target_transform, rect, pass.get());
+      blue_quad_to_target_transform, rect, pass.get());
 
   SolidColorDrawQuad* blue =
       pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
@@ -2128,22 +2107,21 @@ TEST_F(GLRendererPixelTest, ForceAntiAliasingOff) {
   scoped_ptr<RenderPass> pass =
       CreateTestRenderPass(id, rect, transform_to_root);
 
-  gfx::Transform hole_content_to_target_transform;
-  hole_content_to_target_transform.Translate(50, 50);
-  hole_content_to_target_transform.Scale(
-      0.5f + 1.0f / (rect.width() * 2.0f),
-      0.5f + 1.0f / (rect.height() * 2.0f));
+  gfx::Transform hole_quad_to_target_transform;
+  hole_quad_to_target_transform.Translate(50, 50);
+  hole_quad_to_target_transform.Scale(0.5f + 1.0f / (rect.width() * 2.0f),
+                                      0.5f + 1.0f / (rect.height() * 2.0f));
   SharedQuadState* hole_shared_state = CreateTestSharedQuadState(
-      hole_content_to_target_transform, rect, pass.get());
+      hole_quad_to_target_transform, rect, pass.get());
 
   SolidColorDrawQuad* hole =
       pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   hole->SetAll(
       hole_shared_state, rect, rect, rect, false, SK_ColorTRANSPARENT, true);
 
-  gfx::Transform green_content_to_target_transform;
+  gfx::Transform green_quad_to_target_transform;
   SharedQuadState* green_shared_state = CreateTestSharedQuadState(
-      green_content_to_target_transform, rect, pass.get());
+      green_quad_to_target_transform, rect, pass.get());
 
   SolidColorDrawQuad* green =
       pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
@@ -2165,13 +2143,11 @@ TEST_F(GLRendererPixelTest, AntiAliasingPerspective) {
       CreateTestRootRenderPass(RenderPassId(1, 1), rect);
 
   gfx::Rect red_rect(0, 0, 180, 500);
-  gfx::Transform red_content_to_target_transform(
-      1.0f,  2.4520f,  10.6206f, 19.0f,
-      0.0f,  0.3528f,  5.9737f,  9.5f,
-      0.0f, -0.2250f, -0.9744f,  0.0f,
-      0.0f,  0.0225f,  0.0974f,  1.0f);
+  gfx::Transform red_quad_to_target_transform(
+      1.0f, 2.4520f, 10.6206f, 19.0f, 0.0f, 0.3528f, 5.9737f, 9.5f, 0.0f,
+      -0.2250f, -0.9744f, 0.0f, 0.0f, 0.0225f, 0.0974f, 1.0f);
   SharedQuadState* red_shared_state = CreateTestSharedQuadState(
-      red_content_to_target_transform, red_rect, pass.get());
+      red_quad_to_target_transform, red_rect, pass.get());
   SolidColorDrawQuad* red = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   red->SetNew(red_shared_state, red_rect, red_rect, SK_ColorRED, false);
 
@@ -2228,16 +2204,14 @@ TYPED_TEST(SoftwareRendererPixelTest, PictureDrawQuadIdentityScale) {
   scoped_refptr<FakePicturePileImpl> blue_pile =
       FakePicturePileImpl::CreateFromPile(blue_recording.get(), nullptr);
 
-  gfx::Transform blue_content_to_target_transform;
+  gfx::Transform blue_quad_to_target_transform;
   gfx::Vector2d offset(viewport.bottom_right() - blue_rect.bottom_right());
-  blue_content_to_target_transform.Translate(offset.x(), offset.y());
+  blue_quad_to_target_transform.Translate(offset.x(), offset.y());
   gfx::RectF blue_scissor_rect = blue_clip_rect;
-  blue_content_to_target_transform.TransformRect(&blue_scissor_rect);
-  SharedQuadState* blue_shared_state =
-      CreateTestSharedQuadStateClipped(blue_content_to_target_transform,
-                                       blue_rect,
-                                       gfx::ToEnclosingRect(blue_scissor_rect),
-                                       pass.get());
+  blue_quad_to_target_transform.TransformRect(&blue_scissor_rect);
+  SharedQuadState* blue_shared_state = CreateTestSharedQuadStateClipped(
+      blue_quad_to_target_transform, blue_rect,
+      gfx::ToEnclosingRect(blue_scissor_rect), pass.get());
 
   PictureDrawQuad* blue_quad = pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
 
@@ -2257,9 +2231,9 @@ TYPED_TEST(SoftwareRendererPixelTest, PictureDrawQuadIdentityScale) {
   scoped_refptr<FakePicturePileImpl> green_pile =
       FakePicturePileImpl::CreateFromPile(green_recording.get(), nullptr);
 
-  gfx::Transform green_content_to_target_transform;
+  gfx::Transform green_quad_to_target_transform;
   SharedQuadState* green_shared_state = CreateTestSharedQuadState(
-      green_content_to_target_transform, viewport, pass.get());
+      green_quad_to_target_transform, viewport, pass.get());
 
   PictureDrawQuad* green_quad =
       pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
@@ -2299,9 +2273,9 @@ TYPED_TEST(SoftwareRendererPixelTest, PictureDrawQuadOpacity) {
   scoped_refptr<FakePicturePileImpl> green_pile =
       FakePicturePileImpl::CreateFromPile(green_recording.get(), nullptr);
 
-  gfx::Transform green_content_to_target_transform;
+  gfx::Transform green_quad_to_target_transform;
   SharedQuadState* green_shared_state = CreateTestSharedQuadState(
-      green_content_to_target_transform, viewport, pass.get());
+      green_quad_to_target_transform, viewport, pass.get());
   green_shared_state->opacity = 0.5f;
 
   PictureDrawQuad* green_quad =
@@ -2320,9 +2294,9 @@ TYPED_TEST(SoftwareRendererPixelTest, PictureDrawQuadOpacity) {
   scoped_refptr<FakePicturePileImpl> white_pile =
       FakePicturePileImpl::CreateFromPile(white_recording.get(), nullptr);
 
-  gfx::Transform white_content_to_target_transform;
+  gfx::Transform white_quad_to_target_transform;
   SharedQuadState* white_shared_state = CreateTestSharedQuadState(
-      white_content_to_target_transform, viewport, pass.get());
+      white_quad_to_target_transform, viewport, pass.get());
 
   PictureDrawQuad* white_quad =
       pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
@@ -2391,9 +2365,9 @@ TYPED_TEST(SoftwareRendererPixelTest, PictureDrawQuadDisableImageFiltering) {
   scoped_refptr<FakePicturePileImpl> pile =
       FakePicturePileImpl::CreateFromPile(recording.get(), nullptr);
 
-  gfx::Transform content_to_target_transform;
-  SharedQuadState* shared_state = CreateTestSharedQuadState(
-      content_to_target_transform, viewport, pass.get());
+  gfx::Transform quad_to_target_transform;
+  SharedQuadState* shared_state =
+      CreateTestSharedQuadState(quad_to_target_transform, viewport, pass.get());
 
   PictureDrawQuad* quad = pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
   quad->SetNew(shared_state, viewport, gfx::Rect(), viewport,
@@ -2443,9 +2417,9 @@ TYPED_TEST(SoftwareRendererPixelTest, PictureDrawQuadNearestNeighbor) {
   scoped_refptr<FakePicturePileImpl> pile =
       FakePicturePileImpl::CreateFromPile(recording.get(), nullptr);
 
-  gfx::Transform content_to_target_transform;
-  SharedQuadState* shared_state = CreateTestSharedQuadState(
-      content_to_target_transform, viewport, pass.get());
+  gfx::Transform quad_to_target_transform;
+  SharedQuadState* shared_state =
+      CreateTestSharedQuadState(quad_to_target_transform, viewport, pass.get());
 
   PictureDrawQuad* quad = pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
   quad->SetNew(shared_state, viewport, gfx::Rect(), viewport,
@@ -2494,9 +2468,9 @@ TYPED_TEST(RendererPixelTest, TileDrawQuadNearestNeighbor) {
   scoped_ptr<RenderPass> pass =
       CreateTestRenderPass(id, viewport, transform_to_root);
 
-  gfx::Transform content_to_target_transform;
-  SharedQuadState* shared_state = CreateTestSharedQuadState(
-      content_to_target_transform, viewport, pass.get());
+  gfx::Transform quad_to_target_transform;
+  SharedQuadState* shared_state =
+      CreateTestSharedQuadState(quad_to_target_transform, viewport, pass.get());
 
   TileDrawQuad* quad = pass->CreateAndAppendDrawQuad<TileDrawQuad>();
   quad->SetNew(shared_state, viewport, gfx::Rect(), viewport, resource,
@@ -2545,9 +2519,9 @@ TYPED_TEST(SoftwareRendererPixelTest, TextureDrawQuadNearestNeighbor) {
   scoped_ptr<RenderPass> pass =
       CreateTestRenderPass(id, viewport, transform_to_root);
 
-  gfx::Transform content_to_target_transform;
-  SharedQuadState* shared_state = CreateTestSharedQuadState(
-      content_to_target_transform, viewport, pass.get());
+  gfx::Transform quad_to_target_transform;
+  SharedQuadState* shared_state =
+      CreateTestSharedQuadState(quad_to_target_transform, viewport, pass.get());
 
   float vertex_opacity[4] = {1.0f, 1.0f, 1.0f, 1.0f};
   TextureDrawQuad* quad = pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
@@ -2597,9 +2571,9 @@ TYPED_TEST(SoftwareRendererPixelTest, TextureDrawQuadLinear) {
   scoped_ptr<RenderPass> pass =
       CreateTestRenderPass(id, viewport, transform_to_root);
 
-  gfx::Transform content_to_target_transform;
-  SharedQuadState* shared_state = CreateTestSharedQuadState(
-      content_to_target_transform, viewport, pass.get());
+  gfx::Transform quad_to_target_transform;
+  SharedQuadState* shared_state =
+      CreateTestSharedQuadState(quad_to_target_transform, viewport, pass.get());
 
   float vertex_opacity[4] = {1.0f, 1.0f, 1.0f, 1.0f};
   TextureDrawQuad* quad = pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
@@ -2634,7 +2608,7 @@ TYPED_TEST(SoftwareRendererPixelTest, PictureDrawQuadNonIdentityScale) {
   // a few extra "cleanup rects" need to be added to clobber the blending
   // to make the output image more clean.  This will also test subrects
   // of the layer.
-  gfx::Transform green_content_to_target_transform;
+  gfx::Transform green_quad_to_target_transform;
   gfx::Rect green_rect1(gfx::Point(80, 0), gfx::Size(20, 100));
   gfx::Rect green_rect2(gfx::Point(0, 80), gfx::Size(100, 20));
 
@@ -2653,8 +2627,8 @@ TYPED_TEST(SoftwareRendererPixelTest, PictureDrawQuadNonIdentityScale) {
       FakePicturePileImpl::CreateFromPile(green_recording.get(), nullptr);
 
   SharedQuadState* top_right_green_shared_quad_state =
-      CreateTestSharedQuadState(
-          green_content_to_target_transform, viewport, pass.get());
+      CreateTestSharedQuadState(green_quad_to_target_transform, viewport,
+                                pass.get());
 
   PictureDrawQuad* green_quad1 =
       pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
@@ -2676,10 +2650,8 @@ TYPED_TEST(SoftwareRendererPixelTest, PictureDrawQuadNonIdentityScale) {
       gfx::Point(viewport.width() / 2, viewport.height() / 2),
       gfx::Size(viewport.width() / 2, viewport.height() / 2));
   SharedQuadState* bottom_right_green_shared_state =
-      CreateTestSharedQuadStateClipped(green_content_to_target_transform,
-                                       viewport,
-                                       bottom_right_rect,
-                                       pass.get());
+      CreateTestSharedQuadStateClipped(green_quad_to_target_transform, viewport,
+                                       bottom_right_rect, pass.get());
   SolidColorDrawQuad* bottom_right_color_quad =
       pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   bottom_right_color_quad->SetNew(bottom_right_green_shared_state,
@@ -2729,11 +2701,11 @@ TYPED_TEST(SoftwareRendererPixelTest, PictureDrawQuadNonIdentityScale) {
 
   // At a scale of 4x the rectangles with a width of 2.5 will take up 10 pixels,
   // so scale an additional 10x to make them 100x100.
-  gfx::Transform content_to_target_transform;
-  content_to_target_transform.Scale(10.0, 10.0);
+  gfx::Transform quad_to_target_transform;
+  quad_to_target_transform.Scale(10.0, 10.0);
   gfx::Rect quad_content_rect(gfx::Size(20, 20));
   SharedQuadState* blue_shared_state = CreateTestSharedQuadState(
-      content_to_target_transform, quad_content_rect, pass.get());
+      quad_to_target_transform, quad_content_rect, pass.get());
 
   PictureDrawQuad* blue_quad = pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
   blue_quad->SetNew(blue_shared_state, quad_content_rect, gfx::Rect(),
@@ -2742,10 +2714,10 @@ TYPED_TEST(SoftwareRendererPixelTest, PictureDrawQuadNonIdentityScale) {
                     content_union_rect, contents_scale, pile.get());
 
   // Fill left half of viewport with green.
-  gfx::Transform half_green_content_to_target_transform;
+  gfx::Transform half_green_quad_to_target_transform;
   gfx::Rect half_green_rect(gfx::Size(viewport.width() / 2, viewport.height()));
   SharedQuadState* half_green_shared_state = CreateTestSharedQuadState(
-      half_green_content_to_target_transform, half_green_rect, pass.get());
+      half_green_quad_to_target_transform, half_green_rect, pass.get());
   SolidColorDrawQuad* half_color_quad =
       pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   half_color_quad->SetNew(half_green_shared_state,
@@ -2780,9 +2752,9 @@ TEST_F(GLRendererPixelTestWithFlippedOutputSurface, ExplicitFlipTest) {
   scoped_ptr<RenderPass> child_pass =
       CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root);
 
-  gfx::Transform content_to_target_transform;
+  gfx::Transform quad_to_target_transform;
   SharedQuadState* shared_state = CreateTestSharedQuadState(
-      content_to_target_transform, viewport_rect, child_pass.get());
+      quad_to_target_transform, viewport_rect, child_pass.get());
 
   gfx::Rect blue_rect(0,
                       0,
@@ -2828,9 +2800,9 @@ TEST_F(GLRendererPixelTestWithFlippedOutputSurface, CheckChildPassUnflipped) {
   scoped_ptr<RenderPass> child_pass =
       CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root);
 
-  gfx::Transform content_to_target_transform;
+  gfx::Transform quad_to_target_transform;
   SharedQuadState* shared_state = CreateTestSharedQuadState(
-      content_to_target_transform, viewport_rect, child_pass.get());
+      quad_to_target_transform, viewport_rect, child_pass.get());
 
   gfx::Rect blue_rect(0,
                       0,
@@ -2877,9 +2849,9 @@ TEST_F(GLRendererPixelTest, CheckReadbackSubset) {
   scoped_ptr<RenderPass> child_pass =
       CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root);
 
-  gfx::Transform content_to_target_transform;
+  gfx::Transform quad_to_target_transform;
   SharedQuadState* shared_state = CreateTestSharedQuadState(
-      content_to_target_transform, viewport_rect, child_pass.get());
+      quad_to_target_transform, viewport_rect, child_pass.get());
 
   // Draw a green quad full-size with a blue quad in the lower-right corner.
   gfx::Rect blue_rect(this->device_viewport_size_.width() * 3 / 4,
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 @@ void SoftwareRenderer::DoDrawQuad(DrawingFrame* frame,
   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 @@ DrawPolygon::DrawPolygon(const DrawQuad* original,
 // 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 @@ DrawPolygon::DrawPolygon(const DrawQuad* original_ref,
       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 @@ class CC_EXPORT DrawPolygon {
               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 1142cc1..606d7ab 100644
--- a/cc/quads/draw_quad.cc
+++ b/cc/quads/draw_quad.cc
@@ -62,10 +62,9 @@ void DrawQuad::AsValueInto(base::trace_event::TracedValue* value) const {
   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 @@ void DrawQuad::AsValueInto(base::trace_event::TracedValue* value) const {
   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 @@ void DrawQuad::AsValueInto(base::trace_event::TracedValue* value) const {
   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 @@ class CC_EXPORT DrawQuad {
   // 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 @@ static const int kTimeCheckInterval = 10;
 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 @@ SharedQuadState* CreateSharedQuadState(RenderPass* render_pass) {
   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 @@ namespace {
 
 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 @@ TEST(DrawQuadTest, CopySharedQuadState) {
   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 @@ TEST(DrawQuadTest, CopySharedQuadState) {
 
 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 @@ SharedQuadState* CreateSharedQuadState(RenderPass* render_pass) {
   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 e6f39bc..65183af 100644
--- a/cc/quads/render_pass_unittest.cc
+++ b/cc/quads/render_pass_unittest.cc
@@ -57,8 +57,8 @@ static void CompareRenderPassLists(const RenderPassList& expected_list,
          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 @@ void SharedQuadState::CopyFrom(const SharedQuadState* other) {
   *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::SetAll(const gfx::Transform& content_to_target_transform,
 }
 
 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 6f0ef92..a66c7bc 100644
--- a/cc/quads/shared_quad_state.h
+++ b/cc/quads/shared_quad_state.h
@@ -32,9 +32,9 @@ class CC_EXPORT SharedQuadState {
 
   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 @@ class CC_EXPORT SharedQuadState {
               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 a6af98e..e1ee987 100644
--- a/cc/surfaces/surface_aggregator.cc
+++ b/cc/surfaces/surface_aggregator.cc
@@ -259,7 +259,7 @@ void SurfaceAggregator::HandleSurfaceQuad(
     // transform of the surface quad into account to update their transform to
     // the root surface.
     copy_pass->transform_to_root_target.ConcatTransform(
-        surface_quad->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 @@ void SurfaceAggregator::HandleSurfaceQuad(
     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 @@ void SurfaceAggregator::HandleSurfaceQuad(
   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 @@ void SurfaceAggregator::CopySharedQuadState(
   // 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 @@ void SurfaceAggregator::CopyQuadsToPass(
         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 @@ void AddTestSurfaceQuad(TestRenderPass* pass,
                         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 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, RenderPassIdMapping) {
 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 @@ void AddSolidColorQuadWithBlendMode(const gfx::Size& size,
 
   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 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateMultiplePassWithTransform) {
     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 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateMultiplePassWithTransform) {
         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 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateMultiplePassWithTransform) {
 
   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 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateMultiplePassWithTransform) {
   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 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateMultiplePassWithTransform) {
        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 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateDamageRect) {
   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 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateDamageRect) {
 
   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 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateDamageRect) {
     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 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateDamageRect) {
 
     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 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateDamageRect) {
 
     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 @@ SharedQuadState* CreateAndAppendTestSharedQuadState(
     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 @@ void LayerTestCommon::VerifyQuadsExactlyCoverRect(const QuadList& quads,
 
   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 @@ void LayerTestCommon::VerifyQuadsAreOccluded(const QuadList& quads,
   // No quad should exist if it's fully occluded.
   for (const auto& quad : quads) {
     gfx::Rect target_visible_rect = MathUtil::MapEnclosingClippedRect(
-        quad->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 b2242f7..6fda536 100644
--- a/cc/test/render_pass_test_common.cc
+++ b/cc/test/render_pass_test_common.cc
@@ -193,8 +193,8 @@ void TestRenderPass::AppendOneOfEveryQuadType(
   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..e2a7fd6 100644
--- a/cc/trees/draw_property_utils.cc
+++ b/cc/trees/draw_property_utils.cc
@@ -270,7 +270,7 @@ static bool LayerShouldBeSkipped(LayerType* layer,
   // 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..b143b51 100644
--- a/cc/trees/layer_tree_host.cc
+++ b/cc/trees/layer_tree_host.cc
@@ -814,7 +814,7 @@ bool LayerTreeHost::DoUpdateLayers(Layer* root_layer) {
   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 @@ static inline bool LayerClipsSubtree(LayerType* layer) {
 }
 
 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 @@ static bool LayerShouldBeSkipped(LayerType* layer, bool layer_is_drawn) {
   // 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 @@ static void CalculateDrawPropertiesInternal(
       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 @@ static void CalculateDrawPropertiesInternal(
       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 @@ static void CalculateDrawPropertiesInternal(
   }
 
   // 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 @@ template <typename LayerType>
 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 @@ TEST_F(LayerTreeHostCommonTest,
   // 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 @@ TEST_F(LayerTreeHostCommonTest, DrawableAndVisibleContentRectsForSimpleLayers) {
             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 @@ TEST_F(LayerTreeHostCommonTest,
   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 @@ TEST_F(LayerTreeHostCommonTest,
   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 @@ TEST_F(LayerTreeHostCommonTest,
             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 @@ TEST_F(LayerTreeHostCommonTest,
   // 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 @@ TEST_F(LayerTreeHostCommonTest,
 
   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 @@ TEST_F(LayerTreeHostCommonTest,
 
   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 @@ TEST_F(LayerTreeHostCommonTest,
 
   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 @@ TEST_F(LayerTreeHostCommonTest,
   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 @@ TEST_F(LayerTreeHostCommonTest,
 
   // 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 @@ TEST_F(LayerTreeHostCommonTest,
   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 @@ TEST_F(LayerTreeHostCommonTest,
             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 @@ TEST_F(LayerTreeHostCommonTest,
   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 @@ TEST_F(LayerTreeHostCommonTest,
             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 @@ TEST_F(LayerTreeHostCommonTest,
   // 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 @@ TEST_F(LayerTreeHostCommonTest, DrawableAndVisibleContentRectsInHighDPI) {
   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 @@ TEST_F(LayerTreeHostCommonTest, BackFaceCullingWithAnimatingTransforms) {
             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 @@ TEST_F(LayerTreeHostCommonTest, VisibleContentRectInsideSurface) {
   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 @@ TEST_F(LayerTreeHostCommonTest, ClipParentWithInterveningRenderSurface) {
   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 @@ TEST_F(LayerTreeHostCommonTest, ClipParentScrolledInterveningLayer) {
   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 @@ TEST_F(LayerTreeHostCommonTest, DescendantsOfClipChildren) {
             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 @@ TEST_F(LayerTreeHostCommonTest, VisibleContentRectInChildRenderSurface) {
 
   // 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 @@ TEST_F(LayerTreeHostCommonTest, BoundsDeltaAffectVisibleContentRect) {
 
   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 @@ TEST_F(LayerTreeHostCommonTest, BoundsDeltaAffectVisibleContentRect) {
 
   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 51b4198..3109c00 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -850,11 +850,10 @@ DrawResult LayerTreeHostImpl::CalculateRenderPasses(
                                        *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 @@ DrawResult LayerTreeHostImpl::CalculateRenderPasses(
         // 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 @@ DrawResult LayerTreeHostImpl::CalculateRenderPasses(
     }
 
     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 @@ class LayerTreeHostImplTest : public testing::Test,
     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 @@ class DidDrawCheckLayer : public LayerImpl {
         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 @@ TEST_F(LayerTreeHostImplTest, DidDrawNotCalledOnHiddenLayer) {
   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 @@ TEST_F(LayerTreeHostImplTest, DidDrawNotCalledOnHiddenLayer) {
   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 @@ TEST_F(LayerTreeHostImplTest, DidDrawNotCalledOnHiddenLayer) {
   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 @@ static scoped_ptr<LayerTreeHostImpl> SetupLayersForOpacity(
   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 @@ TEST_F(LayerTreeHostImplTest, FarAwayQuadsDontNeedAA) {
 
   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 @@ class LayerTreeHostTestCrispUpAfterPinchEnds : public LayerTreeHostTest {
       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 @@ class LayerTreeHostTestContinuousDrawWhenCreatingVisibleTiles
       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 @@ TEST_F(LayerTreeImplTest,
   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 @@ void OcclusionTracker::MarkOccludedBehindLayer(const LayerImpl* layer) {
   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 @@ void OcclusionTracker::MarkOccludedBehindLayer(const LayerImpl* layer) {
         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 2cbd2e5..08cfcf7 100644
--- a/cc/trees/occlusion_tracker_unittest.cc
+++ b/cc/trees/occlusion_tracker_unittest.cc
@@ -35,12 +35,12 @@ class TestContentLayerImpl : public LayerImpl {
     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 @@ class TestOcclusionTrackerWithClip : public TestOcclusionTracker {
 
   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 @@ class TestOcclusionTrackerWithClip : public TestOcclusionTracker {
   // 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 @@ class OcclusionTrackerTestSurfaceRotatedOffAxis : public OcclusionTrackerTest {
     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);