Decouple PassThroughImageTransportSurface from GpuCommandBufferStub

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/command_line.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"

[piman, 2016/11/09 22:49:36]

nit: is this still needed?

[Fady Samuel, 2016/11/09 23:28:10]

nope, removing.

 #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/base/ui_base_switches.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/swap_result.h"
 #include "ui/gfx/transform.h"
@@ skipping 15 matching lines @@
 }
 
 void IOSurfaceContextNoOp(scoped_refptr<ui::IOSurfaceContext>) {
 }
 
 }  // namespace
 
 namespace gpu {
 
 ImageTransportSurfaceOverlayMac::ImageTransportSurfaceOverlayMac(
-    GpuCommandBufferStub* stub)
-    : stub_(stub->AsWeakPtr()),
+    base::WeakPtr<ImageTransportSurfaceDelegate> delegate)
+    : delegate_(delegate),
       use_remote_layer_api_(ui::RemoteLayerAPISupported()),
       scale_factor_(1),
       gl_renderer_id_(0) {
   ui::GpuSwitchingManager::GetInstance()->AddObserver(this);
 
   static bool av_disabled_at_command_line =
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableAVFoundationOverlays);
 
   bool allow_av_sample_buffer_display_layer =
       !av_disabled_at_command_line &&
-      !stub_->GetFeatureInfo()
+      !delegate_->GetFeatureInfo()
            ->workarounds()
            .disable_av_sample_buffer_display_layer;
 
   ca_layer_tree_coordinator_.reset(new ui::CALayerTreeCoordinator(
       use_remote_layer_api_, allow_av_sample_buffer_display_layer));
 }
 
 ImageTransportSurfaceOverlayMac::~ImageTransportSurfaceOverlayMac() {
   ui::GpuSwitchingManager::GetInstance()->RemoveObserver(this);
-  if (stub_.get()) {
-    stub_->SetLatencyInfoCallback(
+  if (delegate_.get()) {
+    delegate_->SetLatencyInfoCallback(
         base::Callback<void(const std::vector<ui::LatencyInfo>&)>());
   }
   Destroy();
 }
 
 bool ImageTransportSurfaceOverlayMac::Initialize(gl::GLSurface::Format format) {
-  if (!stub_.get() || !stub_->decoder())
+  if (!delegate_)
     return false;
 
-  stub_->SetLatencyInfoCallback(
+  delegate_->SetLatencyInfoCallback(
       base::Bind(&ImageTransportSurfaceOverlayMac::SetLatencyInfo,
                  base::Unretained(this)));
 
   // Create the CAContext to send this to the GPU process, and the layer for
   // the context.
   if (use_remote_layer_api_) {
     CGSConnectionID connection_id = CGSMainConnectionID();
     ca_context_.reset([
         [CAContext contextWithCGSConnection:connection_id options:@{}] retain]);
     [ca_context_ setLayer:ca_layer_tree_coordinator_->GetCALayerForDisplay()];
@@ skipping 34 matching lines @@
     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>(gl::GetGLImplementation()),
                        "width", size.width());
 
-  GpuCommandBufferMsg_SwapBuffersCompleted_Params params;
+  SwapBuffersCompleteParams params;
   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;
 
   for (auto& query : ca_layer_in_use_queries_) {
     gpu::TextureInUseResponse response;
     response.texture = query.texture;
     bool in_use = false;
     gl::GLImageIOSurface* io_surface_image =
         gl::GLImageIOSurface::FromGLImage(query.image.get());
     if (io_surface_image) {
       in_use = io_surface_image->CanCheckIOSurfaceIsInUse() &&
                IOSurfaceIsInUse(io_surface_image->io_surface());
     }
     response.in_use = in_use;
     params.in_use_responses.push_back(std::move(response));
   }
   ca_layer_in_use_queries_.clear();
 
-  stub_->SendSwapBuffersCompleted(params);
+  delegate_->DidSwapBuffersComplete(std::move(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
@@ skipping 200 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