Rename SequencedWorkerPoolTaskRunner to SequencedWorkerPoolSequencedTaskRunner.

Move it into anonymous namespace in sequenced_worker_pool.cc.

BUG=122458
TEST=trybots

Review URL: http://codereview.chromium.org/10005054

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@131733 0039d316-1c4b-4281-b951-d872f2087c98

7 files changed, 164 insertions, 216 deletions

diff --git a/base/base.gyp b/base/base.gyp
index c6058873..d5384f1 100644
--- a/base/base.gyp
+++ b/base/base.gyp
@@ -266,7 +266,6 @@
         'test/trace_event_analyzer_unittest.cc',
         'threading/non_thread_safe_unittest.cc',
         'threading/platform_thread_unittest.cc',
-        'threading/sequenced_worker_pool_task_runner_unittest.cc',
         'threading/sequenced_worker_pool_unittest.cc',
         'threading/simple_thread_unittest.cc',
         'threading/thread_checker_unittest.cc',
diff --git a/base/base.gypi b/base/base.gypi
index 48812a0..6ca8a2e 100644
--- a/base/base.gypi
+++ b/base/base.gypi
@@ -348,8 +348,6 @@
           'threading/post_task_and_reply_impl.h',
           'threading/sequenced_worker_pool.cc',
           'threading/sequenced_worker_pool.h',
-          'threading/sequenced_worker_pool_task_runner.cc',
-          'threading/sequenced_worker_pool_task_runner.h',
           'threading/simple_thread.cc',
           'threading/simple_thread.h',
           'threading/thread.cc',
diff --git a/base/threading/sequenced_worker_pool.cc b/base/threading/sequenced_worker_pool.cc
index 61cd1ac..ba4c43d 100644
--- a/base/threading/sequenced_worker_pool.cc
+++ b/base/threading/sequenced_worker_pool.cc
@@ -22,7 +22,6 @@
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/platform_thread.h"
-#include "base/threading/sequenced_worker_pool_task_runner.h"
 #include "base/threading/simple_thread.h"
 #include "base/time.h"
 #include "base/tracked_objects.h"
@@ -48,6 +47,121 @@ struct SequencedTask {
   Closure task;
 };
 
