Implementation of SequencedTaskRunner based on SequencedWorkerPool.

base/threading/sequenced_worker_pool_task_runner.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_task_runner.h"
+
+#include "base/location.h"
+#include "base/logging.h"
+
+namespace base {
+
+SequencedWorkerPoolTaskRunner::SequencedWorkerPoolTaskRunner(
+    const scoped_refptr<SequencedWorkerPool>& pool,
+    SequencedWorkerPool::SequenceToken token)
+    : pool_(pool),
+      token_(token) {
+}
+
+SequencedWorkerPoolTaskRunner::~SequencedWorkerPoolTaskRunner() {
+}
+
+bool SequencedWorkerPoolTaskRunner::PostDelayedTask(
+    const tracked_objects::Location& from_here,
+    const Closure& task,
+    int64 delay_ms) {
+  return pool_->PostSequencedWorkerTask(token_, from_here, task);

[akalin, 2012/03/26 18:44:08]

you want a DCHECK_EQ(delay_ms, 0) here, too, like below

[Francois, 2012/03/28 14:32:42]

Done.

+}
+
+bool SequencedWorkerPoolTaskRunner::PostDelayedTask(
+    const tracked_objects::Location& from_here,
+    const Closure& task,
+    TimeDelta delay) {
+  return pool_->PostSequencedWorkerTask(token_, from_here, task);

[akalin, 2012/03/26 18:44:08]

here, too.  In fact, you may just want to have a single helper function (with a
boolean for nestable vs. non-nestable) and route all calls through that.

[Francois, 2012/03/28 14:32:42]

Done.

+}
+
+bool SequencedWorkerPoolTaskRunner::RunsTasksOnCurrentThread() const {
+  return pool_->RunsTasksOnCurrentThread();

[michaeln, 2012/03/26 19:57:32]

oh... i hadn't seen this CL until just now... this method impl could be more
meaningful if it tested for whether the pool was  running under the token_

[michaeln, 2012/03/26 21:50:12]

To be more clear, here's an implementation of the method i'm suggesting would be
useful here.
https://chromiumcodereview.appspot.com/9845037/

[akalin, 2012/03/26 21:54:00]

That's a different test, though.  The "RunsTasksOnCurrentThread" method is
supposed to be for whether the current thread is one that the TaskRunner runs
tasks on, not if it's one where the TaskRunner is running a task at this
instant.

I don't know if we really need this more stringent test (the one in your other
CL) -- if you post tasks only via a SequencedWorkerPoolTaskRunner, then it's
correct by construction already (from the point of view of the caller).

+}
+
+bool SequencedWorkerPoolTaskRunner::PostNonNestableDelayedTask(
+    const tracked_objects::Location& from_here,
+    const Closure& task,
+    int64 delay_ms) {
+  // TODO(francoisk777@gmail.com): Change the following two statements once
+  // SequencedWorkerPool supports non-zero delays.
+  DCHECK_EQ(delay_ms, 0)
+      << "SequencedWorkerPoolTaskRunner does not yet support non-zero delays";
+  return pool_->PostSequencedWorkerTask(token_, from_here, task);
+}
+
+bool SequencedWorkerPoolTaskRunner::PostNonNestableDelayedTask(
+    const tracked_objects::Location& from_here,
+    const Closure& task,
+    TimeDelta delay) {
+  // TODO(francoisk777@gmail.com): Change the following two statements once
+  // SequencedWorkerPool supports non-zero delays.
+  DCHECK_EQ(delay.InMillisecondsRoundedUp(), 0)
+      << "SequencedWorkerPoolTaskRunner does not yet support non-zero delays";
+  return pool_->PostSequencedWorkerTask(token_, from_here, task);
+}
+
+}  // namespace base