Route IPC through browser when creating a viewable command buffer.

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/string_piece.h"
 #include "base/threading/thread.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/gpu_blacklist.h"
 #include "chrome/browser/gpu_process_host_ui_shim.h"
 #include "chrome/browser/renderer_host/render_message_filter.h"
+#include "chrome/browser/renderer_host/render_view_host.h"
+#include "chrome/browser/renderer_host/render_widget_host_view.h"
 #include "chrome/browser/tab_contents/render_view_host_delegate_helper.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/gpu_feature_flags.h"
 #include "chrome/common/gpu_info.h"
 #include "chrome/common/gpu_messages.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/gpu/gpu_thread.h"
 #include "grit/browser_resources.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_switches.h"
 #include "media/base/media_switches.h"
 #include "ui/base/resource/resource_bundle.h"
 
+#if defined(OS_LINUX)
+#include "gfx/gtk_native_view_id_manager.h"
+#endif  // defined(OS_LINUX)
+
 namespace {
 
 enum GPUProcessLifetimeEvent {
   LAUNCED,
   CRASHED,
   GPU_PROCESS_LIFETIME_EVENT_MAX
   };
 
 // Tasks used by this file
 class RouteOnUIThreadTask : public Task {
@@ skipping 19 matching lines @@
 static int g_gpu_crash_count = 0;
 // Maximum number of times the gpu process is allowed to crash in a session.
 // Once this limit is reached, any request to launch the gpu process will fail.
 static const int kGpuMaxCrashCount = 3;
 
 void RouteOnUIThread(const IPC::Message& message) {
   BrowserThread::PostTask(BrowserThread::UI,
                           FROM_HERE,
                           new RouteOnUIThreadTask(message));
 }
+
+bool SendDelayedMsg(IPC::Message* reply_msg) {
+  return GpuProcessHost::Get()->Send(reply_msg);
+}
+
+bool SendDelayedMsg(IPC::Message* reply, RenderMessageFilter* filter) {
+  return filter->Send(reply);
+}
+
 }  // anonymous namespace
 
 class GpuMainThread : public base::Thread {
  public:
   explicit GpuMainThread(const std::string& channel_id)
       : base::Thread("CrGpuMain"),
         channel_id_(channel_id) {
   }
 
   ~GpuMainThread() {
@@ skipping 96 matching lines @@
   } else {
     SendEstablishChannelReply(IPC::ChannelHandle(), GPUInfo(), filter);
   }
 }
 
 void GpuProcessHost::Synchronize(IPC::Message* reply,
                                  RenderMessageFilter* filter) {
   DCHECK(CalledOnValidThread());
 
   if (Send(new GpuMsg_Synchronize())) {
-    queued_synchronization_replies_.push(SynchronizationRequest(reply, filter));
+    queued_synchronization_replies_.push(DelayedReply(reply, filter));
   } else {
-    SendSynchronizationReply(reply, filter);
+    SendDelayedMsg(reply, filter);
   }
 }
 
+class CVCBThreadHopping {
+ public:
+  // Send the request for a command buffer from the IO thread and
+  // queue that we are expecting a response.
+  static void DispatchIPCAndQueueReply(
+      gfx::PluginWindowHandle view,
+      int32 render_view_id,
+      int32 renderer_id,
+      const GPUCreateCommandBufferConfig& init_params,
+      IPC::Message* reply,
+      scoped_refptr<RenderMessageFilter> filter);
+
+  // Get a window for the command buffer that we're creating.
+  static void GetViewWindow(
+      int32 render_view_id,
+      int32 renderer_id,
+      const GPUCreateCommandBufferConfig& init_params,
+      IPC::Message* reply,
+      scoped_refptr<RenderMessageFilter> filter);
+};
+
+void CVCBThreadHopping::DispatchIPCAndQueueReply(
+    gfx::PluginWindowHandle view,
+    int32 render_view_id,
+    int32 renderer_id,
+    const GPUCreateCommandBufferConfig& init_params,
+    IPC::Message* reply,
+    scoped_refptr<RenderMessageFilter> filter) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  GpuProcessHost* host = GpuProcessHost::Get();
+
+  if (view != gfx::kNullPluginWindow &&
+      SendDelayedMsg(new GpuMsg_CreateViewCommandBuffer(
+          view, render_view_id, renderer_id, init_params))) {
+    host->create_command_buffer_replies_.push(
+        GpuProcessHost::DelayedReply(reply, filter));
+  } else {
+    int32 route_id = MSG_ROUTING_NONE;
+    ViewHostMsg_CreateViewCommandBuffer::WriteReplyParams(reply, route_id);
+    SendDelayedMsg(reply, filter);
+  }
+}
+
+void CVCBThreadHopping::GetViewWindow(
+    int32 render_view_id,
+    int32 renderer_id,
+    const GPUCreateCommandBufferConfig& init_params,
+    IPC::Message* reply,
+    scoped_refptr<RenderMessageFilter> filter) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  gfx::PluginWindowHandle window = gfx::kNullPluginWindow;
+  RenderViewHost* host = RenderViewHost::FromID(renderer_id,
+                                                render_view_id);
+#if defined(OS_LINUX)
+  gfx::NativeViewId view = NULL;
+  if (host)
+    view = gfx::IdFromNativeView(host->view()->GetNativeView());
+
+  // Lock the window that we will draw into.
+  GtkNativeViewManager* manager = GtkNativeViewManager::GetInstance();
+  if (!manager->GetPermanentXIDForId(&window, view)) {
+    DLOG(ERROR) << "Can't find XID for view id " << view;
+  }
+#elif defined(OS_MACOSX)
+  // On Mac OS X we currently pass a (fake) PluginWindowHandle for the
+  // window that we draw to.
+  window = host->view()->AllocateFakePluginWindowHandle(
+      /*opaque=*/true, /*root=*/true);
+#elif defined(OS_WIN)
+  // Create a window that we will overlay.
+  window = host->view()->GetCompositorHostWindow();
+#endif
+
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, NewRunnableFunction(
+      &CVCBThreadHopping::DispatchIPCAndQueueReply,
+      window, render_view_id, renderer_id, init_params, reply, filter));
+}
+
+void GpuProcessHost::CreateViewCommandBuffer(
+    int32 render_view_id,
+    int32 renderer_id,
+    const GPUCreateCommandBufferConfig& init_params,
+    IPC::Message* reply,
+    RenderMessageFilter* filter) {
+  DCHECK(CalledOnValidThread());
+
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, NewRunnableFunction(
+      &CVCBThreadHopping::GetViewWindow,
+      render_view_id, renderer_id, init_params, reply,
+      static_cast<scoped_refptr<RenderMessageFilter> > (filter)));
+}
+
+
 GpuProcessHost::ChannelRequest::ChannelRequest(RenderMessageFilter* filter)
     : filter(filter) {
 }
 
 GpuProcessHost::ChannelRequest::~ChannelRequest() {}
 
