[Sync] Avoid leaking in WeakHandle even when the owner thread is gone

chrome/browser/sync/weak_handle_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 "chrome/browser/sync/weak_handle.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop.h"
 #include "base/threading/thread.h"
 #include "base/tracked.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace browser_sync {
 namespace {
 
+using ::testing::_;
+using ::testing::SaveArg;
 using ::testing::StrictMock;
 
 class Base {
  public:
   Base() : weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {}
 
   WeakHandle<Base> AsWeakHandle() {
     return MakeWeakHandle(weak_ptr_factory_.GetWeakPtr());
   }
 
   void Kill() {
     weak_ptr_factory_.InvalidateWeakPtrs();
   }
 
   MOCK_METHOD0(Test, void());
   MOCK_METHOD1(Test1, void(const int&));
   MOCK_METHOD2(Test2, void(const int&, Base*));
   MOCK_METHOD3(Test3, void(const int&, Base*, float));
   MOCK_METHOD4(Test4, void(const int&, Base*, float, const char*));
 
+  MOCK_METHOD1(TestWithSelf, void(const WeakHandle<Base>&));
+
  private:
   base::WeakPtrFactory<Base> weak_ptr_factory_;
 };
 
 class WeakHandleTest : public ::testing::Test {
  protected:
   virtual void TearDown() {
     // Process any last-minute posted tasks.
     PumpLoop();
   }
@@ skipping 145 matching lines @@
 
   {
     base::Thread t("Test thread");
     ASSERT_TRUE(t.Start());
     t.message_loop()->DeleteSoon(FROM_HERE, h);
   }
 
   PumpLoop();
 }
 
+void CallTestWithSelf(const WeakHandle<Base>& b1) {
+  StrictMock<Base> b2;
+  b1.Call(FROM_HERE, &Base::TestWithSelf, b2.AsWeakHandle());
+}
+
+TEST_F(WeakHandleTest, WithDestroyedThread) {
+  StrictMock<Base> b1;
+  WeakHandle<Base> b2;
+  EXPECT_CALL(b1, TestWithSelf(_)).WillOnce(SaveArg<0>(&b2));
+
+  {
+    base::Thread t("Test thread");
+    ASSERT_TRUE(t.Start());
+    t.message_loop()->PostTask(FROM_HERE,
+                               base::Bind(&CallTestWithSelf,
+                                          b1.AsWeakHandle()));
+  }
+
+  // Calls b1.TestWithSelf().
+  PumpLoop();
+
+  // Shouldn't do anything, since the thread is gone.
+  b2.Call(FROM_HERE, &Base::Test);
+
+  // |b2| shouldn't leak when it's destroyed, even if the original
+  // thread is gone.
+}
+
 TEST_F(WeakHandleTest, InitializedAcrossCopyAssign) {
   StrictMock<Base> b;
   EXPECT_CALL(b, Test()).Times(3);
 
   EXPECT_TRUE(b.AsWeakHandle().IsInitialized());
   b.AsWeakHandle().Call(FROM_HERE, &Base::Test);
 
   {
     WeakHandle<Base> h(b.AsWeakHandle());
     EXPECT_TRUE(h.IsInitialized());
     h.Call(FROM_HERE, &Base::Test);
     h.Reset();
     EXPECT_FALSE(h.IsInitialized());
   }
 
   {
     WeakHandle<Base> h;
     h = b.AsWeakHandle();
     EXPECT_TRUE(h.IsInitialized());
     h.Call(FROM_HERE, &Base::Test);
     h.Reset();
     EXPECT_FALSE(h.IsInitialized());
   }
 
   PumpLoop();
 }
 
 }  // namespace
 }  // namespace browser_sync