Move AcceleratedSurfaceBuffersSwappedParams to content/common

content/common/gpu/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 "content/common/gpu/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 "content/common/gpu/accelerated_surface_buffers_swapped_params_mac.h"
 #include "content/common/gpu/buffer_presented_params_mac.h"
 #include "content/common/gpu/ca_layer_partial_damage_tree_mac.h"
 #include "content/common/gpu/ca_layer_tree_mac.h"
 #include "content/common/gpu/gpu_channel_manager.h"
 #include "content/common/gpu/gpu_channel_manager_delegate.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/transform.h"
@@ skipping 154 matching lines @@
 
   // 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(
-    AcceleratedSurfaceBuffersSwappedParams params) {
+    int32_t surface_id,
+    CAContextID 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", params.size.width());
+                       "width", size.width());
   // On mac, handle_ is a surface id. See
   // GpuProcessTransportFactory::CreatePerCompositorData
-  params.surface_id = handle_;
-  manager_->delegate()->SendAcceleratedSurfaceBuffersSwapped(params);
+  manager_->delegate()->SendAcceleratedSurfaceBuffersSwapped(
+      surface_id, ca_context_id, io_surface, size, scale_factor,
+      std::move(latency_info));
 }
 
 gfx::SwapResult ImageTransportSurfaceOverlayMac::SwapBuffersInternal(
     const gfx::Rect& pixel_damage_rect) {
   TRACE_EVENT0("gpu", "ImageTransportSurfaceOverlayMac::SwapBuffersInternal");
 
   // Use the same concept of 'now' for the entire function. The duration of
   // this function only affect the result if this function lasts across a vsync
   // boundary, in which case smooth animation is out the window anyway.
   const base::TimeTicks now = base::TimeTicks::Now();
@@ skipping 132 matching lines @@
   base::TimeTicks swap_time = base::TimeTicks::Now();
   for (auto latency_info : swap->latency_info) {
     latency_info.AddLatencyNumberWithTimestamp(
         ui::INPUT_EVENT_GPU_SWAP_BUFFER_COMPONENT, 0, 0, swap_time, 1);
     latency_info.AddLatencyNumberWithTimestamp(
         ui::INPUT_EVENT_LATENCY_TERMINATED_FRAME_SWAP_COMPONENT, 0, 0,
         swap_time, 1);
   }
 
   // Send acknowledgement to the browser.
-  AcceleratedSurfaceBuffersSwappedParams params;
+  CAContextID ca_context_id = 0;
+  gfx::ScopedRefCountedIOSurfaceMachPort io_surface;
   if (use_remote_layer_api_) {
-    params.ca_context_id = [ca_context_ contextId];
+    ca_context_id = [ca_context_ contextId];
   } else if (current_partial_damage_tree_) {
-    params.io_surface.reset(IOSurfaceCreateMachPort(
+    io_surface.reset(IOSurfaceCreateMachPort(
         current_partial_damage_tree_->RootLayerIOSurface()));
   }
-  params.size = swap->pixel_size;
-  params.scale_factor = swap->scale_factor;
-  params.latency_info.swap(swap->latency_info);
-  SendAcceleratedSurfaceBuffersSwapped(params);
+  gfx::Size size = swap->pixel_size;
+  float scale_factor = swap->scale_factor;
+  std::vector<ui::LatencyInfo> latency_info;
+  latency_info.swap(swap->latency_info);
+  SendAcceleratedSurfaceBuffersSwapped(handle_, ca_context_id, io_surface, size,
+                                       scale_factor, std::move(latency_info));
 
   // Remove this from the queue, and reset any callback timers.
   pending_swaps_.pop_front();
 }
 
 void ImageTransportSurfaceOverlayMac::DisplayAndClearAllPendingSwaps() {
   TRACE_EVENT0("gpu",
       "ImageTransportSurfaceOverlayMac::DisplayAndClearAllPendingSwaps");
   while (!pending_swaps_.empty())
     DisplayFirstPendingSwapImmediately();
@@ skipping 161 matching lines @@
   // Compute the previous vsync time.
   base::TimeTicks previous_vsync =
       vsync_interval_ * ((from - vsync_timebase_) / vsync_interval_) +
       vsync_timebase_;
 
   // Return |interval_fraction| through the next vsync.
   return previous_vsync + (1 + interval_fraction) * vsync_interval_;
 }
 
 }  // namespace content