Check for a restarted GPU process in OnCreateViewCommandBuffer.

content/browser/renderer_host/gpu_message_filter.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.
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
 #include "content/browser/renderer_host/gpu_message_filter.h"
 
@@ skipping 85 matching lines @@
   frame_subscription_list.swap(frame_subscription_list_);
   for (FrameSubscriptionList::iterator it = frame_subscription_list.begin();
        it != frame_subscription_list.end(); ++it) {
     if ((*it)->route_id != route_id)
       frame_subscription_list_.push_back(*it);
     else
       EndFrameSubscriptionInternal(*it);
   }
 }
 
+GpuProcessHost* GpuMessageFilter::GetGpuProcessHost(
+    CauseForGpuLaunch cause_for_gpu_launch) {
+  GpuProcessHost* host = GpuProcessHost::FromID(gpu_process_id_);
+  if (!host) {
+    host = GpuProcessHost::Get(GpuProcessHost::GPU_PROCESS_KIND_SANDBOXED,
+                               cause_for_gpu_launch);
+    if (!host) {
+      return NULL;
+    }
+
+    gpu_process_id_ = host->host_id();
+
+    // Apply all frame subscriptions to the new GpuProcessHost.
+    BeginAllFrameSubscriptions();
+  }
+
+  return host;
+}
+
 void GpuMessageFilter::OnEstablishGpuChannel(
     CauseForGpuLaunch cause_for_gpu_launch,
     IPC::Message* reply_ptr) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   scoped_ptr<IPC::Message> reply(reply_ptr);
 
   // TODO(apatrick): Eventually, this will return the route ID of a
   // GpuProcessStub, from which the renderer process will create a
   // GpuProcessProxy. The renderer will use the proxy for all subsequent
   // communication with the GPU process. This means if the GPU process
   // terminates, the renderer process will not find itself unknowingly sending
   // IPCs to a newly launched GPU process. Also, I will rename this function
   // to something like OnCreateGpuProcess.
-  GpuProcessHost* host = GpuProcessHost::FromID(gpu_process_id_);
+  GpuProcessHost* host = GetGpuProcessHost(cause_for_gpu_launch);
   if (!host) {
-    host = GpuProcessHost::Get(GpuProcessHost::GPU_PROCESS_KIND_SANDBOXED,
-                               cause_for_gpu_launch);
-    if (!host) {
-      reply->set_reply_error();
-      Send(reply.release());
-      return;
-    }
-
-    gpu_process_id_ = host->host_id();
-
-    // Apply all frame subscriptions to the new GpuProcessHost.
-    BeginAllFrameSubscriptions();
+    reply->set_reply_error();
+    Send(reply.release());
+    return;
   }
 
   bool share_contexts = true;
   host->EstablishGpuChannel(
       render_process_id_,
       share_contexts,
       base::Bind(&GpuMessageFilter::EstablishChannelCallback,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(&reply)));
 }
@@ skipping 19 matching lines @@
     DLOG(ERROR) << "Renderer " << render_process_id_
                 << " tried to access a surface for renderer " << renderer_id;
   }
 
   if (compositing_surface.parent_client_id &&
       !GpuDataManagerImpl::GetInstance()->CanUseGpuBrowserCompositor()) {
     // For the renderer to fall back to software also.
     compositing_surface = gfx::GLSurfaceHandle();
   }
 
-  GpuProcessHost* host = GpuProcessHost::FromID(gpu_process_id_);
+  GpuProcessHost* host = GetGpuProcessHost(
+      // This is currently the only creator of a view command buffer.
+      CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE);

[piman, 2014/05/08 03:29:21]

So, relaunching the GPU process is not actually good, because while it will give
you a context, it will be on a different channel than the GpuChannelHost you
asked it from.
So on the renderer side, you will have a discrepancy, and trying to send
messages to this command buffer will go on the wrong/old channel and fail.

I think we had a discussion about this with Dana, and the conclusion was IIRC
that we should handle this on the renderer side, if the CreateViewCommandBuffer
fails, that should trigger failure of the GpuChannelHost.

I think that's https://code.google.com/p/chromium/issues/detail?id=356876

[Ken Russell (switch to Gerrit), 2014/05/09 01:36:13]

Thanks for the feedback. I'll redo this as a check in the renderer process and
lose the GpuChannelHost from the RenderThreadImpl if this happens.

Currently tracking down remaining race conditions even if this bug were fixed.
Will post either an updated CL or a new one once everything is working reliably.

   if (!host || compositing_surface.is_null()) {
     // TODO(apatrick): Eventually, this IPC message will be routed to a
     // GpuProcessStub with a particular routing ID. The error will be set if
     // the GpuProcessStub with that routing ID is not in the MessageRouter.
     reply->set_reply_error();
     Send(reply.release());
     return;
   }
 
   host->CreateViewCommandBuffer(
@@ skipping 75 matching lines @@
   // so it is not necessary to end it.
   if (!host || !subscription->surface_id)
     return;
 
   // Note that GpuProcessHost here might not be the same one that frame
   // subscription has applied.
   host->EndFrameSubscription(subscription->surface_id);
 }
 
 }  // namespace content