Use WTF::TimeDelta to specify delays on WebTaskRunner

third_party/WebKit/Source/platform/WebTaskRunner.h

 // Copyright 2015 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 WebTaskRunner_h
 #define WebTaskRunner_h
 
 #include <memory>
 #include "base/callback.h"
 #include "platform/wtf/Compiler.h"
 #include "platform/wtf/Functional.h"
 #include "platform/wtf/RefCounted.h"
+#include "platform/wtf/Time.h"
 #include "platform/wtf/WeakPtr.h"
 #include "public/platform/WebCommon.h"
 #include "public/platform/WebTraceLocation.h"
 
 namespace base {
 class SingleThreadTaskRunner;
 }
 
 namespace blink {
 
@@ skipping 29 matching lines @@
   friend class WebTaskRunner;
 
   explicit TaskHandle(RefPtr<Runner>);
   RefPtr<Runner> runner_;
 };
 
 // The blink representation of a chromium SingleThreadTaskRunner.
 class BLINK_PLATFORM_EXPORT WebTaskRunner
     : public ThreadSafeRefCounted<WebTaskRunner> {
  public:
-  // Schedule a task to be run after |delayMs| on the the associated WebThread.
-  // Can be called from any thread.
-  virtual void PostDelayedTask(const WebTraceLocation&,
-                               base::OnceClosure,
-                               double delay_ms) = 0;
-
   // Drepecated: favor RunsTasksInCurrentSequence().
   // TODO(http://crbug.com/665062): mass redirect callers and remove this.
   bool RunsTasksOnCurrentThread();
 
   // Returns true if tasks posted to this TaskRunner are sequenced
   // with this call.
   virtual bool RunsTasksInCurrentSequence() = 0;
 
   // ---
 
@@ skipping 16 matching lines @@
 
   // Returns the underlying task runner object.
   virtual SingleThreadTaskRunner* ToSingleThreadTaskRunner() = 0;
 
   // Helpers for posting bound functions as tasks.
 
   // For cross-thread posting. Can be called from any thread.
   void PostTask(const WebTraceLocation&, std::unique_ptr<CrossThreadClosure>);
   void PostDelayedTask(const WebTraceLocation&,
                        std::unique_ptr<CrossThreadClosure>,
-                       long long delay_ms);
+                       TimeDelta delay);
 
   // For same-thread posting. Must be called from the associated WebThread.
   void PostTask(const WebTraceLocation&, std::unique_ptr<WTF::Closure>);
   void PostDelayedTask(const WebTraceLocation&,
                        std::unique_ptr<WTF::Closure>,
-                       long long delay_ms);
+                       TimeDelta delay);
 
   // For same-thread cancellable task posting. Returns a TaskHandle object for
   // cancellation.
   WARN_UNUSED_RESULT TaskHandle
   PostCancellableTask(const WebTraceLocation&, std::unique_ptr<WTF::Closure>);
   WARN_UNUSED_RESULT TaskHandle
   PostDelayedCancellableTask(const WebTraceLocation&,
                              std::unique_ptr<WTF::Closure>,
-                             long long delay_ms);
+                             TimeDelta delay);
 
  protected:
   friend ThreadSafeRefCounted<WebTaskRunner>;
   WebTaskRunner() = default;
   virtual ~WebTaskRunner();
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WebTaskRunner);
 };
 
 }  // namespace blink
 
 #endif  // WebTaskRunner_h