Moved creation of GPU transfer buffers into the browser process....

chrome/browser/gpu_process_host_ui_shim.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_ui_shim.h"
 
 #include "app/app_switches.h"
 #include "app/gfx/gl/gl_implementation.h"
 #include "base/command_line.h"
 #include "base/id_map.h"
@@ skipping 90 matching lines @@
 
   RenderWidgetHostView* view = NULL;
   if (host)
     view = host->view();
 
   return view;
 }
 
 GpuProcessHostUIShim::GpuProcessHostUIShim()
     : host_id_(++g_last_host_id),
+      gpu_process_(NULL),
       gpu_feature_flags_set_(false) {
   g_hosts_by_id.AddWithID(this, host_id_);
 }
 
 // static
 GpuProcessHostUIShim* GpuProcessHostUIShim::GetForRenderer(int renderer_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // 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
@@ skipping 19 matching lines @@
   return ui_shim;
 }
 
 // static
 void GpuProcessHostUIShim::Destroy(int host_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   delete FromID(host_id);
 }
 
 // static
+void GpuProcessHostUIShim::NotifyGpuProcessLaunched(
+    int host_id,
+    base::ProcessHandle gpu_process) {
+  DCHECK(gpu_process);
+
+  GpuProcessHostUIShim* ui_shim = FromID(host_id);
+  DCHECK(ui_shim);
+
+  ui_shim->gpu_process_ = gpu_process;
+}
+
+// static
 GpuProcessHostUIShim* GpuProcessHostUIShim::FromID(int host_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (host_id == 0)
     return NULL;
 
   return g_hosts_by_id.Lookup(host_id);
 }
 
 bool GpuProcessHostUIShim::Send(IPC::Message* msg) {
   DCHECK(CalledOnValidThread());
 
   BrowserThread::PostTask(BrowserThread::IO,
                           FROM_HERE,
                           new SendOnIOThreadTask(host_id_, msg));
   return true;
 }
 
 // Post a Task to execute callbacks on a error conditions in order to
 // clear the call stacks (and aid debugging).
 namespace {
 
 void EstablishChannelCallbackDispatcher(
     GpuProcessHostUIShim::EstablishChannelCallback* callback,
     const IPC::ChannelHandle& channel_handle,
+    base::ProcessHandle gpu_renderer_process,
     const GPUInfo& gpu_info) {
   scoped_ptr<GpuProcessHostUIShim::EstablishChannelCallback>
     wrapped_callback(callback);
-  wrapped_callback->Run(channel_handle, gpu_info);
+  wrapped_callback->Run(channel_handle, gpu_renderer_process, gpu_info);
 }
 
 void EstablishChannelError(
     GpuProcessHostUIShim::EstablishChannelCallback* callback,
     const IPC::ChannelHandle& channel_handle,
+    base::ProcessHandle gpu_renderer_process,
     const GPUInfo& gpu_info) {
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       NewRunnableFunction(&EstablishChannelCallbackDispatcher,
-                          callback, channel_handle, gpu_info));
+                          callback,
+                          channel_handle,
+                          gpu_renderer_process,
+                          gpu_info));
 }
 
 void SynchronizeCallbackDispatcher(
     GpuProcessHostUIShim::SynchronizeCallback* callback) {
   scoped_ptr<GpuProcessHostUIShim::SynchronizeCallback>
     wrapped_callback(callback);
   wrapped_callback->Run();
 }
 
 void SynchronizeError(
@@ skipping 20 matching lines @@
                           callback, route_id));
 }
 
 }  // namespace
 
 void GpuProcessHostUIShim::SendOutstandingReplies() {
   // First send empty channel handles for all EstablishChannel requests.
   while (!channel_requests_.empty()) {
     linked_ptr<EstablishChannelCallback> callback = channel_requests_.front();
     channel_requests_.pop();
-    EstablishChannelError(callback.release(), IPC::ChannelHandle(), GPUInfo());
+    EstablishChannelError(callback.release(),
+                          IPC::ChannelHandle(),
+                          NULL,
+                          GPUInfo());
   }
 
   // Now unblock all renderers waiting for synchronization replies.
   while (!synchronize_requests_.empty()) {
     linked_ptr<SynchronizeCallback> callback = synchronize_requests_.front();
     synchronize_requests_.pop();
     SynchronizeError(callback.release());
   }
 }
 
 bool GpuProcessHostUIShim::OnMessageReceived(const IPC::Message& message) {
   DCHECK(CalledOnValidThread());
 
   if (message.routing_id() != MSG_ROUTING_CONTROL)
     return false;
 
   return OnControlMessageReceived(message);
 }
 
 void GpuProcessHostUIShim::EstablishGpuChannel(
-    int renderer_id, EstablishChannelCallback *callback) {
+    int renderer_id,
+    EstablishChannelCallback *callback) {
   DCHECK(CalledOnValidThread());
   linked_ptr<EstablishChannelCallback> wrapped_callback(callback);
 
   // If GPU features are already blacklisted, no need to establish the channel.
   if (gpu_feature_flags_.flags() != 0) {
     EstablishChannelError(
-        wrapped_callback.release(), IPC::ChannelHandle(), GPUInfo());
+        wrapped_callback.release(), IPC::ChannelHandle(), NULL, GPUInfo());
     return;
   }
 
   if (Send(new GpuMsg_EstablishChannel(renderer_id))) {
     channel_requests_.push(wrapped_callback);
   } else {
     EstablishChannelError(
-        wrapped_callback.release(), IPC::ChannelHandle(), GPUInfo());
+        wrapped_callback.release(), IPC::ChannelHandle(), NULL, GPUInfo());
   }
 }
 
 void GpuProcessHostUIShim::Synchronize(SynchronizeCallback* callback) {
   DCHECK(CalledOnValidThread());
   linked_ptr<SynchronizeCallback> wrapped_callback(callback);
 
   if (Send(new GpuMsg_Synchronize())) {
     synchronize_requests_.push(wrapped_callback);
   } else {
@@ skipping 58 matching lines @@
 }
 
 const GPUInfo& GpuProcessHostUIShim::gpu_info() const {
   DCHECK(CalledOnValidThread());
   return gpu_info_;
 }
 
 GpuProcessHostUIShim::~GpuProcessHostUIShim() {
   DCHECK(CalledOnValidThread());
   g_hosts_by_id.Remove(host_id_);
+
+#if defined(OS_WIN)
+  if (gpu_process_)
+    CloseHandle(gpu_process_);
+#endif
 }
 
 bool GpuProcessHostUIShim::Init() {
   return LoadGpuBlacklist();
 }
 
 void GpuProcessHostUIShim::AddCustomLogMessage(int level,
     const std::string& header,
     const std::string& message) {
   OnLogMessage(level, header, message);
@@ skipping 30 matching lines @@
 #endif
     IPC_MESSAGE_UNHANDLED_ERROR()
   IPC_END_MESSAGE_MAP()
 
   return true;
 }
 
 void GpuProcessHostUIShim::OnChannelEstablished(
     const IPC::ChannelHandle& channel_handle,
     const GPUInfo& gpu_info) {
+  // The GPU process should have launched at this point and this object should
+  // have been notified of its process handle.
+  DCHECK(gpu_process_);
+
   uint32 max_entry_id = gpu_blacklist_->max_entry_id();
   // max_entry_id can be zero if we failed to load the GPU blacklist, don't
   // bother with histograms then.
   if (channel_handle.name.size() != 0 && !gpu_feature_flags_set_ &&
       max_entry_id != 0)
   {
     gpu_feature_flags_set_ = true;
 
     const CommandLine& browser_command_line = *CommandLine::ForCurrentProcess();
     if (!browser_command_line.HasSwitch(switches::kIgnoreGpuBlacklist) &&
@@ skipping 19 matching lines @@
       }
     }
   }
   linked_ptr<EstablishChannelCallback> callback = channel_requests_.front();
   channel_requests_.pop();
 
   // Currently if any of the GPU features are blacklisted, we don't establish a
   // GPU channel.
   if (gpu_feature_flags_.flags() != 0) {
     Send(new GpuMsg_CloseChannel(channel_handle));
-    EstablishChannelError(callback.release(), IPC::ChannelHandle(), gpu_info);
+    EstablishChannelError(callback.release(),
+                          IPC::ChannelHandle(),
+                          NULL,
+                          gpu_info);
     AddCustomLogMessage(logging::LOG_WARNING, "WARNING", "GPU is blacklisted.");
-  } else {
-    callback->Run(channel_handle, gpu_info);
+    return;
   }
+
+  callback->Run(channel_handle, gpu_process_, gpu_info);
 }
 
 void GpuProcessHostUIShim::OnSynchronizeReply() {
   // Guard against race conditions in abrupt GPU process termination.
   if (synchronize_requests_.size() > 0) {
     linked_ptr<SynchronizeCallback> callback(synchronize_requests_.front());
     synchronize_requests_.pop();
     callback->Run();
   }
 }
@@ skipping 142 matching lines @@
   static const base::StringPiece gpu_blacklist_json(
       ResourceBundle::GetSharedInstance().GetRawDataResource(
           IDR_GPU_BLACKLIST));
   gpu_blacklist_.reset(new GpuBlacklist());
   if (gpu_blacklist_->LoadGpuBlacklist(gpu_blacklist_json.as_string(), true))
     return true;
   gpu_blacklist_.reset(NULL);
   return false;
 }