Decouple browser-specific GPU IPC messages from GPU service IPCs

content/common/gpu/image_transport_surface.cc

 // Copyright (c) 2012 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.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "content/common/gpu/gpu_channel.h"
 #include "content/common/gpu/gpu_channel_manager.h"
+#include "content/common/gpu/gpu_channel_manager_delegate.h"
 #include "content/common/gpu/gpu_command_buffer_stub.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "gpu/command_buffer/service/sync_point_manager.h"
 #include "ui/gfx/vsync_provider.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_switches.h"
 
+#if defined(OS_MACOSX)
+#include "content/common/gpu/accelerated_surface_buffers_swapped_params_mac.h"
+#include "ui/accelerated_widget_mac/accelerated_widget_mac.h"
+#endif
+
 namespace content {
 
 ImageTransportSurface::ImageTransportSurface() {}
 
 ImageTransportSurface::~ImageTransportSurface() {}
 
 scoped_refptr<gfx::GLSurface> ImageTransportSurface::CreateSurface(
     GpuChannelManager* manager,
     GpuCommandBufferStub* stub,
     const gfx::GLSurfaceHandle& handle,
@@ skipping 11 matching lines @@
 }
 
 ImageTransportHelper::ImageTransportHelper(ImageTransportSurface* surface,
                                            GpuChannelManager* manager,
                                            GpuCommandBufferStub* stub,
                                            gfx::PluginWindowHandle handle)
     : surface_(surface),
       manager_(manager),
       stub_(stub->AsWeakPtr()),
       handle_(handle) {
   route_id_ = manager_->GenerateRouteID();

[no sievers, 2016/02/22 21:57:42]

It doesn't seem right to use GenerateRouteID() here.
Luckily, on Mac the PluginWindowHandle is the surface_id, so we can use that.

But can you move all of this out of ImageTransportHelper, since it's only used
on Mac nowadays, and so that it's obvious what we're doing here with the handle?
(I think it just means moving the Add/RemoveITS() call site from here and into
ImageTransportSurfaceOverlayMac, and removing some code here.)

[Fady Samuel, 2016/02/23 04:45:27]

I've filed a bug to move code out of ImageTransportHelper:
https://bugs.chromium.org/p/chromium/issues/detail?id=588958

I've set it as a blocker to make sure it gets done, but I'd like to do it in a
separate CL so this CL doesn't continue to balloon further. I'm now doing
routing based on the surface_id.

-  manager_->AddRoute(route_id_, this);
+  manager_->AddImageTransportSurface(route_id_, this);
 }
 
 ImageTransportHelper::~ImageTransportHelper() {
   if (stub_.get()) {
     stub_->SetLatencyInfoCallback(
         base::Callback<void(const std::vector<ui::LatencyInfo>&)>());
   }
-  manager_->RemoveRoute(route_id_);
+  manager_->RemoveImageTransportSurface(route_id_);
 }
 
 bool ImageTransportHelper::Initialize(gfx::GLSurface::Format format) {
   gpu::gles2::GLES2Decoder* decoder = Decoder();
 
   if (!decoder)
     return false;
 
   stub_->SetLatencyInfoCallback(
       base::Bind(&ImageTransportHelper::SetLatencyInfo,
                  base::Unretained(this)));
 
   return true;
 }
 
-bool ImageTransportHelper::OnMessageReceived(const IPC::Message& message) {
 #if defined(OS_MACOSX)
-  bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(ImageTransportHelper, message)
-    IPC_MESSAGE_HANDLER(AcceleratedSurfaceMsg_BufferPresented,
-                        OnBufferPresented)
-    IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP()
-  return handled;
-#else
-  NOTREACHED();
-  return false;
-#endif
+void ImageTransportHelper::BufferPresented(
+    const BufferPresentedParams& params) {
+  surface_->BufferPresented(params);
 }
 
-#if defined(OS_MACOSX)
 void ImageTransportHelper::SendAcceleratedSurfaceBuffersSwapped(
-    GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params params) {
+    AcceleratedSurfaceBuffersSwappedParams params) {
   // 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());
   // On mac, handle_ is a surface id. See
   // GpuProcessTransportFactory::CreatePerCompositorData
   params.surface_id = handle_;
   params.route_id = route_id_;
-  manager_->Send(new GpuHostMsg_AcceleratedSurfaceBuffersSwapped(params));
+  manager_->delegate()->SendAcceleratedSurfaceBuffersSwapped(params);
 }
 #endif
 
 bool ImageTransportHelper::MakeCurrent() {
   gpu::gles2::GLES2Decoder* decoder = Decoder();
   if (!decoder)
     return false;
   return decoder->MakeCurrent();
 }
 
 void ImageTransportHelper::SetSwapInterval(gfx::GLContext* context) {
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableGpuVsync))
     context->ForceSwapIntervalZero(true);
   else
     context->SetSwapInterval(1);
 }
 
 gpu::gles2::GLES2Decoder* ImageTransportHelper::Decoder() {
   if (!stub_.get())
     return NULL;
   return stub_->decoder();
 }
 
-#if defined(OS_MACOSX)
-void ImageTransportHelper::OnBufferPresented(
-    const AcceleratedSurfaceMsg_BufferPresented_Params& params) {
-  surface_->OnBufferPresented(params);
-}
-#endif
-
 void ImageTransportHelper::SetLatencyInfo(
     const std::vector<ui::LatencyInfo>& latency_info) {
   surface_->SetLatencyInfo(latency_info);
 }
 
 PassThroughImageTransportSurface::PassThroughImageTransportSurface(
     GpuChannelManager* manager,
     GpuCommandBufferStub* stub,
     gfx::GLSurface* surface)
     : GLSurfaceAdapter(surface),
@@ skipping 83 matching lines @@
 
 bool PassThroughImageTransportSurface::OnMakeCurrent(gfx::GLContext* context) {
   if (!did_set_swap_interval_) {
     ImageTransportHelper::SetSwapInterval(context);
     did_set_swap_interval_ = true;
   }
   return true;
 }
 
 #if defined(OS_MACOSX)
-void PassThroughImageTransportSurface::OnBufferPresented(
-    const AcceleratedSurfaceMsg_BufferPresented_Params& /* params */) {
+void PassThroughImageTransportSurface::BufferPresented(
+    const BufferPresentedParams& /* params */) {
   NOTREACHED();
 }
 #endif
 
 gfx::Size PassThroughImageTransportSurface::GetSize() {
   return GLSurfaceAdapter::GetSize();
 }
 
 PassThroughImageTransportSurface::~PassThroughImageTransportSurface() {}
 
@@ skipping 40 matching lines @@
 
 void PassThroughImageTransportSurface::FinishSwapBuffersAsync(
     scoped_ptr<std::vector<ui::LatencyInfo>> latency_info,
     GLSurface::SwapCompletionCallback callback,
     gfx::SwapResult result) {
   FinishSwapBuffers(std::move(latency_info), result);
   callback.Run(result);
 }
 
 }  // namespace content