Replace WTF::Function with base::OnceCallback in platform/.

Now WTF::Function is an alias of base::OnceCallback, we can safely
replace all the occurrences of WTF::Function with base::OnceCallback.

Bug: 771087
Change-Id: Ifa51238ab929012e5a39ed7e0c29fc1fdc341f96
Reviewed-on: https://chromium-review.googlesource.com/816635
Commit-Queue: Yuta Kitamura <yutak@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Reviewed-by: Taiju Tsuiki <tzik@chromium.org>
Cr-Commit-Position: refs/heads/master@{#522745}

third_party/WebKit/Source/platform/ContentSettingCallbacks.cpp

@@ -36,14 +36,14 @@
 namespace blink {
 
 std::unique_ptr<ContentSettingCallbacks> ContentSettingCallbacks::Create(
-    WTF::Closure allowed,
-    WTF::Closure denied) {
+    base::OnceClosure allowed,
+    base::OnceClosure denied) {
   return WTF::WrapUnique(
       new ContentSettingCallbacks(std::move(allowed), std::move(denied)));
 }
 
-ContentSettingCallbacks::ContentSettingCallbacks(WTF::Closure allowed,
-                                                 WTF::Closure denied)
+ContentSettingCallbacks::ContentSettingCallbacks(base::OnceClosure allowed,
+                                                 base::OnceClosure denied)
     : allowed_(std::move(allowed)), denied_(std::move(denied)) {}
 
 }  // namespace blink

third_party/WebKit/Source/platform/ContentSettingCallbacks.h

@@ -18,18 +18,19 @@ class PLATFORM_EXPORT ContentSettingCallbacks {
   WTF_MAKE_NONCOPYABLE(ContentSettingCallbacks);
 
  public:
-  static std::unique_ptr<ContentSettingCallbacks> Create(WTF::Closure allowed,
-                                                         WTF::Closure denied);
+  static std::unique_ptr<ContentSettingCallbacks> Create(
+      base::OnceClosure allowed,
+      base::OnceClosure denied);
   virtual ~ContentSettingCallbacks() {}
 
   void OnAllowed() { std::move(allowed_).Run(); }
   void OnDenied() { std::move(denied_).Run(); }
 
  private:
-  ContentSettingCallbacks(WTF::Closure allowed, WTF::Closure denied);
+  ContentSettingCallbacks(base::OnceClosure allowed, base::OnceClosure denied);
 
-  WTF::Closure allowed_;
-  WTF::Closure denied_;
+  base::OnceClosure allowed_;
+  base::OnceClosure denied_;
 };
 
 }  // namespace blink

third_party/WebKit/Source/platform/WebTaskRunner.cpp

