Initial port of accelerated compositor to Mac OS X 10.6. Reused...

chrome/browser/gpu_process_host.cc

 // Copyright (c) 2010 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 "chrome/browser/gpu_process_host.h"
 
 #include "app/app_switches.h"
 #include "base/command_line.h"
 #include "base/thread.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/gpu_process_host_ui_shim.h"
+#include "chrome/browser/renderer_host/render_view_host.h"
+#include "chrome/browser/renderer_host/render_widget_host_view.h"
 #include "chrome/common/child_process_logging.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/gpu_messages.h"
 #include "chrome/common/render_messages.h"
 #include "ipc/ipc_switches.h"
 
 #if defined(OS_LINUX)
 #include "gfx/gtk_native_view_id_manager.h"
 #endif
 
@@ skipping 135 matching lines @@
 GPUInfo GpuProcessHost::gpu_info() const {
   return gpu_info_;
 }
 
 void GpuProcessHost::OnControlMessageReceived(const IPC::Message& message) {
   IPC_BEGIN_MESSAGE_MAP(GpuProcessHost, message)
     IPC_MESSAGE_HANDLER(GpuHostMsg_ChannelEstablished, OnChannelEstablished)
     IPC_MESSAGE_HANDLER(GpuHostMsg_SynchronizeReply, OnSynchronizeReply)
 #if defined(OS_LINUX)
     IPC_MESSAGE_HANDLER(GpuHostMsg_GetViewXID, OnGetViewXID)
+#elif defined(OS_MACOSX)
+    IPC_MESSAGE_HANDLER(GpuHostMsg_AcceleratedSurfaceSetIOSurface,
+                        OnAcceleratedSurfaceSetIOSurface)
+    IPC_MESSAGE_HANDLER(GpuHostMsg_AcceleratedSurfaceBuffersSwapped,
+                        OnAcceleratedSurfaceBuffersSwapped)
 #endif
     IPC_MESSAGE_UNHANDLED_ERROR()
   IPC_END_MESSAGE_MAP()
 }
 
 void GpuProcessHost::OnChannelEstablished(
     const IPC::ChannelHandle& channel_handle,
     const GPUInfo& gpu_info) {
   const ChannelRequest& request = sent_requests_.front();
   ReplyToRenderer(channel_handle, request.filter);
@@ skipping 10 matching lines @@
 }
 
 #if defined(OS_LINUX)
 void GpuProcessHost::OnGetViewXID(gfx::NativeViewId id, unsigned long* xid) {
   GtkNativeViewManager* manager = Singleton<GtkNativeViewManager>::get();
   if (!manager->GetXIDForId(xid, id)) {
     DLOG(ERROR) << "Can't find XID for view id " << id;
     *xid = 0;
   }
 }
+
+#elif defined(OS_MACOSX)
+void GpuProcessHost::OnAcceleratedSurfaceSetIOSurface(
+    const GpuHostMsg_AcceleratedSurfaceSetIOSurface_Params& params) {
+  RenderViewHost* host = RenderViewHost::FromID(params.renderer_id,
+                                                params.render_view_id);
+  if (!host)
+    return;
+  RenderWidgetHostView* view = host->view();
+  if (!view)
+    return;
+  view->AcceleratedSurfaceSetIOSurface(params.window,
+                                       params.width,
+                                       params.height,
+                                       params.identifier);
+}
+
+void GpuProcessHost::OnAcceleratedSurfaceBuffersSwapped(
+    int32 renderer_id,
+    int32 render_view_id,
+    gfx::PluginWindowHandle window) {
+  RenderViewHost* host = RenderViewHost::FromID(renderer_id,
+                                                render_view_id);
+  if (!host)
+    return;
+  RenderWidgetHostView* view = host->view();
+  if (!view)
+    return;
+  view->AcceleratedSurfaceBuffersSwapped(window);
+}
 #endif
 
 void GpuProcessHost::ReplyToRenderer(
     const IPC::ChannelHandle& channel,
     ResourceMessageFilter* filter) {
   ViewMsg_GpuChannelEstablished* message =
       new ViewMsg_GpuChannelEstablished(channel);
   // If the renderer process is performing synchronous initialization,
   // it needs to handle this message before receiving the reply for
   // the synchronous ViewHostMsg_SynchronizeGpu message.
   message->set_unblock(true);
   filter->Send(message);
 }
 
 URLRequestContext* GpuProcessHost::GetRequestContext(
     uint32 request_id,
     const ViewHostMsg_Resource_Request& request_data) {
   return NULL;
 }
 
 bool GpuProcessHost::CanShutdown() {
   return true;
 }