Mac: Add more trace events for CAOpenGLLayers

content/common/gpu/image_transport_surface_calayer_mac.mm

 // Copyright 2014 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 "content/common/gpu/image_transport_surface_calayer_mac.h"
 
 #include <OpenGL/CGLRenderers.h>
 
 #include "base/command_line.h"
 #include "base/mac/sdk_forward_declarations.h"
+#include "base/trace_event/trace_event.h"
 #include "ui/accelerated_widget_mac/surface_handle_types.h"
 #include "ui/base/cocoa/animation_utils.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gl/gl_gl_api_implementation.h"
 #include "ui/gl/gl_switches.h"
 #include "ui/gl/gpu_switching_manager.h"
 
 namespace {
 const size_t kFramesToKeepCAContextAfterDiscard = 2;
 const size_t kCanDrawFalsesBeforeSwitchFromAsync = 4;
@@ skipping 269 matching lines @@
   can_draw_returned_false_count_ = 0;
 }
 
 void CALayerStorageProvider::FrameSizeChanged(const gfx::Size& pixel_size,
                                               float scale_factor) {
   DCHECK_EQ(fbo_pixel_size_.ToString(), pixel_size.ToString());
   DCHECK_EQ(fbo_scale_factor_, scale_factor);
 }
 
 void CALayerStorageProvider::SwapBuffers() {
+  TRACE_EVENT0("gpu", "CALayerStorageProvider::SwapBuffers");
   DCHECK(!has_pending_draw_);
 
+  // A trace value of 2 indicates that there is a pending swap ack. See
+  // LayerCanDraw for other value meanings.
+  TRACE_COUNTER_ID1("gpu", "CALayerPendingSwap", this, 2);
+
   // Recreate the CALayer on the new GPU if a GPU switch has occurred. Note
   // that the CAContext will retain a reference to the old CALayer until the
   // call to -[CAContext setLayer:] replaces the old CALayer with the new one.
   if (recreate_layer_after_gpu_switch_) {
     [layer_ resetStorageProvider];
     layer_.reset();
     recreate_layer_after_gpu_switch_ = false;
   }
 
   // Set the pending draw flag only after destroying the old layer (otherwise
@@ skipping 97 matching lines @@
     previously_discarded_contexts_.push_back(
         base::scoped_nsobject<CAContext>());
   }
   previously_discarded_contexts_.push_back(context_);
 
   context_.reset();
 }
 
 void CALayerStorageProvider::SwapBuffersAckedByBrowser(
     bool disable_throttling) {
+  TRACE_EVENT0("gpu", "CALayerStorageProvider::SwapBuffersAckedByBrowser");
   throttling_disabled_ = disable_throttling;
   if (!previously_discarded_contexts_.empty())
     previously_discarded_contexts_.pop_front();
 }
 
 CGLContextObj CALayerStorageProvider::LayerShareGroupContext() {
   return share_group_context_;
 }
 
 base::Closure CALayerStorageProvider::LayerShareGroupContextDirtiedCallback() {
   return share_group_context_dirtied_callback_;
 }
 
 bool CALayerStorageProvider::LayerCanDraw() {
+  TRACE_EVENT0("gpu", "CALayerStorageProvider::LayerCanDraw");
+
+  // This tracing would be more natural to do with a pseudo-thread for each
+  // layer, rather than a counter.
+  // http://crbug.com/366300
+  if (has_pending_draw_) {
+    // If there is a draw pending then increase the signal from 2 to 3, to
+    // indicate that there is a swap pending, and CoreAnimation has asked to
+    // draw it.
+    TRACE_COUNTER_ID1("gpu", "CALayerPendingSwap", this, 3);
+  } else {
+    // If there is not a draw pending, then give an instantaneous blip up from
+    // 0 to 1, indicating that CoreAnimation was ready to draw a frame but we
+    // were not (or didn't have new content to draw).
+    TRACE_COUNTER_ID1("gpu", "CALayerPendingSwap", this, 1);
+    TRACE_COUNTER_ID1("gpu", "CALayerPendingSwap", this, 0);
+  }
+
   if (has_pending_draw_) {
     can_draw_returned_false_count_ = 0;
     return true;
   } else {
     if ([layer_ isAsynchronous]) {
       DCHECK(!gpu_vsync_disabled_);
       // If we are in asynchronous mode, we will be getting callbacks at every
       // vsync, asking us if we have anything to draw. If we get many of these
       // in a row, ask that we stop getting these callback for now, so that we
       // don't waste CPU cycles.
       if (can_draw_returned_false_count_ >= kCanDrawFalsesBeforeSwitchFromAsync)
         [layer_ setAsynchronous:NO];
       else
         can_draw_returned_false_count_ += 1;
     }
     return false;
   }
 }
 
 void CALayerStorageProvider::LayerDoDraw() {
+  TRACE_EVENT0("gpu", "CALayerStorageProvider::LayerDoDraw");
   if (gfx::GetGLImplementation() ==
       gfx::kGLImplementationDesktopGLCoreProfile) {
     glClearColor(1, 0, 1, 1);
     glClear(GL_COLOR_BUFFER_BIT);
     glDisable(GL_BLEND);
     glDisable(GL_CULL_FACE);
     glDisable(GL_DEPTH_TEST);
     glDisable(GL_STENCIL_TEST);
     glDisable(GL_SCISSOR_TEST);
 
@@ skipping 80 matching lines @@
 
 void CALayerStorageProvider::UnblockBrowserIfNeeded() {
   if (!has_pending_draw_)
     return;
   pending_draw_weak_factory_.InvalidateWeakPtrs();
   has_pending_draw_ = false;
   transport_surface_->SendSwapBuffers(
       ui::SurfaceHandleFromCAContextID([context_ contextId]),
       fbo_pixel_size_,
       fbo_scale_factor_);
+
+  // A trace value of 0 indicates that there is no longer a pending swap ack.
+  TRACE_COUNTER_ID1("gpu", "CALayerPendingSwap", this, 0);
 }
 
 }  //  namespace content