Make SequencedWorkerPool a TaskRunner

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 "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/stringprintf.h"
 #include "base/threading/simple_thread.h"
 #include "base/time.h"
 
 namespace base {
 
 // Worker ---------------------------------------------------------------------
 
@@ skipping 120 matching lines @@
 
 bool SequencedWorkerPool::PostSequencedWorkerTaskWithShutdownBehavior(
     SequenceToken sequence_token,
     const tracked_objects::Location& from_here,
     const Closure& task,
     WorkerShutdown shutdown_behavior) {
   return PostTaskHelper(NULL, sequence_token, shutdown_behavior,
                         from_here, task);
 }
 
+bool SequencedWorkerPool::PostDelayedTask(
+    const tracked_objects::Location& from_here,
+    const Closure& task,
+    int64 delay_ms) {
+  // TODO(akalin): Add support for non-zero delays.
+  DCHECK_EQ(delay_ms, 0);
+  return PostWorkerTask(from_here, task);
+}
+
+bool SequencedWorkerPool::RunsTasksOnCurrentThread() const {
+  // TODO(akalin): Add support for this.

[brettw, 2012/02/24 05:25:51]

Can you clarify what this comment is trying to say? Also, I'm not sure the
NOTREACHED is necessary. According to the docs, the current behavior is valid,
and this is the type of thing that I suspect we won't get to soon. It will be
confusing for somebody to call RunsTasksOnCurrentThread and see an assertion
here.

[willchan no longer on Chromium, 2012/02/28 22:29:54]

I think we don't want people to call this function until we support it, since it
won't be doing the correct assertions. I guess there's a tradeoff here between
potentially having some people get confused about hitting a NOTREACHED() (and
then removing their assertion) vs people expecting an assertion to work, and
then having to fix a bunch of assertions later on when we implement this.

I think I prefer the former, since I don't want to place undue burden on the
implementer to fix all call sites later on.

I defer to Brett here.

[akalin, 2012/02/29 00:17:42]

Clarified comment.  I think I agree with willchan here.  I'll check this in now
(since you LGTMed it) and will work on actually implementing that function,
rendering this moot.

+  NOTREACHED();
+  return true;
+}
+
 void SequencedWorkerPool::FlushForTesting() {
   {
     AutoLock lock(lock_);
     while (pending_task_count_ > 0 || waiting_thread_count_ < threads_.size())
       cond_var_.Wait();
   }
   cond_var_.Signal();
 }
 
 void SequencedWorkerPool::Shutdown() {
@@ skipping 337 matching lines @@
 
 bool SequencedWorkerPool::CanShutdown() const {
   lock_.AssertAcquired();
   // See PrepareToStartAdditionalThreadIfHelpful for how thread creation works.
   return !thread_being_created_ &&
          blocking_shutdown_thread_count_ == 0 &&
          blocking_shutdown_pending_task_count_ == 0;
 }
 
 }  // namespace base