content/browser/android/in_process/context_provider_in_process.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/browser/android/in_process/context_provider_in_process.h"
   6
   7 #include "base/bind.h"
   8 #include "base/callback_helpers.h"
   9 #include "base/strings/stringprintf.h"
  10 #include "cc/output/managed_memory_policy.h"
  11 #include "content/common/gpu/client/grcontext_for_webgraphicscontext3d.h"
  12 #include "gpu/blink/webgraphicscontext3d_in_process_command_buffer_impl.h"
  13 #include "gpu/command_buffer/client/gles2_implementation.h"
  14 #include "third_party/skia/include/gpu/GrContext.h"
  15
  16 using gpu_blink::WebGraphicsContext3DInProcessCommandBufferImpl;
  17
  18 namespace content {
  19
  20 class ContextProviderInProcess::LostContextCallbackProxy
  21     : public blink::WebGraphicsContext3D::WebGraphicsContextLostCallback {
  22  public:
  23   explicit LostContextCallbackProxy(ContextProviderInProcess* provider)
  24       : provider_(provider) {
  25     provider_->context3d_->setContextLostCallback(this);
  26   }
  27
  28   virtual ~LostContextCallbackProxy() {
  29     provider_->context3d_->setContextLostCallback(NULL);
  30   }
  31
  32   virtual void onContextLost() {
  33     provider_->OnLostContext();
  34   }
  35
  36  private:
  37   ContextProviderInProcess* provider_;
  38 };
  39
  40 // static
  41 scoped_refptr<ContextProviderInProcess> ContextProviderInProcess::Create(
  42     scoped_ptr<WebGraphicsContext3DInProcessCommandBufferImpl> context3d,
  43     const std::string& debug_name) {
  44   if (!context3d)
  45     return NULL;
  46   return new ContextProviderInProcess(context3d.Pass(), debug_name);
  47 }
  48
  49 ContextProviderInProcess::ContextProviderInProcess(
  50     scoped_ptr<WebGraphicsContext3DInProcessCommandBufferImpl> context3d,
  51     const std::string& debug_name)
  52     : context3d_(context3d.Pass()),
  53       destroyed_(false),
  54       debug_name_(debug_name) {
  55   DCHECK(main_thread_checker_.CalledOnValidThread());
  56   DCHECK(context3d_);
  57   context_thread_checker_.DetachFromThread();
  58 }
  59
  60 ContextProviderInProcess::~ContextProviderInProcess() {
  61   DCHECK(main_thread_checker_.CalledOnValidThread() ||
  62          context_thread_checker_.CalledOnValidThread());
  63 }
  64
  65 blink::WebGraphicsContext3D* ContextProviderInProcess::WebContext3D() {
  66   DCHECK(lost_context_callback_proxy_);  // Is bound to thread.
  67   DCHECK(context_thread_checker_.CalledOnValidThread());
  68
  69   return context3d_.get();
  70 }
  71
  72 bool ContextProviderInProcess::BindToCurrentThread() {
  73   DCHECK(context3d_);
  74
  75   // This is called on the thread the context will be used.
  76   DCHECK(context_thread_checker_.CalledOnValidThread());
  77
  78   if (lost_context_callback_proxy_)
  79     return true;
  80
  81   if (!context3d_->InitializeOnCurrentThread())
  82     return false;
  83
  84   InitializeCapabilities();
  85
  86   const std::string unique_context_name =
  87       base::StringPrintf("%s-%p", debug_name_.c_str(), context3d_.get());
  88   context3d_->traceBeginCHROMIUM("gpu_toplevel",
  89                                  unique_context_name.c_str());
  90
  91   lost_context_callback_proxy_.reset(new LostContextCallbackProxy(this));
  92   return true;
  93 }
  94
  95 void ContextProviderInProcess::DetachFromThread() {
  96   context_thread_checker_.DetachFromThread();
  97 }
  98
  99 void ContextProviderInProcess::InitializeCapabilities() {
 100   capabilities_.gpu = context3d_->GetImplementation()->capabilities();
 101
 102   size_t mapped_memory_limit = context3d_->GetMappedMemoryLimit();
 103   capabilities_.max_transfer_buffer_usage_bytes =
 104       mapped_memory_limit ==
 105               WebGraphicsContext3DInProcessCommandBufferImpl::kNoLimit
 106           ? std::numeric_limits<size_t>::max()
 107           : mapped_memory_limit;
 108 }
 109
 110 cc::ContextProvider::Capabilities
 111 ContextProviderInProcess::ContextCapabilities() {
 112   DCHECK(lost_context_callback_proxy_);  // Is bound to thread.
 113   DCHECK(context_thread_checker_.CalledOnValidThread());
 114   return capabilities_;
 115 }
 116
 117 ::gpu::gles2::GLES2Interface* ContextProviderInProcess::ContextGL() {
 118   DCHECK(context3d_);
 119   DCHECK(lost_context_callback_proxy_);  // Is bound to thread.
 120   DCHECK(context_thread_checker_.CalledOnValidThread());
 121
 122   return context3d_->GetGLInterface();
 123 }
 124
 125 ::gpu::ContextSupport* ContextProviderInProcess::ContextSupport() {
 126   DCHECK(context3d_);
 127   if (!lost_context_callback_proxy_)
 128     return NULL;  // Not bound to anything.
 129
 130   DCHECK(context_thread_checker_.CalledOnValidThread());
 131
 132   return context3d_->GetContextSupport();
 133 }
 134
 135 class GrContext* ContextProviderInProcess::GrContext() {
 136   DCHECK(lost_context_callback_proxy_);  // Is bound to thread.
 137   DCHECK(context_thread_checker_.CalledOnValidThread());
 138
 139   if (gr_context_)
 140     return gr_context_->get();
 141
 142   gr_context_.reset(new GrContextForWebGraphicsContext3D(context3d_.get()));
 143   return gr_context_->get();
 144 }
 145
 146 void ContextProviderInProcess::InvalidateGrContext(uint32_t state) {
 147   DCHECK(lost_context_callback_proxy_);  // Is bound to thread.
 148   DCHECK(context_thread_checker_.CalledOnValidThread());
 149
 150   if (gr_context_)
 151     return gr_context_->get()->resetContext(state);
 152 }
 153
 154 void ContextProviderInProcess::SetupLock() {
 155   context3d_->SetLock(&context_lock_);
 156 }
 157
 158 base::Lock* ContextProviderInProcess::GetLock() {
 159   return &context_lock_;
 160 }
 161
 162 void ContextProviderInProcess::VerifyContexts() {
 163   DCHECK(lost_context_callback_proxy_);  // Is bound to thread.
 164   DCHECK(context_thread_checker_.CalledOnValidThread());
 165
 166   if (ContextGL()->GetGraphicsResetStatusKHR() != GL_NO_ERROR)
 167     OnLostContext();
 168 }
 169
 170 void ContextProviderInProcess::DeleteCachedResources() {
 171   DCHECK(context_thread_checker_.CalledOnValidThread());
 172
 173   if (gr_context_)
 174     gr_context_->FreeGpuResources();
 175 }
 176
 177 void ContextProviderInProcess::OnLostContext() {
 178   DCHECK(context_thread_checker_.CalledOnValidThread());
 179   {
 180     base::AutoLock lock(destroyed_lock_);
 181     if (destroyed_)
 182       return;
 183     destroyed_ = true;
 184   }
 185   if (!lost_context_callback_.is_null())
 186     base::ResetAndReturn(&lost_context_callback_).Run();
 187   if (gr_context_)
 188     gr_context_->OnLostContext();
 189 }
 190
 191 bool ContextProviderInProcess::DestroyedOnMainThread() {
 192   DCHECK(main_thread_checker_.CalledOnValidThread());
 193
 194   base::AutoLock lock(destroyed_lock_);
 195   return destroyed_;
 196 }
 197
 198 void ContextProviderInProcess::SetLostContextCallback(
 199     const LostContextCallback& lost_context_callback) {
 200   DCHECK(context_thread_checker_.CalledOnValidThread());
 201   DCHECK(lost_context_callback_.is_null() ||
 202          lost_context_callback.is_null());
 203   lost_context_callback_ = lost_context_callback;
 204 }
 205
 206 void ContextProviderInProcess::SetMemoryPolicyChangedCallback(
 207     const MemoryPolicyChangedCallback& memory_policy_changed_callback) {
 208   // There's no memory manager for the in-process implementation.
 209 }
 210
 211 }  // namespace content