Send notification from GPU process to browser process of offscreen context creation and destruction…

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 489 matching lines @@
 }
 
 bool GpuProcessHost::OnMessageReceived(const IPC::Message& message) {
   DCHECK(CalledOnValidThread());
   IPC_BEGIN_MESSAGE_MAP(GpuProcessHost, message)
     IPC_MESSAGE_HANDLER(GpuHostMsg_Initialized, OnInitialized)
     IPC_MESSAGE_HANDLER(GpuHostMsg_ChannelEstablished, OnChannelEstablished)
     IPC_MESSAGE_HANDLER(GpuHostMsg_CommandBufferCreated, OnCommandBufferCreated)
     IPC_MESSAGE_HANDLER(GpuHostMsg_DestroyCommandBuffer, OnDestroyCommandBuffer)
     IPC_MESSAGE_HANDLER(GpuHostMsg_ImageCreated, OnImageCreated)
+    IPC_MESSAGE_HANDLER(GpuHostMsg_DidCreateOffscreenContext,
+                        OnDidCreateOffscreenContext)
+    IPC_MESSAGE_HANDLER(GpuHostMsg_DidLoseContext, OnDidLoseContext)
+    IPC_MESSAGE_HANDLER(GpuHostMsg_DidDestroyOffscreenContext,
+                        OnDidDestroyOffscreenContext)
 #if defined(OS_MACOSX)
     IPC_MESSAGE_HANDLER(GpuHostMsg_AcceleratedSurfaceBuffersSwapped,
                         OnAcceleratedSurfaceBuffersSwapped)
 #endif
 #if defined(OS_WIN)
     IPC_MESSAGE_HANDLER(GpuHostMsg_AcceleratedSurfaceBuffersSwapped,
                         OnAcceleratedSurfaceBuffersSwapped)
     IPC_MESSAGE_HANDLER(GpuHostMsg_AcceleratedSurfacePostSubBuffer,
                         OnAcceleratedSurfacePostSubBuffer)
     IPC_MESSAGE_HANDLER(GpuHostMsg_AcceleratedSurfaceSuspend,
@@ skipping 159 matching lines @@
 void GpuProcessHost::OnImageCreated(const gfx::Size size) {
   TRACE_EVENT0("gpu", "GpuProcessHost::OnImageCreated");
 
   if (!create_image_requests_.empty()) {
     CreateImageCallback callback = create_image_requests_.front();
     create_image_requests_.pop();
     callback.Run(size);
   }
 }
 
+void GpuProcessHost::OnDidCreateOffscreenContext(
+    const GURL& containing_document_url) {
+  urls_with_live_offscreen_contexts_.insert(containing_document_url);
+}
+
+void GpuProcessHost::OnDidLoseContext(bool offscreen,
+                                      gpu::error::ContextLostReason reason,
+                                      const GURL& containing_document_url) {
+  // TODO(kbr): would be nice to see the "offscreen" flag too.
+  TRACE_EVENT2("gpu", "GpuProcessHost::OnDidLoseContext",
+               "reason", reason,
+               "containing_document_url",
+               containing_document_url.possibly_invalid_spec());
+
+  if (!offscreen) {
+    // Assume that the loss of the compositor's context is a serious
+    // event and blame the loss on all live offscreen contexts. This
+    // more robustly handles situations where the GPU process may not
+    // actually detect the context loss in the offscreen context.
+    for (std::multiset<GURL>::iterator iter =
+             urls_with_live_offscreen_contexts_.begin();
+         iter != urls_with_live_offscreen_contexts_.end(); ++iter) {

[apatrick, 2012/12/03 20:35:33]

If the GPU process crashes, the GpuProcessHost is automatically destroyed and
this information will be lost. It occurs to me that a serious GPU crash could
cause this to happen without the OnDidLostContext getting through. Maybe you
could do this if the destructor is invoked as well? It's relatively easy to
verify if this is an issue with about:gpucrash.

[Ken Russell (switch to Gerrit), 2012/12/04 05:11:50]

Good point. As it happens, the mechanism I added in my earlier patch introducing
the infobar handles the case where the GPU process crashes, but I agree it would
be better to handle it all here. I've refactored the code and now call it both
from here as well as GpuProcessHost's destructor.

+      GpuDataManagerImpl::GetInstance()->BlockDomainFrom3DAPIs(

[apatrick, 2012/12/03 20:35:33]

I see BlockDomainFrom3DAPIs takes an AutoLock and is probably intended to be
thread safe. I believe the lifetime of the GpuDataManager is forever. Just
making sure you remember this is running on the IO thread.

[Ken Russell (switch to Gerrit), 2012/12/04 05:11:50]

Yes, understood, and this is what was intended.

+          *iter, GpuDataManagerImpl::DOMAIN_GUILT_UNKNOWN);
+    }
+    return;
+  }
+
+  GpuDataManagerImpl::DomainGuilt guilt;
+
+  switch (reason) {
+    case gpu::error::kGuilty:
+      guilt = GpuDataManagerImpl::DOMAIN_GUILT_KNOWN;
+      break;
+    case gpu::error::kUnknown:
+      guilt = GpuDataManagerImpl::DOMAIN_GUILT_UNKNOWN;
+      break;
+    case gpu::error::kInnocent:
+      return;
+  }
+
+  GpuDataManagerImpl::GetInstance()->BlockDomainFrom3DAPIs(
+      containing_document_url, guilt);
+}
+
+void GpuProcessHost::OnDidDestroyOffscreenContext(
+    const GURL& containing_document_url) {
+  urls_with_live_offscreen_contexts_.erase(containing_document_url);
+}
+
 #if defined(OS_MACOSX)
 void GpuProcessHost::OnAcceleratedSurfaceBuffersSwapped(
     const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params) {
   TRACE_EVENT0("gpu", "GpuProcessHost::OnAcceleratedSurfaceBuffersSwapped");
 
   gfx::PluginWindowHandle handle =
       GpuSurfaceTracker::Get()->GetSurfaceWindowHandle(params.surface_id);
   // Compositor window is always gfx::kNullPluginWindow.
   // TODO(jbates) http://crbug.com/105344 This will be removed when there are no
   // plugin windows.
@@ skipping 283 matching lines @@
     const CreateCommandBufferCallback& callback, int32 route_id) {
   callback.Run(route_id);
 }
 
 void GpuProcessHost::CreateImageError(
     const CreateImageCallback& callback, const gfx::Size size) {
   callback.Run(size);
 }
 
 }  // namespace content