cc: Fix capitalization style in chromified files.

cc/trees/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/thread_proxy.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "cc/base/thread.h"
@@ skipping 14 matching lines @@
 const double kContextRecreationTickRate = 0.03;
 
 // Measured in seconds.
 const double kSmoothnessTakesPriorityExpirationDelay = 0.25;
 
 }  // namespace
 
 namespace cc {
 
 scoped_ptr<Proxy> ThreadProxy::Create(LayerTreeHost* layer_tree_host,
-                                      scoped_ptr<Thread> implThread) {
+                                      scoped_ptr<Thread> impl_thread) {
   return make_scoped_ptr(
-      new ThreadProxy(layer_tree_host, implThread.Pass())).PassAs<Proxy>();
+      new ThreadProxy(layer_tree_host, impl_thread.Pass())).PassAs<Proxy>();
 }
 
 ThreadProxy::ThreadProxy(LayerTreeHost* layer_tree_host,
-                         scoped_ptr<Thread> implThread)
-    : Proxy(implThread.Pass()),
+                         scoped_ptr<Thread> impl_thread)
+    : Proxy(impl_thread.Pass()),
       animate_requested_(false),
       commit_requested_(false),
       commit_request_sent_to_impl_thread_(false),
       created_offscreen_context_provider_(false),
       layer_tree_host_(layer_tree_host),
       renderer_initialized_(false),
       started_(false),
       textures_acquired_(true),
       in_composite_and_readback_(false),
       manage_tiles_pending_(false),
