Revert of 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) {
-#if defined(OS_MACOSX)
-  manager_->AddImageTransportSurface(handle_, this);
-#endif
+  route_id_ = manager_->GenerateRouteID();
+  manager_->AddRoute(route_id_, this);
 }
 
 ImageTransportHelper::~ImageTransportHelper() {
   if (stub_.get()) {
     stub_->SetLatencyInfoCallback(
         base::Callback<void(const std::vector<ui::LatencyInfo>&)>());
   }
-#if defined(OS_MACOSX)
-  manager_->RemoveImageTransportSurface(handle_);
-#endif
+  manager_->RemoveRoute(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)
-void ImageTransportHelper::BufferPresented(
-    const BufferPresentedParams& params) {
-  surface_->BufferPresented(params);
+  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
 }
 
+#if defined(OS_MACOSX)
 void ImageTransportHelper::SendAcceleratedSurfaceBuffersSwapped(
-    AcceleratedSurfaceBuffersSwappedParams params) {
+    GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params 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_;
-  manager_->delegate()->SendAcceleratedSurfaceBuffersSwapped(params);
+  params.route_id = route_id_;
+  manager_->Send(new GpuHostMsg_AcceleratedSurfaceBuffersSwapped(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::BufferPresented(
-    const BufferPresentedParams& /* params */) {
+void PassThroughImageTransportSurface::OnBufferPresented(
+    const AcceleratedSurfaceMsg_BufferPresented_Params& /* 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