Don't reuse a GpuProcessHost that failed to send a message

content/browser/gpu/gpu_process_host.cc

 // Copyright (c) 2012 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/base_switches.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
@@ skipping 222 matching lines @@
 
 // static
 bool GpuProcessHost::HostIsValid(GpuProcessHost* host) {
   if (!host)
     return false;
 
   // The Gpu process is invalid if it's not using software, the card is
   // blacklisted, and we can kill it and start over.
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kSingleProcess) ||
       CommandLine::ForCurrentProcess()->HasSwitch(switches::kInProcessGPU) ||
-      host->software_rendering() ||
-      !GpuDataManagerImpl::GetInstance()->ShouldUseSoftwareRendering()) {
+      (host->valid_ &&
+       (host->software_rendering() ||
+        !GpuDataManagerImpl::GetInstance()->ShouldUseSoftwareRendering()))) {
     return true;
   }
 
   host->ForceShutdown();
   return false;
 }
 
 // static
 GpuProcessHost* GpuProcessHost::Get(GpuProcessKind kind,
                                     content::CauseForGpuLaunch cause) {
@@ skipping 45 matching lines @@
     GpuProcessHost* host = g_gpu_process_hosts[i];
     if (host && host->host_id_ == host_id && HostIsValid(host))
       return host;
   }
 
   return NULL;
 }
 
 GpuProcessHost::GpuProcessHost(int host_id, GpuProcessKind kind)
     : host_id_(host_id),
+      valid_(true),
       in_process_(false),
       software_rendering_(false),
       kind_(kind),
       process_launched_(false) {
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kSingleProcess) ||
       CommandLine::ForCurrentProcess()->HasSwitch(switches::kInProcessGPU))
     in_process_ = true;
 
   // 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.
@@ skipping 116 matching lines @@
       base::Bind(&RouteToGpuProcessHostUIShimTask, host_id_, message));
 }
 
 bool GpuProcessHost::Send(IPC::Message* msg) {
   DCHECK(CalledOnValidThread());
   if (process_->GetHost()->IsChannelOpening()) {
     queued_messages_.push(msg);
     return true;
   }
 
-  return process_->Send(msg);
+  bool result = process_->Send(msg);
+  if (!result)
+    valid_ = false;
+  return result;
 }
 
 bool GpuProcessHost::OnMessageReceived(const IPC::Message& message) {
   DCHECK(CalledOnValidThread());
   IPC_BEGIN_MESSAGE_MAP(GpuProcessHost, message)
     IPC_MESSAGE_HANDLER(GpuHostMsg_ChannelEstablished, OnChannelEstablished)
     IPC_MESSAGE_HANDLER(GpuHostMsg_CommandBufferCreated, OnCommandBufferCreated)
     IPC_MESSAGE_HANDLER(GpuHostMsg_DestroyCommandBuffer, OnDestroyCommandBuffer)
 #if defined(OS_MACOSX)
     IPC_MESSAGE_HANDLER(GpuHostMsg_AcceleratedSurfaceBuffersSwapped,
@@ skipping 405 matching lines @@
     const IPC::ChannelHandle& channel_handle,
     base::ProcessHandle renderer_process_for_gpu,
     const content::GPUInfo& gpu_info) {
   callback.Run(channel_handle, gpu_info);
 }
 
 void GpuProcessHost::CreateCommandBufferError(
     const CreateCommandBufferCallback& callback, int32 route_id) {
   callback.Run(route_id);
 }