cc: Fix capitalization style in chromified files.

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/debug/trace_event.h"
 #include "cc/base/math_util.h"
@@ skipping 139 matching lines @@
   if (!layer->DrawsContent() || layer->content_bounds().IsEmpty() ||
       layer->drawable_content_rect().IsEmpty())
     return gfx::Rect();
 
   // Compute visible bounds in target surface space.
   gfx::Rect visible_rect_in_target_surface_space =
       layer->drawable_content_rect();
 
   if (!layer->render_target()->render_surface()->clip_rect().IsEmpty()) {
     // In this case the target surface does clip layers that contribute to
-    // it. So, we have to convert the current surface's clipRect from its
+    // it. So, we have to convert the current surface's clip rect from its
     // ancestor surface space to the current (descendant) surface
     // space. This conversion is done outside this function so that it can
     // be cached instead of computing it redundantly for every layer.
     visible_rect_in_target_surface_space.Intersect(
         ancestor_clip_rect_in_descendant_surface_space);
   }
 
   if (visible_rect_in_target_surface_space.IsEmpty())
     return gfx::Rect();
 
@@ skipping 20 matching lines @@
 template <typename LayerType>
 static bool LayerShouldBeSkipped(LayerType* layer) {
   // Layers can be skipped if any of these conditions are met.
   //   - 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 clipRect is empty
-  //   - the visibleContentRect is empty
+  //   - the intersection of render_surface content and layer clip_rect is empty
+  //   - the visible_content_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->DrawsContent() || layer->bounds().IsEmpty())
     return true;
 
   LayerType* backface_test_layer = layer;
   if (layer->use_parent_backface_visibility()) {
@@ skipping 24 matching lines @@
   // unreliable (since the impl thread may be using a different opacity), so it
   // should not be trusted.
   // In particular, it should not cause the subtree to be skipped.
   // Similarly, for layers that might animate opacity using an impl-only
   // animation, their subtree should also not be skipped.
   return !layer->opacity() && !layer->OpacityIsAnimating() &&
          !layer->OpacityCanAnimateOnImplThread();
 }
 
 // Called on each layer that could be drawn after all information from
-// calcDrawProperties has been updated on that layer.  May have some false
+// CalcDrawProperties has been updated on that layer.  May have some false
 // positives (e.g. layers get this called on them but don't actually get drawn).
 static inline void UpdateTilePrioritiesForLayer(LayerImpl* layer) {
   layer->UpdateTilePriorities();
 
   // Mask layers don't get this call, so explicitly update them so they can
   // kick off tile rasterization.
   if (layer->mask_layer())
     layer->mask_layer()->UpdateTilePriorities();
   if (layer->replica_layer() && layer->replica_layer()->mask_layer())
     layer->replica_layer()->mask_layer()->UpdateTilePriorities();
@@ skipping 87 matching lines @@
   //
   //     Step 1. transform from target surface space to the exact space where
   //           scroll_delta is actually applied.
   //           -- this is inverse of the matrix in step 3
   //     Step 2. undo the scroll_delta
   //           -- this is just a translation by scroll_delta.
   //     Step 3. transform back to target surface space.
   //           -- this transform is the "partial_layer_origin_transform" =
   //           (parent_matrix * scale(layer->pageScaleDelta()));
   //
-  // These steps create a matrix that both start and end in targetSurfaceSpace.
-  // So this matrix can pre-multiply any fixed-position layer's draw_transform
-  // to undo the scroll_deltas -- as long as that fixed position layer is fixed
-  // onto the same render_target as this scrolling_layer.
+  // These steps create a matrix that both start and end in target surface
+  // space. So this matrix can pre-multiply any fixed-position layer's
+  // draw_transform to undo the scroll_deltas -- as long as that fixed position
+  // layer is fixed onto the same render_target as this scrolling_layer.
   //
 
   gfx::Transform partial_layer_origin_transform = parent_matrix;
   partial_layer_origin_transform.PreconcatTransform(
       scrolling_layer->impl_transform());
 
   gfx::Transform scroll_compensation_for_this_layer =
       partial_layer_origin_transform;        // Step 3
   scroll_compensation_for_this_layer.Translate(
       scrolling_layer->scroll_delta().x(),
@@ skipping 54 matching lines @@
 
   // Start as identity matrix.
   gfx::Transform next_scroll_compensation_matrix;
 
   // If this layer is not a container, then it inherits the existing scroll
   // compensations.
   if (!layer->is_container_for_fixed_position_layers())
     next_scroll_compensation_matrix = current_scroll_compensation_matrix;
 
   // If the current layer has a non-zero scroll_delta, then we should compute
-  // its local scrollCompensation and accumulate it to the
+  // its local scroll compensation and accumulate it to the
   // next_scroll_compensation_matrix.
   if (!layer->scroll_delta().IsZero()) {
     gfx::Transform scroll_compensation_for_this_layer =
         ComputeScrollCompensationForThisLayer(layer, parent_matrix);
     next_scroll_compensation_matrix.PreconcatTransform(
         scroll_compensation_for_this_layer);
   }
 
   // If the layer created its own render_surface, we have to adjust
   // next_scroll_compensation_matrix.  The adjustment allows us to continue
-  // using the scrollCompensation on the next surface.
+  // using the scroll compensation on the next surface.
   //  Step 1 (right-most in the math): transform from the new surface to the
   //  original ancestor surface
   //  Step 2: apply the scroll compensation
   //  Step 3: transform back to the new surface.
   if (layer->render_surface() &&
       !next_scroll_compensation_matrix.IsIdentity()) {
     gfx::Transform inverse_surface_draw_transform(
         gfx::Transform::kSkipInitialization);
     if (!layer->render_surface()->draw_transform().GetInverse(
             &inverse_surface_draw_transform)) {
@@ skipping 159 matching lines @@
 }
 
 static void RoundTranslationComponents(gfx::Transform* transform) {
   transform->matrix().
       setDouble(0, 3, MathUtil::Round(transform->matrix().getDouble(0, 3)));
   transform->matrix().
       setDouble(1, 3, MathUtil::Round(transform->matrix().getDouble(1, 3)));
 }
 
 // Recursively walks the layer tree starting at the given node and computes all
-// the necessary transformations, clipRects, render surfaces, etc.
+// the necessary transformations, clip rects, render surfaces, etc.
 template <typename LayerType, typename LayerList, typename RenderSurfaceType>
 static void CalculateDrawPropertiesInternal(
     LayerType* layer,
     const gfx::Transform& parent_matrix,
     const gfx::Transform& full_hierarchy_matrix,
     const gfx::Transform& current_scroll_compensation_matrix,
     gfx::Rect clip_rect_from_ancestor,
     gfx::Rect clip_rect_from_ancestor_in_descendant_space,
     bool ancestor_clips_subtree,
     RenderSurfaceType* nearest_ancestor_that_moves_pixels,
@@ skipping 39 matching lines @@
   //        anchor point
   //
   //        Tr[origin2center] is the translation from the layer's origin to its
   //        center
   //
   //        M[layer] is the layer's matrix (applied at the anchor point)
   //
   //        M[sublayer] is the layer's sublayer transform (also applied at the
   //        layer's anchor point)
   //
-  //        S[layer2content] is the ratio of a layer's ContentBounds() to its
+  //        S[layer2content] is the ratio of a layer's content_bounds() to its
   //        Bounds().
   //
   //    Some composite transforms can help in understanding the sequence of
   //    transforms:
-  //        compositeLayerTransform = Tr[origin2anchor] * M[layer] *
+  //        composite_layer_transform = Tr[origin2anchor] * M[layer] *
   //        Tr[origin2anchor].inverse()
   //
-  //        compositeSublayerTransform = Tr[origin2anchor] * M[sublayer] *
+  //        composite_sublayer_transform = Tr[origin2anchor] * M[sublayer] *
   //        Tr[origin2anchor].inverse()
   //
   // 4. When a layer (or render surface) is drawn, it is drawn into a "target
   // render surface". Therefore the draw transform does not necessarily
   // transform from screen space to local layer space. Instead, the draw
   // transform is the transform between the "target render surface space" and
   // local layer space. Note that render surfaces, except for the root, also
   // draw themselves into a different target render surface, and so their draw
   // transform and origin transforms are also described with respect to the
   // target.
   //
   // Using these definitions, then:
   //
   // The draw transform for the layer is:
-  //        M[draw] = M[parent] * Tr[origin] * compositeLayerTransform *
-  //            S[layer2content] = M[parent] * Tr[layer->Position() + anchor] *
+  //        M[draw] = M[parent] * Tr[origin] * composite_layer_transform *
+  //            S[layer2content] = M[parent] * Tr[layer->position() + anchor] *
   //            M[layer] * Tr[anchor2origin] * S[layer2content]
   //
   //        Interpreting the math left-to-right, this transforms from the
   //        layer's render surface to the origin of the layer in content space.
   //
   // The screen space transform is:
-  //        M[screenspace] = M[root] * Tr[origin] * compositeLayerTransform *
+  //        M[screenspace] = M[root] * Tr[origin] * composite_layer_transform *
   //            S[layer2content]
-  //                       = M[root] * Tr[layer->Position() + anchor] * M[layer]
+  //                       = M[root] * Tr[layer->position() + anchor] * M[layer]
   //                           * Tr[anchor2origin] * S[layer2content]
   //
   //        Interpreting the math left-to-right, this transforms from the root
   //        render surface's content space to the origin of the layer in content
   //        space.
   //
   // The transform hierarchy that is passed on to children (i.e. the child's
   // parent_matrix) is:
   //        M[parent]_for_child = M[parent] * Tr[origin] *
-  //            compositeLayerTransform * compositeSublayerTransform
-  //                            = M[parent] * Tr[layer->Position() + anchor] *
-  //                                M[layer] * Tr[anchor2origin] *
-  //                                compositeSublayerTransform
+  //            composite_layer_transform * composite_sublayer_transform
+  //                            = M[parent] * Tr[layer->position() + anchor] *
+  //                              M[layer] * Tr[anchor2origin] *
+  //                              composite_sublayer_transform
   //
   //        and a similar matrix for the full hierarchy with respect to the
   //        root.
   //
   // Finally, note that the final matrix used by the shader for the layer is P *
   // M[draw] * S . This final product is computed in drawTexturedQuad(), where:
   //        P is the projection matrix
   //        S is the scale adjustment (to scale up a canonical quad to the
   //            layer's size)
   //
   // When a render surface has a replica layer, that layer's transform is used
   // to draw a second copy of the surface.  gfx::Transforms named here are
   // relative to the surface, unless they specify they are relative to the
   // replica layer.
   //
   // We will denote a scale by device scale S[deviceScale]
   //
   // The render surface draw transform to its target surface origin is:
   //        M[surfaceDraw] = M[owningLayer->Draw]
   //
   // The render surface origin transform to its the root (screen space) origin
   // is:
   //        M[surface2root] =  M[owningLayer->screenspace] *
   //            S[deviceScale].inverse()
   //
   // The replica draw transform to its target surface origin is:
   //        M[replicaDraw] = S[deviceScale] * M[surfaceDraw] *
-  //            Tr[replica->Position() + replica->anchor()] * Tr[replica] *
+  //            Tr[replica->position() + replica->anchor()] * Tr[replica] *
   //            Tr[origin2anchor].inverse() * S[contents_scale].inverse()
   //
   // The replica draw transform to the root (screen space) origin is:
-  //        M[replica2root] = M[surface2root] * Tr[replica->Position()] *
+  //        M[replica2root] = M[surface2root] * Tr[replica->position()] *
   //            Tr[replica] * Tr[origin2anchor].inverse()
   //
 
-  // If we early-exit anywhere in this function, the drawableContentRect of this
+  // If we early-exit anywhere in this function, the drawable_content_rect of this
   // subtree should be considered empty.
   *drawable_content_rect_of_subtree = gfx::Rect();
 
-  // The root layer cannot skip calcDrawProperties.
+  // The root layer cannot skip CalcDrawProperties.
   if (!IsRootLayer(layer) && SubtreeShouldBeSkipped(layer))
     return;
 
   // As this function proceeds, these are the properties for the current
   // layer that actually get computed. To avoid unnecessary copies
   // (particularly for matrices), we do computations directly on these values
   // when possible.
   DrawProperties<LayerType, RenderSurfaceType>& layer_draw_properties =
       layer->draw_properties();
 
   gfx::Rect clip_rect_for_subtree;
   bool subtree_should_be_clipped = false;
 
   // This value is cached on the stack so that we don't have to inverse-project
-  // the surface's clipRect redundantly for every layer. This value is the
-  // same as the surface's clipRect, except that instead of being described
+  // the surface's clip rect redundantly for every layer. This value is the
+  // same as the surface's clip rect, except that instead of being described
   // in the target surface space (i.e. the ancestor surface space), it is
   // described in the current surface space.
   gfx::Rect clip_rect_for_subtree_in_descendant_space;
 
   float accumulated_draw_opacity = layer->opacity();
   bool animating_opacity_to_target = layer->OpacityIsAnimating();
   bool animating_opacity_to_screen = animating_opacity_to_target;
   if (layer->parent()) {
     accumulated_draw_opacity *= layer->parent()->draw_opacity();
     animating_opacity_to_target |= layer->parent()->draw_opacity_is_animating();
@@ skipping 24 matching lines @@
     // LT = Tr[origin] * Tr[origin2anchor] * M[layer]
     combined_transform.PreconcatTransform(layer->transform());
     // LT = Tr[origin] * Tr[origin2anchor] * M[layer] * Tr[anchor2origin]
     combined_transform.Translate3d(-anchor_point.x() * bounds.width(),
                                    -anchor_point.y() * bounds.height(),
                                    -layer->anchor_point_z());
   } else {
     combined_transform.Translate(position.x(), position.y());
   }
 
-  // The layer's contentsSize is determined from the combined_transform, which
+  // The layer's contents_scale is determined from the combined_transform, which
   // then informs the layer's draw_transform.
   UpdateLayerContentsScale(layer,
                            combined_transform,
                            device_scale_factor,
                            page_scale_factor,
                            animating_transform_to_screen);
 
   // If there is a transformation from the impl thread then it should be at
   // the start of the combined_transform, but we don't want it to affect the
   // computation of contents_scale above.
-  // Note carefully: this is Concat, not Preconcat (implTransform *
+  // Note carefully: this is Concat, not Preconcat (impl_transform *
   // combined_transform).
   combined_transform.ConcatTransform(layer->impl_transform());
 
   if (!animating_transform_to_target && layer->scrollable() &&
       combined_transform.IsScaleOrTranslation()) {
     // Align the scrollable layer's position to screen space pixels to avoid
     // blurriness.  To avoid side-effects, do this only if the transform is
     // simple.
     RoundTranslationComponents(&combined_transform);
   }
 
   if (layer->fixed_to_container_layer()) {
     // Special case: this layer is a composited fixed-position layer; we need to
     // explicitly compensate for all ancestors' nonzero scroll_deltas to keep
     // this layer fixed correctly.
     // Note carefully: this is Concat, not Preconcat
     // (current_scroll_compensation * combined_transform).
     combined_transform.ConcatTransform(current_scroll_compensation_matrix);
   }
 
   // The draw_transform that gets computed below is effectively the layer's
   // draw_transform, unless the layer itself creates a render_surface. In that
   // case, the render_surface re-parents the transforms.
   layer_draw_properties.target_space_transform = combined_transform;
   // M[draw] = M[parent] * LT * S[layer2content]
   layer_draw_properties.target_space_transform.Scale
       (1.f / layer->contents_scale_x(), 1.f / layer->contents_scale_y());
 
-  // layerScreenSpaceTransform represents the transform between root layer's
-  // "screen space" and local content space.
+  // The layer's screen_space_transform represents the transform between root
+  // layer's "screen space" and local content space.
   layer_draw_properties.screen_space_transform = full_hierarchy_matrix;
   if (!layer->preserves_3d())
     layer_draw_properties.screen_space_transform.FlattenTo2d();
   layer_draw_properties.screen_space_transform.PreconcatTransform
       (layer_draw_properties.target_space_transform);
 
   // Adjusting text AA method during animation may cause repaints, which in-turn
   // causes jank.
   bool adjust_text_aa =
       !animating_opacity_to_screen && !animating_transform_to_screen;
@@ skipping 73 matching lines @@
         animating_transform_to_target;
     layer_draw_properties.screen_space_transform_is_animating =
         animating_transform_to_screen;
 
     // Update the aggregate hierarchy matrix to include the transform of the
     // newly created RenderSurfaceImpl.
     next_hierarchy_matrix.PreconcatTransform(render_surface->draw_transform());
 
     // The new render_surface here will correctly clip the entire subtree. So,
     // we do not need to continue propagating the clipping state further down
-    // the tree. This way, we can avoid transforming clipRects from ancestor
+    // the tree. This way, we can avoid transforming clip rects from ancestor
     // target surface space to current target surface space that could cause
     // more w < 0 headaches.
     subtree_should_be_clipped = false;
 
     if (layer->mask_layer()) {
       DrawProperties<LayerType, RenderSurfaceType>& mask_layer_draw_properties =
           layer->mask_layer()->draw_properties();
       mask_layer_draw_properties.render_target = layer;
       mask_layer_draw_properties.visible_content_rect =
           gfx::Rect(gfx::Point(), layer->content_bounds());
     }
 
     if (layer->replica_layer() && layer->replica_layer()->mask_layer()) {
       DrawProperties<LayerType, RenderSurfaceType>&
       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 =
           gfx::Rect(gfx::Point(), layer->content_bounds());
     }
 
     // TODO(senorblanco): make this smarter for the SkImageFilter case (check
     // for pixel-moving filters)
     if (layer->filters().hasFilterThatMovesPixels() || layer->filter())
       nearest_ancestor_that_moves_pixels = render_surface;
 
-    // The render surface clipRect is expressed in the space where this surface
+    // The render surface clip rect is expressed in the space where this surface
     // draws, i.e. the same space as clip_rect_from_ancestor.
     render_surface->SetIsClipped(ancestor_clips_subtree);
     if (ancestor_clips_subtree) {
       render_surface->SetClipRect(clip_rect_from_ancestor);
 
       gfx::Transform inverse_surface_draw_transform(
           gfx::Transform::kSkipInitialization);
       if (!render_surface->draw_transform().GetInverse(
               &inverse_surface_draw_transform)) {
         // TODO(shawnsingh): Either we need to handle uninvertible transforms
@@ skipping 33 matching lines @@
     sublayer_matrix = combined_transform;
 
     layer->ClearRenderSurface();
 
     // Layers without render_surfaces directly inherit the ancestor's clip
     // status.
     subtree_should_be_clipped = ancestor_clips_subtree;
     if (ancestor_clips_subtree)
       clip_rect_for_subtree = clip_rect_from_ancestor;
 
-    // The surface's cached clipRect value propagates regardless of what
+    // The surface's cached clip rect value propagates regardless of what
     // clipping goes on between layers here.
     clip_rect_for_subtree_in_descendant_space =
         clip_rect_from_ancestor_in_descendant_space;
 
     // Layers that are not their own render_target will render into the target
     // of their nearest ancestor.
     layer_draw_properties.render_target = layer->parent()->render_target();
   }
 
   if (adjust_text_aa)
@@ skipping 70 matching lines @@
         descendants.push_back(child);
     }
   }
 
   if (layer->render_surface() && !IsRootLayer(layer) &&
       layer->render_surface()->layer_list().empty()) {
     RemoveSurfaceForEarlyExit(layer, render_surface_layer_list);
     return;
   }
 
-  // Compute the total drawableContentRect for this subtree (the rect is in
-  // targetSurface space).
+  // Compute the total drawable_content_rect for this subtree (the rect is in
+  // target surface space).
   gfx::Rect local_drawable_content_rect_of_subtree =
       accumulated_drawable_content_rect_of_children;
   if (layer->DrawsContent())
     local_drawable_content_rect_of_subtree.Union(rect_in_target_space);
   if (subtree_should_be_clipped)
     local_drawable_content_rect_of_subtree.Intersect(clip_rect_for_subtree);
 
-  // Compute the layer's drawable content rect (the rect is in targetSurface
+  // Compute the layer's drawable content rect (the rect is in target surface
   // space).
   layer_draw_properties.drawable_content_rect = rect_in_target_space;
   if (subtree_should_be_clipped) {
     layer_draw_properties.drawable_content_rect.
         Intersect(clip_rect_for_subtree);
   }
 
   // Tell the layer the rect that is clipped by. In theory we could use a
-  // tighter clipRect here (drawableContentRect), but that actually does not
+  // tighter clip rect here (drawable_content_rect), but that actually does not
   // reduce how much would be drawn, and instead it would create unnecessary
   // changes to scissor state affecting GPU performance.
   layer_draw_properties.is_clipped = subtree_should_be_clipped;
   if (subtree_should_be_clipped) {
     layer_draw_properties.clip_rect = clip_rect_for_subtree;
   } else {
-    // Initialize the clipRect to a safe value that will not clip the
+    // Initialize the clip rect to a safe value that will not clip the
     // layer, just in case clipping is still accidentally used.
     layer_draw_properties.clip_rect = rect_in_target_space;
   }
 
   // Compute the layer's visible content rect (the rect is in content space)
   layer_draw_properties.visible_content_rect = CalculateVisibleContentRect(
       layer, clip_rect_for_subtree_in_descendant_space, rect_in_target_space);
 
   // Compute the remaining properties for the render surface, if the layer has
   // one.
@@ skipping 118 matching lines @@
     float page_scale_factor,
     int max_texture_size,
     bool can_use_lcd_text,
     std::vector<scoped_refptr<Layer> >* render_surface_layer_list) {
   gfx::Rect total_drawable_content_rect;
   gfx::Transform identity_matrix;
   gfx::Transform device_scale_transform;
   device_scale_transform.Scale(device_scale_factor, device_scale_factor);
   std::vector<scoped_refptr<Layer> > dummy_layer_list;
 
-  // The root layer's render_surface should receive the deviceViewport as the
-  // initial clipRect.
+  // The root layer's render_surface should receive the device viewport as the
+  // initial clip rect.
   bool subtree_should_be_clipped = true;
   gfx::Rect device_viewport_rect(gfx::Point(), device_viewport_size);
   bool update_tile_priorities = false;
 
   // This function should have received a root layer.
   DCHECK(IsRootLayer(root_layer));
 
   PreCalculateMetaInformation<Layer>(root_layer);
   CalculateDrawPropertiesInternal<Layer,
                                   std::vector<scoped_refptr<Layer> >,
@@ skipping 11 matching lines @@
                                                  max_texture_size,
                                                  device_scale_factor,
                                                  page_scale_factor,
                                                  can_use_lcd_text,
                                                  &total_drawable_content_rect,
                                                  update_tile_priorities);
 
   // The dummy layer list should not have been used.
   DCHECK_EQ(dummy_layer_list.size(), 0);
   // A root layer render_surface should always exist after
-  // calculateDrawProperties.
+  // CalculateDrawProperties.
   DCHECK(root_layer->render_surface());
 }
 
 void LayerTreeHostCommon::CalculateDrawProperties(
     LayerImpl* root_layer,
     gfx::Size device_viewport_size,
     float device_scale_factor,
     float page_scale_factor,
     int max_texture_size,
     bool can_use_lcd_text,
     std::vector<LayerImpl*>* render_surface_layer_list,
     bool update_tile_priorities) {
   gfx::Rect total_drawable_content_rect;
   gfx::Transform identity_matrix;
   gfx::Transform device_scale_transform;
   device_scale_transform.Scale(device_scale_factor, device_scale_factor);
   std::vector<LayerImpl*> dummy_layer_list;
   LayerSorter layer_sorter;
 
-  // The root layer's render_surface should receive the deviceViewport as the
-  // initial clipRect.
+  // The root layer's render_surface should receive the device viewport as the
+  // initial clip rect.
   bool subtree_should_be_clipped = true;
   gfx::Rect device_viewport_rect(gfx::Point(), device_viewport_size);
 
   // This function should have received a root layer.
   DCHECK(IsRootLayer(root_layer));
 
   PreCalculateMetaInformation<LayerImpl>(root_layer);
   CalculateDrawPropertiesInternal<LayerImpl,
                                   std::vector<LayerImpl*>,
                                   RenderSurfaceImpl>(
@@ skipping 11 matching lines @@
       max_texture_size,
       device_scale_factor,
       page_scale_factor,
       can_use_lcd_text,
       &total_drawable_content_rect,
       update_tile_priorities);
 
   // The dummy layer list should not have been used.
   DCHECK_EQ(dummy_layer_list.size(), 0);
   // A root layer render_surface should always exist after
-  // calculateDrawProperties.
+  // CalculateDrawProperties.
   DCHECK(root_layer->render_surface());
 }
 
 static bool PointHitsRect(
     gfx::PointF screen_space_point,
     const gfx::Transform& local_space_to_screen_space_transform,
     gfx::RectF local_space_rect) {
   // If the transform is not invertible, then assume that this point doesn't hit
   // this rect.
   gfx::Transform inverse_local_space_to_screen_space(
@@ skipping 175 matching lines @@
   // At this point, we think the point does hit the touch event handler region
   // on the layer, but we need to walk up the parents to ensure that the layer
   // was not clipped in such a way that the hit point actually should not hit
   // the layer.
   if (PointIsClippedBySurfaceOrClipRect(screen_space_point, layer_impl))
     return false;
 
   return true;
 }
 }  // namespace cc