-GpuProcessHost::SynchronizationRequest::SynchronizationRequest(
+GpuProcessHost::DelayedReply::DelayedReply(
     IPC::Message* reply,
     RenderMessageFilter* filter)
     : reply(reply),
       filter(filter) {
 }
 
-GpuProcessHost::SynchronizationRequest::~SynchronizationRequest() {}
+GpuProcessHost::DelayedReply::~DelayedReply() {}
 
 bool GpuProcessHost::OnControlMessageReceived(const IPC::Message& message) {
   DCHECK(CalledOnValidThread());
 
   IPC_BEGIN_MESSAGE_MAP(GpuProcessHost, message)
     IPC_MESSAGE_HANDLER(GpuHostMsg_ChannelEstablished, OnChannelEstablished)
     IPC_MESSAGE_HANDLER(GpuHostMsg_SynchronizeReply, OnSynchronizeReply)
+    IPC_MESSAGE_HANDLER(GpuHostMsg_CommandBufferCreated, OnCommandBufferCreated)
     // 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()
 
   return true;
 }
 
 void GpuProcessHost::OnChannelEstablished(
@@ skipping 28 matching lines @@
     SendEstablishChannelReply(IPC::ChannelHandle(), gpu_info, request.filter);
   } else {
     SendEstablishChannelReply(channel_handle, gpu_info, request.filter);
   }
   sent_requests_.pop();
 }
 
 void GpuProcessHost::OnSynchronizeReply() {
   // Guard against race conditions in abrupt GPU process termination.
   if (queued_synchronization_replies_.size() > 0) {
-    const SynchronizationRequest& request =
+    const DelayedReply& request =
         queued_synchronization_replies_.front();
-    SendSynchronizationReply(request.reply, request.filter);
+    SendDelayedMsg(request.reply, request.filter);
     queued_synchronization_replies_.pop();
   }
 }
 
+void GpuProcessHost::OnCommandBufferCreated(const int32 route_id) {
+  if (create_command_buffer_replies_.size() > 0) {
+    const DelayedReply& request =
+        create_command_buffer_replies_.front();
+    ViewHostMsg_CreateViewCommandBuffer::WriteReplyParams(
+        request.reply, route_id);
+    SendDelayedMsg(request.reply, request.filter);
+    create_command_buffer_replies_.pop();
+  }
+}
+
 void GpuProcessHost::SendEstablishChannelReply(
     const IPC::ChannelHandle& channel,
     const GPUInfo& gpu_info,
     RenderMessageFilter* 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);
 }
 
-// Sends the response for synchronization request to the renderer.
-void GpuProcessHost::SendSynchronizationReply(
-    IPC::Message* reply,
-    RenderMessageFilter* filter) {
-  filter->Send(reply);
-}
-
 void GpuProcessHost::SendOutstandingReplies() {
   // First send empty channel handles for all EstablishChannel requests.
   while (!sent_requests_.empty()) {
     const ChannelRequest& request = sent_requests_.front();
     SendEstablishChannelReply(IPC::ChannelHandle(), GPUInfo(), request.filter);
     sent_requests_.pop();
   }
 
   // Now unblock all renderers waiting for synchronization replies.
   while (!queued_synchronization_replies_.empty()) {
@@ skipping 106 matching lines @@
   const CommandLine& browser_command_line = *CommandLine::ForCurrentProcess();
   if (browser_command_line.HasSwitch(switches::kIgnoreGpuBlacklist) ||
       blacklist->LoadGpuBlacklist(gpu_blacklist_json.as_string(), true)) {
     gpu_blacklist_.reset(blacklist);
     return true;
   }
   delete blacklist;
   return false;
 }