Fix gpu acceleration with --in-process-gpu

content/browser/gpu/gpu_process_host.cc

 // Copyright (c) 2011 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 "content/browser/gpu/gpu_process_host.h"
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram.h"
 #include "base/process_util.h"
 #include "base/string_piece.h"
+#include "base/threading/thread.h"
 #include "chrome/browser/tab_contents/render_view_host_delegate_helper.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/render_messages.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/gpu/gpu_data_manager.h"
 #include "content/browser/gpu/gpu_process_host_ui_shim.h"
 #include "content/browser/renderer_host/render_widget_host.h"
 #include "content/browser/renderer_host/render_widget_host_view.h"
 #include "content/common/gpu/gpu_messages.h"
+#include "content/gpu/gpu_child_thread.h"
+#include "content/gpu/gpu_process.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_switches.h"
 #include "media/base/media_switches.h"
 #include "ui/gfx/gl/gl_context.h"
 #include "ui/gfx/gl/gl_switches.h"
 
 #if defined(OS_LINUX)
 #include "ui/gfx/gtk_native_view_id_manager.h"
 #endif  // defined(OS_LINUX)
 
@@ skipping 76 matching lines @@
   }
 }
 
 GpuProcessHost::SurfaceRef::~SurfaceRef() {
   BrowserThread::PostTask(BrowserThread::UI,
                           FROM_HERE,
                           new ReleasePermanentXIDDispatcher(surface_));
 }
 #endif  // defined(OS_LINUX)
 
+// This class creates a GPU thread (instead of a GPU process), when running
+// with --in-process-gpu or --single-process.
+class GpuThreadWrapper : public base::Thread {
+ public:
+  explicit GpuThreadWrapper(const std::string& channel_id)
+      : base::Thread("Chrome_InProcGpuThread"),
+        channel_id_(channel_id),
+        gpu_process_(NULL) {
+  }
+
+  ~GpuThreadWrapper() {
+    Stop();
+  }
+
+ protected:
+  virtual void Init() {
+    // TODO: Currently, ChildProcess supports only a single static instance,
+    // which is a problem in --single-process mode, where both gpu and renderer
+    // should be able to create separate instances.
+    DCHECK(!GpuProcess::current());

[jam, 2011/05/26 01:15:24]

what happens if someone uses --single-process mode now?  this will break right? 
we should at least keep single process mode rendering working, even if gpu stuff
doesn't work.

[Daniel Sievers (Google), 2011/05/26 01:35:09]

Before this change, it would just not work (time out trying to establish a
channel). 

Ignore the DCHECK(), it would still not work after this change, because of
ChildThread::current() and ChildProcess::current() logic in the code.

I have verified that it would however work, if that issue was solved by allowing
GpuProcess to have it's own instance and patching a few other places.
It actually will not hit the DCHECK() as long as you do not try to enter
compositing, in which case it wouldn't work anyhow. 

+    gpu_process_ = new GpuProcess();
+    gpu_process_->set_main_thread(new GpuChildThread(channel_id_));
+  }
+
+  virtual void CleanUp() {
+    delete gpu_process_;
+  }
+
+ private:
+  std::string channel_id_;
+  // Deleted in CleanUp() on the gpu thread, so don't use smart pointers.
+  GpuProcess* gpu_process_;
+
+  DISALLOW_COPY_AND_ASSIGN(GpuThreadWrapper);
+};
+
 // static
 GpuProcessHost* GpuProcessHost::GetForRenderer(
     int renderer_id, content::CauseForGpuLaunch cause) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // Don't grant further access to GPU if it is not allowed.
   GpuDataManager* gpu_data_manager = GpuDataManager::GetInstance();
   if (gpu_data_manager != NULL && !gpu_data_manager->GpuAccessAllowed())
     return NULL;
 
   // The current policy is to ignore the renderer ID and use a single GPU
   // process for all renderers. Later this will be extended to allow the
   // use of multiple GPU processes.
   if (!g_hosts_by_id.IsEmpty()) {
     IDMap<GpuProcessHost>::iterator it(&g_hosts_by_id);
     return it.GetCurrentValue();
   }
 
   if (cause == content::CAUSE_FOR_GPU_LAUNCH_NO_LAUNCH)
     return NULL;
 
+  bool in_process =

[jam, 2011/05/26 01:15:24]

can you move the in_process bits to inside of GpuProcessHost's constructor,
instead of in the factory method?  It's always nicer to make the constructor
take less arguments

+      CommandLine::ForCurrentProcess()->HasSwitch(switches::kSingleProcess) ||
+      CommandLine::ForCurrentProcess()->HasSwitch(switches::kInProcessGPU);
+
+  // If the 'single GPU process' policy ever changes, we still want to maintain
+  // it for 'gpu thread' mode and only create one instance of host and thread.
+  DCHECK(!in_process || g_hosts_by_id.IsEmpty());
+
   int host_id;
-  /* TODO(apatrick): this is currently broken because this function is called on
-     the IO thread from GpuMessageFilter, and we don't have an IO thread object
-     when running the GPU code in the browser at the moment.
-  if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kSingleProcess) ||
-      CommandLine::ForCurrentProcess()->HasSwitch(switches::kInProcessGPU)) {
-    if (!g_browser_process->gpu_thread())
-      return NULL;
-
-    // Initialize GL on the GPU thread.
-    // TODO(apatrick): Handle failure to initialize (asynchronously).
-    if (!BrowserThread::PostTask(
-        BrowserThread::GPU,
-        FROM_HERE,
-        NewRunnableFunction(&gfx::GLContext::InitializeOneOff))) {
-      return NULL;
-    }
-
-    host_id = 0;
-  } else {
-    host_id = ++g_last_host_id;
-  }
-  */
   host_id = ++g_last_host_id;
 
   UMA_HISTOGRAM_ENUMERATION("GPU.GPUProcessLaunchCause",
                             cause,
                             content::CAUSE_FOR_GPU_LAUNCH_MAX_ENUM);
 
