Make Mac swap code like other platforms

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/mac/scoped_cftyperef.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"
+#include "ui/gfx/swap_result.h"
 #include "ui/gfx/transform.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_fence.h"
 #include "ui/gl/gl_image_io_surface.h"
 #include "ui/gl/gpu_switching_manager.h"
 #include "ui/gl/scoped_api.h"
 #include "ui/gl/scoped_cgl.h"
 
 namespace {
 
 void CheckGLErrors(const char* msg) {
   GLenum gl_error;
   while ((gl_error = glGetError()) != GL_NO_ERROR) {
     LOG(ERROR) << "OpenGL error hit " << msg << ": " << gl_error;
   }
 }
 
 void IOSurfaceContextNoOp(scoped_refptr<ui::IOSurfaceContext>) {
 }
 
 }  // namespace
 
 namespace gpu {
 
 scoped_refptr<gfx::GLSurface> ImageTransportSurfaceCreateNativeSurface(
     GpuChannelManager* manager,
     GpuCommandBufferStub* stub,
     SurfaceHandle handle) {
-  return new ImageTransportSurfaceOverlayMac(manager, stub, handle);
+  return new ImageTransportSurfaceOverlayMac(stub, handle);
 }
 
 ImageTransportSurfaceOverlayMac::ImageTransportSurfaceOverlayMac(
-    GpuChannelManager* manager,
     GpuCommandBufferStub* stub,
     SurfaceHandle handle)
-    : manager_(manager),
-      stub_(stub->AsWeakPtr()),
+    : stub_(stub->AsWeakPtr()),
       handle_(handle),
       use_remote_layer_api_(ui::RemoteLayerAPISupported()),
       scale_factor_(1),
-      gl_renderer_id_(0),
-      vsync_parameters_valid_(false) {
-  manager_->AddBufferPresentedCallback(
-      handle_, base::Bind(&ImageTransportSurfaceOverlayMac::BufferPresented,
-                          base::Unretained(this)));
+      gl_renderer_id_(0) {
   ui::GpuSwitchingManager::GetInstance()->AddObserver(this);
   ca_layer_tree_coordinator_.reset(
       new ui::CALayerTreeCoordinator(use_remote_layer_api_));
 }
 
 ImageTransportSurfaceOverlayMac::~ImageTransportSurfaceOverlayMac() {
   ui::GpuSwitchingManager::GetInstance()->RemoveObserver(this);
   if (stub_.get()) {
     stub_->SetLatencyInfoCallback(
         base::Callback<void(const std::vector<ui::LatencyInfo>&)>());
   }
   Destroy();
-  manager_->RemoveBufferPresentedCallback(handle_);
 }
 
 bool ImageTransportSurfaceOverlayMac::Initialize(
     gfx::GLSurface::Format format) {
   if (!stub_.get() || !stub_->decoder())
     return false;
 
   stub_->SetLatencyInfoCallback(
       base::Bind(&ImageTransportSurfaceOverlayMac::SetLatencyInfo,
                  base::Unretained(this)));
@@ skipping 21 matching lines @@
 bool ImageTransportSurfaceOverlayMac::IsOffscreen() {
   return false;
 }
 
 void ImageTransportSurfaceOverlayMac::SetLatencyInfo(
     const std::vector<ui::LatencyInfo>& latency_info) {
   latency_info_.insert(latency_info_.end(), latency_info.begin(),
                        latency_info.end());
 }
 
-void ImageTransportSurfaceOverlayMac::BufferPresented(
-    gpu::SurfaceHandle surface_handle,
-    const base::TimeTicks& vsync_timebase,
-    const base::TimeDelta& vsync_interval) {
-  vsync_timebase_ = vsync_timebase;
-  vsync_interval_ = vsync_interval;
-  vsync_parameters_valid_ = !vsync_interval_.is_zero();
-
-  // Compute |vsync_timebase_| to be the first vsync after time zero.
-  if (vsync_parameters_valid_) {
-    vsync_timebase_ -=
-        vsync_interval_ *
-        ((vsync_timebase_ - base::TimeTicks()) / vsync_interval_);
-  }
-}
-
 void ImageTransportSurfaceOverlayMac::SendAcceleratedSurfaceBuffersSwapped(
     gpu::SurfaceHandle surface_handle,
     CAContextID ca_context_id,
     bool fullscreen_low_power_ca_context_valid,
     CAContextID fullscreen_low_power_ca_context_id,
     const gfx::ScopedRefCountedIOSurfaceMachPort& io_surface,
     const gfx::Size& size,
     float scale_factor,
     std::vector<ui::LatencyInfo> latency_info) {
   // TRACE_EVENT for gpu tests:
   TRACE_EVENT_INSTANT2("test_gpu", "SwapBuffers", TRACE_EVENT_SCOPE_THREAD,
                        "GLImpl", static_cast<int>(gfx::GetGLImplementation()),
                        "width", size.width());
-  manager_->delegate()->SendAcceleratedSurfaceBuffersSwapped(
-      surface_handle, ca_context_id, fullscreen_low_power_ca_context_valid,
-      fullscreen_low_power_ca_context_id, io_surface, size, scale_factor,
-      std::move(latency_info));
+
+  GpuCommandBufferMsg_SwapBuffersCompleted_Params params;
+  params.surface_handle = surface_handle;
+  params.ca_context_id = ca_context_id;
+  params.fullscreen_low_power_ca_context_valid =
+      fullscreen_low_power_ca_context_valid;
+  params.fullscreen_low_power_ca_context_id =
+      fullscreen_low_power_ca_context_id;
+  params.io_surface = io_surface;
+  params.pixel_size = size;
+  params.scale_factor = scale_factor;
+  params.latency_info = std::move(latency_info);
+  params.result = gfx::SwapResult::SWAP_ACK;
+  stub_->SendSwapBuffersCompleted(params);
 }
 
 gfx::SwapResult ImageTransportSurfaceOverlayMac::SwapBuffersInternal(
     const gfx::Rect& pixel_damage_rect) {
   TRACE_EVENT0("gpu", "ImageTransportSurfaceOverlayMac::SwapBuffersInternal");
 
   // A glFlush is necessary to ensure correct content appears. A glFinish
   // appears empirically to be the best way to get maximum performance when
   // GPU bound.
   {
@@ skipping 152 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::MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(&IOSurfaceContextNoOp, context_on_new_gpu));
 }
 
 }  // namespace gpu