@@ skipping 156 matching lines @@
 void ThreadProxy::SetVisibleOnImplThread(CompletionEvent* completion,
                                          bool visible) {
   TRACE_EVENT0("cc", "ThreadProxy::SetVisibleOnImplThread");
   layer_tree_host_impl_->SetVisible(visible);
   scheduler_on_impl_thread_->SetVisible(visible);
   completion->Signal();
 }
 
 bool ThreadProxy::InitializeRenderer() {
   TRACE_EVENT0("cc", "ThreadProxy::InitializeRenderer");
-  // Make a blocking call to initializeRendererOnImplThread. The results of that
+  // Make a blocking call to InitializeRendererOnImplThread. The results of that
   // call are pushed into the initialize_succeeded and capabilities local
   // variables.
   CompletionEvent completion;
   bool initialize_succeeded = false;
   RendererCapabilities capabilities;
   DebugScopedSetMainThreadBlocked main_thread_blocked(this);
   Proxy::ImplThread()->PostTask(
       base::Bind(&ThreadProxy::InitializeRendererOnImplThread,
                  impl_thread_weak_ptr_,
                  &completion,
@@ skipping 18 matching lines @@
   if (!output_surface)
     return false;
   scoped_refptr<cc::ContextProvider> offscreen_context_provider;
   if (created_offscreen_context_provider_) {
     offscreen_context_provider = layer_tree_host_->client()->
         OffscreenContextProviderForCompositorThread();
     if (!offscreen_context_provider)
       return false;
   }
 
-  // Make a blocking call to recreateOutputSurfaceOnImplThread. The results of
+  // Make a blocking call to RecreateOutputSurfaceOnImplThread. The results of
   // that call are pushed into the recreate_succeeded and capabilities local
   // variables.
   CompletionEvent completion;
   bool recreate_succeeded = false;
   RendererCapabilities capabilities;
   DebugScopedSetMainThreadBlocked main_thread_blocked(this);
   Proxy::ImplThread()->PostTask(
       base::Bind(&ThreadProxy::RecreateOutputSurfaceOnImplThread,
                  impl_thread_weak_ptr_,
                  &completion,
@@ skipping 169 matching lines @@
       layer_tree_host_impl_->resource_provider());
 }
 
 void ThreadProxy::SendManagedMemoryStats() {
   DCHECK(IsImplThread());
   if (!layer_tree_host_impl_)
     return;
   if (!layer_tree_host_->contents_texture_manager())
     return;
 
-  // If we are using impl-side painting, then sendManagedMemoryStats is called
+  // If we are using impl-side painting, then SendManagedMemoryStats is called
   // directly after the tile manager's manage function, and doesn't need to
   // interact with main thread's layer tree.
   if (layer_tree_host_->settings().impl_side_painting)
     return;
 
   layer_tree_host_impl_->SendManagedMemoryStats(
       layer_tree_host_->contents_texture_manager()->MemoryVisibleBytes(),
       layer_tree_host_->contents_texture_manager()->
           MemoryVisibleAndNearbyBytes(),
       layer_tree_host_->contents_texture_manager()->MemoryUseBytes());
@@ skipping 27 matching lines @@
                    base::Passed(&pending_deferred_commit_)));
 }
 
 bool ThreadProxy::CommitRequested() const {
   DCHECK(IsMainThread());
   return commit_requested_;
 }
 
 void ThreadProxy::SetNeedsRedrawOnImplThread() {
   DCHECK(IsImplThread());
-  TRACE_EVENT0("cc", "ThreadProxy::setNeedsRedrawOnImplThread");
+  TRACE_EVENT0("cc", "ThreadProxy::SetNeedsRedrawOnImplThread");
   scheduler_on_impl_thread_->SetNeedsRedraw();
 }
 
 void ThreadProxy::DidSwapUseIncompleteTileOnImplThread() {
   DCHECK(IsImplThread());
   TRACE_EVENT0("cc", "ThreadProxy::DidSwapUseIncompleteTileOnImplThread");
   scheduler_on_impl_thread_->DidSwapUseIncompleteTile();
 }
 
 void ThreadProxy::DidInitializeVisibleTileOnImplThread() {
@@ skipping 116 matching lines @@
     return;
 
   if (defer_commits_) {
     pending_deferred_commit_ = begin_frame_state.Pass();
     layer_tree_host_->DidDeferCommit();
     TRACE_EVENT0("cc", "EarlyOut_DeferCommits");
     return;
   }
 
   // Do not notify the impl thread of commit requests that occur during
-  // the apply/animate/layout part of the beginFrameAndCommit process since
+  // the apply/animate/layout part of the BeginFrameAndCommit process since
   // those commit requests will get painted immediately. Once we have done
   // the paint, commit_requested_ will be set to false to allow new commit
   // requests to be scheduled.
   commit_requested_ = true;
   commit_request_sent_to_impl_thread_ = true;
 
-  // On the other hand, the animationRequested flag needs to be cleared
+  // On the other hand, the AnimationRequested flag needs to be cleared
   // here so that any animation requests generated by the apply or animate
   // callbacks will trigger another frame.
   animate_requested_ = false;
 
   if (begin_frame_state) {
     layer_tree_host_->ApplyScrollAndScale(*begin_frame_state->scroll_info);
     layer_tree_host_->SetImplTransform(begin_frame_state->impl_transform);
   }
 
   if (!in_composite_and_readback_ && !layer_tree_host_->visible()) {
     commit_requested_ = false;
     commit_request_sent_to_impl_thread_ = false;
 
     TRACE_EVENT0("cc", "EarlyOut_NotVisible");
     Proxy::ImplThread()->PostTask(base::Bind(
         &ThreadProxy::BeginFrameAbortedOnImplThread, impl_thread_weak_ptr_));
     return;
   }
 
   layer_tree_host_->WillBeginFrame();
 
   if (begin_frame_state) {
     layer_tree_host_->UpdateAnimations(
         begin_frame_state->monotonic_frame_begin_time);
   }
 
   // Unlink any backings that the impl thread has evicted, so that we know to
-  // re-paint them in updateLayers.
+  // re-paint them in UpdateLayers.
   if (layer_tree_host_->contents_texture_manager()) {
     layer_tree_host_->contents_texture_manager()->
         UnlinkAndClearEvictedBackings();
   }
 
   layer_tree_host_->Layout();
 
   // Clear the commit flag after updating animations and layout here --- objects
-  // that only layout when painted will trigger another setNeedsCommit inside
-  // updateLayers.
+  // that only layout when painted will trigger another SetNeedsCommit inside
+  // UpdateLayers.
   commit_requested_ = false;
   commit_request_sent_to_impl_thread_ = false;
 
   if (!layer_tree_host_->InitializeRendererIfNeeded()) {
     TRACE_EVENT0("cc", "EarlyOut_InitializeFailed");
     return;
   }
 
   scoped_ptr<ResourceUpdateQueue> queue =
       make_scoped_ptr(new ResourceUpdateQueue);
   layer_tree_host_->UpdateLayers(
       queue.get(),
       begin_frame_state ? begin_frame_state->memory_allocation_limit_bytes
                         : 0u);
 
   // Once single buffered layers are committed, they cannot be modified until
   // they are drawn by the impl thread.
   textures_acquired_ = false;
 
   layer_tree_host_->WillCommit();
   // Before applying scrolls and calling animate, we set animate_requested_ to
-  // false. If it is true now, it means setNeedAnimate was called again, but
+  // false. If it is true now, it means SetNeedAnimate was called again, but
   // during a state when commit_request_sent_to_impl_thread_ = true. We need to
   // force that call to happen again now so that the commit request is sent to
   // the impl thread.
   if (animate_requested_) {
-    // Forces setNeedsAnimate to consider posting a commit task.
+    // Forces SetNeedsAnimate to consider posting a commit task.
     animate_requested_ = false;
     SetNeedsAnimate();
   }
 
   scoped_refptr<cc::ContextProvider> offscreen_context_provider;
   if (renderer_capabilities_main_thread_copy_.using_offscreen_context3d &&
       layer_tree_host_->needs_offscreen_context()) {
     offscreen_context_provider = layer_tree_host_->client()->
         OffscreenContextProviderForCompositorThread();
     if (offscreen_context_provider)
       created_offscreen_context_provider_ = true;
   }
 
-  // Notify the impl thread that the beginFrame has completed. This will
+  // Notify the impl thread that the BeginFrame has completed. This will
   // begin the commit process, which is blocking from the main thread's
   // point of view, but asynchronously performed on the impl thread,
   // coordinated by the Scheduler.
   {
     TRACE_EVENT0("cc", "commit");
 
     DebugScopedSetMainThreadBlocked main_thread_blocked(this);
 
     RenderingStatsInstrumentation* stats_instrumentation =
         layer_tree_host_->rendering_stats_instrumentation();
@@ skipping 179 matching lines @@
 
   // Check for tree activation.
   if (completion_event_for_commit_held_on_tree_activation_ &&
       !layer_tree_host_impl_->pending_tree()) {
     TRACE_EVENT_INSTANT0("cc", "ReleaseCommitbyActivation");
     DCHECK(layer_tree_host_impl_->settings().impl_side_painting);
     completion_event_for_commit_held_on_tree_activation_->Signal();
     completion_event_for_commit_held_on_tree_activation_ = NULL;
   }
 
-  // Check for a pending compositeAndReadback.
+  // Check for a pending CompositeAndReadback.
   if (readback_request_on_impl_thread_) {
     readback_request_on_impl_thread_->success = false;
     if (draw_frame) {
       layer_tree_host_impl_->Readback(readback_request_on_impl_thread_->pixels,
                                       readback_request_on_impl_thread_->rect);
       readback_request_on_impl_thread_->success =
           !layer_tree_host_impl_->IsContextLost();
     }
     readback_request_on_impl_thread_->completion.Signal();
     readback_request_on_impl_thread_ = NULL;
@@ skipping 123 matching lines @@
         output_surface_recreation_callback_.callback());
   else if (result == LayerTreeHost::RecreateSucceeded)
     output_surface_recreation_callback_.Cancel();
 }
 
 void ThreadProxy::InitializeImplOnImplThread(CompletionEvent* completion,
                                              InputHandler* handler) {
   TRACE_EVENT0("cc", "ThreadProxy::InitializeImplOnImplThread");
   DCHECK(IsImplThread());
   layer_tree_host_impl_ = layer_tree_host_->CreateLayerTreeHostImpl(this);
-  const base::TimeDelta displayRefreshInterval =
+  const base::TimeDelta display_refresh_interval =
       base::TimeDelta::FromMicroseconds(base::Time::kMicrosecondsPerSecond /
                                         60);
   scoped_ptr<FrameRateController> frame_rate_controller;
   if (render_vsync_enabled_) {
     frame_rate_controller.reset(
         new FrameRateController(DelayBasedTimeSource::Create(
-            displayRefreshInterval, Proxy::ImplThread())));
+            display_refresh_interval, Proxy::ImplThread())));
   } else {
     frame_rate_controller.reset(new FrameRateController(Proxy::ImplThread()));
   }
   SchedulerSettings scheduler_settings;
   scheduler_settings.impl_side_painting =
       layer_tree_host_->settings().impl_side_painting;
   scheduler_on_impl_thread_ = Scheduler::Create(this,
                                                 frame_rate_controller.Pass(),
                                                 scheduler_settings);
   scheduler_on_impl_thread_->SetVisible(layer_tree_host_impl_->visible());
