Migrate Bind to BindOnce or BindRepeating in //base/message_loop

base/message_loop/message_loop.cc

 // Copyright 2013 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/message_loop/message_loop.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 67 matching lines @@
 MessageLoop::NestingObserver::~NestingObserver() {}
 
 //------------------------------------------------------------------------------
 
 MessageLoop::MessageLoop(Type type)
     : MessageLoop(type, MessagePumpFactoryCallback()) {
   BindToCurrentThread();
 }
 
 MessageLoop::MessageLoop(std::unique_ptr<MessagePump> pump)
-    : MessageLoop(TYPE_CUSTOM, Bind(&ReturnPump, Passed(&pump))) {
+    : MessageLoop(TYPE_CUSTOM, BindOnce(&ReturnPump, Passed(&pump))) {
   BindToCurrentThread();
 }
 
 MessageLoop::~MessageLoop() {
   // If |pump_| is non-null, this message loop has been bound and should be the
   // current one on this thread. Otherwise, this loop is being destructed before
   // it was bound to a thread, so a different message loop (or no loop at all)
   // may be current.
   DCHECK((pump_ && current() == this) || (!pump_ && current() != this));
 
@@ skipping 203 matching lines @@
   // queue.
   return incoming_task_queue_->IsIdleForTesting();
 }
 
 //------------------------------------------------------------------------------
 
 // static
 std::unique_ptr<MessageLoop> MessageLoop::CreateUnbound(
     Type type,
     MessagePumpFactoryCallback pump_factory) {
-  return WrapUnique(new MessageLoop(type, pump_factory));
+  return WrapUnique(new MessageLoop(type, std::move(pump_factory)));
 }
 
 MessageLoop::MessageLoop(Type type, MessagePumpFactoryCallback pump_factory)
     : type_(type),
 #if defined(OS_WIN)
       pending_high_res_tasks_(0),
       in_high_res_mode_(false),
 #endif
       nestable_tasks_allowed_(true),
-      pump_factory_(pump_factory),
+      pump_factory_(std::move(pump_factory)),
       run_loop_(nullptr),
       current_pending_task_(nullptr),
       incoming_task_queue_(new internal::IncomingTaskQueue(this)),
       unbound_task_runner_(
           new internal::MessageLoopTaskRunner(incoming_task_queue_)),
       task_runner_(unbound_task_runner_),
       thread_id_(kInvalidThreadId) {
   // If type is TYPE_CUSTOM non-null pump_factory must be given.
   DCHECK(type_ != TYPE_CUSTOM || !pump_factory_.is_null());
 }
 
 void MessageLoop::BindToCurrentThread() {
   DCHECK(!pump_);
   if (!pump_factory_.is_null())
-    pump_ = pump_factory_.Run();
+    pump_ = std::move(pump_factory_).Run();
   else
     pump_ = CreateMessagePumpForType(type_);
 
   DCHECK(!current()) << "should only have one message loop per thread";
   GetTLSMessageLoop()->Set(this);
 
   incoming_task_queue_->StartScheduling();
   unbound_task_runner_->BindToCurrentThread();
   unbound_task_runner_ = nullptr;
   SetThreadTaskRunnerHandle();
@@ skipping 238 matching lines @@
   }
 #endif
   return false;
 }
 
 #if !defined(OS_NACL)
 //------------------------------------------------------------------------------
 // MessageLoopForUI
 
 MessageLoopForUI::MessageLoopForUI(std::unique_ptr<MessagePump> pump)
-    : MessageLoop(TYPE_UI, Bind(&ReturnPump, Passed(&pump))) {}
+    : MessageLoop(TYPE_UI, BindOnce(&ReturnPump, std::move(pump))) {}
 
 #if defined(OS_ANDROID)
 void MessageLoopForUI::Start() {
   // No Histogram support for UI message loop as it is managed by Java side
   static_cast<MessagePumpForUI*>(pump_.get())->Start(this);
 }
 
 void MessageLoopForUI::StartForTesting(
     base::android::JavaMessageHandlerFactory* factory,
     WaitableEvent* test_done_event) {
@@ skipping 59 matching lines @@
       persistent,
       mode,
       controller,
       delegate);
 }
 #endif
 
 #endif  // !defined(OS_NACL_SFI)
 
 }  // namespace base