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/thread.h"
 #include "chrome/browser/browser_process.h"
@@ skipping 176 matching lines @@
     IPC_MESSAGE_HANDLER(GpuHostMsg_SynchronizeReply, OnSynchronizeReply)
     IPC_MESSAGE_HANDLER(GpuHostMsg_GraphicsInfoCollected,
                         OnGraphicsInfoCollected)
 #if defined(OS_LINUX)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuHostMsg_GetViewXID, OnGetViewXID)
 #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)
+    IPC_MESSAGE_HANDLER(GpuHostMsg_ScheduleComposite, OnScheduleComposite)
 #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, gpu_info, request.filter);
@@ skipping 128 matching lines @@
 void GpuProcessHost::OnAcceleratedSurfaceBuffersSwapped(
     int32 renderer_id,
     int32 render_view_id,
     gfx::PluginWindowHandle window,
     uint64 surface_id) {
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       new BuffersSwappedDispatcher(
           renderer_id, render_view_id, window, surface_id));
 }
+
+#elif defined(OS_WIN)
+
+namespace {
+
+void SendDelayedReply(IPC::Message* reply_msg) {

[apatrick_chromium, 2010/11/11 22:32:15]

I think some of this code might belong in GpuProcessHostUIShim. You might also
be able to use RouteOnUIThreadTask and SendOnIOThreadTask to pass the messages
between threads,

[nduca, 2010/11/11 23:53:33]

I don't have any religion here... this is largely copying the lead of the Mac &
Linux equivalent functions, which do basically the same thing all inline in this
file.

I think a cleanup might be nice, though, so if we can get to consensus about
what the clean way to do this is, I could fix my windows commit and then file
and own a follwup bug for cleanup of the other platforms.

On 2010/11/11 22:32:15, apatrick_chromium wrote:

+  GpuProcessHost::Get()->Send(reply_msg);
+}
+
+void CreateCompositorHostWindowDispatcher(int32 renderer_id,

[apatrick_chromium, 2010/11/11 22:32:15]

Wrap first argument to next line.

[nduca, 2010/11/11 23:53:33]

Done.

+    int32 render_view_id,
+    IPC::Message* reply_msg) {
+
+  RenderViewHost* host = RenderViewHost::FromID(renderer_id,
+                                                render_view_id);
+  DCHECK(host);
+
+  RenderWidgetHostView* view = host->view();
+  DCHECK(view);
+  gfx::PluginWindowHandle id = view->CreateCompositorHostWindow();
+
+  GpuHostMsg_CreateCompositorHostWindow::WriteReplyParams(reply_msg, id);
+
+  // Have to reply from IO thread.
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      NewRunnableFunction(&SendDelayedReply, reply_msg));
+}
+
+void ScheduleCompositeDispatcher(int32 renderer_id, int32 render_view_id) {
+  RenderViewHost* host = RenderViewHost::FromID(renderer_id,
+                                                render_view_id);
+  DCHECK(host);
+
+
+  host->ScheduleComposite();
+}
+} // namespace
+
+void GpuProcessHost::OnCreateCompositorHostWindow(
+    int32 renderer_id,
+    int32 render_view_id,
+    IPC::Message* reply_message) {
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      NewRunnableFunction(&CreateCompositorHostWindowDispatcher,
+          renderer_id, render_view_id, reply_message));
+}
+
+void GpuProcessHost::OnScheduleComposite(int renderer_id, int render_view_id) {
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      NewRunnableFunction(&ScheduleCompositeDispatcher,
+          renderer_id, render_view_id));
+}
 #endif
 
 void GpuProcessHost::ReplyToRenderer(
     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
   // 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;
 }