Use inner HWND for accelerated rendering on windows

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/metrics/histogram.h"
 #include "base/thread.h"
@@ skipping 159 matching lines @@
     IPC_MESSAGE_HANDLER(GpuHostMsg_ChannelEstablished, OnChannelEstablished)
     IPC_MESSAGE_HANDLER(GpuHostMsg_SynchronizeReply, OnSynchronizeReply)
 #if defined(OS_LINUX)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuHostMsg_GetViewXID, OnGetViewXID)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuHostMsg_ResizeXID, OnResizeXID)
 #elif defined(OS_MACOSX)
     IPC_MESSAGE_HANDLER(GpuHostMsg_AcceleratedSurfaceSetIOSurface,
                         OnAcceleratedSurfaceSetIOSurface)
     IPC_MESSAGE_HANDLER(GpuHostMsg_AcceleratedSurfaceBuffersSwapped,
                         OnAcceleratedSurfaceBuffersSwapped)
+#elif defined(OS_WIN)
+    IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuHostMsg_CreateCompositorHostWindow,
+                                    OnCreateCompositorHostWindow)
 #endif
     // If the IO thread does not handle the message then automatically route it
     // to the UI thread. The UI thread will report an error if it does not
     // handle it.
     IPC_MESSAGE_UNHANDLED(RouteOnUIThread(message))
   IPC_END_MESSAGE_MAP()
 }
 
 void GpuProcessHost::OnChannelEstablished(
     const IPC::ChannelHandle& channel_handle,
@@ skipping 108 matching lines @@
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       new SetIOSurfaceDispatcher(params));
 }
 
 namespace {
 
 class BuffersSwappedDispatcher : public Task {
  public:
   BuffersSwappedDispatcher(
-      int32 renderer_id,
-      int32 render_view_id,
+      int renderer_id,
+      int render_view_id,
       gfx::PluginWindowHandle window,
       uint64 surface_id,
       int32 route_id,
       uint64 swap_buffers_count)
       : renderer_id_(renderer_id),
         render_view_id_(render_view_id),
         window_(window),
         surface_id_(surface_id),
         route_id_(route_id),
         swap_buffers_count_(swap_buffers_count) {
@@ skipping 11 matching lines @@
         // Parameters needed to swap the IOSurface.
         window_,
         surface_id_,
         // Parameters needed to formulate an acknowledgment.
         renderer_id_,
         route_id_,
         swap_buffers_count_);
   }
 
  private:
-  int32 renderer_id_;
-  int32 render_view_id_;
+  int renderer_id_;
+  int render_view_id_;
   gfx::PluginWindowHandle window_;
   uint64 surface_id_;
   int32 route_id_;
   uint64 swap_buffers_count_;
 
   DISALLOW_COPY_AND_ASSIGN(BuffersSwappedDispatcher);
 };
 
 }  // namespace
 
 void GpuProcessHost::OnAcceleratedSurfaceBuffersSwapped(
     const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params) {
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       new BuffersSwappedDispatcher(
           // These are the parameters needed to look up the IOSurface
           // on this side.
           params.renderer_id,
           params.render_view_id,
           params.window,
           params.surface_id,
           // These are additional parameters needed to formulate an
           // acknowledgment.
           params.route_id,
           params.swap_buffers_count));
 }
+
+#elif defined(OS_WIN)
+
+namespace {
+
+void SendDelayedReply(IPC::Message* reply_msg) {
+  GpuProcessHost::Get()->Send(reply_msg);
+}
+
+void CreateCompositorHostWindowDispatcher(
+    int renderer_id,
+    int render_view_id,
+    IPC::Message* reply_msg) {
+  RenderViewHost* host = RenderViewHost::FromID(renderer_id,
+                                                render_view_id);
+  if (!host) {
+    return;
+  }
+
+  RenderWidgetHostView* view = host->view();
+  gfx::PluginWindowHandle id = view->CreateCompositorHostWindow();
+
+
+  GpuHostMsg_CreateCompositorHostWindow::WriteReplyParams(reply_msg, id);
+  BrowserThread::PostTask(
+    BrowserThread::IO, FROM_HERE,
+    NewRunnableFunction(&SendDelayedReply, reply_msg));
+}
+
+}  // namespace
+
+void GpuProcessHost::OnCreateCompositorHostWindow(
+    int renderer_id,
+    int render_view_id,
+    IPC::Message* reply_message) {
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      NewRunnableFunction(&CreateCompositorHostWindowDispatcher,
+          renderer_id, render_view_id, reply_message));
+}
+
 #endif
 
 void GpuProcessHost::SendEstablishChannelReply(
     const IPC::ChannelHandle& channel,
     const GPUInfo& gpu_info,
     ResourceMessageFilter* filter) {
   ViewMsg_GpuChannelEstablished* message =
       new ViewMsg_GpuChannelEstablished(channel, gpu_info);
   // If the renderer process is performing synchronous initialization,
   // it needs to handle this message before receiving the reply for
@@ skipping 75 matching lines @@
       false,  // Never use the zygote (GPU plugin can't be sandboxed).
       base::environment_vector(),
 #endif
       cmd_line);
 
   UMA_HISTOGRAM_ENUMERATION("GPU.GPUProcessLifetimeEvents",
                             kLaunched, kGPUProcessLifetimeEvent_Max);
   return true;
 }