cc: Fix capitalization style in chromified files.

cc/trees/single_thread_proxy.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/single_thread_proxy.h"
 
 #include "base/auto_reset.h"
 #include "base/debug/trace_event.h"
 #include "cc/base/thread.h"
 #include "cc/output/context_provider.h"
@@ skipping 34 matching lines @@
 }
 
 SingleThreadProxy::~SingleThreadProxy() {
   TRACE_EVENT0("cc", "SingleThreadProxy::~SingleThreadProxy");
   DCHECK(Proxy::IsMainThread());
   DCHECK(!layer_tree_host_impl_.get() &&
          !layer_tree_host_);  // make sure Stop() got called.
 }
 
 bool SingleThreadProxy::CompositeAndReadback(void* pixels, gfx::Rect rect) {
-  TRACE_EVENT0("cc", "SingleThreadProxy::compositeAndReadback");
+  TRACE_EVENT0("cc", "SingleThreadProxy::CompositeAndReadback");
   DCHECK(Proxy::IsMainThread());
 
   if (!CommitAndComposite(base::TimeTicks::Now()))
     return false;
 
   {
     DebugScopedSetImplThread impl(this);
     layer_tree_host_impl_->Readback(pixels, rect);
 
     if (layer_tree_host_impl_->IsContextLost())
@@ skipping 22 matching lines @@
   }
 }
 
 bool SingleThreadProxy::IsStarted() const {
   DCHECK(Proxy::IsMainThread());
   return layer_tree_host_impl_.get();
 }
 
 bool SingleThreadProxy::InitializeOutputSurface() {
   DCHECK(Proxy::IsMainThread());
-  scoped_ptr<OutputSurface> outputSurface =
+  scoped_ptr<OutputSurface> output_surface =
       layer_tree_host_->CreateOutputSurface();
-  if (!outputSurface.get())
+  if (!output_surface.get())
     return false;
-  output_surface_before_initialization_ = outputSurface.Pass();
+  output_surface_before_initialization_ = output_surface.Pass();
   return true;
 }
 
 void SingleThreadProxy::SetSurfaceReady() {
   // Scheduling is controlled by the embedder in the single thread case, so
   // nothing to do.
 }
 
 void SingleThreadProxy::SetVisible(bool visible) {
   DebugScopedSetImplThread impl(this);
@@ skipping 11 matching lines @@
       renderer_initialized_ = true;
       renderer_capabilities_for_main_thread_ =
           layer_tree_host_impl_->GetRendererCapabilities();
     }
 
     return ok;
   }
 }
 
 bool SingleThreadProxy::RecreateOutputSurface() {
-  TRACE_EVENT0("cc", "SingleThreadProxy::recreateContext");
+  TRACE_EVENT0("cc", "SingleThreadProxy::RecreateContext");
   DCHECK(Proxy::IsMainThread());
   DCHECK(output_surface_lost_);
 
-  scoped_ptr<OutputSurface> outputSurface =
+  scoped_ptr<OutputSurface> output_surface =
       layer_tree_host_->CreateOutputSurface();
-  if (!outputSurface.get())
+  if (!output_surface.get())
     return false;
   scoped_refptr<cc::ContextProvider> offscreen_context_provider;
   if (created_offscreen_context_provider_) {
     offscreen_context_provider =
         layer_tree_host_->client()->OffscreenContextProviderForMainThread();
     if (!offscreen_context_provider)
       return false;
   }
 
   bool initialized;
   {
     DebugScopedSetMainThreadBlocked mainThreadBlocked(this);
     DebugScopedSetImplThread impl(this);
     layer_tree_host_->DeleteContentsTexturesOnImplThread(
         layer_tree_host_impl_->resource_provider());
     initialized =
-        layer_tree_host_impl_->InitializeRenderer(outputSurface.Pass());
+        layer_tree_host_impl_->InitializeRenderer(output_surface.Pass());
     if (initialized) {
       renderer_capabilities_for_main_thread_ =
           layer_tree_host_impl_->GetRendererCapabilities();
       layer_tree_host_impl_->resource_provider()->
           set_offscreen_context_provider(offscreen_context_provider);
     } else if (offscreen_context_provider) {
       offscreen_context_provider->VerifyContexts();
     }
   }
 
@@ skipping 16 matching lines @@
 
 void SingleThreadProxy::DoCommit(scoped_ptr<ResourceUpdateQueue> queue) {
   DCHECK(Proxy::IsMainThread());
   // Commit immediately.
   {
     DebugScopedSetMainThreadBlocked mainThreadBlocked(this);
     DebugScopedSetImplThread impl(this);
 
     RenderingStatsInstrumentation* stats_instrumentation =
         layer_tree_host_->rendering_stats_instrumentation();
-    base::TimeTicks startTime = stats_instrumentation->StartRecording();
+    base::TimeTicks start_time = stats_instrumentation->StartRecording();
 
     layer_tree_host_impl_->BeginCommit();
 
     layer_tree_host_->contents_texture_manager()->
         PushTexturePrioritiesToBackings();
     layer_tree_host_->BeginCommitOnImplThread(layer_tree_host_impl_.get());
 
-    scoped_ptr<ResourceUpdateController> updateController =
+    scoped_ptr<ResourceUpdateController> update_controller =
         ResourceUpdateController::Create(
             NULL,
             Proxy::MainThread(),
             queue.Pass(),
             layer_tree_host_impl_->resource_provider());
-    updateController->Finalize();
+    update_controller->Finalize();
 
     layer_tree_host_->FinishCommitOnImplThread(layer_tree_host_impl_.get());
 
     layer_tree_host_impl_->CommitComplete();
 
 #ifndef NDEBUG
     // In the single-threaded case, the scroll deltas should never be
     // touched on the impl layer tree.
-    scoped_ptr<ScrollAndScaleSet> scrollInfo =
+    scoped_ptr<ScrollAndScaleSet> scroll_info =
         layer_tree_host_impl_->ProcessScrollDeltas();
-    DCHECK(!scrollInfo->scrolls.size());
+    DCHECK(!scroll_info->scrolls.size());
 #endif
 
-    base::TimeDelta duration = stats_instrumentation->EndRecording(startTime);
+    base::TimeDelta duration = stats_instrumentation->EndRecording(start_time);
     stats_instrumentation->AddCommit(duration);
   }
   layer_tree_host_->CommitComplete();
   next_frame_is_newly_committed_frame_ = true;
 }
 
 void SingleThreadProxy::SetNeedsCommit() {
   DCHECK(Proxy::IsMainThread());
   layer_tree_host_->ScheduleComposite();
 }
 
 void SingleThreadProxy::SetNeedsRedraw() {
   // FIXME: Once we move render_widget scheduling into this class, we can
-  // treat redraw requests more efficiently than commitAndRedraw requests.
+  // treat redraw requests more efficiently than CommitAndRedraw requests.
   layer_tree_host_impl_->SetFullRootLayerDamage();
   SetNeedsCommit();
 }
 
 void SingleThreadProxy::OnHasPendingTreeStateChanged(bool have_pending_tree) {
   // Thread-only feature.
   NOTREACHED();
 }
 
 void SingleThreadProxy::SetDeferCommits(bool defer_commits) {
@@ skipping 199 matching lines @@
 
 bool SingleThreadProxy::CommitPendingForTesting() { return false; }
 
 skia::RefPtr<SkPicture> SingleThreadProxy::CapturePicture() {
   // Impl-side painting only.
   NOTREACHED();
   return skia::RefPtr<SkPicture>();
 }
 
 }  // namespace cc