Fixed a hang in the renderer process. If the renderer process requests for a ...

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 134 matching lines @@
                             FROM_HERE,
                             new RouteOnUIThreadTask(message));
   }
 }
 
 void GpuProcessHost::EstablishGpuChannel(int renderer_id,
                                          ResourceMessageFilter* filter) {
   if (Send(new GpuMsg_EstablishChannel(renderer_id))) {
     sent_requests_.push(ChannelRequest(filter));
   } else {
-    ReplyToRenderer(IPC::ChannelHandle(), GPUInfo(), filter);
+    SendEstablishChannelReply(IPC::ChannelHandle(), GPUInfo(), filter);
   }
 }
 
 void GpuProcessHost::Synchronize(IPC::Message* reply,
                                  ResourceMessageFilter* filter) {
-  queued_synchronization_replies_.push(SynchronizationRequest(reply, filter));
-  Send(new GpuMsg_Synchronize());
+  if (Send(new GpuMsg_Synchronize())) {
+    queued_synchronization_replies_.push(SynchronizationRequest(reply, filter));
+  } else {
+    SendSynchronizationReply(reply, filter);
+  }
 }
 
-GPUInfo GpuProcessHost::gpu_info() const {
+const GPUInfo& GpuProcessHost::gpu_info() const {
   return gpu_info_;
 }
 
 GpuProcessHost::ChannelRequest::ChannelRequest(ResourceMessageFilter* filter)
     : filter(filter) {
 }
 
 GpuProcessHost::ChannelRequest::~ChannelRequest() {}
 
 GpuProcessHost::SynchronizationRequest::SynchronizationRequest(
@@ skipping 20 matching lines @@
                         OnAcceleratedSurfaceBuffersSwapped)
 #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);
+  SendEstablishChannelReply(channel_handle, gpu_info, request.filter);
   sent_requests_.pop();
   gpu_info_ = gpu_info;
   child_process_logging::SetGpuInfo(gpu_info);
 }
 
 void GpuProcessHost::OnSynchronizeReply() {
   const SynchronizationRequest& request =
       queued_synchronization_replies_.front();
-  request.filter->Send(request.reply);
+  SendSynchronizationReply(request.reply, request.filter);
   queued_synchronization_replies_.pop();
 }
 
 void GpuProcessHost::OnGraphicsInfoCollected(const GPUInfo& gpu_info) {
   gpu_info_ = gpu_info;
 }
 
 #if defined(OS_LINUX)
 
 namespace {
@@ skipping 111 matching lines @@
     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));
 }
 #endif
 
-void GpuProcessHost::ReplyToRenderer(
+void GpuProcessHost::SendEstablishChannelReply(
     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);
 }
 
+// Sends the response for synchronization request to the renderer.
+void GpuProcessHost::SendSynchronizationReply(
+    IPC::Message* reply,
+    ResourceMessageFilter* filter) {
+  filter->Send(reply);
+}
+
 URLRequestContext* GpuProcessHost::GetRequestContext(
     uint32 request_id,
     const ViewHostMsg_Resource_Request& request_data) {
   return NULL;
 }
 
 bool GpuProcessHost::CanShutdown() {
   return true;
 }
+
+void GpuProcessHost::OnProcessCrashed() {
+  // TODO(alokp): Update gpu process crash rate.
+  BrowserChildProcessHost::OnProcessCrashed();
+}
+