Make WeakPtr thread-safe, i.e. allow cross-thread copying of WeakPtr

base/memory/weak_ptr_unittest.cc

 // Copyright (c) 2011 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/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "base/message_loop.h"
 #include "base/threading/thread.h"
 
@@ skipping 20 matching lines @@
     *result = new T;
   }
 };
 
 struct Base {};
 struct Derived : Base {};
 
 struct Producer : SupportsWeakPtr<Producer> {};
 struct Consumer { WeakPtr<Producer> producer; };
 
+struct Complex {
+  Complex() {
+    consumer.producer = producer.AsWeakPtr();
+  }
+  Producer producer;
+  Consumer consumer;
+};
+
 }  // namespace
 
 TEST(WeakPtrTest, Basic) {
   int data;
   WeakPtrFactory<int> factory(&data);
   WeakPtr<int> ptr = factory.GetWeakPtr();
   EXPECT_EQ(&data, ptr.get());
 }
 
 TEST(WeakPtrTest, Comparison) {
@@ skipping 90 matching lines @@
 TEST(WeakPtrTest, SingleThreaded2) {
   // Test that it is OK to create a class that has a WeakPtr member on one
   // thread, but use it on another.  This tests that we do not trip runtime
   // checks that ensure that a weak reference is not used by multiple threads.
   scoped_ptr<Consumer> consumer(OffThreadObjectCreator<Consumer>::NewObject());
   Producer producer;
   consumer->producer = producer.AsWeakPtr();
   EXPECT_EQ(&producer, consumer->producer.get());
 }
 
+TEST(WeakPtrTest, ReattachThread) {

[awong, 2011/08/18 23:58:19]

I feel like we should have more unittest to ensure WeakPtr is safe to delete on
other threads.  Off the top of my head, I think we should test:

(1) Originating thread has a WeakPtr that outlives others.
  - Thread A creates WeakPtr<>
  - Make a copy and pass to Thread B.
  - B destructs its copy.
   - A Destructs its copy
no crash.

(2) Originating thread drops all references before another thread.
  - Thread A creates WeakPtr<>
  - Make a copy and pass to Thread B.
   - A Destructs its copy
  - B destructs its copy.
no crash.

(3) Originating thread invalidates WeakPtrs while its held by other thread.
  - Thread A creates WeakPtr<> and passes Copy to Thread B.
  - Thread A destructs the WeakReferenceOwner.
  - B destructs WeakPtr.
no crash.

(4) WeakPtr can be passed alway the way through and back:
  - Thread A creates WeakPtr<> and passes Copy to Thread B.
  - Thread A destructs the WeakReferenceOwner.
  - B passes WeakPtr<> back to A
  - A inspects WeakPtr<> and correctly sees that it is invalidated.
no crash.

+  // Test that we can move a class that supports weak references to another
+  // thread. This should work and not trip any runtime checks as long as
+  // there are no references in existence.
+  scoped_ptr<Complex> complex(OffThreadObjectCreator<Complex>::NewObject());
+  complex->consumer.producer.reset();
+  complex->consumer.producer = complex->producer.AsWeakPtr();
+  EXPECT_EQ(complex->consumer.producer.get(), &complex->producer);
+}
+
 }  // namespace base