Make SequencedWorkerPool::IsRunningSequenceOnCurrentThread() private.

This method is not used outside of SequencedWorkerPool itself. Making it private
will prevent external users from using it directly, which will help the deprecation
of SequencedWorkerPool.

SequencedWorkerPool::IsRunningSequenceOnCurrentThread() is still used
by the RunsTasksOnCurrentThread() method of SequencedTaskRunners
returned by a SequencedWokrerPool.

BUG=622400

Review-Url: https://codereview.chromium.org/2341063002
Cr-Commit-Position: refs/heads/master@{#418984}

base/threading/sequenced_task_runner_handle.cc

@@ -40,8 +40,10 @@ scoped_refptr<SequencedTaskRunner> SequencedTaskRunnerHandle::Get() {
     SequencedWorkerPool::SequenceToken sequence_token =
         SequencedWorkerPool::GetSequenceTokenForCurrentThread();
     DCHECK(sequence_token.IsValid());
-    DCHECK(pool->IsRunningSequenceOnCurrentThread(sequence_token));
-    return pool->GetSequencedTaskRunner(sequence_token);
+    scoped_refptr<SequencedTaskRunner> sequenced_task_runner(
+        pool->GetSequencedTaskRunner(sequence_token));
+    DCHECK(sequenced_task_runner->RunsTasksOnCurrentThread());
+    return sequenced_task_runner;
   }
 
   // Return the SingleThreadTaskRunner for the current thread otherwise.

base/threading/sequenced_worker_pool.cc

@@ -118,6 +118,14 @@ struct SequencedTaskLessThan {
   }
 };
 
+// Create a process-wide unique ID to represent this task in trace events. This
+// will be mangled with a Process ID hash to reduce the likelyhood of colliding
+// with MessageLoop pointers on other processes.
+uint64_t GetTaskTraceID(const SequencedTask& task, void* pool) {
+  return (static_cast<uint64_t>(task.trace_id) << 32) |
+         static_cast<uint64_t>(reinterpret_cast<intptr_t>(pool));
+}
+
 // SequencedWorkerPoolTaskRunner ---------------------------------------------
 // A TaskRunner which posts tasks to a SequencedWorkerPool with a
 // fixed ShutdownBehavior.
@@ -168,14 +176,17 @@ bool SequencedWorkerPoolTaskRunner::RunsTasksOnCurrentThread() const {
   return pool_->RunsTasksOnCurrentThread();
 }
 
-// SequencedWorkerPoolSequencedTaskRunner ------------------------------------
+}  // namespace
+
+// SequencedWorkerPool::PoolSequencedTaskRunner ------------------------------
 // A SequencedTaskRunner which posts tasks to a SequencedWorkerPool with a
 // fixed sequence token.
 //
 // Note that this class is RefCountedThreadSafe (inherited from TaskRunner).
