cc: Rename visible_content_rect and content stuff on quads.

cc/output/renderer_pixeltest.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/message_loop/message_loop.h"
 #include "cc/output/gl_renderer.h"
 #include "cc/quads/draw_quad.h"
 #include "cc/quads/picture_draw_quad.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/resources/video_resource_updater.h"
@@ skipping 29 matching lines @@
     const gfx::Rect& rect,
     const gfx::Transform& transform_to_root_target) {
   scoped_ptr<RenderPass> pass = RenderPass::Create();
   const gfx::Rect output_rect = rect;
   const gfx::Rect damage_rect = rect;
   pass->SetNew(id, output_rect, damage_rect, transform_to_root_target);
   return pass.Pass();
 }
 
 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;
 }
 
 void CreateTestRenderPassDrawQuad(const SharedQuadState* shared_state,
                                   const gfx::Rect& rect,
                                   RenderPassId pass_id,
                                   RenderPass* render_pass) {
   RenderPassDrawQuad* quad =
       render_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
   quad->SetNew(shared_state,
@@ skipping 1111 matching lines @@
   RenderPassId root_pass_id(1, 1);
   scoped_ptr<RenderPass> root_pass =
       CreateTestRootRenderPass(root_pass_id, viewport_rect);
 
   RenderPassId child_pass_id(2, 2);
   gfx::Rect pass_rect(this->device_viewport_size_);
   gfx::Transform transform_to_root;
   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,
                       0,
                       this->device_viewport_size_.width(),
                       this->device_viewport_size_.height() / 2);
   SolidColorDrawQuad* blue =
       child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false);
   gfx::Rect yellow_rect(0,
                         this->device_viewport_size_.height() / 2,
                         this->device_viewport_size_.width(),
                         this->device_viewport_size_.height() / 2);
   SolidColorDrawQuad* yellow =
       child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   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>();
   white->SetNew(
       blank_state, viewport_rect, viewport_rect, SK_ColorWHITE, false);
 
   SharedQuadState* pass_shared_state =
       CreateTestSharedQuadState(gfx::Transform(), pass_rect, root_pass.get());
 
   SkScalar matrix[20];
@@ skipping 50 matching lines @@
   RenderPassId root_pass_id(1, 1);
   scoped_ptr<RenderPass> root_pass =
       CreateTestRootRenderPass(root_pass_id, viewport_rect);
 
   RenderPassId child_pass_id(2, 2);
   gfx::Rect pass_rect(this->device_viewport_size_);
   gfx::Transform transform_to_root;
   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,
                       0,
                       this->device_viewport_size_.width(),
                       this->device_viewport_size_.height() / 2);
   SolidColorDrawQuad* blue =
       child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false);
   gfx::Rect yellow_rect(0,
                         this->device_viewport_size_.height() / 2,
                         this->device_viewport_size_.width(),
                         this->device_viewport_size_.height() / 2);
   SolidColorDrawQuad* yellow =
       child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   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>();
   white->SetNew(
       blank_state, viewport_rect, viewport_rect, SK_ColorWHITE, false);
 
   SharedQuadState* pass_shared_state =
       CreateTestSharedQuadState(gfx::Transform(), pass_rect, root_pass.get());
 
   FilterOperations filters;
@@ skipping 29 matching lines @@
   RenderPassId root_pass_id(1, 1);
   scoped_ptr<RenderPass> root_pass =
       CreateTestRootRenderPass(root_pass_id, viewport_rect);
 
   RenderPassId child_pass_id(2, 2);
   gfx::Rect pass_rect(this->device_viewport_size_);
   gfx::Transform transform_to_root;
   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,
                       0,
                       this->device_viewport_size_.width(),
                       this->device_viewport_size_.height() / 2);
   SolidColorDrawQuad* blue =
       child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false);
   gfx::Rect yellow_rect(0,
                         this->device_viewport_size_.height() / 2,
                         this->device_viewport_size_.width(),
                         this->device_viewport_size_.height() / 2);
   SolidColorDrawQuad* yellow =
       child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   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>();
   white->SetNew(
       blank_state, viewport_rect, viewport_rect, SK_ColorWHITE, false);
 
   SharedQuadState* pass_shared_state =
       CreateTestSharedQuadState(gfx::Transform(), pass_rect, root_pass.get());
 
   FilterOperations filters;
