GLInProcessContext: support async flushes and dedicated GPU thread

base/memory/weak_ptr.h

 // Copyright (c) 2012 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.
 
 // Weak pointers are pointers to an object that do not affect its lifetime,
 // and which may be invalidated (i.e. reset to NULL) by the object, or its
 // owner, at any time, most commonly when the object is about to be deleted.
 
 // Weak pointers are useful when an object needs to be accessed safely by one
 // or more objects other than its owner, and those callers can cope with the
@@ skipping 72 matching lines @@
  public:
   // Although Flag is bound to a specific thread, it may be deleted from another
   // via base::WeakPtr::~WeakPtr().
   class Flag : public RefCountedThreadSafe<Flag> {
    public:
     Flag();
 
     void Invalidate();
     bool IsValid() const;
 
-    // Remove this when crbug.com/234964 is addressed.
-    void DetachFromThreadHack() { sequence_checker_.DetachFromSequence(); }
-
    private:
     friend class base::RefCountedThreadSafe<Flag>;
 
     ~Flag();
 
     SequenceChecker sequence_checker_;
     bool is_valid_;
   };
 
   WeakReference();
@@ skipping 12 matching lines @@
   ~WeakReferenceOwner();
 
   WeakReference GetRef() const;
 
   bool HasRefs() const {
     return flag_.get() && !flag_->HasOneRef();
   }
 
   void Invalidate();
 
-  // Remove this when crbug.com/234964 is addressed.
-  void DetachFromThreadHack() {
-    if (flag_.get())
-      flag_->DetachFromThreadHack();
-  }
-
  private:
   mutable scoped_refptr<WeakReference::Flag> flag_;
 };
 
 // This class simplifies the implementation of WeakPtr's type conversion
 // constructor by avoiding the need for a public accessor for ref_.  A
 // WeakPtr<T> cannot access the private members of WeakPtr<U>, so this
 // base class gives us a way to access ref_ in a protected fashion.
 class BASE_EXPORT WeakPtrBase {
  public:
@@ skipping 160 matching lines @@
 // destroyed, its use can lead to subtle use-after-destroy issues.
 template <class T>
 class SupportsWeakPtr : public internal::SupportsWeakPtrBase {
  public:
   SupportsWeakPtr() {}
 
   WeakPtr<T> AsWeakPtr() {
     return WeakPtr<T>(weak_reference_owner_.GetRef(), static_cast<T*>(this));
   }
 
-  // Removes the binding, if any, from this object to a particular thread.
-  // This is used in WebGraphicsContext3DInProcessCommandBufferImpl to work-
-  // around access to cmmand buffer objects by more than one thread.
-  // Remove this when crbug.com/234964 is addressed.
-  void DetachFromThreadHack() {
-    weak_reference_owner_.DetachFromThreadHack();
-  }
-
  protected:
   ~SupportsWeakPtr() {}
 
  private:
   internal::WeakReferenceOwner weak_reference_owner_;
   DISALLOW_COPY_AND_ASSIGN(SupportsWeakPtr);
 };
 
 // Helper function that uses type deduction to safely return a WeakPtr<Derived>
 // when Derived doesn't directly extend SupportsWeakPtr<Derived>, instead it
@@ skipping 14 matching lines @@
 //   base::WeakPtr<Derived> ptr = derived.AsWeakPtr();  // Fails.
 
 template <typename Derived>
 WeakPtr<Derived> AsWeakPtr(Derived* t) {
   return internal::SupportsWeakPtrBase::StaticAsWeakPtr<Derived>(t);
 }
 
 }  // namespace base
 
 #endif  // BASE_MEMORY_WEAK_PTR_H_