Revert "Allow SequencedTaskRunnerHandle::Get() while running unsequenced tasks."

base/threading/sequenced_worker_pool_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/threading/sequenced_worker_pool.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <memory>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
-#include "base/sequence_checker_impl.h"
 #include "base/stl_util.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
-#include "base/synchronization/waitable_event.h"
 #include "base/test/sequenced_task_runner_test_template.h"
 #include "base/test/sequenced_worker_pool_owner.h"
 #include "base/test/task_runner_test_template.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/platform_thread.h"
 #include "base/time/time.h"
 #include "base/tracked_objects.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
@@ skipping 858 matching lines @@
   // Should be fine to call on an idle instance with all threads created, and
   // spamming the method shouldn't deadlock or confuse the class.
   pool()->FlushForTesting();
   pool()->FlushForTesting();
 
   // Should be fine to call after shutdown too.
   pool()->Shutdown();
   pool()->FlushForTesting();
 }
 
-// Helper method for VerifyCurrentSequencedTaskRunner() and
-// VerifyCurrentSequencedTaskRunnerForUnsequencedTask().
-void VerifySequencedTaskRunnerRunsOnCurrentThread(
-    SequencedTaskRunner* task_runner,
-    bool should_run_on_current_thread,
-    const Closure& callback) {
-  EXPECT_EQ(should_run_on_current_thread,
-            task_runner->RunsTasksOnCurrentThread());
-  callback.Run();
+namespace {
+
+void CheckWorkerPoolAndSequenceToken(
+      const scoped_refptr<SequencedWorkerPool>& expected_pool,
+    SequencedWorkerPool::SequenceToken expected_token) {
+  SequencedWorkerPool::SequenceToken token =
+      SequencedWorkerPool::GetSequenceTokenForCurrentThread();
+  EXPECT_EQ(expected_token.ToString(), token.ToString());
+
+  scoped_refptr<SequencedWorkerPool> pool =
+      SequencedWorkerPool::GetWorkerPoolForCurrentThread();
+  EXPECT_EQ(expected_pool, pool);
 }
 
-void VerifyCurrentSequencedTaskRunner(
-    SequencedTaskRunner* expected_task_runner,
-    bool expected_equal,
-    const Closure& callback) {
-  scoped_refptr<SequencedTaskRunner> task_runner =
-      SequencedWorkerPool::GetSequencedTaskRunnerForCurrentThread();
+}  // namespace
 
-  EXPECT_TRUE(task_runner->RunsTasksOnCurrentThread());
-
-  // SequencedTaskRunner does not allow directly checking for equality, but we
-  // can post a task to one task runner and verify that the other task runner
-  // is on the same sequence.
-  task_runner->PostTask(
-      FROM_HERE,
-      Bind(&VerifySequencedTaskRunnerRunsOnCurrentThread,
-           base::Unretained(expected_task_runner), expected_equal, callback));
-}
-
-void VerifyCurrentSequencedTaskRunnerForUnsequencedTask(
-    SequencedWorkerPool* pool,
-    const Closure& callback) {
-  EXPECT_FALSE(
-      SequencedWorkerPool::GetSequenceTokenForCurrentThread().IsValid());
-
-  scoped_refptr<SequencedTaskRunner> task_runner =
-      SequencedWorkerPool::GetSequencedTaskRunnerForCurrentThread();
-
-  EXPECT_TRUE(task_runner->RunsTasksOnCurrentThread());
-
-  scoped_refptr<SequencedTaskRunner> expected_task_runner =
-      SequencedWorkerPool::GetSequencedTaskRunnerForCurrentThread();
-
-  // The pool should now be running a sequence. This also verifies that no other
-  // thread will start running tasks with this sequence token.
-  const SequencedWorkerPool::SequenceToken sequence_token =
-      SequencedWorkerPool::GetSequenceTokenForCurrentThread();
-  ASSERT_TRUE(sequence_token.IsValid());
-  EXPECT_TRUE(pool->IsRunningSequence(sequence_token));
-
-  // The two sequenced task runners should be the same. See
-  // VerifyCurrentSequencedTaskRunner() above for why the check is implemented
-  // this way.
-  const bool expected_equal = true;
-  task_runner->PostTask(FROM_HERE,
-                        Bind(&VerifySequencedTaskRunnerRunsOnCurrentThread,
-                             RetainedRef(std::move(expected_task_runner)),
-                             expected_equal, callback));
-}
-
-TEST_F(SequencedWorkerPoolTest, GetSequencedTaskRunnerForCurrentThread) {
+TEST_F(SequencedWorkerPoolTest, GetWorkerPoolAndSequenceTokenForCurrentThread) {
   EnsureAllWorkersCreated();
 
-  // The current thread should not have a sequenced task runner from a
-  // worker pool.
-  scoped_refptr<SequencedTaskRunner> local_task_runner =
-      SequencedWorkerPool::GetSequencedTaskRunnerForCurrentThread();
-  EXPECT_FALSE(local_task_runner);
+  // The current thread should have neither a worker pool nor a sequence token.
+  SequencedWorkerPool::SequenceToken local_token =
+      SequencedWorkerPool::GetSequenceTokenForCurrentThread();
+  scoped_refptr<SequencedWorkerPool> local_pool =
+      SequencedWorkerPool::GetWorkerPoolForCurrentThread();
+  EXPECT_FALSE(local_token.IsValid()) << local_token.ToString();
+  EXPECT_FALSE(local_pool);
 
-  WaitableEvent event(WaitableEvent::ResetPolicy::AUTOMATIC,
-                      WaitableEvent::InitialState::NOT_SIGNALED);
-  Closure signal = Bind(&WaitableEvent::Signal, Unretained(&event));
-  scoped_refptr<SequencedTaskRunner> task_runner_1 =
-      pool()->GetSequencedTaskRunner(SequencedWorkerPool::GetSequenceToken());
-  scoped_refptr<SequencedTaskRunner> task_runner_2 =
-      pool()->GetSequencedTaskRunner(SequencedWorkerPool::GetSequenceToken());
-  task_runner_1->PostTask(
-      FROM_HERE, Bind(&VerifyCurrentSequencedTaskRunner,
-                      base::Unretained(task_runner_1.get()), true, signal));
-  event.Wait();
-  task_runner_2->PostTask(
-      FROM_HERE, Bind(&VerifyCurrentSequencedTaskRunner,
-                      base::Unretained(task_runner_2.get()), true, signal));
-  event.Wait();
+  SequencedWorkerPool::SequenceToken token1 = pool()->GetSequenceToken();
+  SequencedWorkerPool::SequenceToken token2 = pool()->GetSequenceToken();
+  pool()->PostSequencedWorkerTask(
+      token1, FROM_HERE,
+      base::Bind(&CheckWorkerPoolAndSequenceToken, pool(), token1));
+  pool()->PostSequencedWorkerTask(
+      token2, FROM_HERE,
+      base::Bind(&CheckWorkerPoolAndSequenceToken, pool(), token2));
 
-  task_runner_1->PostTask(
-      FROM_HERE, Bind(&VerifyCurrentSequencedTaskRunner,
-                      base::Unretained(task_runner_2.get()), false, signal));
-  event.Wait();
+  pool()->PostWorkerTask(FROM_HERE,
+                         base::Bind(&CheckWorkerPoolAndSequenceToken, pool(),
+                                    SequencedWorkerPool::SequenceToken()));
 
-  pool()->PostWorkerTask(
-      FROM_HERE, Bind(&VerifyCurrentSequencedTaskRunnerForUnsequencedTask,
-                      RetainedRef(pool()), signal));
-  event.Wait();
-}
-
-class ChecksSequenceOnDestruction
-    : public RefCountedThreadSafe<ChecksSequenceOnDestruction> {
- public:
-  void DoNothing() {}
-
- private:
-  friend class RefCountedThreadSafe<ChecksSequenceOnDestruction>;
-
-  ~ChecksSequenceOnDestruction() {
-    EXPECT_TRUE(sequence_checker_.CalledOnValidSequence());
-  }
-
-  SequenceCheckerImpl sequence_checker_;
-};
-
-void VerifySequenceOnDestruction(const Closure& callback) {
-  scoped_refptr<SequencedTaskRunner> task_runner =
-      SequencedWorkerPool::GetSequencedTaskRunnerForCurrentThread();
-  scoped_refptr<ChecksSequenceOnDestruction> check_sequence(
-      new ChecksSequenceOnDestruction);
-
-  // Post a task to an empty method. This will keep the only reference to the
-  // object, so it will be destroyed right after running the task.
-  task_runner->PostTask(FROM_HERE, Bind(&ChecksSequenceOnDestruction::DoNothing,
-                                        std::move(check_sequence)));
-
-  // Post the callback afterwards, so we can be sure the first task completed.
-  task_runner->PostTask(FROM_HERE, callback);
-}
-
-TEST_F(SequencedWorkerPoolTest, CheckSequenceOnDestruction) {
-  EnsureAllWorkersCreated();
-
-  WaitableEvent event(WaitableEvent::ResetPolicy::AUTOMATIC,
-                      WaitableEvent::InitialState::NOT_SIGNALED);
-  Closure signal = Bind(&WaitableEvent::Signal, Unretained(&event));
-  pool()->PostWorkerTask(FROM_HERE, Bind(&VerifySequenceOnDestruction, signal));
-  event.Wait();
+  pool()->FlushForTesting();
 }
 
 TEST_F(SequencedWorkerPoolTest, ShutsDownCleanWithContinueOnShutdown) {
   scoped_refptr<SequencedTaskRunner> task_runner =
       pool()->GetSequencedTaskRunnerWithShutdownBehavior(
           pool()->GetSequenceToken(),
           base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN);
 
   // Upon test exit, should shut down without hanging.
   pool()->Shutdown();
@@ skipping 118 matching lines @@
     SequencedWorkerPoolSequencedTaskRunner, SequencedTaskRunnerTest,
     SequencedWorkerPoolSequencedTaskRunnerTestDelegate);
 INSTANTIATE_TYPED_TEST_CASE_P(
     SequencedWorkerPoolSequencedTaskRunner,
     SequencedTaskRunnerDelayedTest,
     SequencedWorkerPoolSequencedTaskRunnerTestDelegate);
 
 }  // namespace
 
 }  // namespace base