Make EstablishGpuChannel synchronous. Remove obsolete Synchronize msg.

content/renderer/render_thread.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/renderer/render_thread.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <vector>
@@ skipping 371 matching lines @@
   IPC_BEGIN_MESSAGE_MAP(RenderThread, msg)
     IPC_MESSAGE_HANDLER(ViewMsg_SetZoomLevelForCurrentURL,
                         OnSetZoomLevelForCurrentURL)
     IPC_MESSAGE_HANDLER(ViewMsg_SetNextPageID, OnSetNextPageID)
     IPC_MESSAGE_HANDLER(ViewMsg_SetCSSColors, OnSetCSSColors)
     // TODO(port): removed from render_messages_internal.h;
     // is there a new non-windows message I should add here?
     IPC_MESSAGE_HANDLER(ViewMsg_New, OnCreateNewView)
     IPC_MESSAGE_HANDLER(ViewMsg_PurgePluginListCache, OnPurgePluginListCache)
     IPC_MESSAGE_HANDLER(DOMStorageMsg_Event, OnDOMStorageEvent)
-    IPC_MESSAGE_HANDLER(GpuMsg_GpuChannelEstablished, OnGpuChannelEstablished)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void RenderThread::OnSetNextPageID(int32 next_page_id) {
   // This should only be called at process initialization time, so we shouldn't
   // have to worry about thread-safety.
   RenderView::SetNextPageID(next_page_id);
 }
@@ skipping 55 matching lines @@
 
 void RenderThread::ClearPredictorCache() {
   int rv;
   Send(new ViewHostMsg_ClearPredictorCache(&rv));
 }
 
 void RenderThread::EnableSpdy(bool enable) {
   Send(new ViewHostMsg_EnableSpdy(enable));
 }
 
-void RenderThread::EstablishGpuChannel(
+GpuChannelHost* RenderThread::EstablishGpuChannelSync(
     content::CauseForGpuLaunch cause_for_gpu_launch) {
   if (gpu_channel_.get()) {
     // Do nothing if we already have a GPU channel or are already
     // establishing one.
     if (gpu_channel_->state() == GpuChannelHost::kUnconnected ||
         gpu_channel_->state() == GpuChannelHost::kConnected)
-      return;
+      return GetGpuChannel();
 
     // Recreate the channel if it has been lost.
     if (gpu_channel_->state() == GpuChannelHost::kLost)
       gpu_channel_ = NULL;
   }
 
   if (!gpu_channel_.get())
     gpu_channel_ = new GpuChannelHost;
 
   // Ask the browser for the channel name.
-  Send(new GpuHostMsg_EstablishGpuChannel(cause_for_gpu_launch));
-}
+  IPC::ChannelHandle channel_handle;
+  base::ProcessHandle renderer_process_for_gpu;
+  GPUInfo gpu_info;
+  if (!Send(new GpuHostMsg_EstablishGpuChannel(cause_for_gpu_launch,
+                                               &channel_handle,
+                                               &renderer_process_for_gpu,
+                                               &gpu_info)) ||
+      channel_handle.name.empty() ||
+      renderer_process_for_gpu == base::kNullProcessHandle) {
+    // Otherwise cancel the connection.
+    gpu_channel_ = NULL;
+    return NULL;
+  }
 
-GpuChannelHost* RenderThread::EstablishGpuChannelSync(
-    content::CauseForGpuLaunch cause_for_gpu_launch) {
-  EstablishGpuChannel(cause_for_gpu_launch);
-  Send(new GpuHostMsg_SynchronizeGpu());
+  gpu_channel_->set_gpu_info(gpu_info);
+  content::GetContentClient()->SetGpuInfo(gpu_info);
+
+  // Connect to the GPU process if a channel name was received.
+  gpu_channel_->Connect(channel_handle, renderer_process_for_gpu);
+
   return GetGpuChannel();
 }
 
 GpuChannelHost* RenderThread::GetGpuChannel() {
   if (!gpu_channel_.get())
     return NULL;
 
   if (gpu_channel_->state() != GpuChannelHost::kConnected)
     return NULL;
 
@@ skipping 137 matching lines @@
   EnsureWebKitInitialized();
   // The call below will cause a GetPlugins call with refresh=true, but at this
   // point we already know that the browser has refreshed its list, so disable
   // refresh temporarily to prevent each renderer process causing the list to be
   // regenerated.
   plugin_refresh_allowed_ = false;
   WebKit::resetPluginCache(reload_pages);
   plugin_refresh_allowed_ = true;
 }
 
-void RenderThread::OnGpuChannelEstablished(
-    const IPC::ChannelHandle& channel_handle,
-    base::ProcessHandle renderer_process_for_gpu,
-    const GPUInfo& gpu_info) {
-  gpu_channel_->set_gpu_info(gpu_info);
-  content::GetContentClient()->SetGpuInfo(gpu_info);
-
-  if (!channel_handle.name.empty() && renderer_process_for_gpu != 0) {
-    // Connect to the GPU process if a channel name was received.
-    gpu_channel_->Connect(channel_handle, renderer_process_for_gpu);
-  } else {
-    // Otherwise cancel the connection.
-    gpu_channel_ = NULL;
-  }
-}
-
 scoped_refptr<base::MessageLoopProxy>
 RenderThread::GetFileThreadMessageLoopProxy() {
   DCHECK(message_loop() == MessageLoop::current());
   if (!file_thread_.get()) {
     file_thread_.reset(new base::Thread("Renderer::FILE"));
     file_thread_->Start();
   }
   return file_thread_->message_loop_proxy();
 }
 
 void RenderThread::RegisterExtension(v8::Extension* extension) {
   WebScriptController::registerExtension(extension);
   v8_extensions_.insert(extension->name());
 }
 
 bool RenderThread::IsRegisteredExtension(
     const std::string& v8_extension_name) const {
   return v8_extensions_.find(v8_extension_name) != v8_extensions_.end();
 }