+// SequencedWorkerPoolSequencedTaskRunner ------------------------------------
+// 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 {
+ public:
+  SequencedWorkerPoolSequencedTaskRunner(
+      const scoped_refptr<SequencedWorkerPool>& pool,
+      SequencedWorkerPool::SequenceToken token);
+
+  // TaskRunner implementation
+  virtual bool PostDelayedTask(const tracked_objects::Location& from_here,
+                               const Closure& task,
+                               int64 delay_ms) OVERRIDE;
+  virtual bool PostDelayedTask(const tracked_objects::Location& from_here,
+                               const Closure& task,
+                               TimeDelta delay) OVERRIDE;
+  virtual bool RunsTasksOnCurrentThread() const OVERRIDE;
+
+  // SequencedTaskRunner implementation
+  virtual bool PostNonNestableDelayedTask(
+      const tracked_objects::Location& from_here,
+      const Closure& task,
+      int64 delay_ms) OVERRIDE;
+  virtual bool PostNonNestableDelayedTask(
+      const tracked_objects::Location& from_here,
+      const Closure& task,
+      TimeDelta delay) OVERRIDE;
+
+ private:
+  virtual ~SequencedWorkerPoolSequencedTaskRunner();
+
+  // Helper function for posting a delayed task. Asserts that the delay is
+  // zero because non-zero delays are not yet supported.
+  bool PostDelayedTaskAssertZeroDelay(
+      const tracked_objects::Location& from_here,
+      const Closure& task,
+      int64 delay_ms);
+  bool PostDelayedTaskAssertZeroDelay(
+      const tracked_objects::Location& from_here,
+      const Closure& task,
+      TimeDelta delay);
+
+  const scoped_refptr<SequencedWorkerPool> pool_;
+
+  const SequencedWorkerPool::SequenceToken token_;
+
+  DISALLOW_COPY_AND_ASSIGN(SequencedWorkerPoolSequencedTaskRunner);
+};
+
+SequencedWorkerPoolSequencedTaskRunner::SequencedWorkerPoolSequencedTaskRunner(
+    const scoped_refptr<SequencedWorkerPool>& pool,
+    SequencedWorkerPool::SequenceToken token)
+    : pool_(pool),
+      token_(token) {
+}
+
+SequencedWorkerPoolSequencedTaskRunner::
+~SequencedWorkerPoolSequencedTaskRunner() {
+}
+
+bool SequencedWorkerPoolSequencedTaskRunner::PostDelayedTask(
+    const tracked_objects::Location& from_here,
+    const Closure& task,
+    int64 delay_ms) {
+  return PostDelayedTaskAssertZeroDelay(from_here, task, delay_ms);
+}
+
+bool SequencedWorkerPoolSequencedTaskRunner::PostDelayedTask(
+    const tracked_objects::Location& from_here,
+    const Closure& task,
+    TimeDelta delay) {
+  return PostDelayedTaskAssertZeroDelay(from_here, task, delay);
+}
+
+bool SequencedWorkerPoolSequencedTaskRunner::RunsTasksOnCurrentThread() const {
+  return pool_->IsRunningSequenceOnCurrentThread(token_);
+}
+
+bool SequencedWorkerPoolSequencedTaskRunner::PostNonNestableDelayedTask(
+    const tracked_objects::Location& from_here,
+    const Closure& task,
+    int64 delay_ms) {
+  return PostDelayedTaskAssertZeroDelay(from_here, task, delay_ms);
+}
+
+bool SequencedWorkerPoolSequencedTaskRunner::PostNonNestableDelayedTask(
+    const tracked_objects::Location& from_here,
+    const Closure& task,
+    TimeDelta delay) {
+  return PostDelayedTaskAssertZeroDelay(from_here, task, delay);
+}
+
+bool SequencedWorkerPoolSequencedTaskRunner::PostDelayedTaskAssertZeroDelay(
+    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)
+      << "SequencedWorkerPoolSequencedTaskRunner does not yet support non-zero"
+         " delays";
+  return pool_->PostSequencedWorkerTask(token_, from_here, task);
+}
+
+bool SequencedWorkerPoolSequencedTaskRunner::PostDelayedTaskAssertZeroDelay(
+    const tracked_objects::Location& from_here,
+    const Closure& task,
+    TimeDelta delay) {
+  return PostDelayedTaskAssertZeroDelay(from_here,
+                                        task,
+                                        delay.InMillisecondsRoundedUp());
+}
+
 }  // namespace
 
 // Worker ---------------------------------------------------------------------