@@ skipping 31 matching lines @@
   RenderPassId root_pass_id(1, 1);
   scoped_ptr<RenderPass> root_pass =
       CreateTestRootRenderPass(root_pass_id, viewport_rect);
 
   RenderPassId child_pass_id(2, 2);
   gfx::Rect pass_rect(this->device_viewport_size_);
   gfx::Transform transform_to_root;
   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,
                       0,
                       this->device_viewport_size_.width(),
                       this->device_viewport_size_.height() / 2);
   SolidColorDrawQuad* blue =
       child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false);
   gfx::Rect yellow_rect(0,
                         this->device_viewport_size_.height() / 2,
                         this->device_viewport_size_.width(),
                         this->device_viewport_size_.height() / 2);
   SolidColorDrawQuad* yellow =
       child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   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>();
   white->SetNew(
       blank_state, viewport_rect, viewport_rect, SK_ColorWHITE, false);
 
   SharedQuadState* pass_shared_state =
       CreateTestSharedQuadState(gfx::Transform(), pass_rect, root_pass.get());
 
   SkScalar matrix[20];
@@ skipping 54 matching lines @@
   RenderPassId root_pass_id(1, 1);
   scoped_ptr<RenderPass> root_pass =
       CreateTestRootRenderPass(root_pass_id, viewport_rect);
 
   RenderPassId child_pass_id(2, 2);
   gfx::Rect pass_rect(this->device_viewport_size_);
   gfx::Transform transform_to_root;
   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,
                       this->device_viewport_size_.width(),
                       this->device_viewport_size_.height() / 2);
   SolidColorDrawQuad* blue =
       child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false);
   gfx::Rect yellow_rect(0,
                         this->device_viewport_size_.height() / 2,
@@ skipping 26 matching lines @@
   RenderPassId root_pass_id(1, 1);
   scoped_ptr<RenderPass> root_pass =
       CreateTestRootRenderPass(root_pass_id, viewport_rect);
 
   RenderPassId child_pass_id(2, 2);
   gfx::Rect pass_rect(this->device_viewport_size_);
   gfx::Transform transform_to_root;
   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,
                       this->device_viewport_size_.width(),
                       this->device_viewport_size_.height() / 2);
   SolidColorDrawQuad* blue =
       child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false);
   gfx::Rect yellow_rect(0,
                         this->device_viewport_size_.height() / 2,
@@ skipping 134 matching lines @@
     : public RendererPixelTest<RendererType> {
  protected:
   void SetUpRenderPassList() {
     gfx::Rect device_viewport_rect(this->device_viewport_size_);
 
     RenderPassId root_id(1, 1);
     scoped_ptr<RenderPass> root_pass =
         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
                                FilterOperations(),  // filters
                                gfx::Vector2dF(),    // filters_scale
                                this->background_filters_);
     }
 
     const int kColumnWidth = device_viewport_rect.width() / 3;
 
     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(
           shared_state, left_rect, left_rect, SK_ColorGREEN, false);
       left_rect += gfx::Vector2d(0, left_rect.height() + 1);
     }
 
     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(
           shared_state, middle_rect, middle_rect, SK_ColorRED, false);
       middle_rect += gfx::Vector2d(0, middle_rect.height() + 1);
     }
 
     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(
           shared_state, right_rect, right_rect, SK_ColorBLUE, false);
       right_rect += gfx::Vector2d(0, right_rect.height() + 1);
     }
 
     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,
                             device_viewport_rect,
                             device_viewport_rect,
                             SK_ColorWHITE,
                             false);
 
     pass_list_.push_back(filter_pass.Pass());
     pass_list_.push_back(root_pass.Pass());
   }
 
   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>
     BackgroundFilterRendererTypes;
 TYPED_TEST_CASE(RendererPixelTestWithBackgroundFilter,
                 BackgroundFilterRendererTypes);
 
 typedef RendererPixelTestWithBackgroundFilter<GLRenderer>
 GLRendererPixelTestWithBackgroundFilter;
 
 // TODO(skaslev): The software renderer does not support filters yet.
 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(
       &this->pass_list_,
       base::FilePath(FILE_PATH_LITERAL("background_filter.png")),
       ExactPixelComparator(true)));
 }
 
 class ExternalStencilPixelTest : public GLRendererPixelTest {
  protected:
@@ skipping 86 matching lines @@
   scoped_ptr<RenderPass> root_pass =
       CreateTestRootRenderPass(root_pass_id, viewport_rect);
   root_pass->has_transparent_background = false;
 
   RenderPassId child_pass_id(2, 2);
   gfx::Rect pass_rect(this->device_viewport_size_);
   gfx::Transform transform_to_root;
   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,
                       this->device_viewport_size_.width(),
                       this->device_viewport_size_.height());
   SolidColorDrawQuad* blue =
       child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false);
 
   SharedQuadState* pass_shared_state =
