cc: Rename visible_content_rect and content stuff on quads.

cc/surfaces/surface_aggregator_unittest.cc

 // Copyright 2014 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 "cc/output/compositor_frame.h"
 #include "cc/output/delegated_frame_data.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/surface_draw_quad.h"
@@ skipping 672 matching lines @@
   ASSERT_EQ(render_pass_quads[1]->material, DrawQuad::RENDER_PASS);
   EXPECT_EQ(
       actual_pass_ids[1],
       RenderPassDrawQuad::MaterialCast(render_pass_quads[1])->render_pass_id);
   factory_.Destroy(child_surface_id);
 }
 
 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;
   float opacity = 1.f;
 
   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);
 }
 
 // This tests that we update shared quad state pointers correctly within
 // aggregated passes.  The shared quad state list on the aggregated pass will
 // include the shared quad states from each pass in one list so the quads will
 // end up pointed to shared quad state objects at different offsets. This test
 // uses the blend_mode value stored on the shared quad state to track the shared
 // quad state, but anything saved on the shared quad state would work.
 //
@@ skipping 154 matching lines @@
                    child_pass_id[1])};
 
     RenderPassList child_pass_list;
     AddPasses(&child_pass_list, gfx::Rect(SurfaceSize()), child_passes,
               arraysize(child_passes));
 
     RenderPass* child_nonroot_pass = child_pass_list.at(0u);
     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);
 
     scoped_ptr<DelegatedFrameData> child_frame_data(new DelegatedFrameData);
     child_pass_list.swap(child_frame_data->render_pass_list);
 
     scoped_ptr<CompositorFrame> child_frame(new CompositorFrame);
     child_frame->delegated_frame_data = child_frame_data.Pass();
 
     factory_.SubmitFrame(child_surface_id, child_frame.Pass(),
@@ skipping 12 matching lines @@
 
     RenderPassList middle_pass_list;
     AddPasses(&middle_pass_list, gfx::Rect(SurfaceSize()), middle_passes,
               arraysize(middle_passes));
 
     RenderPass* middle_root_pass = middle_pass_list.at(0u);
     middle_root_pass->quad_list.ElementAt(0)->visible_rect =
         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);
 
     scoped_ptr<CompositorFrame> middle_frame(new CompositorFrame);
     middle_frame->delegated_frame_data = middle_frame_data.Pass();
 
     factory_.SubmitFrame(middle_surface_id, middle_frame.Pass(),
                          SurfaceFactory::DrawCallback());
   }
 
   // Root surface.
   test::Quad secondary_quads[] = {
       test::Quad::SolidColorQuad(1),
       test::Quad::SurfaceQuad(middle_surface_id, 1.f)};
   test::Quad root_quads[] = {test::Quad::SolidColorQuad(1)};
   test::Pass root_passes[] = {
       test::Pass(secondary_quads, arraysize(secondary_quads)),
       test::Pass(root_quads, arraysize(root_quads))};
 
   RenderPassList root_pass_list;
   AddPasses(&root_pass_list,
             gfx::Rect(SurfaceSize()),
             root_passes,
             arraysize(root_passes));
 
   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);
 
   root_pass_list[0]->transform_to_root_target.Translate(10, 5);
 
   scoped_ptr<DelegatedFrameData> root_frame_data(new DelegatedFrameData);
   root_pass_list.swap(root_frame_data->render_pass_list);
 
   scoped_ptr<CompositorFrame> root_frame(new CompositorFrame);
   root_frame->delegated_frame_data = root_frame_data.Pass();
@@ skipping 25 matching lines @@
   EXPECT_EQ(1u, aggregated_pass_list[2]->shared_quad_state_list.size());
 
   SharedQuadState* aggregated_first_pass_sqs =
       aggregated_pass_list[0]->shared_quad_state_list.front();
 
   // The first pass's transform should be unaffected by the embedding and still
   // be a translation by +5 in the x direction.
   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.
   gfx::Transform expected_first_pass_transform_to_root_target;
   expected_first_pass_transform_to_root_target.Translate(10, 5);
   expected_first_pass_transform_to_root_target.Translate(0, 10);
   expected_first_pass_transform_to_root_target.Scale(2, 3);
   expected_first_pass_transform_to_root_target.Translate(8, 0);
   EXPECT_EQ(expected_first_pass_transform_to_root_target.ToString(),
             aggregated_pass_list[0]->transform_to_root_target.ToString());
