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

content/common/gpu/gpu_command_buffer_stub.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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/hash.h"
 #include "base/json/json_writer.h"
 #include "base/memory/shared_memory.h"
@@ skipping 403 matching lines @@
     OnRetireSyncPoint(sync_points_.front());
 
   if (decoder_)
     decoder_->set_engine(NULL);
 
   // The scheduler has raw references to the decoder and the command buffer so
   // destroy it before those.
   scheduler_.reset();
 
   bool have_context = false;
-  if (decoder_ && command_buffer_ &&
-      command_buffer_->GetLastState().error != gpu::error::kLostContext)
-    have_context = decoder_->MakeCurrent();
+  if (decoder_) {
+    // Try to make the context current regardless of whether it was lost, so we
+    // don't leak resources.

[Ken Russell (switch to Gerrit), 2015/04/27 22:35:33]

Presumably if the driver has actually lost the context then the resources have
all been invalidated / reclaimed. This change seems OK though.

[no sievers, 2015/04/27 23:24:41]

But it's a problem if we forced the context to be lost for GL_OUT_OF_MEMORY or
something else.

+    have_context = decoder_->GetGLContext()->MakeCurrent(surface_.get());
+  }
   FOR_EACH_OBSERVER(DestructionObserver,
                     destruction_observers_,
                     OnWillDestroyStub());
 
   if (decoder_) {
     decoder_->Destroy(have_context);
     decoder_.reset();
   }
 
   command_buffer_.reset();
@@ skipping 227 matching lines @@
   }
 
   decoder_->ProduceFrontBuffer(mailbox);
 }
 
 void GpuCommandBufferStub::OnParseError() {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnParseError");
   DCHECK(command_buffer_.get());
   gpu::CommandBuffer::State state = command_buffer_->GetLastState();
   IPC::Message* msg = new GpuCommandBufferMsg_Destroyed(
-      route_id_, state.context_lost_reason);
+      route_id_, state.context_lost_reason, state.error);
   msg->set_unblock(true);
   Send(msg);
 
   // Tell the browser about this context loss as well, so it can
   // determine whether client APIs like WebGL need to be immediately
   // blocked from automatically running.
   GpuChannelManager* gpu_channel_manager = channel_->gpu_channel_manager();
   gpu_channel_manager->Send(new GpuHostMsg_DidLoseContext(
       handle_.is_null(), state.context_lost_reason, active_url_));
 
@@ skipping 397 matching lines @@
   return was_lost;
 }
 
 void GpuCommandBufferStub::MarkContextLost() {
   if (!command_buffer_ ||
       command_buffer_->GetLastState().error == gpu::error::kLostContext)
     return;
 
   command_buffer_->SetContextLostReason(gpu::error::kUnknown);
   if (decoder_)
-    decoder_->LoseContext(GL_UNKNOWN_CONTEXT_RESET_ARB);
+    decoder_->MarkContextLost(gpu::error::kUnknown);
   command_buffer_->SetParseError(gpu::error::kLostContext);
 }
 
 uint64 GpuCommandBufferStub::GetMemoryUsage() const {
   return GetMemoryManager()->GetClientMemoryUsage(this);
 }
 
 void GpuCommandBufferStub::SendSwapBuffersCompleted(
     const std::vector<ui::LatencyInfo>& latency_info) {
   Send(new GpuCommandBufferMsg_SwapBuffersCompleted(route_id_, latency_info));
 }
 
 void GpuCommandBufferStub::SendUpdateVSyncParameters(base::TimeTicks timebase,
                                                      base::TimeDelta interval) {
   Send(new GpuCommandBufferMsg_UpdateVSyncParameters(route_id_, timebase,
                                                      interval));
 }
 
 }  // namespace content