@@ skipping 34 matching lines @@
       ExactPixelComparator(true)));
 }
 
 // Software renderer does not support anti-aliased edges.
 TEST_F(GLRendererPixelTest, AntiAliasing) {
   gfx::Rect rect(this->device_viewport_size_);
 
   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>();
   blue->SetNew(blue_shared_state, rect, rect, SK_ColorBLUE, false);
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
 
   EXPECT_TRUE(this->RunPixelTest(
       &pass_list,
       base::FilePath(FILE_PATH_LITERAL("anti_aliasing.png")),
       FuzzyPixelOffByOneComparator(true)));
 }
 
 // This test tests that anti-aliasing works for axis aligned quads.
 // Anti-aliasing is only supported in the gl renderer.
 TEST_F(GLRendererPixelTest, AxisAligned) {
   gfx::Rect rect(this->device_viewport_size_);
 
   RenderPassId id(1, 1);
   gfx::Transform transform_to_root;
   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>();
   blue->SetNew(blue_shared_state, rect, rect, SK_ColorBLUE, false);
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
 
   EXPECT_TRUE(this->RunPixelTest(
       &pass_list,
       base::FilePath(FILE_PATH_LITERAL("axis_aligned.png")),
       ExactPixelComparator(true)));
 }
 
 // This test tests that forcing anti-aliasing off works as expected.
 // Anti-aliasing is only supported in the gl renderer.
 TEST_F(GLRendererPixelTest, ForceAntiAliasingOff) {
   gfx::Rect rect(this->device_viewport_size_);
 
   RenderPassId id(1, 1);
   gfx::Transform transform_to_root;
   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>();
   green->SetNew(green_shared_state, rect, rect, SK_ColorGREEN, false);
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
 
   EXPECT_TRUE(this->RunPixelTest(
       &pass_list,
       base::FilePath(FILE_PATH_LITERAL("force_anti_aliasing_off.png")),
       ExactPixelComparator(false)));
 }
 
 TEST_F(GLRendererPixelTest, AntiAliasingPerspective) {
   gfx::Rect rect(this->device_viewport_size_);
 
   scoped_ptr<RenderPass> pass =
       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);
 
   gfx::Rect green_rect(19, 7, 180, 10);
   SharedQuadState* green_shared_state =
       CreateTestSharedQuadState(gfx::Transform(), green_rect, pass.get());
   SolidColorDrawQuad* green =
       pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   green->SetNew(
       green_shared_state, green_rect, green_rect, SK_ColorGREEN, false);
@@ skipping 36 matching lines @@
   red_paint.setColor(SK_ColorRED);
   blue_recording->add_draw_rect_with_paint(blue_rect, red_paint);
   SkPaint blue_paint;
   blue_paint.setColor(SK_ColorBLUE);
   blue_recording->add_draw_rect_with_paint(blue_clip_rect, blue_paint);
   blue_recording->Rerecord();
 
   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>();
 
   blue_quad->SetNew(blue_shared_state,
                     viewport,  // Intentionally bigger than clip.
                     gfx::Rect(), viewport, gfx::RectF(viewport),
                     viewport.size(), nearest_neighbor, texture_format, viewport,
                     1.f, blue_pile.get());
 
   // One viewport-filling green quad.
   scoped_ptr<FakePicturePile> green_recording =
       FakePicturePile::CreateFilledPile(pile_tile_size, viewport.size());
   SkPaint green_paint;
   green_paint.setColor(SK_ColorGREEN);
   green_recording->add_draw_rect_with_paint(viewport, green_paint);
   green_recording->Rerecord();
   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>();
   green_quad->SetNew(green_shared_state, viewport, gfx::Rect(), viewport,
                      gfx::RectF(0.f, 0.f, 1.f, 1.f), viewport.size(),
                      nearest_neighbor, texture_format, viewport, 1.f,
                      green_pile.get());
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
@@ skipping 19 matching lines @@
   // One viewport-filling 0.5-opacity green quad.
   scoped_ptr<FakePicturePile> green_recording =
       FakePicturePile::CreateFilledPile(pile_tile_size, viewport.size());
   SkPaint green_paint;
   green_paint.setColor(SK_ColorGREEN);
   green_recording->add_draw_rect_with_paint(viewport, green_paint);
   green_recording->Rerecord();
   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 =
       pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
   green_quad->SetNew(green_shared_state, viewport, gfx::Rect(), viewport,
                      gfx::RectF(0, 0, 1, 1), viewport.size(), nearest_neighbor,
                      texture_format, viewport, 1.f, green_pile.get());
 
   // One viewport-filling white quad.
   scoped_ptr<FakePicturePile> white_recording =
       FakePicturePile::CreateFilledPile(pile_tile_size, viewport.size());
   SkPaint white_paint;
   white_paint.setColor(SK_ColorWHITE);
   white_recording->add_draw_rect_with_paint(viewport, white_paint);
   white_recording->Rerecord();
   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>();
   white_quad->SetNew(white_shared_state, viewport, gfx::Rect(), viewport,
                      gfx::RectF(0, 0, 1, 1), viewport.size(), nearest_neighbor,
                      texture_format, viewport, 1.f, white_pile.get());
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
 