@@ -761,7 +875,7 @@ SequencedWorkerPool::SequenceToken SequencedWorkerPool::GetNamedSequenceToken(
 
 scoped_refptr<SequencedTaskRunner> SequencedWorkerPool::GetSequencedTaskRunner(
     SequenceToken token) {
-  return new SequencedWorkerPoolTaskRunner(this, token);
+  return new SequencedWorkerPoolSequencedTaskRunner(this, token);
 }
 
 bool SequencedWorkerPool::PostWorkerTask(
diff --git a/base/threading/sequenced_worker_pool_task_runner.cc b/base/threading/sequenced_worker_pool_task_runner.cc
deleted file mode 100644
index 3ba7670..0000000
--- a/base/threading/sequenced_worker_pool_task_runner.cc
+++ /dev/null
@@ -1,75 +0,0 @@
-// 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/callback.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 PostDelayedTaskAssertZeroDelay(from_here, task, delay_ms);
-}
-
-bool SequencedWorkerPoolTaskRunner::PostDelayedTask(
-    const tracked_objects::Location& from_here,
-    const Closure& task,
-    TimeDelta delay) {
-  return PostDelayedTaskAssertZeroDelay(from_here, task, delay);
-}
-
-bool SequencedWorkerPoolTaskRunner::RunsTasksOnCurrentThread() const {
-  return pool_->IsRunningSequenceOnCurrentThread(token_);
-}
-
-bool SequencedWorkerPoolTaskRunner::PostNonNestableDelayedTask(
-    const tracked_objects::Location& from_here,
-    const Closure& task,
-    int64 delay_ms) {
-  return PostDelayedTaskAssertZeroDelay(from_here, task, delay_ms);
-}
-
-bool SequencedWorkerPoolTaskRunner::PostNonNestableDelayedTask(
-    const tracked_objects::Location& from_here,
-    const Closure& task,
-    TimeDelta delay) {
-  return PostDelayedTaskAssertZeroDelay(from_here, task, delay);
-}
-
-bool SequencedWorkerPoolTaskRunner::PostDelayedTaskAssertZeroDelay(
-    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::PostDelayedTaskAssertZeroDelay(
-    const tracked_objects::Location& from_here,
-    const Closure& task,
-    TimeDelta delay) {
-  return PostDelayedTaskAssertZeroDelay(from_here,
-                                        task,
-                                        delay.InMillisecondsRoundedUp());
-}
-
-}  // namespace base
diff --git a/base/threading/sequenced_worker_pool_task_runner.h b/base/threading/sequenced_worker_pool_task_runner.h
deleted file mode 100644
index 34d65b9..0000000
--- a/base/threading/sequenced_worker_pool_task_runner.h
+++ /dev/null
@@ -1,74 +0,0 @@
-// 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.
-
-#ifndef BASE_THREADING_SEQUENCED_WORKER_POOL_TASK_RUNNER_H_
-#define BASE_THREADING_SEQUENCED_WORKER_POOL_TASK_RUNNER_H_
-#pragma once
-
-#include "base/basictypes.h"
-#include "base/callback_forward.h"
-#include "base/compiler_specific.h"
-#include "base/memory/ref_counted.h"
-#include "base/sequenced_task_runner.h"
-#include "base/threading/sequenced_worker_pool.h"
-#include "base/time.h"
-
-namespace tracked_objects {
-class Location;
-}  // namespace tracked_objects
-
-namespace base {
-
-// A SequencedTaskRunner which posts tasks to a SequencedWorkerPool with a
-// fixed sequence token.
-//
-// Note that this class is RefCountedThreadSafe (inherited from TaskRunner).
-class BASE_EXPORT SequencedWorkerPoolTaskRunner : public SequencedTaskRunner {
- public:
-  SequencedWorkerPoolTaskRunner(const scoped_refptr<SequencedWorkerPool>& pool,
-                                SequencedWorkerPool::SequenceToken token);
-
-  // TaskRunner implementation
-  virtual bool PostDelayedTask(const tracked_objects::Location& from_here,
-                               const Closure& task,
-                               int64 delay_ms) OVERRIDE;
-  virtual bool PostDelayedTask(const tracked_objects::Location& from_here,
-                               const Closure& task,
-                               TimeDelta delay) OVERRIDE;
-  virtual bool RunsTasksOnCurrentThread() const OVERRIDE;
-
-  // SequencedTaskRunner implementation
-  virtual bool PostNonNestableDelayedTask(
-      const tracked_objects::Location& from_here,
-      const Closure& task,
-      int64 delay_ms) OVERRIDE;
-  virtual bool PostNonNestableDelayedTask(
-      const tracked_objects::Location& from_here,
-      const Closure& task,
-      TimeDelta delay) OVERRIDE;
-
- private:
-  virtual ~SequencedWorkerPoolTaskRunner();
-
-  // Helper function for posting a delayed task. Asserts that the delay is
-  // zero because non-zero delays are not yet supported.
-  bool PostDelayedTaskAssertZeroDelay(
-      const tracked_objects::Location& from_here,
-      const Closure& task,
-      int64 delay_ms);
-  bool PostDelayedTaskAssertZeroDelay(
-      const tracked_objects::Location& from_here,
-      const Closure& task,
-      TimeDelta delay);
-
-  const scoped_refptr<SequencedWorkerPool> pool_;
-
-  const SequencedWorkerPool::SequenceToken token_;
-
-  DISALLOW_COPY_AND_ASSIGN(SequencedWorkerPoolTaskRunner);
-};
-
-}  // namespace base
-
-#endif  // BASE_THREADING_SEQUENCED_TASK_RUNNER_IMPL_H_
diff --git a/base/threading/sequenced_worker_pool_task_runner_unittest.cc b/base/threading/sequenced_worker_pool_task_runner_unittest.cc
deleted file mode 100644
index effb905..0000000
--- a/base/threading/sequenced_worker_pool_task_runner_unittest.cc
+++ /dev/null
@@ -1,61 +0,0 @@
-// 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/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/message_loop.h"
-#include "base/test/sequenced_task_runner_test_template.h"
-#include "base/test/sequenced_worker_pool_owner.h"
-#include "base/test/task_runner_test_template.h"
-#include "base/threading/sequenced_worker_pool_task_runner.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-class SequencedWorkerPoolTaskRunnerTestDelegate {
- public:
-  SequencedWorkerPoolTaskRunnerTestDelegate() {}
-
-  ~SequencedWorkerPoolTaskRunnerTestDelegate() {
-  }
-
-  void StartTaskRunner() {
-    pool_owner_.reset(
-        new SequencedWorkerPoolOwner(10, "SequencedWorkerPoolTaskRunnerTest"));
-    task_runner_ = pool_owner_->pool()->GetSequencedTaskRunner(
-        pool_owner_->pool()->GetSequenceToken());
-  }
-
-  scoped_refptr<SequencedTaskRunner> GetTaskRunner() {
-    return task_runner_;
-  }
-
-  void StopTaskRunner() {
-    pool_owner_->pool()->FlushForTesting();
-    pool_owner_->pool()->Shutdown();
-    // Don't reset |pool_owner_| here, as the test may still hold a
-    // reference to the pool.
-  }
-
-  bool TaskRunnerHandlesNonZeroDelays() const {
-    // TODO(akalin): Set this to true once SequencedWorkerPool handles
-    // non-zero delays.
-    return false;
-  }
-
- private:
-  MessageLoop message_loop_;
-  scoped_ptr<SequencedWorkerPoolOwner> pool_owner_;
-  scoped_refptr<SequencedTaskRunner> task_runner_;
-};
-
-INSTANTIATE_TYPED_TEST_CASE_P(
-    SequencedWorkerPoolTaskRunner, TaskRunnerTest,
-    SequencedWorkerPoolTaskRunnerTestDelegate);
-
-INSTANTIATE_TYPED_TEST_CASE_P(
-    SequencedWorkerPoolTaskRunner, SequencedTaskRunnerTest,
-    SequencedWorkerPoolTaskRunnerTestDelegate);
-
-}  // namespace base
diff --git a/base/threading/sequenced_worker_pool_unittest.cc b/base/threading/sequenced_worker_pool_unittest.cc
index 2becd09..dcb9bff 100644
--- a/base/threading/sequenced_worker_pool_unittest.cc
+++ b/base/threading/sequenced_worker_pool_unittest.cc
@@ -2,6 +2,8 @@
 // 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 <algorithm>
 
 #include "base/bind.h"
