Make SequencedWorkerPool::IsRunningSequenceOnCurrentThread() private.

base/threading/sequenced_worker_pool.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 <stdint.h>
 
 #include <list>
 #include <map>
@@ skipping 99 matching lines @@
       return true;
 
     if (lhs.time_to_run > rhs.time_to_run)
       return false;
 
     // If the time happen to match, then we use the sequence number to decide.
     return lhs.sequence_task_number < rhs.sequence_task_number;
   }
 };
 
+// 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.
 //
 // Note that this class is RefCountedThreadSafe (inherited from TaskRunner).
 class SequencedWorkerPoolTaskRunner : public TaskRunner {
  public:
   SequencedWorkerPoolTaskRunner(
       scoped_refptr<SequencedWorkerPool> pool,
       SequencedWorkerPool::WorkerShutdown shutdown_behavior);
@@ skipping 30 matching lines @@
     return pool_->PostWorkerTaskWithShutdownBehavior(
         from_here, task, shutdown_behavior_);
   }
   return pool_->PostDelayedWorkerTask(from_here, task, delay);
 }
 
 bool SequencedWorkerPoolTaskRunner::RunsTasksOnCurrentThread() const {
   return pool_->RunsTasksOnCurrentThread();
 }
 
-// SequencedWorkerPoolSequencedTaskRunner ------------------------------------
+}  // namespace
+
+// SequencedWorkerPool::SequencedWorkerPoolSequencedTaskRunner ---------------

[robliao, 2016/09/15 14:14:16]

Make SequencedWorkerPool::SequencedTaskRunner or
SequencedWorkerPool::PoolTaskRunner to reduce duplication and avoid collisions
with the existing SequencedTaskRunner.

[fdoray, 2016/09/15 15:21:59]

Done. (PoolSequencedTaskRunner instead of PoolTaskRunner since there is also a
"SequencedWorkerPoolTaskRunner")

 // 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::SequencedWorkerPoolSequencedTaskRunner
+    : public SequencedTaskRunner {
  public:
   SequencedWorkerPoolSequencedTaskRunner(
       scoped_refptr<SequencedWorkerPool> pool,
       SequencedWorkerPool::SequenceToken token,
       SequencedWorkerPool::WorkerShutdown shutdown_behavior);
 
   // TaskRunner implementation
   bool PostDelayedTask(const tracked_objects::Location& from_here,
                        const Closure& task,
                        TimeDelta delay) override;
   bool RunsTasksOnCurrentThread() const override;
 
   // SequencedTaskRunner implementation
   bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
                                   const Closure& task,
                                   TimeDelta delay) override;
 
  private:
   ~SequencedWorkerPoolSequencedTaskRunner() override;
 
   const scoped_refptr<SequencedWorkerPool> pool_;
 
   const SequencedWorkerPool::SequenceToken token_;
 
   const SequencedWorkerPool::WorkerShutdown shutdown_behavior_;
 
   DISALLOW_COPY_AND_ASSIGN(SequencedWorkerPoolSequencedTaskRunner);
 };
 
-SequencedWorkerPoolSequencedTaskRunner::SequencedWorkerPoolSequencedTaskRunner(
-    scoped_refptr<SequencedWorkerPool> pool,
-    SequencedWorkerPool::SequenceToken token,
-    SequencedWorkerPool::WorkerShutdown shutdown_behavior)
+SequencedWorkerPool::SequencedWorkerPoolSequencedTaskRunner::
+    SequencedWorkerPoolSequencedTaskRunner(
+        scoped_refptr<SequencedWorkerPool> pool,
+        SequencedWorkerPool::SequenceToken token,
+        SequencedWorkerPool::WorkerShutdown shutdown_behavior)
     : pool_(std::move(pool)),
       token_(token),
       shutdown_behavior_(shutdown_behavior) {}
 
-SequencedWorkerPoolSequencedTaskRunner::
-~SequencedWorkerPoolSequencedTaskRunner() {
-}
+SequencedWorkerPool::SequencedWorkerPoolSequencedTaskRunner::
+    ~SequencedWorkerPoolSequencedTaskRunner() = default;
 
-bool SequencedWorkerPoolSequencedTaskRunner::PostDelayedTask(
-    const tracked_objects::Location& from_here,
-    const Closure& task,
-    TimeDelta delay) {
+bool SequencedWorkerPool::SequencedWorkerPoolSequencedTaskRunner::
+    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_);
   }
   return pool_->PostDelayedSequencedWorkerTask(token_, from_here, task, delay);
 }
 
