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) {
+  GpuProcessHost::Get()->Send(reply_msg);
+}
+
+void CreateCompositorHostWindowDispatcher(
+    int32 renderer_id,
+    int32 render_view_id,
+    IPC::Message* reply_msg) {
+

[jam, 2010/11/12 18:08:00]

nit:extra line

[nduca, 2010/11/12 19:45:32]

Done.

+  RenderViewHost* host = RenderViewHost::FromID(renderer_id,
+                                                render_view_id);
+  DCHECK(host);

[jam, 2010/11/12 18:08:00]

this, and 368:  we normally don't add NULL dchecks.  in release builds, they're
compiled out, but we don't care since if it happens we'll get crash reports from
the line below them and it's easy to see what happened.  in debug builds,
developers will get a crash anyways so they'll investigate.  so the dcheck
doesn't add much value.

[nduca, 2010/11/12 19:45:32]

Done.

+
+  RenderWidgetHostView* view = host->view();
+  DCHECK(view);
+  gfx::PluginWindowHandle id = view->CreateCompositorHostWindow();
+
+  GpuHostMsg_CreateCompositorHostWindow::WriteReplyParams(reply_msg, id);
+
+  // Have to reply from IO thread.

[jam, 2010/11/12 18:08:00]

you can actually just do host->Send directly

[nduca, 2010/11/12 19:45:32]

Done.

[jam, 2010/11/12 20:34:41]

I actually meant "host->Send", i.e. using the RenderViewHost.  GPUProcessHost
lives on the IO thread and so shouldn't be accessed on the UI 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;
 }