GLInProcessContext: support async flushes and dedicated GPU thread

base/memory/weak_ptr_unittest.cc

 // 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.
 
 #include "base/memory/weak_ptr.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/debug/leak_annotations.h"
@@ skipping 318 matching lines @@
 
     // The new WeakPtr is owned by background thread.
     EXPECT_EQ(target, background.DeRef(&arrow));
   }
 
   // Target can only be deleted on background thread.
   background.DeleteTarget(target);
   background.DeleteArrow(arrow);
 }
 
-TEST(WeakPtrTest, MoveOwnershipExplicitlyObjectNotReferenced) {
-  // Case 1: The target is not bound to any thread yet. So calling
-  // DetachFromThread() is a no-op.
-  Target target;
-  target.DetachFromThreadHack();
-
-  // Case 2: The target is bound to main thread but no WeakPtr is pointing to
-  // it. In this case, it will be re-bound to any thread trying to get a
-  // WeakPtr pointing to it. So detach function call is again no-op.
-  {
-    WeakPtr<Target> weak_ptr = target.AsWeakPtr();
-  }
-  target.DetachFromThreadHack();
-}
-
 TEST(WeakPtrTest, MoveOwnershipExplicitly) {

[Wez, 2013/07/31 19:06:26]

The process for "moving" ownership is now:

1. Take WeakPtr to object.
2. De-ref it on thread A -> now owned by thread A.
3. Invalidate it on thread A.
4. Take new WeakPtr to object.
5. De-ref it on thread B -> if you'd skipped (3) then this would fail.

It looks like I missed adding a test for that when I updated the WeakPtr
semantics, so either adapt this test accordingly, or remove it and file a bug
for me to do that, please. :)

   BackgroundThread background;
   background.Start();
 
   Arrow* arrow;
   {
     Target target;
-    // Background thread creates WeakPtr(and implicitly owns the object).
+    // Background thread creates WeakPtr.
     background.CreateArrowFromTarget(&arrow, &target);
-    EXPECT_EQ(&target, background.DeRef(arrow));
 
-    // Detach from background thread.
-    target.DetachFromThreadHack();
-
-    // Re-bind to main thread.
+    // Bind to main thread.
     EXPECT_EQ(&target, arrow->target.get());
 
     // Main thread can now delete the target.
   }
 
   // WeakPtr can be deleted on non-owner thread.
   background.DeleteArrow(arrow);
 }
 
 TEST(WeakPtrTest, MainThreadRefOutlivesBackgroundThreadRef) {
@@ skipping 203 matching lines @@
   background.Start();
   background.DeleteTarget(target.release());
 
   // Main thread attempts to dereference the target, violating thread binding.
   ASSERT_DEATH(arrow.target.get(), "");
 }
 
 #endif
 
 }  // namespace base