content/common/gpu/client/context_provider_command_buffer.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/common/gpu/client/context_provider_command_buffer.h"
   6
   7 #include <set>
   8 #include <vector>
   9
  10 #include "base/callback_helpers.h"
  11 #include "base/strings/stringprintf.h"
  12 #include "cc/output/managed_memory_policy.h"
  13 #include "content/common/gpu/client/grcontext_for_webgraphicscontext3d.h"
  14 #include "gpu/command_buffer/client/gles2_implementation.h"
  15 #include "third_party/skia/include/gpu/GrContext.h"
  16
  17 namespace content {
  18
  19 class ContextProviderCommandBuffer::LostContextCallbackProxy
  20     : public blink::WebGraphicsContext3D::WebGraphicsContextLostCallback {
  21  public:
  22   explicit LostContextCallbackProxy(ContextProviderCommandBuffer* provider)
  23       : provider_(provider) {
  24     provider_->context3d_->setContextLostCallback(this);
  25   }
  26
  27   virtual ~LostContextCallbackProxy() {
  28     provider_->context3d_->setContextLostCallback(NULL);
  29   }
  30
  31   virtual void onContextLost() {
  32     provider_->OnLostContext();
  33   }
  34
  35  private:
  36   ContextProviderCommandBuffer* provider_;
  37 };
  38
  39 scoped_refptr<ContextProviderCommandBuffer>
  40 ContextProviderCommandBuffer::Create(
  41     scoped_ptr<WebGraphicsContext3DCommandBufferImpl> context3d,
  42     CommandBufferContextType type) {
  43   if (!context3d)
  44     return NULL;
  45
  46   return new ContextProviderCommandBuffer(context3d.Pass(), type);
  47 }
  48
  49 ContextProviderCommandBuffer::ContextProviderCommandBuffer(
  50     scoped_ptr<WebGraphicsContext3DCommandBufferImpl> context3d,
  51     CommandBufferContextType type)
  52     : context3d_(context3d.Pass()),
  53       context_type_(type),
  54       debug_name_(CommandBufferContextTypeToString(type)),
  55       destroyed_(false) {
  56   DCHECK(main_thread_checker_.CalledOnValidThread());
  57   DCHECK(context3d_);
  58   context_thread_checker_.DetachFromThread();
  59 }
  60
  61 ContextProviderCommandBuffer::~ContextProviderCommandBuffer() {
  62   DCHECK(main_thread_checker_.CalledOnValidThread() ||
  63          context_thread_checker_.CalledOnValidThread());
  64
  65   base::AutoLock lock(main_thread_lock_);
  66
  67   // Destroy references to the context3d_ before leaking it.
  68   if (context3d_->GetCommandBufferProxy()) {
  69     context3d_->GetCommandBufferProxy()->SetLock(nullptr);
  70     context3d_->GetCommandBufferProxy()->SetMemoryAllocationChangedCallback(
  71         CommandBufferProxyImpl::MemoryAllocationChangedCallback());
  72   }
  73   lost_context_callback_proxy_.reset();
  74 }
  75
  76
  77 CommandBufferProxyImpl* ContextProviderCommandBuffer::GetCommandBufferProxy() {
  78   return context3d_->GetCommandBufferProxy();
  79 }
  80
  81 WebGraphicsContext3DCommandBufferImpl*
  82 ContextProviderCommandBuffer::WebContext3D() {
  83   DCHECK(context3d_);
  84   DCHECK(lost_context_callback_proxy_);  // Is bound to thread.
  85   DCHECK(context_thread_checker_.CalledOnValidThread());
  86
  87   return context3d_.get();
  88 }
  89
  90 bool ContextProviderCommandBuffer::BindToCurrentThread() {
  91   // This is called on the thread the context will be used.
  92   DCHECK(context_thread_checker_.CalledOnValidThread());
  93
  94   if (lost_context_callback_proxy_)
  95     return true;
  96
  97   context3d_->SetContextType(context_type_);
  98   if (!context3d_->InitializeOnCurrentThread())
  99     return false;
 100
 101   InitializeCapabilities();
 102
 103   std::string unique_context_name =
 104       base::StringPrintf("%s-%p", debug_name_.c_str(), context3d_.get());
 105   context3d_->traceBeginCHROMIUM("gpu_toplevel", unique_context_name.c_str());
 106
 107   lost_context_callback_proxy_.reset(new LostContextCallbackProxy(this));
 108   return true;
 109 }
 110
 111 void ContextProviderCommandBuffer::DetachFromThread() {
 112   context_thread_checker_.DetachFromThread();
 113 }
 114
 115 gpu::gles2::GLES2Interface* ContextProviderCommandBuffer::ContextGL() {
 116   DCHECK(context3d_);
 117   DCHECK(lost_context_callback_proxy_);  // Is bound to thread.
 118   DCHECK(context_thread_checker_.CalledOnValidThread());
 119
 120   return context3d_->GetImplementation();
 121 }
 122
 123 gpu::ContextSupport* ContextProviderCommandBuffer::ContextSupport() {
 124   return context3d_->GetContextSupport();
 125 }
 126
 127 class GrContext* ContextProviderCommandBuffer::GrContext() {
 128   DCHECK(lost_context_callback_proxy_);  // Is bound to thread.
 129   DCHECK(context_thread_checker_.CalledOnValidThread());
 130
 131   if (gr_context_)
 132     return gr_context_->get();
 133
 134   gr_context_.reset(new GrContextForWebGraphicsContext3D(context3d_.get()));
 135
 136   // If GlContext is already lost, also abandon the new GrContext.
 137   if (gr_context_->get() &&
 138       ContextGL()->GetGraphicsResetStatusKHR() != GL_NO_ERROR)
 139     gr_context_->get()->abandonContext();
 140
 141   return gr_context_->get();
 142 }
 143
 144 void ContextProviderCommandBuffer::InvalidateGrContext(uint32_t state) {
 145   if (gr_context_) {
 146     DCHECK(lost_context_callback_proxy_);  // Is bound to thread.
 147     DCHECK(context_thread_checker_.CalledOnValidThread());
 148     gr_context_->get()->resetContext(state);
 149   }
 150 }
 151
 152 void ContextProviderCommandBuffer::SetupLock() {
 153   DCHECK(context3d_);
 154   context3d_->GetCommandBufferProxy()->SetLock(&context_lock_);
 155 }
 156
 157 base::Lock* ContextProviderCommandBuffer::GetLock() {
 158   return &context_lock_;
 159 }
 160
 161 cc::ContextProvider::Capabilities
 162 ContextProviderCommandBuffer::ContextCapabilities() {
 163   DCHECK(lost_context_callback_proxy_);  // Is bound to thread.
 164   DCHECK(context_thread_checker_.CalledOnValidThread());
 165
 166   return capabilities_;
 167 }
 168
 169 void ContextProviderCommandBuffer::VerifyContexts() {
 170   DCHECK(lost_context_callback_proxy_);  // Is bound to thread.
 171   DCHECK(context_thread_checker_.CalledOnValidThread());
 172
 173   if (ContextGL()->GetGraphicsResetStatusKHR() != GL_NO_ERROR)
 174     OnLostContext();
 175 }
 176
 177 void ContextProviderCommandBuffer::DeleteCachedResources() {
 178   DCHECK(context_thread_checker_.CalledOnValidThread());
 179
 180   if (gr_context_)
 181     gr_context_->FreeGpuResources();
 182 }
 183
 184 void ContextProviderCommandBuffer::OnLostContext() {
 185   DCHECK(context_thread_checker_.CalledOnValidThread());
 186   {
 187     base::AutoLock lock(main_thread_lock_);
 188     if (destroyed_)
 189       return;
 190     destroyed_ = true;
 191   }
 192   if (!lost_context_callback_.is_null())
 193     base::ResetAndReturn(&lost_context_callback_).Run();
 194   if (gr_context_)
 195     gr_context_->OnLostContext();
 196 }
 197
 198 void ContextProviderCommandBuffer::OnMemoryAllocationChanged(
 199     const gpu::MemoryAllocation& allocation) {
 200   DCHECK(context_thread_checker_.CalledOnValidThread());
 201
 202   if (memory_policy_changed_callback_.is_null())
 203     return;
 204
 205   memory_policy_changed_callback_.Run(cc::ManagedMemoryPolicy(allocation));
 206 }
 207
 208 void ContextProviderCommandBuffer::InitializeCapabilities() {
 209   Capabilities caps;
 210   caps.gpu = context3d_->GetImplementation()->capabilities();
 211
 212   size_t mapped_memory_limit = context3d_->GetMappedMemoryLimit();
 213   caps.max_transfer_buffer_usage_bytes =
 214       mapped_memory_limit == WebGraphicsContext3DCommandBufferImpl::kNoLimit
 215       ? std::numeric_limits<size_t>::max() : mapped_memory_limit;
 216
 217   capabilities_ = caps;
 218 }
 219
 220 bool ContextProviderCommandBuffer::DestroyedOnMainThread() {
 221   DCHECK(main_thread_checker_.CalledOnValidThread());
 222
 223   base::AutoLock lock(main_thread_lock_);
 224   return destroyed_;
 225 }
 226
 227 void ContextProviderCommandBuffer::SetLostContextCallback(
 228     const LostContextCallback& lost_context_callback) {
 229   DCHECK(context_thread_checker_.CalledOnValidThread());
 230   DCHECK(lost_context_callback_.is_null() ||
 231          lost_context_callback.is_null());
 232   lost_context_callback_ = lost_context_callback;
 233 }
 234
 235 void ContextProviderCommandBuffer::SetMemoryPolicyChangedCallback(
 236     const MemoryPolicyChangedCallback& memory_policy_changed_callback) {
 237   DCHECK(context_thread_checker_.CalledOnValidThread());
 238   DCHECK(memory_policy_changed_callback_.is_null() ||
 239          memory_policy_changed_callback.is_null());
 240   memory_policy_changed_callback_ = memory_policy_changed_callback;
 241
 242   if (!memory_policy_changed_callback_.is_null()) {
 243     DCHECK(context3d_->GetCommandBufferProxy());
 244     context3d_->GetCommandBufferProxy()->SetMemoryAllocationChangedCallback(
 245         base::Bind(&ContextProviderCommandBuffer::OnMemoryAllocationChanged,
 246                    base::Unretained(this)));
 247   }
 248 }
 249
 250 }  // namespace content