cc: Implement shared worker contexts. (v1)

cc/output/context_provider.h

Index: cc/output/context_provider.h
diff --git a/cc/output/context_provider.h b/cc/output/context_provider.h
index c024e02328e9a3930b7593e54b986bdff3566ae5..b3e721498334dee5b1e85d9db09d0cf81f8f8284 100644
--- a/cc/output/context_provider.h
+++ b/cc/output/context_provider.h
@@ -32,16 +32,20 @@ class ContextProvider : public base::RefCountedThreadSafe<ContextProvider> {
     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:
@@ -107,6 +111,9 @@ class ContextProvider : public base::RefCountedThreadSafe<ContextProvider> {
   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() {}