@@ skipping 10 matching lines @@
   // (0, 10), the middle surface draw quad's scale of (2, 3), and the
   // child surface draw quad's translation (8, 0).
   expected_root_pass_quad_transforms[1].Translate(0, 10);
   expected_root_pass_quad_transforms[1].Scale(2, 3);
   expected_root_pass_quad_transforms[1].Translate(8, 0);
 
   for (auto iter = aggregated_pass_list[1]->quad_list.cbegin();
        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();
   }
 
   EXPECT_TRUE(
       aggregated_pass_list[1]->shared_quad_state_list.ElementAt(1)->is_clipped);
 
   // The second quad in the root pass is aggregated from the child, so its
   // clip rect must be transformed by the child's translation/scale and
   // clipped be the visible_rects for both children.
   EXPECT_EQ(gfx::Rect(0, 13, 8, 12).ToString(),
@@ skipping 16 matching lines @@
 
   RenderPassList child_pass_list;
   AddPasses(&child_pass_list,
             gfx::Rect(SurfaceSize()),
             child_passes,
             arraysize(child_passes));
 
   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);
 
   scoped_ptr<CompositorFrame> child_frame(new CompositorFrame);
   child_frame->delegated_frame_data = child_frame_data.Pass();
 
   factory_.SubmitFrame(child_surface_id, child_frame.Pass(),
                        SurfaceFactory::DrawCallback());
 
   RenderPassId pass_id(5, 10);
   test::Quad first_quads[] = {test::Quad::SurfaceQuad(child_surface_id, 1.f)};
   test::Quad root_quads[] = {test::Quad::RenderPassQuad(pass_id)};
 
   test::Pass root_passes[] = {
       test::Pass(first_quads, arraysize(first_quads), pass_id),
       test::Pass(root_quads, arraysize(root_quads))};
 
   RenderPassList root_pass_list;
   AddPasses(&root_pass_list,
             gfx::Rect(SurfaceSize()),
             root_passes,
             arraysize(root_passes));
 
   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);
 
   scoped_ptr<DelegatedFrameData> root_frame_data(new DelegatedFrameData);
   root_pass_list.swap(root_frame_data->render_pass_list);
 
   scoped_ptr<CompositorFrame> root_frame(new CompositorFrame);
   root_frame->delegated_frame_data = root_frame_data.Pass();
 
   factory_.SubmitFrame(root_surface_id_, root_frame.Pass(),
@@ skipping 17 matching lines @@
 
   {
     AddPasses(&child_pass_list,
               gfx::Rect(SurfaceSize()),
               child_passes,
               arraysize(child_passes));
 
     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);
     child_pass_list.swap(child_frame_data->render_pass_list);
 
     scoped_ptr<CompositorFrame> child_frame(new CompositorFrame);
     child_frame->delegated_frame_data = child_frame_data.Pass();
 
     factory_.SubmitFrame(child_surface_id, child_frame.Pass(),
                          SurfaceFactory::DrawCallback());
@@ skipping 19 matching lines @@
 
   {
     RenderPassList root_pass_list;
     AddPasses(&root_pass_list,
               gfx::Rect(SurfaceSize()),
               root_passes,
               arraysize(root_passes));
 
     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);
     root_pass_list.swap(root_frame_data->render_pass_list);
 
     scoped_ptr<CompositorFrame> root_frame(new CompositorFrame);
     root_frame->delegated_frame_data = root_frame_data.Pass();
 
     factory_.SubmitFrame(root_surface_id_, root_frame.Pass(),
                          SurfaceFactory::DrawCallback());
   }
 
   {
     RenderPassList root_pass_list;
     AddPasses(&root_pass_list,
               gfx::Rect(SurfaceSize()),
               root_passes,
               arraysize(root_passes));
 
     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);
     root_pass_list.swap(root_frame_data->render_pass_list);
 
     scoped_ptr<CompositorFrame> root_frame(new CompositorFrame);
     root_frame->delegated_frame_data = root_frame_data.Pass();
 
     factory_.SubmitFrame(root_surface_id_, root_frame.Pass(),
                          SurfaceFactory::DrawCallback());
@@ skipping 292 matching lines @@
   EXPECT_EQ(9u, pass_list->back()->quad_list.size());
 
   factory.Destroy(root_surface_id);
   factory.Destroy(child_surface_id);
   factory.Destroy(middle_surface_id);
 }
 
 }  // namespace
 }  // namespace cc