-bool SequencedWorkerPoolSequencedTaskRunner::RunsTasksOnCurrentThread() const {
+bool SequencedWorkerPool::SequencedWorkerPoolSequencedTaskRunner::
+    RunsTasksOnCurrentThread() const {
   return pool_->IsRunningSequenceOnCurrentThread(token_);
 }
 
-bool SequencedWorkerPoolSequencedTaskRunner::PostNonNestableDelayedTask(
-    const tracked_objects::Location& from_here,
-    const Closure& task,
-    TimeDelta delay) {
+bool SequencedWorkerPool::SequencedWorkerPoolSequencedTaskRunner::
+    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 {
  public:
   // Hold a (cyclic) ref to |worker_pool|, since we want to keep it
   // around as long as we are running.
   Worker(scoped_refptr<SequencedWorkerPool> worker_pool,
          int thread_number,
          const std::string& thread_name_prefix);
   ~Worker() override;
@@ skipping 571 matching lines @@
     }
     return runs_tasks_on_verifier_->RunsTasksOnCurrentThread();
   } else {
     return ContainsKey(threads_, PlatformThread::CurrentId());
   }
 }
 
 bool SequencedWorkerPool::Inner::IsRunningSequenceOnCurrentThread(
     SequenceToken sequence_token) const {
   AutoLock lock(lock_);
-  if (subtle::NoBarrier_Load(&g_all_pools_state) ==
-      AllPoolsState::REDIRECTED_TO_TASK_SCHEDULER) {
-    // TODO(gab): This currently only verifies that the current thread is a
-    // thread on which a task bound to |sequence_token| *could* run, but it
-    // doesn't verify that the current is *currently running* a task bound to
-    // |sequence_token|.
-    const auto sequenced_task_runner_it =
-        sequenced_task_runner_map_.find(sequence_token.id_);
-    return sequenced_task_runner_it != sequenced_task_runner_map_.end() &&
-           sequenced_task_runner_it->second->RunsTasksOnCurrentThread();
-  } else {
-    ThreadMap::const_iterator found =
-        threads_.find(PlatformThread::CurrentId());
-    if (found == threads_.end())
-      return false;
-    return found->second->is_processing_task() &&
-           sequence_token.Equals(found->second->task_sequence_token());
-  }
+  DCHECK_NE(subtle::NoBarrier_Load(&g_all_pools_state),

[gab, 2016/09/15 13:50:47]

Actually, under redirection: SWP::GetSequencedTaskRunner() will still return a
SWP TaskRunner, not one from the scheduler. This works because the hook is in
PostTask() anyways, but this method can definitely be called in both modes.

Note: maybe we should be returning TaskScheduler provided TaskRunners but then
not all redirected tasks will go through SWP, haven't thought through whether
that'd be okay.

[fdoray, 2016/09/15 15:21:59]

You're right. This CL no longer changes IsRunningSequenceOnCurrentThread(). I'll
work on the TODO in a separate CL.

+            AllPoolsState::REDIRECTED_TO_TASK_SCHEDULER);
+  ThreadMap::const_iterator found = threads_.find(PlatformThread::CurrentId());
+  if (found == threads_.end())

[gab, 2016/09/15 13:50:47]

Incorporate below, i.e.

return found != threads_.end() && ...

[fdoray, 2016/09/15 15:21:59]

I'll fix this method in a separate CL.

+    return false;
+  return found->second->is_processing_task() &&
+         sequence_token.Equals(found->second->task_sequence_token());
 }
 
 // See https://code.google.com/p/chromium/issues/detail?id=168415
 void SequencedWorkerPool::Inner::CleanupForTesting() {
   DCHECK(!RunsTasksOnCurrentThread());
   base::ThreadRestrictions::ScopedAllowWait allow_wait;
   AutoLock lock(lock_);
   CHECK_EQ(CLEANUP_DONE, cleanup_state_);
   if (shutdown_called_)
     return;
@@ skipping 677 matching lines @@
     const tracked_objects::Location& from_here,
     const Closure& task,
     TimeDelta delay) {
   return PostDelayedWorkerTask(from_here, task, delay);
 }
 
 bool SequencedWorkerPool::RunsTasksOnCurrentThread() const {
   return inner_->RunsTasksOnCurrentThread();
 }
 
-bool SequencedWorkerPool::IsRunningSequenceOnCurrentThread(
-    SequenceToken sequence_token) const {
-  return inner_->IsRunningSequenceOnCurrentThread(sequence_token);
-}
-
 void SequencedWorkerPool::FlushForTesting() {
   inner_->CleanupForTesting();
 }
 
 void SequencedWorkerPool::SignalHasWorkForTesting() {
   inner_->SignalHasWorkForTesting();
 }
 
 void SequencedWorkerPool::Shutdown(int max_new_blocking_tasks_after_shutdown) {
   DCHECK(constructor_task_runner_->BelongsToCurrentThread());
   inner_->Shutdown(max_new_blocking_tasks_after_shutdown);
 }
 
 bool SequencedWorkerPool::IsShutdownInProgress() {
   return inner_->IsShutdownInProgress();
 }
 
+bool SequencedWorkerPool::IsRunningSequenceOnCurrentThread(
+    SequenceToken sequence_token) const {
+  return inner_->IsRunningSequenceOnCurrentThread(sequence_token);
+}
+
 }  // namespace base