Remove old Sleep and PostDelayedTask interfaces that use int ms instead of TimeDelta.

The previous version of this patch was reverted due to crashing cros_x86 and cros_tegra2 builds.  See: http://codereview.chromium.org/9703053/

BUG=108171

Review URL: https://chromiumcodereview.appspot.com/10572030

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

8 files changed, 123 insertions, 102 deletions

diff --git a/base/threading/platform_thread.h b/base/threading/platform_thread.h
index 3843ce5..fc64f78 100644
--- a/base/threading/platform_thread.h
+++ b/base/threading/platform_thread.h
@@ -64,9 +64,6 @@ class BASE_EXPORT PlatformThread {
   // Yield the current thread so another thread can be scheduled.
   static void YieldCurrentThread();
 
-  // Sleeps for the specified duration (units are milliseconds).
-  static void Sleep(int duration_ms);
-
   // Sleeps for the specified duration.
   static void Sleep(base::TimeDelta duration);
 
diff --git a/base/threading/platform_thread_posix.cc b/base/threading/platform_thread_posix.cc
index 77039a0..59162b9 100644
--- a/base/threading/platform_thread_posix.cc
+++ b/base/threading/platform_thread_posix.cc
@@ -176,13 +176,6 @@ void PlatformThread::YieldCurrentThread() {
 }
 
 // static
-void PlatformThread::Sleep(int duration_ms) {
-  // NOTE: This function will be supplanted by the other version of Sleep
-  // in the future.  See issue 108171 for more information.
-  Sleep(TimeDelta::FromMilliseconds(duration_ms));
-}
-
-// static
 void PlatformThread::Sleep(TimeDelta duration) {
   struct timespec sleep_time, remaining;
 
diff --git a/base/threading/platform_thread_win.cc b/base/threading/platform_thread_win.cc
index 4dc839b..82981ad 100644
--- a/base/threading/platform_thread_win.cc
+++ b/base/threading/platform_thread_win.cc
@@ -110,11 +110,6 @@ void PlatformThread::YieldCurrentThread() {
 }
 
 // static
-void PlatformThread::Sleep(int duration_ms) {
-  ::Sleep(duration_ms);
-}
-
-// static
 void PlatformThread::Sleep(TimeDelta duration) {
   ::Sleep(duration.InMillisecondsRoundedUp());
 }
diff --git a/base/threading/sequenced_worker_pool.cc b/base/threading/sequenced_worker_pool.cc
index 59c4187..3bc26b4 100644
--- a/base/threading/sequenced_worker_pool.cc
+++ b/base/threading/sequenced_worker_pool.cc
@@ -62,9 +62,6 @@ class SequencedWorkerPoolTaskRunner : public TaskRunner {
   // 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;
 
@@ -76,10 +73,6 @@ class SequencedWorkerPoolTaskRunner : public TaskRunner {
   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_;
@@ -102,13 +95,6 @@ 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);
 }
@@ -120,24 +106,15 @@ bool SequencedWorkerPoolTaskRunner::RunsTasksOnCurrentThread() const {
 bool SequencedWorkerPoolTaskRunner::PostDelayedTaskAssertZeroDelay(
     const tracked_objects::Location& from_here,
     const Closure& task,
-    int64 delay_ms) {
+    TimeDelta delay) {
   // TODO(francoisk777@gmail.com): Change the following two statements once
   // SequencedWorkerPool supports non-zero delays.
-  DCHECK_EQ(delay_ms, 0)
+  DCHECK_EQ(delay.InMillisecondsRoundedUp(), 0)
       << "SequencedWorkerPoolTaskRunner does not yet support non-zero delays";
   return pool_->PostWorkerTaskWithShutdownBehavior(
       from_here, task, shutdown_behavior_);
 }
 
-bool SequencedWorkerPoolTaskRunner::PostDelayedTaskAssertZeroDelay(
-    const tracked_objects::Location& from_here,
-    const Closure& task,
-    TimeDelta delay) {
-  return PostDelayedTaskAssertZeroDelay(from_here,
-                                        task,
-                                        delay.InMillisecondsRoundedUp());
-}
-
 // SequencedWorkerPoolSequencedTaskRunner ------------------------------------
 // A SequencedTaskRunner which posts tasks to a SequencedWorkerPool with a
 // fixed sequence token.
@@ -153,9 +130,6 @@ class SequencedWorkerPoolSequencedTaskRunner : public SequencedTaskRunner {
   // 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;
 
@@ -163,10 +137,6 @@ class SequencedWorkerPoolSequencedTaskRunner : public SequencedTaskRunner {
   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:
@@ -177,10 +147,6 @@ class SequencedWorkerPoolSequencedTaskRunner : public SequencedTaskRunner {
   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_;
@@ -208,13 +174,6 @@ 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);
 }
@@ -226,13 +185,6 @@ bool SequencedWorkerPoolSequencedTaskRunner::RunsTasksOnCurrentThread() const {
 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);
 }
@@ -240,25 +192,16 @@ bool SequencedWorkerPoolSequencedTaskRunner::PostNonNestableDelayedTask(
 bool SequencedWorkerPoolSequencedTaskRunner::PostDelayedTaskAssertZeroDelay(
     const tracked_objects::Location& from_here,
     const Closure& task,
-    int64 delay_ms) {
+    TimeDelta delay) {
   // TODO(francoisk777@gmail.com): Change the following two statements once
   // SequencedWorkerPool supports non-zero delays.
-  DCHECK_EQ(delay_ms, 0)
+  DCHECK_EQ(delay.InMillisecondsRoundedUp(), 0)
       << "SequencedWorkerPoolSequencedTaskRunner does not yet support non-zero"
          " delays";
   return pool_->PostSequencedWorkerTaskWithShutdownBehavior(
       token_, from_here, task, shutdown_behavior_);
 }
 
-bool SequencedWorkerPoolSequencedTaskRunner::PostDelayedTaskAssertZeroDelay(
-    const tracked_objects::Location& from_here,
-    const Closure& task,
-    TimeDelta delay) {
-  return PostDelayedTaskAssertZeroDelay(from_here,
-                                        task,
-                                        delay.InMillisecondsRoundedUp());
-}
-
 }  // namespace
 
 // Worker ---------------------------------------------------------------------
@@ -1033,15 +976,6 @@ bool SequencedWorkerPool::PostSequencedWorkerTaskWithShutdownBehavior(
 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::PostDelayedTask(
-    const tracked_objects::Location& from_here,
-    const Closure& task,
     TimeDelta delay) {
   // TODO(akalin): Add support for non-zero delays.
   DCHECK_EQ(delay.InMillisecondsRoundedUp(), 0);
diff --git a/base/threading/sequenced_worker_pool.h b/base/threading/sequenced_worker_pool.h
index 740c26d..73c670f 100644
--- a/base/threading/sequenced_worker_pool.h
+++ b/base/threading/sequenced_worker_pool.h
@@ -231,9 +231,6 @@ class BASE_EXPORT SequencedWorkerPool : public TaskRunner {
   // TaskRunner implementation.  Forwards to PostWorkerTask().
   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;
 
diff --git a/base/threading/sequenced_worker_pool_task_runner.cc b/base/threading/sequenced_worker_pool_task_runner.cc
new file mode 100644
index 0000000..b7579a7
--- /dev/null
+++ b/base/threading/sequenced_worker_pool_task_runner.cc
@@ -0,0 +1,52 @@
+// 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,
+    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,
+    TimeDelta delay) {
+  return PostDelayedTaskAssertZeroDelay(from_here, task, delay);
+}
+
+bool SequencedWorkerPoolTaskRunner::PostDelayedTaskAssertZeroDelay(
+    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
diff --git a/base/threading/sequenced_worker_pool_task_runner.h b/base/threading/sequenced_worker_pool_task_runner.h
new file mode 100644
index 0000000..068fb3e
--- /dev/null
+++ b/base/threading/sequenced_worker_pool_task_runner.h
@@ -0,0 +1,63 @@
+// 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,
+                               TimeDelta delay) OVERRIDE;
+  virtual bool RunsTasksOnCurrentThread() const OVERRIDE;
+
+  // SequencedTaskRunner implementation
+  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,
+      TimeDelta delay);
+
+  const scoped_refptr<SequencedWorkerPool> pool_;
+
+  const SequencedWorkerPool::SequenceToken token_;
+
+  DISALLOW_COPY_AND_ASSIGN(SequencedWorkerPoolTaskRunner);
+};
+
+}  // namespace base
+
+#endif  // BASE_THREADING_SEQUENCED_WORKER_POOL_TASK_RUNNER_H_
diff --git a/base/threading/worker_pool.cc b/base/threading/worker_pool.cc
index 978584c..16cc061 100644
--- a/base/threading/worker_pool.cc
+++ b/base/threading/worker_pool.cc
@@ -41,9 +41,6 @@ class WorkerPoolTaskRunner : public TaskRunner {
   // 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;
 
@@ -55,7 +52,7 @@ class WorkerPoolTaskRunner : public TaskRunner {
   bool PostDelayedTaskAssertZeroDelay(
       const tracked_objects::Location& from_here,
       const Closure& task,
-      int64 delay_ms);
+      base::TimeDelta delay);
 
   const bool tasks_are_slow_;
 
@@ -72,15 +69,8 @@ WorkerPoolTaskRunner::~WorkerPoolTaskRunner() {
 bool WorkerPoolTaskRunner::PostDelayedTask(
     const tracked_objects::Location& from_here,
     const Closure& task,
-    int64 delay_ms) {
-  return PostDelayedTaskAssertZeroDelay(from_here, task, delay_ms);
-}
-
-bool WorkerPoolTaskRunner::PostDelayedTask(
-    const tracked_objects::Location& from_here,
-    const Closure& task,
     TimeDelta delay) {
-  return PostDelayedTask(from_here, task, delay.InMillisecondsRoundedUp());
+  return PostDelayedTaskAssertZeroDelay(from_here, task, delay);
 }
 
 bool WorkerPoolTaskRunner::RunsTasksOnCurrentThread() const {
@@ -90,8 +80,8 @@ bool WorkerPoolTaskRunner::RunsTasksOnCurrentThread() const {
 bool WorkerPoolTaskRunner::PostDelayedTaskAssertZeroDelay(
     const tracked_objects::Location& from_here,
     const Closure& task,
-    int64 delay_ms) {
-  DCHECK_EQ(delay_ms, 0)
+    base::TimeDelta delay) {
+  DCHECK_EQ(delay.InMillisecondsRoundedUp(), 0)
       << "WorkerPoolTaskRunner does not support non-zero delays";
   return WorkerPool::PostTask(from_here, task, tasks_are_slow_);
 }