cc: Fix capitalization style in chromified files.

cc/layers/layer_impl.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/layers/layer_impl.h"
 
 #include "base/debug/trace_event.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
 #include "cc/animation/animation_registrar.h"
@@ skipping 105 matching lines @@
                 draw_properties_.content_bounds,
                 draw_properties_.visible_content_rect,
                 draw_properties_.clip_rect,
                 draw_properties_.is_clipped,
                 draw_properties_.opacity);
   return state.Pass();
 }
 
 void LayerImpl::WillDraw(ResourceProvider* resource_provider) {
 #ifndef NDEBUG
-  // willDraw/didDraw must be matched.
+  // WillDraw/DidDraw must be matched.
   DCHECK(!between_will_draw_and_did_draw_);
   between_will_draw_and_did_draw_ = true;
 #endif
 }
 
 void LayerImpl::DidDraw(ResourceProvider* resource_provider) {
 #ifndef NDEBUG
   DCHECK(between_will_draw_and_did_draw_);
   between_will_draw_and_did_draw_ = false;
 #endif
@@ skipping 25 matching lines @@
     const SharedQuadState* shared_quad_state,
     AppendQuadsData* append_quads_data) const {
   if (!ShowDebugBorders())
     return;
 
   SkColor color;
   float width;
   GetDebugBorderProperties(&color, &width);
 
   gfx::Rect content_rect(content_bounds());
-  scoped_ptr<DebugBorderDrawQuad> debugBorderQuad =
+  scoped_ptr<DebugBorderDrawQuad> debug_border_quad =
       DebugBorderDrawQuad::Create();
-  debugBorderQuad->SetNew(shared_quad_state, content_rect, color, width);
-  quad_sink->Append(debugBorderQuad.PassAs<DrawQuad>(), append_quads_data);
+  debug_border_quad->SetNew(shared_quad_state, content_rect, color, width);
+  quad_sink->Append(debug_border_quad.PassAs<DrawQuad>(), append_quads_data);
 }
 
 bool LayerImpl::HasDelegatedContent() const {
   return false;
 }
 
 bool LayerImpl::HasContributingDelegatedRenderPasses() const {
   return false;
 }
 
@@ skipping 31 matching lines @@
   gfx::Vector2dF unscrolled = scroll_delta_ + scroll - new_delta;
 
   SetScrollDelta(new_delta);
   return unscrolled;
 }
 
 InputHandlerClient::ScrollStatus LayerImpl::TryScroll(
     gfx::PointF screen_space_point,
     InputHandlerClient::ScrollInputType type) const {
   if (should_scroll_on_main_thread()) {
-    TRACE_EVENT0("cc", "LayerImpl::tryScroll: Failed shouldScrollOnMainThread");
+    TRACE_EVENT0("cc", "LayerImpl::TryScroll: Failed ShouldScrollOnMainThread");
     return InputHandlerClient::ScrollOnMainThread;
   }
 
   if (!screen_space_transform().IsInvertible()) {
-    TRACE_EVENT0("cc", "LayerImpl::tryScroll: Ignored nonInvertibleTransform");
+    TRACE_EVENT0("cc", "LayerImpl::TryScroll: Ignored NonInvertibleTransform");
     return InputHandlerClient::ScrollIgnored;
   }
 
   if (!non_fast_scrollable_region().IsEmpty()) {
     bool clipped = false;
     gfx::Transform inverse_screen_space_transform(
         gfx::Transform::kSkipInitialization);
     if (!screen_space_transform().GetInverse(&inverse_screen_space_transform)) {
       // TODO(shawnsingh): We shouldn't be applying a projection if screen space
       // transform is uninvertible here. Perhaps we should be returning
       // ScrollOnMainThread in this case?
     }
 
     gfx::PointF hit_test_point_in_content_space =
         MathUtil::ProjectPoint(inverse_screen_space_transform,
                                screen_space_point,
                                &clipped);
     gfx::PointF hit_test_point_in_layer_space =
         gfx::ScalePoint(hit_test_point_in_content_space,
                         1.f / contents_scale_x(),
                         1.f / contents_scale_y());
     if (!clipped &&
         non_fast_scrollable_region().Contains(
             gfx::ToRoundedPoint(hit_test_point_in_layer_space))) {
       TRACE_EVENT0("cc",
-                   "LayerImpl::tryScroll: Failed nonFastScrollableRegion");
+                   "LayerImpl::tryScroll: Failed NonFastScrollableRegion");
       return InputHandlerClient::ScrollOnMainThread;
     }
   }
 
   if (type == InputHandlerClient::Wheel && have_wheel_event_handlers()) {
-    TRACE_EVENT0("cc", "LayerImpl::tryScroll: Failed wheelEventHandlers");
+    TRACE_EVENT0("cc", "LayerImpl::tryScroll: Failed WheelEventHandlers");
     return InputHandlerClient::ScrollOnMainThread;
   }
 
   if (!scrollable()) {
     TRACE_EVENT0("cc", "LayerImpl::tryScroll: Ignored not scrollable");
     return InputHandlerClient::ScrollIgnored;
   }
 
   if (max_scroll_offset_.x() <= 0 && max_scroll_offset_.y() <= 0) {
     TRACE_EVENT0("cc",
@@ skipping 67 matching lines @@
   layer->SetUseParentBackfaceVisibility(use_parent_backface_visibility_);
   layer->SetSublayerTransform(sublayer_transform_);
   layer->SetTransform(transform_);
 
   layer->SetScrollable(scrollable_);
   layer->SetScrollOffset(scroll_offset_);
   layer->SetMaxScrollOffset(max_scroll_offset_);
 
   // If the main thread commits multiple times before the impl thread actually
   // draws, then damage tracking will become incorrect if we simply clobber the
-  // updateRect here. The LayerImpl's updateRect needs to accumulate (i.e.
+  // update_rect here. The LayerImpl's update_rect needs to accumulate (i.e.
   // union) any update changes that have occurred on the main thread.
   update_rect_.Union(layer->update_rect());
   layer->set_update_rect(update_rect_);
 
   layer->SetScrollDelta(layer->scroll_delta() - layer->sent_scroll_delta());
   layer->SetSentScrollDelta(gfx::Vector2d());
 
   layer->SetStackingOrderChanged(stacking_order_changed_);
 
   layer_animation_controller_->PushAnimationUpdatesTo(
@@ skipping 594 matching lines @@
 
 }
 
 scoped_ptr<base::Value> LayerImpl::AsValue() const {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
   AsValueInto(state.get());
   return state.PassAs<base::Value>();
 }
 
 }  // namespace cc