-class SequencedWorkerPoolSequencedTaskRunner : public SequencedTaskRunner {
+class SequencedWorkerPool::PoolSequencedTaskRunner
+    : public SequencedTaskRunner {
  public:
-  SequencedWorkerPoolSequencedTaskRunner(
+  PoolSequencedTaskRunner(
       scoped_refptr<SequencedWorkerPool> pool,
       SequencedWorkerPool::SequenceToken token,
       SequencedWorkerPool::WorkerShutdown shutdown_behavior);
@@ -192,7 +203,7 @@ class SequencedWorkerPoolSequencedTaskRunner : public SequencedTaskRunner {
                                   TimeDelta delay) override;
 
  private:
-  ~SequencedWorkerPoolSequencedTaskRunner() override;
+  ~PoolSequencedTaskRunner() override;
 
   const scoped_refptr<SequencedWorkerPool> pool_;
 
@@ -200,25 +211,25 @@ class SequencedWorkerPoolSequencedTaskRunner : public SequencedTaskRunner {
 
   const SequencedWorkerPool::WorkerShutdown shutdown_behavior_;
 
-  DISALLOW_COPY_AND_ASSIGN(SequencedWorkerPoolSequencedTaskRunner);
+  DISALLOW_COPY_AND_ASSIGN(PoolSequencedTaskRunner);
 };
 
-SequencedWorkerPoolSequencedTaskRunner::SequencedWorkerPoolSequencedTaskRunner(
-    scoped_refptr<SequencedWorkerPool> pool,
-    SequencedWorkerPool::SequenceToken token,
-    SequencedWorkerPool::WorkerShutdown shutdown_behavior)
+SequencedWorkerPool::PoolSequencedTaskRunner::
+    PoolSequencedTaskRunner(
+        scoped_refptr<SequencedWorkerPool> pool,
+        SequencedWorkerPool::SequenceToken token,
+        SequencedWorkerPool::WorkerShutdown shutdown_behavior)
     : pool_(std::move(pool)),
       token_(token),
       shutdown_behavior_(shutdown_behavior) {}
 
-SequencedWorkerPoolSequencedTaskRunner::
-~SequencedWorkerPoolSequencedTaskRunner() {
-}
+SequencedWorkerPool::PoolSequencedTaskRunner::
+    ~PoolSequencedTaskRunner() = default;
 
-bool SequencedWorkerPoolSequencedTaskRunner::PostDelayedTask(
-    const tracked_objects::Location& from_here,
-    const Closure& task,
-    TimeDelta delay) {
+bool SequencedWorkerPool::PoolSequencedTaskRunner::
+    PostDelayedTask(const tracked_objects::Location& from_here,
+                    const Closure& task,
+                    TimeDelta delay) {
   if (delay.is_zero()) {
     return pool_->PostSequencedWorkerTaskWithShutdownBehavior(
         token_, from_here, task, shutdown_behavior_);
@@ -226,29 +237,20 @@ bool SequencedWorkerPoolSequencedTaskRunner::PostDelayedTask(
   return pool_->PostDelayedSequencedWorkerTask(token_, from_here, task, delay);
 }
 
-bool SequencedWorkerPoolSequencedTaskRunner::RunsTasksOnCurrentThread() const {
+bool SequencedWorkerPool::PoolSequencedTaskRunner::
+    RunsTasksOnCurrentThread() const {
   return pool_->IsRunningSequenceOnCurrentThread(token_);
 }
 
-bool SequencedWorkerPoolSequencedTaskRunner::PostNonNestableDelayedTask(
-    const tracked_objects::Location& from_here,
-    const Closure& task,
-    TimeDelta delay) {
+bool SequencedWorkerPool::PoolSequencedTaskRunner::
+    PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
+                               const Closure& task,
+                               TimeDelta delay) {
   // There's no way to run nested tasks, so simply forward to
   // PostDelayedTask.
   return PostDelayedTask(from_here, task, delay);
 }
 
-// Create a process-wide unique ID to represent this task in trace events. This
-// will be mangled with a Process ID hash to reduce the likelyhood of colliding
-// with MessageLoop pointers on other processes.
-uint64_t GetTaskTraceID(const SequencedTask& task, void* pool) {
-  return (static_cast<uint64_t>(task.trace_id) << 32) |
-         static_cast<uint64_t>(reinterpret_cast<intptr_t>(pool));
-}
-
-}  // namespace
-
 // Worker ---------------------------------------------------------------------
 
 class SequencedWorkerPool::Worker : public SimpleThread {
@@ -1513,7 +1515,7 @@ scoped_refptr<SequencedTaskRunner> SequencedWorkerPool::GetSequencedTaskRunner(
 scoped_refptr<SequencedTaskRunner>
 SequencedWorkerPool::GetSequencedTaskRunnerWithShutdownBehavior(
     SequenceToken token, WorkerShutdown shutdown_behavior) {
-  return new SequencedWorkerPoolSequencedTaskRunner(
+  return new PoolSequencedTaskRunner(
       this, token, shutdown_behavior);
 }
 
@@ -1596,11 +1598,6 @@ bool SequencedWorkerPool::RunsTasksOnCurrentThread() const {
   return inner_->RunsTasksOnCurrentThread();
 }
 
-bool SequencedWorkerPool::IsRunningSequenceOnCurrentThread(
-    SequenceToken sequence_token) const {
-  return inner_->IsRunningSequenceOnCurrentThread(sequence_token);
-}
-
 void SequencedWorkerPool::FlushForTesting() {
   inner_->CleanupForTesting();
 }
@@ -1618,4 +1615,9 @@ bool SequencedWorkerPool::IsShutdownInProgress() {
   return inner_->IsShutdownInProgress();
 }
 
+bool SequencedWorkerPool::IsRunningSequenceOnCurrentThread(
+    SequenceToken sequence_token) const {
+  return inner_->IsRunningSequenceOnCurrentThread(sequence_token);
+}
+
 }  // namespace base

base/threading/sequenced_worker_pool.h

@@ -323,10 +323,6 @@ class BASE_EXPORT SequencedWorkerPool : public TaskRunner {
                        TimeDelta delay) override;
   bool RunsTasksOnCurrentThread() const override;
 
-  // Returns true if the current thread is processing a task with the given
-  // sequence_token.
-  bool IsRunningSequenceOnCurrentThread(SequenceToken sequence_token) const;
-
   // Blocks until all pending tasks are complete. This should only be called in
   // unit tests when you want to validate something that should have happened.
   // This will not flush delayed tasks; delayed tasks get deleted.
@@ -371,8 +367,13 @@ class BASE_EXPORT SequencedWorkerPool : public TaskRunner {
   friend class DeleteHelper<SequencedWorkerPool>;
 
   class Inner;
+  class PoolSequencedTaskRunner;
   class Worker;
 
+  // Returns true if the current thread is processing a task with the given
+  // sequence_token.
+  bool IsRunningSequenceOnCurrentThread(SequenceToken sequence_token) const;
+
   const scoped_refptr<SingleThreadTaskRunner> constructor_task_runner_;
 
   // Avoid pulling in too many headers by putting (almost) everything

base/threading/sequenced_worker_pool_unittest.cc

@@ -769,55 +769,56 @@ TEST_F(SequencedWorkerPoolTest, SpuriousWorkSignal) {
   EXPECT_EQ(old_has_work_call_count + 1, has_work_call_count());
 }
 
-void IsRunningOnCurrentThreadTask(
-    SequencedWorkerPool::SequenceToken test_positive_token,
-    SequencedWorkerPool::SequenceToken test_negative_token,
+void VerifyRunsTasksOnCurrentThread(
+    scoped_refptr<TaskRunner> test_positive_task_runner,
+    scoped_refptr<TaskRunner> test_negative_task_runner,
     SequencedWorkerPool* pool,
     SequencedWorkerPool* unused_pool) {
+  EXPECT_TRUE(test_positive_task_runner->RunsTasksOnCurrentThread());
+  EXPECT_FALSE(test_negative_task_runner->RunsTasksOnCurrentThread());
   EXPECT_TRUE(pool->RunsTasksOnCurrentThread());
-  EXPECT_TRUE(pool->IsRunningSequenceOnCurrentThread(test_positive_token));
-  EXPECT_FALSE(pool->IsRunningSequenceOnCurrentThread(test_negative_token));
   EXPECT_FALSE(unused_pool->RunsTasksOnCurrentThread());
-  EXPECT_FALSE(
-      unused_pool->IsRunningSequenceOnCurrentThread(test_positive_token));
-  EXPECT_FALSE(
-      unused_pool->IsRunningSequenceOnCurrentThread(test_negative_token));
 }
 
-// Verify correctness of the IsRunningSequenceOnCurrentThread method.
-TEST_F(SequencedWorkerPoolTest, IsRunningOnCurrentThread) {
-  SequencedWorkerPool::SequenceToken token1 = pool()->GetSequenceToken();
-  SequencedWorkerPool::SequenceToken token2 = pool()->GetSequenceToken();
-  SequencedWorkerPool::SequenceToken unsequenced_token;
+// Verify correctness of the RunsTasksOnCurrentThread() method on
+// SequencedWorkerPool and on TaskRunners it returns.
+TEST_F(SequencedWorkerPoolTest, RunsTasksOnCurrentThread) {
+  const scoped_refptr<SequencedTaskRunner> sequenced_task_runner_1 =
+      pool()->GetSequencedTaskRunner(SequencedWorkerPool::GetSequenceToken());
+  const scoped_refptr<SequencedTaskRunner> sequenced_task_runner_2 =
+      pool()->GetSequencedTaskRunner(SequencedWorkerPool::GetSequenceToken());
+  const scoped_refptr<TaskRunner> unsequenced_task_runner =
+      pool()->GetTaskRunnerWithShutdownBehavior(
+          SequencedWorkerPool::BLOCK_SHUTDOWN);
 
   SequencedWorkerPoolOwner unused_pool_owner(2, "unused_pool");
 
   EXPECT_FALSE(pool()->RunsTasksOnCurrentThread());
-  EXPECT_FALSE(pool()->IsRunningSequenceOnCurrentThread(token1));
-  EXPECT_FALSE(pool()->IsRunningSequenceOnCurrentThread(token2));
-  EXPECT_FALSE(pool()->IsRunningSequenceOnCurrentThread(unsequenced_token));
+  EXPECT_FALSE(sequenced_task_runner_1->RunsTasksOnCurrentThread());
+  EXPECT_FALSE(sequenced_task_runner_2->RunsTasksOnCurrentThread());
+  EXPECT_FALSE(unsequenced_task_runner->RunsTasksOnCurrentThread());
   EXPECT_FALSE(unused_pool_owner.pool()->RunsTasksOnCurrentThread());
-  EXPECT_FALSE(
-      unused_pool_owner.pool()->IsRunningSequenceOnCurrentThread(token1));
-  EXPECT_FALSE(
-      unused_pool_owner.pool()->IsRunningSequenceOnCurrentThread(token2));
-  EXPECT_FALSE(unused_pool_owner.pool()->IsRunningSequenceOnCurrentThread(
-      unsequenced_token));
 
-  pool()->PostSequencedWorkerTask(
-      token1, FROM_HERE,
-      base::Bind(&IsRunningOnCurrentThreadTask, token1, token2,
-                 base::RetainedRef(pool()),
+  // From a task posted to |sequenced_task_runner_1|:
+  // - sequenced_task_runner_1->RunsTasksOnCurrentThread() returns true.
+  // - sequenced_task_runner_2->RunsTasksOnCurrentThread() returns false.
+  // - pool()->RunsTasksOnCurrentThread() returns true.
+  // - unused_pool_owner.pool()->RunsTasksOnCurrentThread() returns false.
+  sequenced_task_runner_1->PostTask(
+      FROM_HERE,
+      base::Bind(&VerifyRunsTasksOnCurrentThread, sequenced_task_runner_1,
+                 sequenced_task_runner_2, base::RetainedRef(pool()),
                  base::RetainedRef(unused_pool_owner.pool())));
-  pool()->PostSequencedWorkerTask(
-      token2, FROM_HERE,
-      base::Bind(&IsRunningOnCurrentThreadTask, token2, unsequenced_token,
-                 base::RetainedRef(pool()),
+  // From a task posted to |unsequenced_task_runner|:
+  // - unsequenced_task_runner->RunsTasksOnCurrentThread() returns true.
+  // - sequenced_task_runner_1->RunsTasksOnCurrentThread() returns false.
+  // - pool()->RunsTasksOnCurrentThread() returns true.
+  // - unused_pool_owner.pool()->RunsTasksOnCurrentThread() returns false.
+  unsequenced_task_runner->PostTask(
+      FROM_HERE,
+      base::Bind(&VerifyRunsTasksOnCurrentThread, unsequenced_task_runner,
+                 sequenced_task_runner_1, base::RetainedRef(pool()),
                  base::RetainedRef(unused_pool_owner.pool())));
-  pool()->PostWorkerTask(
-      FROM_HERE, base::Bind(&IsRunningOnCurrentThreadTask, unsequenced_token,
-                            token1, base::RetainedRef(pool()),
-                            base::RetainedRef(unused_pool_owner.pool())));
 }
 
 // Checks that tasks are destroyed in the right context during shutdown. If a