@@ skipping 48 matching lines @@
 
   scoped_ptr<FakePicturePile> recording =
       FakePicturePile::CreateFilledPile(pile_tile_size, viewport.size());
   SkPaint paint;
   paint.setFilterQuality(kLow_SkFilterQuality);
   recording->add_draw_bitmap_with_paint(bitmap, gfx::Point(), paint);
   recording->Rerecord();
   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,
                gfx::RectF(0, 0, 2, 2), viewport.size(), nearest_neighbor,
                texture_format, viewport, 1.f, pile.get());
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
 
   this->disable_picture_quad_image_filtering_ = true;
@@ skipping 29 matching lines @@
 
   scoped_ptr<FakePicturePile> recording =
       FakePicturePile::CreateFilledPile(pile_tile_size, viewport.size());
   SkPaint paint;
   paint.setFilterQuality(kLow_SkFilterQuality);
   recording->add_draw_bitmap_with_paint(bitmap, gfx::Point(), paint);
   recording->Rerecord();
   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,
                gfx::RectF(0, 0, 2, 2), viewport.size(), nearest_neighbor,
                texture_format, viewport, 1.f, pile.get());
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
 
   EXPECT_TRUE(this->RunPixelTest(
@@ skipping 28 matching lines @@
     SkAutoLockPixels lock(bitmap);
     this->resource_provider_->CopyToResource(
         resource, static_cast<uint8_t*>(bitmap.getPixels()), tile_size);
   }
 
   RenderPassId id(1, 1);
   gfx::Transform transform_to_root;
   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,
                gfx::Rect(tile_size), tile_size, swizzle_contents,
                nearest_neighbor);
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
 
   EXPECT_TRUE(this->RunPixelTest(
@@ skipping 28 matching lines @@
     SkAutoLockPixels lock(bitmap);
     this->resource_provider_->CopyToResource(
         resource, static_cast<uint8_t*>(bitmap.getPixels()), tile_size);
   }
 
   RenderPassId id(1, 1);
   gfx::Transform transform_to_root;
   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>();
   quad->SetNew(shared_state, viewport, gfx::Rect(), viewport, resource, false,
                gfx::PointF(0, 0), gfx::PointF(1, 1), SK_ColorBLACK,
                vertex_opacity, false, nearest_neighbor);
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
 
@@ skipping 29 matching lines @@
     SkAutoLockPixels lock(bitmap);
     this->resource_provider_->CopyToResource(
         resource, static_cast<uint8_t*>(bitmap.getPixels()), tile_size);
   }
 
   RenderPassId id(1, 1);
   gfx::Transform transform_to_root;
   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>();
   quad->SetNew(shared_state, viewport, gfx::Rect(), viewport, resource, false,
                gfx::PointF(0, 0), gfx::PointF(1, 1), SK_ColorBLACK,
                vertex_opacity, false, nearest_neighbor);
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
 
