cc: Chromify Layer and LayerImpl classes.

cc/damage_tracker.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/damage_tracker.h"
 
 #include "cc/layer_impl.h"
 #include "cc/layer_tree_host_common.h"
 #include "cc/math_util.h"
 #include "cc/render_surface_impl.h"
@@ skipping 192 matching lines @@
 gfx::RectF DamageTracker::TrackDamageFromSurfaceMask(
     LayerImpl* target_surface_mask_layer) {
   gfx::RectF damage_rect = gfx::RectF();
 
   if (!target_surface_mask_layer)
     return damage_rect;
 
   // Currently, if there is any change to the mask, we choose to damage the
   // entire surface. This could potentially be optimized later, but it is not
   // expected to be a common case.
-  if (target_surface_mask_layer->layerPropertyChanged() ||
-      !target_surface_mask_layer->updateRect().IsEmpty()) {
+  if (target_surface_mask_layer->LayerPropertyChanged() ||
+      !target_surface_mask_layer->update_rect().IsEmpty()) {
     damage_rect = gfx::RectF(gfx::PointF(),
                              target_surface_mask_layer->bounds());
   }
 
   return damage_rect;
 }
 
 gfx::RectF DamageTracker::TrackDamageFromLeftoverRects() {
   // After computing damage for all active layers, any leftover items in the
   // current rect history correspond to layers/surfaces that no longer exist.
@@ skipping 10 matching lines @@
 
   return damage_rect;
 }
 
 static bool LayerNeedsToRedrawOntoItsTargetSurface(LayerImpl* layer) {
   // If the layer does NOT own a surface but has SurfacePropertyChanged,
   // this means that its target surface is affected and needs to be redrawn.
   // However, if the layer DOES own a surface, then the SurfacePropertyChanged 
   // flag should not be used here, because that flag represents whether the
   // layer's surface has changed.
-  if (layer->renderSurface())
-    return layer->layerPropertyChanged();
-  return layer->layerPropertyChanged() || layer->layerSurfacePropertyChanged();
+  if (layer->render_surface())
+    return layer->LayerPropertyChanged();
+  return layer->LayerPropertyChanged() || layer->LayerSurfacePropertyChanged();
 }
 
 void DamageTracker::ExtendDamageForLayer(LayerImpl* layer,
                                          gfx::RectF* target_damage_rect) {
   // There are two ways that a layer can damage a region of the target surface:
   //   1. Property change (e.g. opacity, position, transforms):
   //        - the entire region of the layer itself damages the surface.
   //        - the old layer region also damages the surface, because this region
   //          is now exposed.
   //        - note that in many cases the old and new layer rects may overlap,
   //          which is fine.
   //
   //   2. Repaint/update: If a region of the layer that was repainted/updated,
   //      that region damages the surface.
   //
   // Property changes take priority over update rects.
   //
   // This method is called when we want to consider how a layer contributes to
   // its targetRenderSurface, even if that layer owns the targetRenderSurface
   // itself. To consider how a layer's targetSurface contributes to the
   // ancestorSurface, ExtendDamageForRenderSurface() must be called instead.
 
   bool layer_is_new = false;
   gfx::RectF old_rect_in_target_space =
       RemoveRectFromCurrentFrame(layer->id(), &layer_is_new);
 
   gfx::RectF rect_in_target_space = MathUtil::mapClippedRect(
-      layer->drawTransform(),
-      gfx::RectF(gfx::PointF(), layer->contentBounds()));
+      layer->draw_transform(),
+      gfx::RectF(gfx::PointF(), layer->content_bounds()));
   SaveRectForNextFrame(layer->id(), rect_in_target_space);
 
   if (layer_is_new || LayerNeedsToRedrawOntoItsTargetSurface(layer)) {
     // If a layer is new or has changed, then its entire layer rect affects the
     // target surface.
     target_damage_rect->Union(rect_in_target_space);
 
     // The layer's old region is now exposed on the target surface, too.
     // Note old_rect_in_target_space is already in target space.
     target_damage_rect->Union(old_rect_in_target_space);
-  } else if (!layer->updateRect().IsEmpty()) {
+  } else if (!layer->update_rect().IsEmpty()) {
     // If the layer properties haven't changed, then the the target surface is
     // only affected by the layer's update area, which could be empty.
     gfx::RectF update_content_rect =
-        layer->layerRectToContentRect(layer->updateRect());
+        layer->LayerRectToContentRect(layer->update_rect());
     gfx::RectF update_rect_in_target_space =
-        MathUtil::mapClippedRect(layer->drawTransform(), update_content_rect);
+        MathUtil::mapClippedRect(layer->draw_transform(), update_content_rect);
     target_damage_rect->Union(update_rect_in_target_space);
   }
 }
 
 void DamageTracker::ExtendDamageForRenderSurface(
     LayerImpl* layer, gfx::RectF* target_damage_rect) {
   // There are two ways a "descendant surface" can damage regions of the "target
   // surface":
   //   1. Property change:
   //        - a surface's geometry can change because of
   //            - changes to descendants (i.e. the subtree) that affect the
   //              surface's content rect
   //            - changes to ancestor layers that propagate their property
   //              changes to their entire subtree.
   //        - just like layers, both the old surface rect and new surface rect
   //          will damage the target surface in this case.
   //
   //   2. Damage rect: This surface may have been damaged by its own layer_list
   //      as well, and that damage should propagate to the target surface.
   //
 
-  RenderSurfaceImpl* render_surface = layer->renderSurface();
+  RenderSurfaceImpl* render_surface = layer->render_surface();
 
   bool surface_is_new = false;
   gfx::RectF old_surface_rect = RemoveRectFromCurrentFrame(layer->id(),
                                                            &surface_is_new);
 
   // The drawableContextRect() already includes the replica if it exists.
   gfx::RectF surface_rect_in_target_space =
       render_surface->DrawableContentRect();
   SaveRectForNextFrame(layer->id(), surface_rect_in_target_space);
 
   gfx::RectF damage_rect_in_local_space;
   if (surface_is_new ||
       render_surface->SurfacePropertyChanged() ||
-      layer->layerSurfacePropertyChanged()) {
+      layer->LayerSurfacePropertyChanged()) {
     // The entire surface contributes damage.
     damage_rect_in_local_space = render_surface->content_rect();
 
     // The surface's old region is now exposed on the target surface, too.
     target_damage_rect->Union(old_surface_rect);
   } else {
     // Only the surface's damage_rect will damage the target surface.
     damage_rect_in_local_space =
         render_surface->damage_tracker()->current_damage_rect();
   }
 
   // If there was damage, transform it to target space, and possibly contribute
   // its reflection if needed.
   if (!damage_rect_in_local_space.IsEmpty()) {
     const gfx::Transform& draw_transform = render_surface->draw_transform();
     gfx::RectF damage_rect_in_target_space =
         MathUtil::mapClippedRect(draw_transform, damage_rect_in_local_space);
     target_damage_rect->Union(damage_rect_in_target_space);
 
-    if (layer->replicaLayer()) {
+    if (layer->replica_layer()) {
       const gfx::Transform& replica_draw_transform =
           render_surface->replica_draw_transform();
       target_damage_rect->Union(MathUtil::mapClippedRect(
           replica_draw_transform, damage_rect_in_local_space));
     }
   }
 
   // If there was damage on the replica's mask, then the target surface receives
   // that damage as well.
-  if (layer->replicaLayer() && layer->replicaLayer()->maskLayer()) {
-    LayerImpl* replica_mask_layer = layer->replicaLayer()->maskLayer();
+  if (layer->replica_layer() && layer->replica_layer()->mask_layer()) {
+    LayerImpl* replica_mask_layer = layer->replica_layer()->mask_layer();
 
     bool replica_is_new = false;
     RemoveRectFromCurrentFrame(replica_mask_layer->id(), &replica_is_new);
 
     const gfx::Transform& replica_draw_transform =
         render_surface->replica_draw_transform();
     gfx::RectF replica_mask_layer_rect = MathUtil::mapClippedRect(
         replica_draw_transform,
         gfx::RectF(gfx::PointF(), replica_mask_layer->bounds()));
     SaveRectForNextFrame(replica_mask_layer->id(), replica_mask_layer_rect);
 
     // In the current implementation, a change in the replica mask damages the
     // entire replica region.
     if (replica_is_new ||
-        replica_mask_layer->layerPropertyChanged() ||
-        !replica_mask_layer->updateRect().IsEmpty())
+        replica_mask_layer->LayerPropertyChanged() ||
+        !replica_mask_layer->update_rect().IsEmpty())
       target_damage_rect->Union(replica_mask_layer_rect);
   }
 
   // If the layer has a background filter, this may cause pixels in our surface
   // to be expanded, so we will need to expand any damage at or below this
   // layer. We expand the damage from this layer too, as we need to readback
   // those pixels from the surface with only the contents of layers below this
   // one in them. This means we need to redraw any pixels in the surface being
   // used for the blur in this layer this frame.
-  if (layer->backgroundFilters().hasFilterThatMovesPixels()) {
+  if (layer->background_filters().hasFilterThatMovesPixels()) {
     ExpandDamageRectInsideRectWithFilters(target_damage_rect,
                                           surface_rect_in_target_space,
-                                          layer->backgroundFilters());
+                                          layer->background_filters());
   }
 }
 
 }  // namespace cc