cc/test/test_context_provider.cc

   1 // Copyright 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 "cc/test/test_context_provider.h"
   6
   7 #include <set>
   8 #include <vector>
   9
  10 #include "base/bind.h"
  11 #include "base/callback_helpers.h"
  12 #include "base/logging.h"
  13 #include "cc/test/test_gles2_interface.h"
  14 #include "cc/test/test_web_graphics_context_3d.h"
  15 #include "third_party/skia/include/gpu/GrContext.h"
  16 #include "third_party/skia/include/gpu/gl/SkNullGLContext.h"
  17
  18 namespace cc {
  19
  20 // static
  21 scoped_refptr<TestContextProvider> TestContextProvider::Create() {
  22   return Create(TestWebGraphicsContext3D::Create().Pass());
  23 }
  24
  25 // static
  26 scoped_refptr<TestContextProvider> TestContextProvider::Create(
  27     scoped_ptr<TestWebGraphicsContext3D> context) {
  28   if (!context)
  29     return NULL;
  30   return new TestContextProvider(context.Pass());
  31 }
  32
  33 TestContextProvider::TestContextProvider(
  34     scoped_ptr<TestWebGraphicsContext3D> context)
  35     : context3d_(context.Pass()),
  36       context_gl_(new TestGLES2Interface(context3d_.get())),
  37       bound_(false),
  38       destroyed_(false),
  39       weak_ptr_factory_(this) {
  40   DCHECK(main_thread_checker_.CalledOnValidThread());
  41   DCHECK(context3d_);
  42   context_thread_checker_.DetachFromThread();
  43   context3d_->set_test_support(&support_);
  44 }
  45
  46 TestContextProvider::~TestContextProvider() {
  47   DCHECK(main_thread_checker_.CalledOnValidThread() ||
  48          context_thread_checker_.CalledOnValidThread());
  49 }
  50
  51 bool TestContextProvider::BindToCurrentThread() {
  52   // This is called on the thread the context will be used.
  53   DCHECK(context_thread_checker_.CalledOnValidThread());
  54
  55   if (bound_)
  56     return true;
  57
  58   if (context3d_->isContextLost()) {
  59     base::AutoLock lock(destroyed_lock_);
  60     destroyed_ = true;
  61     return false;
  62   }
  63   bound_ = true;
  64
  65   context3d_->set_context_lost_callback(
  66       base::Bind(&TestContextProvider::OnLostContext,
  67                  base::Unretained(this)));
  68
  69   return true;
  70 }
  71
  72 void TestContextProvider::DetachFromThread() {
  73   context_thread_checker_.DetachFromThread();
  74 }
  75
  76 ContextProvider::Capabilities TestContextProvider::ContextCapabilities() {
  77   DCHECK(bound_);
  78   DCHECK(context_thread_checker_.CalledOnValidThread());
  79
  80   return context3d_->test_capabilities();
  81 }
  82
  83 gpu::gles2::GLES2Interface* TestContextProvider::ContextGL() {
  84   DCHECK(context3d_);
  85   DCHECK(bound_);
  86   DCHECK(context_thread_checker_.CalledOnValidThread());
  87
  88   return context_gl_.get();
  89 }
  90
  91 gpu::ContextSupport* TestContextProvider::ContextSupport() {
  92   return &support_;
  93 }
  94
  95 class GrContext* TestContextProvider::GrContext() {
  96   DCHECK(bound_);
  97   DCHECK(context_thread_checker_.CalledOnValidThread());
  98
  99   if (gr_context_)
 100     return gr_context_.get();
 101
 102   skia::RefPtr<class SkGLContext> gl_context =
 103       skia::AdoptRef(SkNullGLContext::Create(kNone_GrGLStandard));
 104   gl_context->makeCurrent();
 105   gr_context_ = skia::AdoptRef(GrContext::Create(
 106       kOpenGL_GrBackend, reinterpret_cast<GrBackendContext>(gl_context->gl())));
 107
 108   // If GlContext is already lost, also abandon the new GrContext.
 109   if (IsContextLost())
 110     gr_context_->abandonContext();
 111
 112   return gr_context_.get();
 113 }
 114
 115 void TestContextProvider::InvalidateGrContext(uint32_t state) {
 116   DCHECK(bound_);
 117   DCHECK(context_thread_checker_.CalledOnValidThread());
 118
 119   if (gr_context_)
 120     gr_context_.get()->resetContext(state);
 121 }
 122
 123 void TestContextProvider::SetupLock() {
 124 }
 125
 126 base::Lock* TestContextProvider::GetLock() {
 127   return &context_lock_;
 128 }
 129
 130 bool TestContextProvider::IsContextLost() {
 131   DCHECK(bound_);
 132   DCHECK(context_thread_checker_.CalledOnValidThread());
 133
 134   return context3d_->isContextLost();
 135 }
 136
 137 void TestContextProvider::VerifyContexts() {
 138   DCHECK(bound_);
 139   DCHECK(context_thread_checker_.CalledOnValidThread());
 140
 141   if (context3d_->isContextLost()) {
 142     base::AutoLock lock(destroyed_lock_);
 143     destroyed_ = true;
 144   }
 145 }
 146
 147 void TestContextProvider::DeleteCachedResources() {
 148 }
 149
 150 bool TestContextProvider::DestroyedOnMainThread() {
 151   DCHECK(main_thread_checker_.CalledOnValidThread());
 152
 153   base::AutoLock lock(destroyed_lock_);
 154   return destroyed_;
 155 }
 156
 157 void TestContextProvider::OnLostContext() {
 158   DCHECK(context_thread_checker_.CalledOnValidThread());
 159   {
 160     base::AutoLock lock(destroyed_lock_);
 161     if (destroyed_)
 162       return;
 163     destroyed_ = true;
 164   }
 165   if (!lost_context_callback_.is_null())
 166     base::ResetAndReturn(&lost_context_callback_).Run();
 167   if (gr_context_)
 168     gr_context_->abandonContext();
 169 }
 170
 171 TestWebGraphicsContext3D* TestContextProvider::TestContext3d() {
 172   DCHECK(bound_);
 173   DCHECK(context_thread_checker_.CalledOnValidThread());
 174
 175   return context3d_.get();
 176 }
 177
 178 TestWebGraphicsContext3D* TestContextProvider::UnboundTestContext3d() {
 179   return context3d_.get();
 180 }
 181
 182 void TestContextProvider::SetMemoryAllocation(
 183     const ManagedMemoryPolicy& policy) {
 184   if (memory_policy_changed_callback_.is_null())
 185     return;
 186   memory_policy_changed_callback_.Run(policy);
 187 }
 188
 189 void TestContextProvider::SetLostContextCallback(
 190     const LostContextCallback& cb) {
 191   DCHECK(context_thread_checker_.CalledOnValidThread());
 192   DCHECK(lost_context_callback_.is_null() || cb.is_null());
 193   lost_context_callback_ = cb;
 194 }
 195
 196 void TestContextProvider::SetMemoryPolicyChangedCallback(
 197     const MemoryPolicyChangedCallback& cb) {
 198   DCHECK(context_thread_checker_.CalledOnValidThread());
 199   DCHECK(memory_policy_changed_callback_.is_null() || cb.is_null());
 200   memory_policy_changed_callback_ = cb;
 201 }
 202
 203 void TestContextProvider::SetMaxTransferBufferUsageBytes(
 204     size_t max_transfer_buffer_usage_bytes) {
 205   context3d_->SetMaxTransferBufferUsageBytes(max_transfer_buffer_usage_bytes);
 206 }
 207
 208 }  // namespace cc