cc: Rename visible_content_rect and content stuff on quads.

cc/surfaces/surface_aggregator.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/surfaces/surface_aggregator.h"
 
 #include <map>
 
 #include "base/bind.h"
 #include "base/containers/hash_tables.h"
@@ skipping 241 matching lines @@
     copy_pass->SetAll(remapped_pass_id, source.output_rect, gfx::Rect(),
                       source.transform_to_root_target,
                       source.has_transparent_background);
 
     MoveMatchingRequests(source.id, &copy_requests, &copy_pass->copy_requests);
 
     // Contributing passes aggregated in to the pass list need to take the
     // 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);
 
     CopyQuadsToPass(source.quad_list, source.shared_quad_state_list,
                     child_to_parent_map, gfx::Transform(), ClipData(),
                     copy_pass.get(), surface_id);
 
     if (j == referenced_passes.size() - 1)
       surface_damage = gfx::UnionRects(surface_damage, copy_pass->damage_rect);
 
     dest_pass_list_->push_back(copy_pass.Pass());
   }
 
   const RenderPass& last_pass = *render_pass_list.back();
   if (merge_pass) {
     // TODO(jamesr): Clean up last pass special casing.
     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(
           surface_quad->shared_quad_state->clip_rect);
     }
 
     ClipData quads_clip =
         CalculateClipRect(clip_rect, surface_quad_clip_rect, target_transform);
 
     CopyQuadsToPass(quads, last_pass.shared_quad_state_list,
@@ skipping 16 matching lines @@
                  0,
                  gfx::Vector2dF(),
                  gfx::Size(),
                  FilterOperations(),
                  gfx::Vector2dF(),
                  FilterOperations());
   }
   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);
 }
 
 void SurfaceAggregator::CopySharedQuadState(
     const SharedQuadState* source_sqs,
     const gfx::Transform& target_transform,
     const ClipData& clip_rect,
     RenderPass* dest_render_pass) {
   SharedQuadState* copy_shared_quad_state =
       dest_render_pass->CreateAndAppendSharedQuadState();
   copy_shared_quad_state->CopyFrom(source_sqs);
   // target_transform contains any transformation that may exist
   // between the context that these quads are being copied from (i.e. the
   // surface's draw transform when aggregated from within a surface) to the
   // 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(
       clip_rect, ClipData(source_sqs->is_clipped, source_sqs->clip_rect),
       target_transform);
   copy_shared_quad_state->is_clipped = new_clip_rect.is_clipped;
   copy_shared_quad_state->clip_rect = new_clip_rect.rect;
 }
 
 void SurfaceAggregator::CopyQuadsToPass(
@@ skipping 39 matching lines @@
             break;
           }
         }
 
         dest_quad = dest_pass->CopyFromAndAppendRenderPassDrawQuad(
             pass_quad, dest_pass->shared_quad_state_list.back(),
             remapped_pass_id);
         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(
             quad, dest_pass->shared_quad_state_list.back());
       }
       if (!child_to_parent_map.empty()) {
         for (ResourceId& resource_id : dest_quad->resources) {
           ResourceProvider::ResourceIdMap::const_iterator it =
               child_to_parent_map.find(resource_id);
           DCHECK(it != child_to_parent_map.end());
@@ skipping 128 matching lines @@
 
 void SurfaceAggregator::SetFullDamageForSurface(SurfaceId surface_id) {
   auto it = previous_contained_surfaces_.find(surface_id);
   if (it == previous_contained_surfaces_.end())
     return;
   // Set the last drawn index as 0 to ensure full damage next time it's drawn.
   it->second = 0;
 }
 
 }  // namespace cc