-  GpuProcessHost* host = new GpuProcessHost(host_id);
+  GpuProcessHost* host = new GpuProcessHost(host_id, in_process);
   if (host->Init())
     return host;
 
   delete host;
   return NULL;
 }
 
 // static 
 void GpuProcessHost::SendOnIO(int renderer_id,
                               content::CauseForGpuLaunch cause,
                               IPC::Message* message) {
   BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         NewRunnableFunction(
             &SendGpuProcessMessage, renderer_id, cause, message));
 }
 
 // static
 GpuProcessHost* GpuProcessHost::FromID(int host_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (host_id == 0)
     return NULL;
 
   return g_hosts_by_id.Lookup(host_id);
 }
 
-GpuProcessHost::GpuProcessHost(int host_id)
+GpuProcessHost::GpuProcessHost(int host_id, bool in_process)
     : BrowserChildProcessHost(GPU_PROCESS),
       host_id_(host_id),
-      gpu_process_(base::kNullProcessHandle) {
+      gpu_process_(base::kNullProcessHandle),
+      in_process_(in_process) {
   g_hosts_by_id.AddWithID(this, host_id_);
   if (host_id == 0)
     gpu_process_ = base::GetCurrentProcessHandle();
 
   // Post a task to create the corresponding GpuProcessHostUIShim.  The
   // GpuProcessHostUIShim will be destroyed if either the browser exits,
   // in which case it calls GpuProcessHostUIShim::DestroyAll, or the
   // GpuProcessHost is destroyed, which happens when the corresponding GPU
   // process terminates or fails to launch.
   BrowserThread::PostTask(
@@ skipping 20 matching lines @@
   BrowserThread::PostTask(BrowserThread::UI,
                           FROM_HERE,
                           NewRunnableFunction(GpuProcessHostUIShim::Destroy,
                                               host_id_));
 }
 
 bool GpuProcessHost::Init() {
   if (!CreateChannel())
     return false;
 
-  if (!LaunchGpuProcess())
+  if (in_process_) {
+    CommandLine::ForCurrentProcess()->AppendSwitch(
+        switches::kDisableGpuWatchdog);
+
+    in_process_gpu_thread_.reset(new GpuThreadWrapper(channel_id()));
+
+    base::Thread::Options options;
+#if defined(OS_WIN)
+  // On Windows the GPU thread needs to pump the compositor child window's
+  // message loop. TODO(apatrick): make this an IO thread if / when we get rid
+  // of this child window. Unfortunately it might always be necessary for
+  // Windows XP because we cannot share the backing store textures between
+  // processes.
+  options.message_loop_type = MessageLoop::TYPE_UI;
+#else
+  options.message_loop_type = MessageLoop::TYPE_IO;
+#endif
+    in_process_gpu_thread_->StartWithOptions(options);
+
+    OnProcessLaunched();  // Fake a callback that the process is ready.
+  } else if (!LaunchGpuProcess())
     return false;
 
   return Send(new GpuMsg_Initialize());
 }
 
 void GpuProcessHost::RouteOnUIThread(const IPC::Message& message) {
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       new RouteToGpuProcessHostUIShimTask(host_id_, message));
@@ skipping 169 matching lines @@
 }
 
 bool GpuProcessHost::CanShutdown() {
   return true;
 }
 
 void GpuProcessHost::OnProcessLaunched() {
   // Send the GPU process handle to the UI thread before it has to
   // respond to any requests to establish a GPU channel. The response
   // to such requests require that the GPU process handle be known.
+
+  base::ProcessHandle child_handle = in_process_ ?
+      base::GetCurrentProcessHandle() : handle();
+
 #if defined(OS_WIN)
   DuplicateHandle(base::GetCurrentProcessHandle(),
-                  handle(),
+                  child_handle,
                   base::GetCurrentProcessHandle(),
                   &gpu_process_,
                   PROCESS_DUP_HANDLE,
                   FALSE,
                   0);
 #else
-  gpu_process_ = handle();
+  gpu_process_ = child_handle;
 #endif
 }
 
 void GpuProcessHost::OnChildDied() {
   SendOutstandingReplies();
   // Located in OnChildDied because OnProcessCrashed suffers from a race
   // condition on Linux.
   UMA_HISTOGRAM_ENUMERATION("GPU.GPUProcessLifetimeEvents",
                             DIED_FIRST_TIME + g_gpu_crash_count,
                             GPU_PROCESS_LIFETIME_EVENT_MAX);
@@ skipping 109 matching lines @@
     CreateCommandBufferCallback* callback, int32 route_id) {
   scoped_ptr<GpuProcessHost::CreateCommandBufferCallback>
     wrapped_callback(callback);
   callback->Run(route_id);
 }
 
 void GpuProcessHost::SynchronizeError(SynchronizeCallback* callback) {
   scoped_ptr<SynchronizeCallback> wrapped_callback(callback);
   wrapped_callback->Run();
 }