@@ -13,9 +15,9 @@
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/test/sequenced_worker_pool_owner.h"
+#include "base/test/sequenced_task_runner_test_template.h"
 #include "base/test/task_runner_test_template.h"
 #include "base/threading/platform_thread.h"
-#include "base/threading/sequenced_worker_pool.h"
 #include "base/tracked_objects.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -533,6 +535,51 @@ INSTANTIATE_TYPED_TEST_CASE_P(
     SequencedWorkerPool, TaskRunnerTest,
     SequencedWorkerPoolTaskRunnerTestDelegate);
 
+class SequencedWorkerPoolSequencedTaskRunnerTestDelegate {
+ public:
+  SequencedWorkerPoolSequencedTaskRunnerTestDelegate() {}
+
+  ~SequencedWorkerPoolSequencedTaskRunnerTestDelegate() {
+  }
+
+  void StartTaskRunner() {
+    pool_owner_.reset(new SequencedWorkerPoolOwner(
+        10, "SequencedWorkerPoolSequencedTaskRunnerTest"));
+    task_runner_ = pool_owner_->pool()->GetSequencedTaskRunner(
+        pool_owner_->pool()->GetSequenceToken());
+  }
+
+  scoped_refptr<SequencedTaskRunner> GetTaskRunner() {
+    return task_runner_;
+  }
+
+  void StopTaskRunner() {
+    pool_owner_->pool()->FlushForTesting();
+    pool_owner_->pool()->Shutdown();
+    // Don't reset |pool_owner_| here, as the test may still hold a
+    // reference to the pool.
+  }
+
+  bool TaskRunnerHandlesNonZeroDelays() const {
+    // TODO(akalin): Set this to true once SequencedWorkerPool handles
+    // non-zero delays.
+    return false;
+  }
+
+ private:
+  MessageLoop message_loop_;
+  scoped_ptr<SequencedWorkerPoolOwner> pool_owner_;
+  scoped_refptr<SequencedTaskRunner> task_runner_;
+};
+
+INSTANTIATE_TYPED_TEST_CASE_P(
+    SequencedWorkerPoolSequencedTaskRunner, TaskRunnerTest,
+    SequencedWorkerPoolSequencedTaskRunnerTestDelegate);
+
+INSTANTIATE_TYPED_TEST_CASE_P(
+    SequencedWorkerPoolSequencedTaskRunner, SequencedTaskRunnerTest,
+    SequencedWorkerPoolSequencedTaskRunnerTestDelegate);
+
 }  // namespace
 
 }  // namespace base