Fix bug whereby OnGpuSwitched was never called

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>
@@ skipping 172 matching lines @@
   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()) {
     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");
+      TRACE_EVENT0("gpu", "ClientWait");
 
       // Ensure we are using the context with which the fence was created.
       gl::ScopedCGLSetCurrentContext scoped_set_current(fence_context_obj_);
 
       // While we could call GLFence::ClientWait, this performs a busy wait on
       // Mac, leading to high CPU usage. Instead we poll with a 1ms delay. This
       // should have minimal impact, as we will only hit this path when we are
       // more than one frame (16ms) behind.
       //
       // Note that on some platforms (10.9), fences appear to sometimes get
@@ skipping 11 matching lines @@
     }
 
     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");
+    {
+      TRACE_EVENT0("gpu", "glFlush");
+      glFlush();
+      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.
-    TRACE_EVENT0("gpu", "ImageTransportSurfaceOverlayMac::glFinish");
+    TRACE_EVENT0("gpu", "glFinish");
     CheckGLErrors("Before finish");
     glFinish();
     CheckGLErrors("After finish");
     after_flush_before_commit_time = base::TimeTicks::Now();
   }
 
   bool fullscreen_low_power_layer_valid = false;
-  ca_layer_tree_coordinator_->CommitPendingTreesToCA(
-      pixel_damage_rect, &fullscreen_low_power_layer_valid);
+  {
+    TRACE_EVENT0("gpu", "CommitPendingTreesToCA");
+    ca_layer_tree_coordinator_->CommitPendingTreesToCA(
+        pixel_damage_rect, &fullscreen_low_power_layer_valid);
+  }
 
   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,
         after_flush_before_commit_time, 1);
@@ skipping 145 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