cc: Implement shared worker contexts. (v1)

cc/output/context_provider.h

 // 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.
 
 #ifndef CC_OUTPUT_CONTEXT_PROVIDER_H_
 #define CC_OUTPUT_CONTEXT_PROVIDER_H_
 
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/synchronization/lock.h"
@@ skipping 14 matching lines @@
 namespace cc {
 struct ManagedMemoryPolicy;
 
 class ContextProvider : public base::RefCountedThreadSafe<ContextProvider> {
  public:
   class ScopedContextLock {
    public:
     explicit ScopedContextLock(ContextProvider* context_provider)
         : context_provider_(context_provider),
           context_lock_(*context_provider_->GetLock()) {
-      // Allow current thread to bind to |context_provider|.
+      // Allow current thread to use |context_provider_|.
       context_provider_->DetachFromThread();
     }
     ~ScopedContextLock() {
-      // Allow a different thread to bind to |context_provider|.
+      // Allow usage by thread for which |context_provider_| is bound to.
       context_provider_->DetachFromThread();
     }
 
+    // Returns a raw pointer to the GLES2Interface or null if context has been
+    // destroyed.
     gpu::gles2::GLES2Interface* ContextGL() {
-      return context_provider_->ContextGL();
+      return context_provider_->HasBeenDestroyed()
+                 ? nullptr
+                 : context_provider_->ContextGL();
     }
 
    private:
     ContextProvider* const context_provider_;
     base::AutoLock context_lock_;
   };
   // Bind the 3d context to the current thread. This should be called before
   // accessing the contexts. Calling it more than once should have no effect.
   // Once this function has been called, the class should only be accessed
   // from the same thread.
@@ skipping 45 matching lines @@
   virtual void SetLostContextCallback(
       const LostContextCallback& lost_context_callback) = 0;
 
   // Sets a callback to be called when the memory policy changes. This should be
   // called from the same thread that the context is bound to.
   typedef base::Callback<void(const ManagedMemoryPolicy& policy)>
       MemoryPolicyChangedCallback;
   virtual void SetMemoryPolicyChangedCallback(
       const MemoryPolicyChangedCallback& memory_policy_changed_callback) = 0;
 
+  // Return true if the context inside the provider is no longer valid.

[danakj, 2015/09/04 18:28:07]

Can we maybe make this clear that this function is only to be used with a
ContextProvider that has been SetupLock()'d? And maybe we could DCHECK that?

[reveman, 2015/09/04 18:55:50]

I prefer to have this function be consistent with the other functions of this
interface. That is, if the context provider is setup for usage on multiple
threads, then the lock must be held, if only used on the thread it's bound to
then there's no need to acquire the lock before calling this function.
Implementations typically have a
DCHECK(context_thread_checker_.CalledOnValidThread()) that will fail if used
incorrectly.

[danakj, 2015/09/04 20:02:15]

My concern is that this adds a whole other state to the provider where
ContextGL() will be null. We don't want people having to worry about that state
(or causing that state) for contexts that aren't being used through the scoped
lock, do we? The idea of ContextProvider is that it's always usable even tho it
can do nothing if lost.

Having the ScopedLock return null is cool, but the way this is implemented in
https://codereview.chromium.org/1317743002/diff/280001/content/common/gpu/cli...
means that the ContextProvider will give back nulls too. Which is scarier?

+  virtual bool HasBeenDestroyed() = 0;
+
  protected:
   friend class base::RefCountedThreadSafe<ContextProvider>;
   virtual ~ContextProvider() {}
 };
 
 }  // namespace cc
 
 #endif  // CC_OUTPUT_CONTEXT_PROVIDER_H_