base: Change WeakPtr to use SequenceChecker instead of ThreadChecker.

base/sequence_checker_unittest.cc

-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Copyright 2013 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/basictypes.h"
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/location.h"
+#include "base/logging.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/message_loop.h"
 #include "base/sequence_checker.h"
-
-#include <cstddef>
-
-#include "base/compiler_specific.h"
-#include "base/memory/ref_counted.h"
-#include "base/test/null_task_runner.h"
+#include "base/test/sequenced_worker_pool_owner.h"
+#include "base/threading/simple_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+// Duplicated from base/sequence_checker.h so that we can be good citizens
+// there and undef the macro.
+#if (!defined(NDEBUG) || defined(DCHECK_ALWAYS_ON))
+#define ENABLE_SEQUENCE_CHECKER 1
+#else
+#define ENABLE_SEQUENCE_CHECKER 0
+#endif
+
 namespace base {
 
 namespace {
 
-// Call various methods of SequenceChecker to make sure nothing blows
-// up in either debug or release mode.
-TEST(SequenceCheckerTest, Basic) {
-  SequenceChecker sequence_checker(new NullTaskRunner());
-  sequence_checker.CalledOnValidSequence();
-  sequence_checker.ChangeSequence(NULL);
-  sequence_checker.CalledOnValidSequence();
-}
+const size_t kNumWorkerThreads = 3;
+
+// Simple class to exercise the basics of SequenceChecker.
+// Both the destructor and DoStuff should verify that they were
+// called on the same thread as the constructor.
+class SequenceCheckerClass : public SequenceChecker {
+ public:
+  SequenceCheckerClass() {}
+  ~SequenceCheckerClass() {}
+
+  // Verifies that it was called on the same thread as the constructor.
+  void DoStuff() {
+    DCHECK(CalledOnValidSequence());
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(SequenceCheckerClass);
+};
+
+// Calls ThreadCheckerClass::DoStuff on another thread.

[vandebo (ex-Chrome), 2013/06/28 21:00:06]

nit: this doesn't do it on a different thread, but is a helper to enable that...

[tommycli, 2013/06/28 22:37:07]

Done.

+class CallDoStuffOnThread : public base::SimpleThread {
+ public:
+  explicit CallDoStuffOnThread(SequenceCheckerClass* sequence_checker_class)
+      : SimpleThread("call_do_stuff_on_thread"),
+        sequence_checker_class_(sequence_checker_class) {
+  }
+
+  virtual void Run() OVERRIDE {
+    sequence_checker_class_->DoStuff();
+  }
+
+ private:
+  SequenceCheckerClass* sequence_checker_class_;
+
+  DISALLOW_COPY_AND_ASSIGN(CallDoStuffOnThread);
+};
+
+// Deletes ThreadCheckerClass on a different thread.
+class DeleteThreadCheckerClassOnThread : public base::SimpleThread {
+ public:
+  explicit DeleteThreadCheckerClassOnThread(
+      SequenceCheckerClass* sequence_checker_class)
+      : SimpleThread("delete_sequence_checker_class_on_thread"),
+        sequence_checker_class_(sequence_checker_class) {
+  }
+
+  virtual void Run() OVERRIDE {
+    sequence_checker_class_.reset();
+  }
+
+ private:
+  scoped_ptr<SequenceCheckerClass> sequence_checker_class_;

[vandebo (ex-Chrome), 2013/06/28 21:00:06]

nit: why is this one a scope_ptr, but CallDoStuffOnThread has a raw ptr?

[tommycli, 2013/06/28 22:37:07]

DeleteThreadCheckerClassThread must take possession of the object to delete it.
CallDoStuffThread should not take possession.

+
+  DISALLOW_COPY_AND_ASSIGN(DeleteThreadCheckerClassOnThread);
+};
+
+class SequenceCheckerTest : public testing::Test {
+ public:
+  SequenceCheckerTest() {
+    ResetPool();
+  }
+
+  virtual ~SequenceCheckerTest() {}
+
+  virtual void SetUp() OVERRIDE {}
+
+  virtual void TearDown() OVERRIDE {
+    pool()->Shutdown();
+  }
+
+ protected:
+  const scoped_refptr<SequencedWorkerPool>& pool() {
+    return pool_owner_->pool();
+  }
+
+  void PostDoStuffToWorkerPool(SequenceCheckerClass* sequence_checker,
+                               const std::string& token_name) {
+    pool()->PostNamedSequencedWorkerTask(
+        token_name,
+        FROM_HERE,
+        base::Bind(&SequenceCheckerClass::DoStuff,
+                   base::Unretained(sequence_checker)));
+  }
+
+  // Destroys the SequencedWorkerPool instance, blocking until it is fully shut
+  // down, and creates a new instance.
+  void ResetPool() {
+    pool_owner_.reset(new SequencedWorkerPoolOwner(kNumWorkerThreads, "test"));
+  }
+
+  void DifferentSequenceTokensDeathTest();
+  void WorkerPoolAndSimpleThreadDeathTest();
+  void TwoDifferentWorkerPoolsDeathTest();
+
+ private:
+  MessageLoop message_loop_;
+  scoped_ptr<SequencedWorkerPoolOwner> pool_owner_;
+};
 
 }  // namespace
 
+TEST(SequenceCheckerNoWorkerPoolTest, CallsAllowedOnSameThread) {
+  scoped_ptr<SequenceCheckerClass> sequence_checker_class(
+      new SequenceCheckerClass);
+
+  // Verify that DoStuff doesn't assert.
+  sequence_checker_class->DoStuff();
+
+  // Verify that the destructor doesn't assert.
+  sequence_checker_class.reset();
+}
+
+TEST(SequenceCheckerNoWorkerPoolTest, DestructorAllowedOnDifferentThread) {
+  scoped_ptr<SequenceCheckerClass> sequence_checker_class(
+      new SequenceCheckerClass);
+
+  // Verify that the destructor doesn't assert
+  // when called on a different thread.
+  DeleteThreadCheckerClassOnThread delete_on_thread(
+      sequence_checker_class.release());
+
+  delete_on_thread.Start();
+  delete_on_thread.Join();
+}
+
+TEST(SequenceCheckerNoWorkerPoolTest, DetachFromSequence) {
+  scoped_ptr<SequenceCheckerClass> sequence_checker_class(
+      new SequenceCheckerClass);
+
+  // Verify that DoStuff doesn't assert when called on a different thread after
+  // a call to DetachFromSequence.
+  sequence_checker_class->DetachFromSequence();
+  CallDoStuffOnThread call_on_thread(sequence_checker_class.get());
+
+  call_on_thread.Start();
+  call_on_thread.Join();
+}
+
+void MethodOnDifferentThreadImpl() {
+  scoped_ptr<SequenceCheckerClass> sequence_checker_class(
+      new SequenceCheckerClass);
+
+  // DoStuff should assert in debug builds only when called on a
+  // different thread.
+  CallDoStuffOnThread call_on_thread(sequence_checker_class.get());
+
+  call_on_thread.Start();
+  call_on_thread.Join();
+}
+
+#if GTEST_HAS_DEATH_TEST && ENABLE_SEQUENCE_CHECKER
+TEST(SequenceCheckerNoWorkerPoolDeathTest,
+     MethodNotAllowedOnDifferentThreadInDebug) {
+  ASSERT_DEATH({
+    MethodOnDifferentThreadImpl();
+  }, "");
+}
+#else
+TEST(SequenceCheckerNoWorkerPoolTest, MethodAllowedOnDifferentThreadInRelease) {
+  MethodOnDifferentThreadImpl();
+}
+#endif  // GTEST_HAS_DEATH_TEST && ENABLE_SEQUENCE_CHECKER
+
+void DetachThenCallFromDifferentThreadImpl() {
+  scoped_ptr<SequenceCheckerClass> sequence_checker_class(
+      new SequenceCheckerClass);
+
+  // DoStuff doesn't assert when called on a different thread
+  // after a call to DetachFromSequence.
+  sequence_checker_class->DetachFromSequence();
+  CallDoStuffOnThread call_on_thread(sequence_checker_class.get());
+
+  call_on_thread.Start();
+  call_on_thread.Join();
+
+  // DoStuff should assert in debug builds only after moving to
+  // another thread.
+  sequence_checker_class->DoStuff();
+}
+
+#if GTEST_HAS_DEATH_TEST && ENABLE_SEQUENCE_CHECKER
+TEST(SequenceCheckerNoWorkerPoolDeathTest, DetachFromSequenceInDebug) {
+  ASSERT_DEATH({
+    DetachThenCallFromDifferentThreadImpl();
+  }, "");
+}
+#else
+TEST(SequenceCheckerNoWorkerPoolTest, DetachFromThreadInRelease) {
+  DetachThenCallFromDifferentThreadImpl();
+}
+#endif  // GTEST_HAS_DEATH_TEST && ENABLE_SEQUENCE_CHECKER
+
+TEST_F(SequenceCheckerTest, SameSequenceTokenValid) {
+  SequenceCheckerClass checker;
+
+  checker.DetachFromSequence();
+  PostDoStuffToWorkerPool(&checker, "A");
+  PostDoStuffToWorkerPool(&checker, "A");
+  PostDoStuffToWorkerPool(&checker, "A");
+  PostDoStuffToWorkerPool(&checker, "A");
+  pool()->FlushForTesting();
+}
+
+TEST_F(SequenceCheckerTest, DetachSequenceTokenValid) {
+  SequenceCheckerClass checker;
+
+  checker.DetachFromSequence();
+  PostDoStuffToWorkerPool(&checker, "A");
+  PostDoStuffToWorkerPool(&checker, "A");
+  pool()->FlushForTesting();
+
+  checker.DetachFromSequence();
+  PostDoStuffToWorkerPool(&checker, "B");
+  PostDoStuffToWorkerPool(&checker, "B");
+  pool()->FlushForTesting();
+}
+
+void SequenceCheckerTest::DifferentSequenceTokensDeathTest() {
+  SequenceCheckerClass checker;
+
+  checker.DetachFromSequence();
+  PostDoStuffToWorkerPool(&checker, "A");
+  PostDoStuffToWorkerPool(&checker, "A");
+  PostDoStuffToWorkerPool(&checker, "B");
+  PostDoStuffToWorkerPool(&checker, "B");
+  pool()->FlushForTesting();
+}
+
+#if GTEST_HAS_DEATH_TEST && ENABLE_SEQUENCE_CHECKER
+TEST_F(SequenceCheckerTest, DifferentSequenceTokensDeathTestInDebug) {
+  ASSERT_DEATH({
+    DifferentSequenceTokensDeathTest();
+  }, "");
+}
+#else
+TEST(SequenceCheckerNoWorkerPoolTest,
+     DifferentSequenceTokensDeathTestInRelease) {
+  DifferentSequenceTokensDeathTest();
+}
+#endif  // GTEST_HAS_DEATH_TEST && ENABLE_SEQUENCE_CHECKER
+
+void SequenceCheckerTest::WorkerPoolAndSimpleThreadDeathTest() {
+  SequenceCheckerClass checker;
+
+  checker.DetachFromSequence();
+  PostDoStuffToWorkerPool(&checker, "A");
+  PostDoStuffToWorkerPool(&checker, "A");
+  pool()->FlushForTesting();
+
+  CallDoStuffOnThread call_on_thread(&checker);
+  call_on_thread.Start();
+  call_on_thread.Join();
+}
+
+#if GTEST_HAS_DEATH_TEST && ENABLE_SEQUENCE_CHECKER
+TEST_F(SequenceCheckerTest, WorkerPoolAndSimpleThreadDeathTestInDebug) {
+  ASSERT_DEATH({
+    WorkerPoolAndSimpleThreadDeathTest();
+  }, "");
+}
+#else
+TEST(SequenceCheckerNoWorkerPoolTest,
+     WorkerPoolAndSimpleThreadDeathTestInRelease) {
+  WorkerPoolAndSimpleThreadDeathTest();
+}
+#endif  // GTEST_HAS_DEATH_TEST && ENABLE_SEQUENCE_CHECKER
+
+void SequenceCheckerTest::TwoDifferentWorkerPoolsDeathTest() {
+  SequenceCheckerClass checker;
+
+  checker.DetachFromSequence();
+  PostDoStuffToWorkerPool(&checker, "A");
+  PostDoStuffToWorkerPool(&checker, "A");
+  pool()->FlushForTesting();
+
+  SequencedWorkerPoolOwner second_pool_owner(kNumWorkerThreads, "test2");
+  second_pool_owner.pool()->PostNamedSequencedWorkerTask(
+      "A",
+      FROM_HERE,
+      base::Bind(&SequenceCheckerClass::DoStuff,
+                 base::Unretained(&checker)));
+  second_pool_owner.pool()->FlushForTesting();
+  second_pool_owner.pool()->Shutdown();
+}
+
+#if GTEST_HAS_DEATH_TEST && ENABLE_SEQUENCE_CHECKER
+TEST_F(SequenceCheckerTest, TwoDifferentWorkerPoolsDeathTestInDebug) {
+  ASSERT_DEATH({
+    TwoDifferentWorkerPoolsDeathTest();
+  }, "");
+}
+#else
+TEST(SequenceCheckerNoWorkerPoolTest,
+     TwoDifferentWorkerPoolsDeathTestInRelease) {
+  TwoDifferentWorkerPoolsDeathTest();
+}
+#endif  // GTEST_HAS_DEATH_TEST && ENABLE_SEQUENCE_CHECKER
+
+// Just in case we ever get lumped together with other compilation units.
+#undef ENABLE_SEQUENCE_CHECKER
+
 }  // namespace base