Move attributes and context type out to ContextProviderCommandBuffer.

content/common/gpu/client/context_provider_command_buffer.cc

 // Copyright (c) 2013 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/context_provider_command_buffer.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/strings/stringprintf.h"
 #include "cc/output/managed_memory_policy.h"
+#include "content/common/gpu/client/command_buffer_metrics.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "gpu/command_buffer/client/gles2_trace_implementation.h"
 #include "gpu/command_buffer/client/gpu_switches.h"
 #include "gpu/skia_bindings/grcontext_for_gles2_interface.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 
 namespace content {
 
 ContextProviderCommandBuffer::SharedProviders::SharedProviders() = default;
 ContextProviderCommandBuffer::SharedProviders::~SharedProviders() = default;
@@ skipping 13 matching lines @@
 
   void onContextLost() override { provider_->OnLostContext(); }
 
  private:
   ContextProviderCommandBuffer* provider_;
 };
 
 ContextProviderCommandBuffer::ContextProviderCommandBuffer(
     std::unique_ptr<WebGraphicsContext3DCommandBufferImpl> context3d,
     const gpu::SharedMemoryLimits& memory_limits,
+    const gpu::gles2::ContextCreationAttribHelper& attributes,
     ContextProviderCommandBuffer* shared_context_provider,
-    CommandBufferContextType type)
+    command_buffer_metrics::ContextType type)
     : shared_providers_(shared_context_provider
                             ? shared_context_provider->shared_providers_
                             : new SharedProviders),
       context3d_(std::move(context3d)),
       memory_limits_(memory_limits),
-      context_type_(type),
-      debug_name_(CommandBufferContextTypeToString(type)) {
+      attributes_(attributes),
+      context_type_(type) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK(context3d_);
   context_thread_checker_.DetachFromThread();
 }
 
 ContextProviderCommandBuffer::~ContextProviderCommandBuffer() {
   DCHECK(main_thread_checker_.CalledOnValidThread() ||
          context_thread_checker_.CalledOnValidThread());
 
   {
@@ skipping 20 matching lines @@
   return context3d_->GetCommandBufferProxy();
 }
 
 bool ContextProviderCommandBuffer::BindToCurrentThread() {
   // This is called on the thread the context will be used.
   DCHECK(context_thread_checker_.CalledOnValidThread());
 
   if (lost_context_callback_proxy_)
     return true;
 
-  context3d_->SetContextType(context_type_);
-
   // It's possible to be running BindToCurrentThread on two contexts
   // on different threads at the same time, but which will be in the same share
   // group. To ensure they end up in the same group, hold the lock on the
   // shared_providers_ (which they will share) after querying the group, until
   // this context has been added to the list.
   {
     ContextProviderCommandBuffer* shared_context_provider = nullptr;
     gpu::CommandBufferProxyImpl* shared_command_buffer = nullptr;
     scoped_refptr<gpu::gles2::ShareGroup> share_group;
 
     base::AutoLock hold(shared_providers_->lock);
 
     if (!shared_providers_->list.empty()) {
       shared_context_provider = shared_providers_->list.front();
       shared_command_buffer =
           shared_context_provider->context3d_->GetCommandBufferProxy();
       share_group = shared_context_provider->context3d_->GetImplementation()
                         ->share_group();
     }
 
     if (!context3d_->InitializeOnCurrentThread(
-            memory_limits_, shared_command_buffer, std::move(share_group)))
+            memory_limits_, shared_command_buffer, std::move(share_group),
+            attributes_, context_type_))
       return false;
 
     // If any context in the share group has been lost, then abort and don't
     // continue since we need to go back to the caller of the constructor to
     // find the correct share group.
     // This may happen in between the share group being chosen at the
     // constructor, and getting to run this BindToCurrentThread method which
     // can be on some other thread.
     // We intentionally call this *after* creating the command buffer via the
     // GpuChannelHost. Once that has happened, the service knows we are in the
@@ skipping 12 matching lines @@
 
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableGpuClientTracing)) {
     // This wraps the real GLES2Implementation and we should always use this
     // instead when it's present.
     trace_impl_.reset(new gpu::gles2::GLES2TraceImplementation(
         context3d_->GetImplementation()));
   }
 
   // Do this last once the context is set up.
+  std::string type_name =
+      command_buffer_metrics::ContextTypeToString(context_type_);
   std::string unique_context_name =
-      base::StringPrintf("%s-%p", debug_name_.c_str(), context3d_.get());
+      base::StringPrintf("%s-%p", type_name.c_str(), context3d_.get());
   ContextGL()->TraceBeginCHROMIUM("gpu_toplevel", unique_context_name.c_str());
   return true;
 }
 
 void ContextProviderCommandBuffer::DetachFromThread() {
   context_thread_checker_.DetachFromThread();
 }
 
 gpu::gles2::GLES2Interface* ContextProviderCommandBuffer::ContextGL() {
   DCHECK(context3d_);
@@ skipping 57 matching lines @@
     gr_context_->FreeGpuResources();
 }
 
 void ContextProviderCommandBuffer::OnLostContext() {
   DCHECK(context_thread_checker_.CalledOnValidThread());
 
   if (!lost_context_callback_.is_null())
     lost_context_callback_.Run();
   if (gr_context_)
     gr_context_->OnLostContext();
+
+  gpu::CommandBuffer::State state = GetCommandBufferProxy()->GetLastState();
+  command_buffer_metrics::UmaRecordContextLost(context_type_, state.error,
+                                               state.context_lost_reason);
 }
 
 void ContextProviderCommandBuffer::SetLostContextCallback(
     const LostContextCallback& lost_context_callback) {
   DCHECK(context_thread_checker_.CalledOnValidThread());
   DCHECK(lost_context_callback_.is_null() ||
          lost_context_callback.is_null());
   lost_context_callback_ = lost_context_callback;
 }
 
 }  // namespace content