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.
+  DLOG_IF(WARNING, delay_ms > 0) << "Ignoring delay of " << delay_ms << " ms";

[willchan no longer on Chromium, 2012/02/23 19:39:57]

I suggest NOTREACHED() instead. If this starts happening, we should know about
it and change the consumer or actually implement it.

[akalin, 2012/02/23 22:52:21]

Done.  Used DCHECK_EQ instead of NOTREACHED().  Added delegate method to skip
testing delays (since it'll hit the NOTREACHED()).

+  return PostWorkerTask(from_here, task);
+}
+
+bool SequencedWorkerPool::RunsTasksOnCurrentThread() const {
+  // TODO(akalin): Add support for this.

[willchan no longer on Chromium, 2012/02/23 19:39:57]

When is this coming? Do not land without it, or use a NOTREACHED() to make sure
no one is calling it.

[akalin, 2012/02/23 22:52:21]

Use NOTREACHED().  I'll see if I can implement this in an upcoming CL.

+  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