gpu: Fix some context lost marking glitches+leaks and add UMA stats

content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.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/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
 
 #include "third_party/khronos/GLES2/gl2.h"
 #ifndef GL_GLEXT_PROTOTYPES
 #define GL_GLEXT_PROTOTYPES 1
 #endif
@@ skipping 79 matching lines @@
     const Attributes& attributes,
     bool lose_context_when_out_of_memory,
     const SharedMemoryLimits& limits,
     WebGraphicsContext3DCommandBufferImpl* share_context)
     : lose_context_when_out_of_memory_(lose_context_when_out_of_memory),
       attributes_(attributes),
       visible_(false),
       host_(host),
       surface_id_(surface_id),
       active_url_(active_url),
+      context_type_(CONTEXT_TYPE_UNKNOWN),
       gpu_preference_(attributes.preferDiscreteGPU ? gfx::PreferDiscreteGpu
                                                    : gfx::PreferIntegratedGpu),
       mem_limits_(limits),
       weak_ptr_factory_(this) {
+  if (attributes_.webGL)
+    context_type_ = OFFSCREEN_CONTEXT_FOR_WEBGL;
   if (share_context) {
     DCHECK(!attributes_.shareResources);
     share_group_ = share_context->share_group_;
   } else {
     share_group_ = attributes_.shareResources
         ? GetDefaultShareGroupForHost(host)
         : scoped_refptr<WebGraphicsContext3DCommandBufferImpl::ShareGroup>(
             new ShareGroup());
   }
 }
@@ skipping 24 matching lines @@
   if (!CreateContext(surface_id_ != 0)) {
     Destroy();
 
     initialize_failed_ = true;
     return false;
   }
 
   if (gl_ && attributes_.webGL)
     gl_->EnableFeatureCHROMIUM("webgl_enable_glsl_webgl_validation");
 
-  command_buffer_->SetChannelErrorCallback(
-      base::Bind(&WebGraphicsContext3DCommandBufferImpl::OnGpuChannelLost,
+  command_buffer_->SetContextLostCallback(
+      base::Bind(&WebGraphicsContext3DCommandBufferImpl::OnContextLost,
                  weak_ptr_factory_.GetWeakPtr()));
 
   command_buffer_->SetOnConsoleMessageCallback(
       base::Bind(&WebGraphicsContext3DCommandBufferImpl::OnErrorMessage,
                  weak_ptr_factory_.GetWeakPtr()));
 
   real_gl_->SetErrorMessageCallback(getErrorMessageCallback());
 
   visible_ = true;
   initialized_ = true;
@@ skipping 31 matching lines @@
     command_buffer_.reset(host_->CreateOffscreenCommandBuffer(
         gfx::Size(1, 1),
         share_group_command_buffer,
         attribs,
         active_url_,
         gpu_preference_));
   }
 
   if (!command_buffer_) {
     DLOG(ERROR) << "GpuChannelHost failed to create command buffer.";
+    UmaRecordContextInitFailed(context_type_);
     return false;
   }
 
   DVLOG_IF(1, gpu::error::IsError(command_buffer_->GetLastError()))
       << "Context dead on arrival. Last error: "
       << command_buffer_->GetLastError();
   // Initialize the command buffer.
   bool result = command_buffer_->Initialize();
   LOG_IF(ERROR, !result) << "CommandBufferProxy::Initialize failed.";
+  if (!result)
+    UmaRecordContextInitFailed(context_type_);
   return result;
 }
 
 bool WebGraphicsContext3DCommandBufferImpl::CreateContext(bool onscreen) {
   TRACE_EVENT0("gpu", "WebGfxCtx3DCmdBfrImpl::CreateContext");
   scoped_refptr<gpu::gles2::ShareGroup> gles2_share_group;
 
   scoped_ptr<base::AutoLock> share_group_lock;
   bool add_to_share_group = false;
   if (!command_buffer_) {
@@ skipping 124 matching lines @@
 
   return context_lost_reason_;
 }
 
 bool WebGraphicsContext3DCommandBufferImpl::IsCommandBufferContextLost() {
   // If the channel shut down unexpectedly, let that supersede the
   // command buffer's state.
   if (host_.get() && host_->IsLost())
     return true;
   gpu::CommandBuffer::State state = command_buffer_->GetLastState();
-  return state.error == gpu::error::kLostContext;
+  return gpu::error::IsError(state.error);
 }
 
 // static
 WebGraphicsContext3DCommandBufferImpl*
 WebGraphicsContext3DCommandBufferImpl::CreateOffscreenContext(
     GpuChannelHost* host,
     const WebGraphicsContext3D::Attributes& attributes,
     bool lose_context_when_out_of_memory,
     const GURL& active_url,
     const SharedMemoryLimits& limits,
@@ skipping 15 matching lines @@
 }
 
 namespace {
 
 WGC3Denum convertReason(gpu::error::ContextLostReason reason) {
   switch (reason) {
   case gpu::error::kGuilty:
     return GL_GUILTY_CONTEXT_RESET_ARB;
   case gpu::error::kInnocent:
     return GL_INNOCENT_CONTEXT_RESET_ARB;
+  case gpu::error::kOutOfMemory:
+  case gpu::error::kMakeCurrentFailed:
   case gpu::error::kUnknown:
     return GL_UNKNOWN_CONTEXT_RESET_ARB;
   }
 
   NOTREACHED();
   return GL_UNKNOWN_CONTEXT_RESET_ARB;
 }
 
 }  // anonymous namespace
 
-void WebGraphicsContext3DCommandBufferImpl::OnGpuChannelLost() {
-  context_lost_reason_ = convertReason(
-      command_buffer_->GetLastState().context_lost_reason);
+void WebGraphicsContext3DCommandBufferImpl::OnContextLost() {
+  context_lost_reason_ =
+      convertReason(command_buffer_->GetLastState().context_lost_reason);
   if (context_lost_callback_) {
     context_lost_callback_->onContextLost();
   }
 
   share_group_->RemoveAllContexts();
 
   DCHECK(host_.get());
   {
     base::AutoLock lock(g_default_share_groups_lock.Get());
     g_default_share_groups.Get().erase(host_.get());
   }
+
+  gpu::CommandBuffer::State state = command_buffer_->GetLastState();
+  UmaRecordContextLost(context_type_, state.error, state.context_lost_reason);
 }
 
 }  // namespace content