Mac: Loosen CoreAnimation blacklist on 10.10 and histograms to watch

gpu/ipc/service/image_transport_surface_overlay_mac.mm

 // Copyright 2015 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 "gpu/ipc/service/image_transport_surface_overlay_mac.h"
 
 #include <CoreGraphics/CoreGraphics.h>
 #include <IOSurface/IOSurface.h>
 #include <OpenGL/CGLRenderers.h>
 #include <OpenGL/CGLTypes.h>
 #include <OpenGL/gl.h>
 #include <stddef.h>
 
 #include <algorithm>
 
 // This type consistently causes problem on Mac, and needs to be dealt with
 // in a systemic way.
 // http://crbug.com/517208
 #ifndef GL_OES_EGL_image
 typedef void* GLeglImageOES;
 #endif
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "gpu/ipc/common/gpu_messages.h"
 #include "gpu/ipc/service/gpu_channel_manager.h"
 #include "gpu/ipc/service/gpu_channel_manager_delegate.h"
 #include "ui/accelerated_widget_mac/ca_layer_tree_coordinator.h"
 #include "ui/accelerated_widget_mac/io_surface_context.h"
 #include "ui/base/cocoa/animation_utils.h"
 #include "ui/base/cocoa/remote_layer_api.h"
 #include "ui/gfx/geometry/rect_conversions.h"
@@ skipping 140 matching lines @@
   }
   ca_layer_in_use_queries_.clear();
 
   stub_->SendSwapBuffersCompleted(params);
 }
 
 gfx::SwapResult ImageTransportSurfaceOverlayMac::SwapBuffersInternal(
     const gfx::Rect& pixel_damage_rect) {
   TRACE_EVENT0("gpu", "ImageTransportSurfaceOverlayMac::SwapBuffersInternal");
 
+  base::TimeTicks before_flush_time;
+  base::TimeTicks after_flush_before_commit_time;
+
   // If supported, use GLFence to ensure that we haven't gotten more than one
   // frame ahead of GL.
   if (gl::GLFence::IsSupported()) {
     gl::ScopedSetGLToRealGLApi scoped_set_gl_api;
     CheckGLErrors("Before fence/flush");
 
     // If we have gotten more than one frame ahead of GL, wait for the previous
     // frame to complete.
     if (previous_frame_fence_) {
       TRACE_EVENT0("gpu", "ImageTransportSurfaceOverlayMac::ClientWait");
@@ skipping 13 matching lines @@
       while (!previous_frame_fence_->HasCompleted() && timeout_msec > 0) {
         --timeout_msec;
         base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(1));
       }
       if (!previous_frame_fence_->HasCompleted()) {
         // We timed out waiting for the above fence, just issue a glFinish.
         glFinish();
       }
     }
 
+    before_flush_time = base::TimeTicks::Now();
+
     // Create a fence for the current frame's work and save the context.
     previous_frame_fence_.reset(gl::GLFence::Create());
     fence_context_obj_.reset(CGLGetCurrentContext(),
                              base::scoped_policy::RETAIN);
 
     // A glFlush is necessary to ensure correct content appears.
     glFlush();
+    CheckGLErrors("After fence/flush");
 
-    CheckGLErrors("After fence/flush");
+    after_flush_before_commit_time = base::TimeTicks::Now();
+    UMA_HISTOGRAM_TIMES("GPU.IOSurface.GLFlushTime",
+                        after_flush_before_commit_time - before_flush_time);
   } else {
     // GLFence isn't supported - issue a glFinish on each frame to ensure
     // there is backpressure from GL.
     gl::ScopedSetGLToRealGLApi scoped_set_gl_api;
     TRACE_EVENT0("gpu", "ImageTransportSurfaceOverlayMac::glFinish");
     CheckGLErrors("Before finish");
     glFinish();
     CheckGLErrors("After finish");
+    after_flush_before_commit_time = base::TimeTicks::Now();
   }
 
-  base::TimeTicks finish_time = base::TimeTicks::Now();
-
   bool fullscreen_low_power_layer_valid = false;
   ca_layer_tree_coordinator_->CommitPendingTreesToCA(
       pixel_damage_rect, &fullscreen_low_power_layer_valid);
-  // TODO(ccameron): Plumb the fullscreen low power layer through to the
-  // appropriate window.
+
+  base::TimeTicks after_transaction_time = base::TimeTicks::Now();
+  UMA_HISTOGRAM_TIMES("GPU.IOSurface.CATransactionTime",
+                      after_transaction_time - after_flush_before_commit_time);
 
   // Update the latency info to reflect the swap time.
   for (auto& latency_info : latency_info_) {
     latency_info.AddLatencyNumberWithTimestamp(
-        ui::INPUT_EVENT_GPU_SWAP_BUFFER_COMPONENT, 0, 0, finish_time, 1);
+        ui::INPUT_EVENT_GPU_SWAP_BUFFER_COMPONENT, 0, 0,
+        after_flush_before_commit_time, 1);
     latency_info.AddLatencyNumberWithTimestamp(
         ui::INPUT_EVENT_LATENCY_TERMINATED_FRAME_SWAP_COMPONENT, 0, 0,
-        finish_time, 1);
+        after_flush_before_commit_time, 1);
   }
 
   // Send acknowledgement to the browser.
   CAContextID ca_context_id = 0;
   CAContextID fullscreen_low_power_ca_context_id = 0;
   gfx::ScopedRefCountedIOSurfaceMachPort io_surface_mach_port;
   if (use_remote_layer_api_) {
     ca_context_id = [ca_context_ contextId];
     fullscreen_low_power_ca_context_id =
         [fullscreen_low_power_ca_context_ contextId];
@@ skipping 117 matching lines @@
   gl_renderer_id_ = context_renderer_id & kCGLRendererIDMatchingMask;
 
   // Post a task holding a reference to the new GL context. The reason for
   // this is to avoid creating-then-destroying the context for every image
   // transport surface that is observing the GPU switch.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&IOSurfaceContextNoOp, context_on_new_gpu));
 }
 
 }  // namespace gpu