cc: Fix capitalization style in chromified files.

cc/layers/layer_impl.h

 // 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.
 
 #ifndef CC_LAYERS_LAYER_IMPL_H_
 #define CC_LAYERS_LAYER_IMPL_H_
 
 #include <string>
 
 #include "base/logging.h"
@@ skipping 76 matching lines @@
 
   bool has_mask() const { return mask_layer_; }
   bool has_replica() const { return replica_layer_; }
   bool replica_has_mask() const {
     return replica_layer_ && (mask_layer_ || replica_layer_->mask_layer_);
   }
 
   LayerTreeImpl* layer_tree_impl() const { return layer_tree_impl_; }
 
   scoped_ptr<SharedQuadState> CreateSharedQuadState() const;
-  // willDraw must be called before appendQuads. If willDraw is called,
-  // didDraw is guaranteed to be called before another willDraw or before
+  // WillDraw must be called before AppendQuads. If WillDraw is called,
+  // DidDraw is guaranteed to be called before another WillDraw or before
   // the layer is destroyed. To enforce this, any class that overrides
-  // willDraw/didDraw must call the base class version.
+  // WillDraw/DqidDraw must call the base class version.
   virtual void WillDraw(ResourceProvider* resource_provider);
   virtual void AppendQuads(QuadSink* quad_sink,
                            AppendQuadsData* append_quads_data) {}
   virtual void DidDraw(ResourceProvider* resource_provider);
 
   virtual ResourceProvider::ResourceId ContentsResourceId() const;
 
   virtual bool HasDelegatedContent() const;
   virtual bool HasContributingDelegatedRenderPasses() const;
   virtual RenderPass::Id FirstContributingRenderPassId() const;
@@ skipping 71 matching lines @@
     return sublayer_transform_;
   }
 
   // Debug layer name.
   void SetDebugName(const std::string& debug_name) { debug_name_ = debug_name; }
   std::string debug_name() const { return debug_name_; }
 
   bool ShowDebugBorders() const;
 
   // These invalidate the host's render surface layer list.  The caller
-  // is responsible for calling setNeedsUpdateDrawProperties on the host
+  // is responsible for calling set_needs_update_draw_properties on the tree
   // so that its list can be recreated.
   void CreateRenderSurface();
   void ClearRenderSurface() { draw_properties_.render_surface.reset(); }
 
   DrawProperties<LayerImpl, RenderSurfaceImpl>& draw_properties() {
     return draw_properties_;
   }
   const DrawProperties<LayerImpl, RenderSurfaceImpl>& draw_properties() const {
     return draw_properties_;
   }
@@ skipping 35 matching lines @@
   }
   const LayerImpl* render_target() const {
     DCHECK(!draw_properties_.render_target ||
            draw_properties_.render_target->render_surface());
     return draw_properties_.render_target;
   }
   RenderSurfaceImpl* render_surface() const {
  return draw_properties_.render_surface.get();
   }
 
-  // The client should be responsible for setting bounds, contentBounds and
-  // contentsScale to appropriate values. LayerImpl doesn't calculate any of
+  // The client should be responsible for setting bounds, content bounds and
+  // contents scale to appropriate values. LayerImpl doesn't calculate any of
   // them from the other values.
 
   void SetBounds(gfx::Size bounds);
   gfx::Size bounds() const { return bounds_; }
 
   void SetContentBounds(gfx::Size content_bounds);
   gfx::Size content_bounds() const { return draw_properties_.content_bounds; }
 
   float contents_scale_x() const { return draw_properties_.contents_scale_x; }
   float contents_scale_y() const { return draw_properties_.contents_scale_y; }
   void SetContentsScale(float contents_scale_x, float contents_scale_y);
 
   virtual void CalculateContentsScale(float ideal_contents_scale,
                                       bool animating_transform_to_screen,
                                       float* contents_scale_x,
                                       float* contents_scale_y,
-                                      gfx::Size* contentBounds);
+                                      gfx::Size* content_bounds);
 
   void SetScrollOffset(gfx::Vector2d scroll_offset);
   gfx::Vector2d scroll_offset() const { return scroll_offset_; }
 
   void SetMaxScrollOffset(gfx::Vector2d max_scroll_offset);
   gfx::Vector2d max_scroll_offset() const { return max_scroll_offset_; }
 
   void SetScrollDelta(gfx::Vector2dF scroll_delta);
   gfx::Vector2dF scroll_delta() const { return scroll_delta_; }
 
@@ skipping 171 matching lines @@
   bool stacking_order_changed_;
 
   // Whether the "back" of this layer should draw.
   bool double_sided_;
 
   // Tracks if drawing-related properties have changed since last redraw.
   bool layer_property_changed_;
 
   // Indicates that a property has changed on this layer that would not
   // affect the pixels on its target surface, but would require redrawing
-  // the targetSurface onto its ancestor targetSurface.
+  // the target_surface onto its ancestor target_surface.
   // For layers that do not own a surface this flag acts as
   // layer_property_changed_.
   bool layer_surface_property_changed_;
 
   bool masks_to_bounds_;
   bool contents_opaque_;
   float opacity_;
   gfx::PointF position_;
   bool preserves_3d_;
   bool use_parent_backface_visibility_;
@@ skipping 50 matching lines @@
   // Group of properties that need to be computed based on the layer tree
   // hierarchy before layers can be drawn.
   DrawProperties<LayerImpl, RenderSurfaceImpl> draw_properties_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerImpl);
 };
 
 }
 
 #endif  // CC_LAYERS_LAYER_IMPL_H_