cc: Rename visible_content_rect and content stuff on quads.

cc/trees/layer_tree_host_common.cc

 // Copyright 2011 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/trees/layer_tree_host_common.h"
 
 #include <algorithm>
 
 #include "base/trace_event/trace_event.h"
 #include "cc/base/math_util.h"
@@ skipping 352 matching lines @@
   // visibility for themselves.
   return false;
 }
 
 template <typename LayerType>
 static inline bool LayerClipsSubtree(LayerType* layer) {
   return layer->masks_to_bounds() || layer->mask_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) {
   DCHECK(layer->render_target());
 
   // Nothing is visible if the layer bounds are empty.
   if (!layer->DrawsContent() || layer->bounds().IsEmpty() ||
       layer->drawable_content_rect().IsEmpty())
     return gfx::Rect();
 
@@ skipping 41 matching lines @@
   //   - is not drawn due to it or one of its ancestors being hidden (or having
   //     no copy requests).
   //   - does not draw content.
   //   - is transparent.
   //   - has empty bounds
   //   - the layer is not double-sided, but its back face is visible.
   //
   // 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
   // into this function, so it is safe to omit this check here.
 
   if (!layer_is_drawn)
     return true;
 
   if (!layer->DrawsContent() || layer->bounds().IsEmpty())
     return true;
@@ skipping 1464 matching lines @@
         render_surface->draw_transform());
 
     // A render surface inherently acts as a flattening point for the content of
     // its descendants.
     data_for_children.full_hierarchy_matrix.FlattenTo2d();
 
     if (layer->mask_layer()) {
       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());
     }
 
     if (layer->replica_layer() && layer->replica_layer()->mask_layer()) {
       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());
     }
 
     // Ignore occlusion from outside the surface when surface contents need to
     // be fully drawn. Layers with copy-request need to be complete.
     // We could be smarter about layers with replica and exclude regions
     // where both layer and the replica are occluded, but this seems like an
     // overkill. The same is true for layers with filters that move pixels.
     // TODO(senorblanco): make this smarter for the SkImageFilter case (check
     // for pixel-moving filters)
@@ skipping 276 matching lines @@
   if (layer_or_ancestor_clips_descendants) {
     layer_draw_properties.drawable_content_rect.Intersect(
         clip_rect_in_target_space);
   }
   if (layer->DrawsContent()) {
     local_drawable_content_rect_of_subtree.Union(
         layer_draw_properties.drawable_content_rect);
   }
 
   // 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
   // one.
   if (IsRootLayer(layer)) {
     // The root layer's surface's content_rect is always the entire viewport.
     DCHECK(render_to_separate_surface);
     layer->render_surface()->SetContentRect(
         ancestor_clip_rect_in_target_space);
   } else if (render_to_separate_surface) {
@@ skipping 238 matching lines @@
     }
   }
 
   return true;
 }
 
 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();
 
   const bool draw_transforms_match =
       ApproximatelyEqual(current_layer->draw_transform(),
                          DrawTransformFromPropertyTrees(
                              current_layer, property_trees->transform_tree));
   CHECK(draw_transforms_match)
       << "expected: " << current_layer->draw_transform().ToString()
       << " actual: "
@@ skipping 145 matching lines @@
 
 PropertyTrees* GetPropertyTrees(Layer* layer) {
   return layer->layer_tree_host()->property_trees();
 }
 
 PropertyTrees* GetPropertyTrees(LayerImpl* layer) {
   return layer->layer_tree_impl()->property_trees();
 }
 
 }  // namespace cc