@@ skipping 20 matching lines @@
   TRACE_EVENT0("cc", "ThreadProxy::InitializeRendererOnImplThread");
   DCHECK(IsImplThread());
   DCHECK(output_surface_before_initialization_on_impl_thread_.get());
   *initialize_succeeded = layer_tree_host_impl_->InitializeRenderer(
       output_surface_before_initialization_on_impl_thread_.Pass());
   if (*initialize_succeeded) {
     *capabilities = layer_tree_host_impl_->GetRendererCapabilities();
     scheduler_on_impl_thread_->SetSwapBuffersCompleteSupported(
         capabilities->using_swap_complete_callback);
 
-    int maxFramesPending = layer_tree_host_impl_->output_surface()->
+    int max_frames_pending = layer_tree_host_impl_->output_surface()->
         capabilities().max_frames_pending;
-    if (maxFramesPending <= 0)
-      maxFramesPending = FrameRateController::DEFAULT_MAX_FRAMES_PENDING;
+    if (max_frames_pending <= 0)
+      max_frames_pending = FrameRateController::DEFAULT_MAX_FRAMES_PENDING;
     if (layer_tree_host_impl_->output_surface()->capabilities().
             has_parent_compositor)
-      maxFramesPending = 1;
-    scheduler_on_impl_thread_->SetMaxFramesPending(maxFramesPending);
+      max_frames_pending = 1;
+    scheduler_on_impl_thread_->SetMaxFramesPending(max_frames_pending);
   }
 
   completion->Signal();
 }
 
 void ThreadProxy::LayerTreeHostClosedOnImplThread(CompletionEvent* completion) {
   TRACE_EVENT0("cc", "ThreadProxy::LayerTreeHostClosedOnImplThread");
   DCHECK(IsImplThread());
   layer_tree_host_->DeleteContentsTexturesOnImplThread(
       layer_tree_host_impl_->resource_provider());
@@ skipping 182 matching lines @@
       base::Bind(&ThreadProxy::StartScrollbarAnimationOnImplThread,
                  impl_thread_weak_ptr_),
       delay);
 }
 
 void ThreadProxy::StartScrollbarAnimationOnImplThread() {
   layer_tree_host_impl_->StartScrollbarAnimation(base::TimeTicks::Now());
 }
 
 }  // namespace cc