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
+  // canDrawInCGLContext for other value meanings.

[erikchen, 2015/05/14 01:43:53]

This comment is out of date.

[ccameron, 2015/05/14 01:55:12]

Oops. Changed to LayerCanDraw.

+  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");
+
+  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);

[erikchen, 2015/05/14 01:43:53]

Why is this not an instantaneous blip? When I look at the code in
"ui/accelerated_widget_mac/io_surface_layer.mm", which appears to be where you
mostly copied the comments/formatting of this tracing from, it immediately drops
back down to 2/0.

[ccameron, 2015/05/14 01:55:12]

I didn't feel that having a blip was helpful. It won't be the case that you get
multiple LayerCanDraw calls (a blip would suggest that). It's also useful to see
the "can have draw and draw is ready" as a separate state (it's a very brief
state).

I changed the IOSurface code to do it this way.

+  } 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