@@ skipping 14 matching lines @@
 
   RenderPassId id(1, 1);
   gfx::Transform transform_to_root;
   scoped_ptr<RenderPass> pass =
       CreateTestRenderPass(id, viewport, transform_to_root);
 
   // As scaling up the blue checkerboards will cause sampling on the GPU,
   // 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));
 
   scoped_ptr<FakePicturePile> green_recording =
       FakePicturePile::CreateFilledPile(pile_tile_size, viewport.size());
 
   SkPaint red_paint;
   red_paint.setColor(SK_ColorRED);
   green_recording->add_draw_rect_with_paint(viewport, red_paint);
   SkPaint green_paint;
   green_paint.setColor(SK_ColorGREEN);
   green_recording->add_draw_rect_with_paint(green_rect1, green_paint);
   green_recording->add_draw_rect_with_paint(green_rect2, green_paint);
   green_recording->Rerecord();
   scoped_refptr<FakePicturePileImpl> green_pile =
       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>();
   green_quad1->SetNew(top_right_green_shared_quad_state, green_rect1,
                       gfx::Rect(), green_rect1, gfx::RectF(green_rect1.size()),
                       green_rect1.size(), nearest_neighbor, texture_format,
                       green_rect1, 1.f, green_pile.get());
 
   PictureDrawQuad* green_quad2 =
       pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
   green_quad2->SetNew(top_right_green_shared_quad_state, green_rect2,
                       gfx::Rect(), green_rect2, gfx::RectF(green_rect2.size()),
                       green_rect2.size(), nearest_neighbor, texture_format,
                       green_rect2, 1.f, green_pile.get());
 
   // Add a green clipped checkerboard in the bottom right to help test
   // interleaving picture quad content and solid color content.
   gfx::Rect bottom_right_rect(
       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,
                                   viewport,
                                   viewport,
                                   SK_ColorGREEN,
                                   false);
 
   // Add two blue checkerboards taking up the bottom left and top right,
   // but use content scales as content rects to make this happen.
@@ skipping 29 matching lines @@
   scoped_refptr<FakePicturePileImpl> pile =
       FakePicturePileImpl::CreateFromPile(recording.get(), nullptr);
 
   gfx::Rect content_rect(
       gfx::ScaleToEnclosingRect(layer_rect, contents_scale));
   gfx::Rect content_union_rect(
       gfx::ToEnclosingRect(gfx::ScaleRect(union_layer_rect, contents_scale)));
 
   // 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(),
                     quad_content_rect, gfx::RectF(quad_content_rect),
                     content_union_rect.size(), nearest_neighbor, texture_format,
                     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,
                           half_green_rect,
                           half_green_rect,
                           SK_ColorGREEN,
                           false);
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
@@ skipping 14 matching lines @@
   RenderPassId root_pass_id(1, 1);
   scoped_ptr<RenderPass> root_pass =
       CreateTestRootRenderPass(root_pass_id, viewport_rect);
 
   RenderPassId child_pass_id(2, 2);
   gfx::Rect pass_rect(this->device_viewport_size_);
   gfx::Transform transform_to_root;
   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,
                       this->device_viewport_size_.width(),
                       this->device_viewport_size_.height() / 2);
   SolidColorDrawQuad* blue =
       child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false);
   gfx::Rect yellow_rect(0,
                         this->device_viewport_size_.height() / 2,
@@ skipping 25 matching lines @@
   RenderPassId root_pass_id(1, 1);
   scoped_ptr<RenderPass> root_pass =
       CreateTestRootRenderPass(root_pass_id, viewport_rect);
 
   RenderPassId child_pass_id(2, 2);
   gfx::Rect pass_rect(this->device_viewport_size_);
   gfx::Transform transform_to_root;
   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,
                       this->device_viewport_size_.width(),
                       this->device_viewport_size_.height() / 2);
   SolidColorDrawQuad* blue =
       child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false);
   gfx::Rect yellow_rect(0,
                         this->device_viewport_size_.height() / 2,
@@ skipping 26 matching lines @@
   RenderPassId root_pass_id(1, 1);
   scoped_ptr<RenderPass> root_pass =
       CreateTestRootRenderPass(root_pass_id, viewport_rect);
 
   RenderPassId child_pass_id(2, 2);
   gfx::Rect pass_rect(this->device_viewport_size_);
   gfx::Transform transform_to_root;
   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,
                       this->device_viewport_size_.height() * 3 / 4,
                       this->device_viewport_size_.width() * 3 / 4,
                       this->device_viewport_size_.height() * 3 / 4);
   SolidColorDrawQuad* blue =
       child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false);
   gfx::Rect green_rect(0,
@@ skipping 178 matching lines @@
           ? FILE_PATH_LITERAL("four_blue_green_checkers.png")
           : FILE_PATH_LITERAL("checkers_big.png");
   EXPECT_TRUE(this->RunPixelTest(&pass_list, base::FilePath(path),
                                  ExactPixelComparator(true)));
 }
 
 #endif  // !defined(OS_ANDROID)
 
 }  // namespace
 }  // namespace cc