cc: Implement shared worker contexts. (v1)

blimp/client/compositor/blimp_context_provider.cc

 // Copyright 2015 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 "blimp/client/compositor/blimp_context_provider.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/lazy_instance.h"
 #include "gpu/command_buffer/client/gl_in_process_context.h"
@@ skipping 29 matching lines @@
 }  // namespace
 
 namespace blimp {
 
 // static
 scoped_refptr<BlimpContextProvider> BlimpContextProvider::Create(
     gfx::AcceleratedWidget widget) {
   return new BlimpContextProvider(widget);
 }
 
-BlimpContextProvider::BlimpContextProvider(gfx::AcceleratedWidget widget) {
+BlimpContextProvider::BlimpContextProvider(gfx::AcceleratedWidget widget)
+    : lost_(false) {
   context_thread_checker_.DetachFromThread();
 
   gpu::gles2::ContextCreationAttribHelper attribs_for_gles2;
   attribs_for_gles2.alpha_size = 8;
   attribs_for_gles2.depth_size = 0;
   attribs_for_gles2.stencil_size = 0;
   attribs_for_gles2.samples = 0;
   attribs_for_gles2.sample_buffers = 0;
   attribs_for_gles2.fail_if_major_perf_caveat = false;
   attribs_for_gles2.bind_generates_resource = false;
   attribs_for_gles2.webgl_version = 0;
   attribs_for_gles2.lose_context_when_out_of_memory = true;
 
   context_.reset(gpu::GLInProcessContext::Create(
       nullptr /* service */, nullptr /* surface */, false /* is_offscreen */,
       widget, gfx::Size(1, 1), nullptr /* share_context */,
       false /* share_resources */, attribs_for_gles2, gfx::PreferDiscreteGpu,
       gpu::GLInProcessContextSharedMemoryLimits(),
       nullptr /* gpu_memory_buffer_manager */, nullptr /* memory_limits */));
   context_->SetContextLostCallback(
       base::Bind(&BlimpContextProvider::OnLostContext, base::Unretained(this)));
 }
 
 BlimpContextProvider::~BlimpContextProvider() {
-  DCHECK(main_thread_checker_.CalledOnValidThread() ||
-         context_thread_checker_.CalledOnValidThread());
 }
 
 bool BlimpContextProvider::BindToCurrentThread() {
   DCHECK(context_thread_checker_.CalledOnValidThread());
   capabilities_.gpu = context_->GetImplementation()->capabilities();
   capabilities_.gpu.image = true;
   return true;
 }
 
 void BlimpContextProvider::DetachFromThread() {
@@ skipping 56 matching lines @@
   DCHECK(context_thread_checker_.CalledOnValidThread());
 }
 
 void BlimpContextProvider::DeleteCachedResources() {
   DCHECK(context_thread_checker_.CalledOnValidThread());
 
   if (gr_context_)
     gr_context_->freeGpuResources();
 }
 
-bool BlimpContextProvider::DestroyedOnMainThread() {
+bool BlimpContextProvider::HasBeenLostOnMainThread() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
 
-  base::AutoLock lock(destroyed_lock_);
-  return destroyed_;
+  base::AutoLock lock(lost_lock_);
+  return lost_;
 }
 
 void BlimpContextProvider::SetLostContextCallback(
     const LostContextCallback& lost_context_callback) {
   DCHECK(context_thread_checker_.CalledOnValidThread());
   lost_context_callback_ = lost_context_callback;
 }
 
 void BlimpContextProvider::SetMemoryPolicyChangedCallback(
     const MemoryPolicyChangedCallback& memory_policy_changed_callback) {
   // There's no memory manager for the in-process implementation.
   // TODO(dtrainor): Figure out if we need a memory manager for Blimp.
 }
 
 void BlimpContextProvider::OnLostContext() {
   DCHECK(context_thread_checker_.CalledOnValidThread());
 
   {
-    base::AutoLock lock(destroyed_lock_);
-    if (destroyed_)
+    base::AutoLock lock(lost_lock_);
+    if (lost_)
       return;
-    destroyed_ = true;
+    lost_ = true;
   }
 
   if (!lost_context_callback_.is_null())
     base::ResetAndReturn(&lost_context_callback_).Run();
   if (gr_context_)
     gr_context_->abandonContext();
 }
 
+bool BlimpContextProvider::HasBeenDestroyed() {
+  DCHECK(context_thread_checker_.CalledOnValidThread());
+  return false;
+}
+
 }  // namespace blimp