@@ -39,7 +39,7 @@ void RunCrossThreadClosure(CrossThreadClosure task) {
 
 class TaskHandle::Runner : public WTF::ThreadSafeRefCounted<Runner> {
  public:
-  explicit Runner(WTF::Closure task)
+  explicit Runner(base::OnceClosure task)
       : task_(std::move(task)), weak_ptr_factory_(this) {}
 
   base::WeakPtr<Runner> AsWeakPtr() { return weak_ptr_factory_.GetWeakPtr(); }
@@ -47,7 +47,7 @@ class TaskHandle::Runner : public WTF::ThreadSafeRefCounted<Runner> {
   bool IsActive() const { return task_ && !task_.IsCancelled(); }
 
   void Cancel() {
-    WTF::Closure task = std::move(task_);
+    base::OnceClosure task = std::move(task_);
     weak_ptr_factory_.InvalidateWeakPtrs();
   }
 
@@ -68,15 +68,15 @@ class TaskHandle::Runner : public WTF::ThreadSafeRefCounted<Runner> {
   // There is a circular reference in the example above as:
   //   foo -> m_handle -> m_runner -> m_task -> Persistent<Foo> in WTF::bind.
   // The TaskHandle parameter on run() is needed to break the circle by clearing
-  // |m_task| when the wrapped WTF::Closure is deleted.
+  // |m_task| when the wrapped base::OnceClosure is deleted.
   void Run(const TaskHandle&) {
-    WTF::Closure task = std::move(task_);
+    base::OnceClosure task = std::move(task_);
     weak_ptr_factory_.InvalidateWeakPtrs();
     std::move(task).Run();
   }
 
  private:
-  WTF::Closure task_;
+  base::OnceClosure task_;
   base::WeakPtrFactory<Runner> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Runner);
@@ -131,12 +131,12 @@ void WebTaskRunner::PostDelayedTask(const WebTraceLocation& location,
 }
 
 void WebTaskRunner::PostTask(const WebTraceLocation& location,
-                             WTF::Closure task) {
+                             base::OnceClosure task) {
   PostDelayedTask(location, std::move(task), base::TimeDelta());
 }
 
 TaskHandle WebTaskRunner::PostCancellableTask(const WebTraceLocation& location,
-                                              WTF::Closure task) {
+                                              base::OnceClosure task) {
   DCHECK(RunsTasksInCurrentSequence());
   scoped_refptr<TaskHandle::Runner> runner =
       base::AdoptRef(new TaskHandle::Runner(std::move(task)));
@@ -147,7 +147,7 @@ TaskHandle WebTaskRunner::PostCancellableTask(const WebTraceLocation& location,
 
 TaskHandle WebTaskRunner::PostDelayedCancellableTask(
     const WebTraceLocation& location,
-    WTF::Closure task,
+    base::OnceClosure task,
     TimeDelta delay) {
   DCHECK(RunsTasksInCurrentSequence());
   scoped_refptr<TaskHandle::Runner> runner =

third_party/WebKit/Source/platform/WebTaskRunner.h

@@ -77,15 +77,15 @@ class BLINK_PLATFORM_EXPORT WebTaskRunner
                        TimeDelta delay);
 
   // For same-thread posting. Must be called from the associated WebThread.
-  void PostTask(const WebTraceLocation&, WTF::Closure);
+  void PostTask(const WebTraceLocation&, base::OnceClosure);
 
   // For same-thread cancellable task posting. Returns a TaskHandle object for
   // cancellation.
   WARN_UNUSED_RESULT TaskHandle PostCancellableTask(const WebTraceLocation&,
-                                                    WTF::Closure);
+                                                    base::OnceClosure);
   WARN_UNUSED_RESULT TaskHandle
   PostDelayedCancellableTask(const WebTraceLocation&,
-                             WTF::Closure,
+                             base::OnceClosure,
                              TimeDelta delay);
 
  protected:

third_party/WebKit/Source/platform/WebThreadSupportingGC.h

@@ -34,12 +34,12 @@ class PLATFORM_EXPORT WebThreadSupportingGC final {
   static std::unique_ptr<WebThreadSupportingGC> CreateForThread(WebThread*);
   ~WebThreadSupportingGC();
 
-  void PostTask(const WebTraceLocation& location, WTF::Closure task) {
+  void PostTask(const WebTraceLocation& location, base::OnceClosure task) {
     thread_->GetWebTaskRunner()->PostTask(location, std::move(task));
   }
 
   void PostDelayedTask(const WebTraceLocation& location,
-                       WTF::Closure task,
+                       base::OnceClosure task,
                        TimeDelta delay) {
     thread_->GetWebTaskRunner()->PostDelayedTask(location, std::move(task),
                                                  delay);

third_party/WebKit/Source/platform/bindings/Microtask.cpp

@@ -42,16 +42,16 @@ void Microtask::PerformCheckpoint(v8::Isolate* isolate) {
 }
 
 static void MicrotaskFunctionCallback(void* data) {
-  std::unique_ptr<WTF::Closure> task =
-      WTF::WrapUnique(static_cast<WTF::Closure*>(data));
+  std::unique_ptr<base::OnceClosure> task =
+      WTF::WrapUnique(static_cast<base::OnceClosure*>(data));
   std::move(*task).Run();
 }
 
-void Microtask::EnqueueMicrotask(WTF::Closure callback) {
+void Microtask::EnqueueMicrotask(base::OnceClosure callback) {
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   isolate->EnqueueMicrotask(
       &MicrotaskFunctionCallback,
-      static_cast<void*>(new WTF::Closure(std::move(callback))));
+      static_cast<void*>(new base::OnceClosure(std::move(callback))));
 }
 
 }  // namespace blink

third_party/WebKit/Source/platform/bindings/Microtask.h

@@ -70,7 +70,7 @@ class PLATFORM_EXPORT Microtask {
   // TODO(jochen): Make all microtasks pass in the ScriptState they want to be
   // executed in. Until then, all microtasks have to keep track of their
   // ScriptState themselves.
-  static void EnqueueMicrotask(WTF::Closure);
+  static void EnqueueMicrotask(base::OnceClosure);
 };
 
 }  // namespace blink

third_party/WebKit/Source/platform/bindings/V8PerIsolateData.cpp

@@ -318,12 +318,12 @@ v8::Local<v8::Object> V8PerIsolateData::FindInstanceInPrototypeChain(
       templ);
 }
 
-void V8PerIsolateData::AddEndOfScopeTask(WTF::Closure task) {
+void V8PerIsolateData::AddEndOfScopeTask(base::OnceClosure task) {
   end_of_scope_tasks_.push_back(std::move(task));
 }
 
 void V8PerIsolateData::RunEndOfScopeTasks() {
-  Vector<WTF::Closure> tasks;
+  Vector<base::OnceClosure> tasks;
   tasks.swap(end_of_scope_tasks_);
   for (auto& task : tasks)
     std::move(task).Run();

third_party/WebKit/Source/platform/bindings/V8PerIsolateData.h

@@ -185,7 +185,7 @@ class PLATFORM_EXPORT V8PerIsolateData {
   // to C++ from script, after executing a script task (e.g. callback,
   // event) or microtasks (e.g. promise). This is explicitly needed for
   // Indexed DB transactions per spec, but should in general be avoided.
-  void AddEndOfScopeTask(WTF::Closure);
+  void AddEndOfScopeTask(base::OnceClosure);
   void RunEndOfScopeTasks();
   void ClearEndOfScopeTasks();
 
@@ -300,7 +300,7 @@ class PLATFORM_EXPORT V8PerIsolateData {
   bool is_handling_recursion_level_error_;
   bool is_reporting_exception_;
 
-  Vector<WTF::Closure> end_of_scope_tasks_;
+  Vector<base::OnceClosure> end_of_scope_tasks_;
   std::unique_ptr<Data> thread_debugger_;
 
   Persistent<ActiveScriptWrappableSet> active_script_wrappables_;

third_party/WebKit/Source/platform/heap/HeapTest.cpp

@@ -5072,11 +5072,11 @@ TEST(HeapTest, RegressNullIsStrongified) {
 }
 
 TEST(HeapTest, Bind) {
-  WTF::Closure closure =
+  base::OnceClosure closure =
       WTF::Bind(static_cast<void (Bar::*)(Visitor*)>(&Bar::Trace),
                 WrapPersistent(Bar::Create()), nullptr);
   // OffHeapInt* should not make Persistent.
-  WTF::Closure closure2 =
+  base::OnceClosure closure2 =
       WTF::Bind(&OffHeapInt::VoidFunction, OffHeapInt::Create(1));
   PreciselyCollectGarbage();
   // The closure should have a persistent handle to the Bar.
@@ -5084,7 +5084,7 @@ TEST(HeapTest, Bind) {
 
   UseMixin::trace_count_ = 0;
   Mixin* mixin = UseMixin::Create();
-  WTF::Closure mixin_closure =
+  base::OnceClosure mixin_closure =
       WTF::Bind(static_cast<void (Mixin::*)(Visitor*)>(&Mixin::Trace),
                 WrapPersistent(mixin), nullptr);
   PreciselyCollectGarbage();

third_party/WebKit/Source/platform/scheduler/renderer/web_view_scheduler.h

@@ -109,7 +109,7 @@ class PLATFORM_EXPORT WebViewScheduler {
   // policy is not affected when the budget expires.
   virtual void GrantVirtualTimeBudget(
       base::TimeDelta budget,
-      WTF::Closure budget_exhausted_callback) = 0;
+      base::OnceClosure budget_exhausted_callback) = 0;
 
   // It's possible for pages to send infinite messages which can arbitrarily
   // block virtual time.  We can prevent this by setting an upper limit on the

third_party/WebKit/Source/platform/scheduler/renderer/web_view_scheduler_impl.cc

@@ -191,7 +191,7 @@ bool WebViewSchedulerImpl::VirtualTimeAllowedToAdvance() const {
 
 void WebViewSchedulerImpl::GrantVirtualTimeBudget(
     base::TimeDelta budget,
-    WTF::Closure budget_exhausted_callback) {
+    base::OnceClosure budget_exhausted_callback) {
   renderer_scheduler_->VirtualTimeControlTaskQueue()->PostDelayedTask(
       FROM_HERE, std::move(budget_exhausted_callback), budget);
 }

third_party/WebKit/Source/platform/scheduler/renderer/web_view_scheduler_impl.h

@@ -53,8 +53,9 @@ class PLATFORM_EXPORT WebViewSchedulerImpl : public WebViewScheduler {
   void DisableVirtualTimeForTesting() override;
   bool VirtualTimeAllowedToAdvance() const override;
   void SetVirtualTimePolicy(VirtualTimePolicy virtual_time_policy) override;
-  void GrantVirtualTimeBudget(base::TimeDelta budget,
-                              WTF::Closure budget_exhausted_callback) override;
+  void GrantVirtualTimeBudget(
+      base::TimeDelta budget,
+      base::OnceClosure budget_exhausted_callback) override;
   void SetMaxVirtualTimeTaskStarvationCount(
       int max_task_starvation_count) override;
   void AudioStateChanged(bool is_audio_playing) override;

third_party/WebKit/Source/platform/scheduler/renderer/web_view_scheduler_impl_unittest.cc

@@ -211,7 +211,7 @@ void RunVirtualTimeRecorderTask(base::SimpleTestTickClock* clock,
       task_runner->MonotonicallyIncreasingVirtualTimeSeconds() * 1000.0);
 }
 
-WTF::Closure MakeVirtualTimeRecorderTask(
+base::OnceClosure MakeVirtualTimeRecorderTask(
     base::SimpleTestTickClock* clock,
     scoped_refptr<WebTaskRunner> task_runner,
     std::vector<base::TimeTicks>* out_real_times,

third_party/WebKit/Source/platform/scheduler/test/fake_web_view_scheduler.h

@@ -63,7 +63,7 @@ class FakeWebViewScheduler : public WebViewScheduler {
   void AddVirtualTimeObserver(VirtualTimeObserver* observer) override {}
   void RemoveVirtualTimeObserver(VirtualTimeObserver* observer) override {}
   void GrantVirtualTimeBudget(base::TimeDelta budget,
-                              WTF::Closure callback) override {}
+                              base::OnceClosure callback) override {}
   void SetMaxVirtualTimeTaskStarvationCount(int count) override {}
   void AudioStateChanged(bool is_audio_playing) override {}
   bool HasActiveConnectionForTest() const override { return false; }

third_party/WebKit/Source/platform/wtf/FunctionalTest.cpp

@@ -152,13 +152,13 @@ TEST(FunctionalTest, WeakPtr) {
   EXPECT_EQ(1, counter);
 }
 
-void MakeClosure(Closure** closure_out) {
-  *closure_out = new Closure(WTF::Bind([] {}));
+void MakeClosure(base::OnceClosure** closure_out) {
+  *closure_out = new base::OnceClosure(WTF::Bind([] {}));
   LEAK_SANITIZER_IGNORE_OBJECT(*closure_out);
 }
 
 TEST(FunctionalTest, ThreadRestriction) {
-  Closure* closure = nullptr;
+  base::OnceClosure* closure = nullptr;
 
   base::Thread thread("testing");
   thread.Start();