Remove outdated TODO in SequencedWorkerPool::Inner::IsRunningSequenceOnCurrentThread().

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 861 matching lines @@
           ExecutionMode::PARALLEL);
     }
     return runs_tasks_on_verifier_->RunsTasksOnCurrentThread();
   } else {
     return ContainsKey(threads_, PlatformThread::CurrentId());
   }
 }
 
 bool SequencedWorkerPool::Inner::IsRunningSequenceOnCurrentThread(
     SequenceToken sequence_token) const {
+  DCHECK(sequence_token.IsValid());

[fdoray, 2016/09/15 15:57:13]

This is always called from PoolSequencedTaskRunner::RunsTasksOnCurrentThread
with a valid sequence token (hmm... unless the PoolSequencedTaskRunner was
created with an invalid SequenceToken, which doesn't seem like a valid thing to
do...)

+
   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

[danakj, 2016/09/15 18:31:09]

Isn't SequencedWorkerPool::Inner::RunsTasksOnCurrentThread still just making a
task runner and checking if it uses the current thread? I'm kinda confused

[fdoray, 2016/09/15 18:39:23]

|sequenced_task_runner_map_| contains TaskScheduler TaskRunners. Line 892 calls
SchedulerSequencedTaskRunner::RunsTasksOnCurrentThread which does exactly what
we want (i.e. tell us if the current task is part of the the sequence associated
with |sequence_token|) since https://codereview.chromium.org/2340793002/

[danakj, 2016/09/15 18:41:26]

Thanks for the context! LGTM

-    // 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() &&
+    return found != threads_.end() && 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_);
@@ skipping 702 matching lines @@
 bool SequencedWorkerPool::IsShutdownInProgress() {
   return inner_->IsShutdownInProgress();
 }
 
 bool SequencedWorkerPool::IsRunningSequenceOnCurrentThread(
     SequenceToken sequence_token) const {
   return inner_->IsRunningSequenceOnCurrentThread(sequence_token);
 }
 
 }  // namespace base