cc: Add TRACE_EVENTs to SingleThreadProxy

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 <string>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
@@ skipping 383 matching lines @@
 
   if (main().commit_requested)
     return;
   TRACE_EVENT0("cc", "ThreadProxy::SetNeedsCommit");
   main().commit_requested = true;
 
   SendCommitRequestToImplThreadIfNeeded();
 }
 
 void ThreadProxy::DidLoseOutputSurfaceOnImplThread() {
+  TRACE_EVENT0("cc", "ThreadProxy::DidLoseOutputSurfaceOnImplThread");
   DCHECK(IsImplThread());
-  TRACE_EVENT0("cc", "ThreadProxy::DidLoseOutputSurfaceOnImplThread");
   CheckOutputSurfaceStatusOnImplThread();
 }
 
 void ThreadProxy::CheckOutputSurfaceStatusOnImplThread() {
+  TRACE_EVENT0("cc", "ThreadProxy::CheckOutputSurfaceStatusOnImplThread");
   DCHECK(IsImplThread());
-  TRACE_EVENT0("cc", "ThreadProxy::CheckOutputSurfaceStatusOnImplThread");
   if (!impl().layer_tree_host_impl->IsContextLost())
     return;
   if (ContextProvider* offscreen_contexts =
           impl().layer_tree_host_impl->offscreen_context_provider())
     offscreen_contexts->VerifyContexts();
   impl().scheduler->DidLoseOutputSurface();
 }
 
 void ThreadProxy::OnSwapBuffersCompleteOnImplThread() {
+  TRACE_EVENT0("cc", "ThreadProxy::OnSwapBuffersCompleteOnImplThread");
   DCHECK(IsImplThread());
-  TRACE_EVENT0("cc", "ThreadProxy::OnSwapBuffersCompleteOnImplThread");
   Proxy::MainThreadTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&ThreadProxy::DidCompleteSwapBuffers, main_thread_weak_ptr_));
 }
 
 void ThreadProxy::SetNeedsBeginImplFrame(bool enable) {
+  TRACE_EVENT1("cc", "ThreadProxy::SetNeedsBeginImplFrame", "enable", enable);
   DCHECK(IsImplThread());
-  TRACE_EVENT1("cc", "ThreadProxy::SetNeedsBeginImplFrame", "enable", enable);
   impl().layer_tree_host_impl->SetNeedsBeginImplFrame(enable);
   UpdateBackgroundAnimateTicking();
 }
 
 void ThreadProxy::BeginImplFrame(const BeginFrameArgs& args) {
+  TRACE_EVENT0("cc", "ThreadProxy::BeginImplFrame");
   DCHECK(IsImplThread());
-  TRACE_EVENT0("cc", "ThreadProxy::BeginImplFrame");
 
   // Sample the frame time now. This time will be used for updating animations
   // when we draw.
   impl().layer_tree_host_impl->CurrentFrameTimeTicks();
 
   impl().scheduler->BeginImplFrame(args);
 }
 
 void ThreadProxy::OnCanDrawStateChanged(bool can_draw) {
-  DCHECK(IsImplThread());
   TRACE_EVENT1(
       "cc", "ThreadProxy::OnCanDrawStateChanged", "can_draw", can_draw);
+  DCHECK(IsImplThread());
   impl().scheduler->SetCanDraw(can_draw);
   UpdateBackgroundAnimateTicking();
 }
 
 void ThreadProxy::NotifyReadyToActivate() {
   TRACE_EVENT0("cc", "ThreadProxy::NotifyReadyToActivate");
   impl().scheduler->NotifyReadyToActivate();
 }
 
 void ThreadProxy::SetNeedsCommitOnImplThread() {
+  TRACE_EVENT0("cc", "ThreadProxy::SetNeedsCommitOnImplThread");
   DCHECK(IsImplThread());
-  TRACE_EVENT0("cc", "ThreadProxy::SetNeedsCommitOnImplThread");
   impl().scheduler->SetNeedsCommit();
 }
 
 void ThreadProxy::PostAnimationEventsToMainThreadOnImplThread(
     scoped_ptr<AnimationEventsVector> events,
     base::Time wall_clock_time) {
-  DCHECK(IsImplThread());
   TRACE_EVENT0("cc",
                "ThreadProxy::PostAnimationEventsToMainThreadOnImplThread");
+  DCHECK(IsImplThread());
   Proxy::MainThreadTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&ThreadProxy::SetAnimationEvents,
                  main_thread_weak_ptr_,
                  base::Passed(&events),
                  wall_clock_time));
 }
 
 bool ThreadProxy::ReduceContentsTextureMemoryOnImplThread(size_t limit_bytes,
                                                           int priority_cutoff) {
@@ skipping 36 matching lines @@
 
   impl().layer_tree_host_impl->SendManagedMemoryStats(
       impl().contents_texture_manager->MemoryVisibleBytes(),
       impl().contents_texture_manager->MemoryVisibleAndNearbyBytes(),
       impl().contents_texture_manager->MemoryUseBytes());
 }
 
 bool ThreadProxy::IsInsideDraw() { return impl().inside_draw; }
 
 void ThreadProxy::SetNeedsRedraw(const gfx::Rect& damage_rect) {
+  TRACE_EVENT0("cc", "ThreadProxy::SetNeedsRedraw");
   DCHECK(IsMainThread());
-  TRACE_EVENT0("cc", "ThreadProxy::SetNeedsRedraw");
   Proxy::ImplThreadTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&ThreadProxy::SetNeedsRedrawRectOnImplThread,
                  impl_thread_weak_ptr_,
                  damage_rect));
 }
 
 void ThreadProxy::SetNextCommitWaitsForActivation() {
   DCHECK(IsMainThread());
   DCHECK(!blocked_main().main_thread_inside_commit);
@@ skipping 22 matching lines @@
   DCHECK(IsMainThread());
   return main().commit_requested;
 }
 
 bool ThreadProxy::BeginMainFrameRequested() const {
   DCHECK(IsMainThread());
   return main().commit_request_sent_to_impl_thread;
 }
 
 void ThreadProxy::SetNeedsRedrawOnImplThread() {
+  TRACE_EVENT0("cc", "ThreadProxy::SetNeedsRedrawOnImplThread");
   DCHECK(IsImplThread());
-  TRACE_EVENT0("cc", "ThreadProxy::SetNeedsRedrawOnImplThread");
   impl().scheduler->SetNeedsRedraw();
 }
 
 void ThreadProxy::SetNeedsManageTilesOnImplThread() {
   DCHECK(IsImplThread());
   impl().scheduler->SetNeedsManageTiles();
 }
 
 void ThreadProxy::SetNeedsRedrawRectOnImplThread(const gfx::Rect& damage_rect) {
   DCHECK(IsImplThread());
   impl().layer_tree_host_impl->SetViewportDamage(damage_rect);
   SetNeedsRedrawOnImplThread();
 }
 
 void ThreadProxy::SetSwapUsedIncompleteTileOnImplThread(
     bool used_incomplete_tile) {
   DCHECK(IsImplThread());
   if (used_incomplete_tile) {
     TRACE_EVENT_INSTANT0("cc",
                          "ThreadProxy::SetSwapUsedIncompleteTileOnImplThread",
                          TRACE_EVENT_SCOPE_THREAD);
   }
   impl().scheduler->SetSwapUsedIncompleteTile(used_incomplete_tile);
 }
 
 void ThreadProxy::DidInitializeVisibleTileOnImplThread() {
+  TRACE_EVENT0("cc", "ThreadProxy::DidInitializeVisibleTileOnImplThread");
   DCHECK(IsImplThread());
-  TRACE_EVENT0("cc", "ThreadProxy::DidInitializeVisibleTileOnImplThread");
   impl().scheduler->SetNeedsRedraw();
 }
 
 void ThreadProxy::MainThreadHasStoppedFlinging() {
   DCHECK(IsMainThread());
   Proxy::ImplThreadTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&ThreadProxy::MainThreadHasStoppedFlingingOnImplThread,
                  impl_thread_weak_ptr_));
 }
@@ skipping 466 matching lines @@
 
   impl().commit_complete_time = base::TimeTicks::HighResNow();
   impl().begin_main_frame_to_commit_duration_history.InsertSample(
       impl().commit_complete_time - impl().begin_main_frame_sent_time);
 
   // SetVisible kicks off the next scheduler action, so this must be last.
   impl().scheduler->SetVisible(impl().layer_tree_host_impl->visible());
 }
 
 void ThreadProxy::ScheduledActionUpdateVisibleTiles() {
+  TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionUpdateVisibleTiles");
   DCHECK(IsImplThread());
-  TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionUpdateVisibleTiles");
   impl().layer_tree_host_impl->UpdateVisibleTiles();
 }
 
 void ThreadProxy::ScheduledActionActivatePendingTree() {
+  TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionActivatePendingTree");
   DCHECK(IsImplThread());
-  TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionActivatePendingTree");
   impl().layer_tree_host_impl->ActivatePendingTree();
 }
 
 void ThreadProxy::ScheduledActionBeginOutputSurfaceCreation() {
+  TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionBeginOutputSurfaceCreation");
   DCHECK(IsImplThread());
-  TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionBeginOutputSurfaceCreation");
   Proxy::MainThreadTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&ThreadProxy::CreateAndInitializeOutputSurface,
                  main_thread_weak_ptr_));
 }
 
 DrawSwapReadbackResult ThreadProxy::DrawSwapReadbackInternal(
     bool forced_draw,
     bool swap_requested,
     bool readback_requested) {
@@ skipping 545 matching lines @@
       base::Bind(&ThreadProxy::StartScrollbarAnimationOnImplThread,
                  impl_thread_weak_ptr_),
       delay);
 }
 
 void ThreadProxy::StartScrollbarAnimationOnImplThread() {
   impl().layer_tree_host_impl->StartScrollbarAnimation();
 }
 
 void ThreadProxy::DidActivatePendingTree() {
+  TRACE_EVENT0("cc", "ThreadProxy::DidActivatePendingTreeOnImplThread");
   DCHECK(IsImplThread());
-  TRACE_EVENT0("cc", "ThreadProxy::DidActivatePendingTreeOnImplThread");
 
   if (impl().completion_event_for_commit_held_on_tree_activation &&
       !impl().layer_tree_host_impl->pending_tree()) {
     TRACE_EVENT_INSTANT0(
         "cc", "ReleaseCommitbyActivation", TRACE_EVENT_SCOPE_THREAD);
     DCHECK(impl().layer_tree_host_impl->settings().impl_side_painting);
     impl().completion_event_for_commit_held_on_tree_activation->Signal();
     impl().completion_event_for_commit_held_on_tree_activation = NULL;
   }
 
   UpdateBackgroundAnimateTicking();
 
   impl().commit_to_activate_duration_history.InsertSample(
       base::TimeTicks::HighResNow() - impl().commit_complete_time);
 }
 
 void ThreadProxy::DidManageTiles() {
   DCHECK(IsImplThread());
   impl().scheduler->DidManageTiles();
 }
 
 }  // namespace cc