Remove use of deprecated MessageLoop methods in components.

components/pairing/fake_controller_pairing_controller.cc

 // Copyright 2014 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 "components/pairing/fake_controller_pairing_controller.h"
 
 #include <map>
 
 #include "base/bind.h"
+#include "base/location.h"
 #include "base/logging.h"
-#include "base/message_loop/message_loop.h"
 #include "base/rand_util.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
+#include "base/threading/thread_task_runner_handle.h"
 
 namespace pairing_chromeos {
 
 FakeControllerPairingController::FakeControllerPairingController(
     const std::string& config)
     : current_stage_(STAGE_NONE),
       should_fail_on_connecting_(false),
       connection_lost_begin_(STAGE_NONE),
       connection_lost_end_(STAGE_NONE),
       enrollment_should_fail_(false) {
@@ skipping 202 matching lines @@
 }
 
 void FakeControllerPairingController::ChangeStage(Stage new_stage) {
   if (current_stage_ == new_stage)
     return;
   current_stage_ = new_stage;
   FOR_EACH_OBSERVER(Observer, observers_, PairingStageChanged(new_stage));
 }
 
 void FakeControllerPairingController::ChangeStageLater(Stage new_stage) {
-  base::MessageLoop::current()->PostDelayedTask(
-      FROM_HERE,
-      base::Bind(&FakeControllerPairingController::ChangeStage,
-                 base::Unretained(this),
-                 new_stage),
+  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+      FROM_HERE, base::Bind(&FakeControllerPairingController::ChangeStage,
+                            base::Unretained(this), new_stage),
       async_duration_);
 }
 
 void FakeControllerPairingController::ExecuteDiscoveryEvent(
     size_t event_position) {
   if (current_stage_ != STAGE_DEVICES_DISCOVERY)
     return;
   CHECK(event_position < discovery_scenario_.size());
   const DiscoveryEvent& event = discovery_scenario_[event_position];
   switch (event.first) {
     case DEVICE_FOUND: {
       DeviceFound(event.second);
       break;
     }
     case DEVICE_LOST: {
       DeviceLost(event.second);
       break;
     }
     case NOTHING_FOUND: {
       ChangeStage(STAGE_DEVICE_NOT_FOUND);
       break;
     }
   }
   if (++event_position == discovery_scenario_.size()) {
     return;
   }
-  base::MessageLoop::current()->PostDelayedTask(
+  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&FakeControllerPairingController::ExecuteDiscoveryEvent,
-                 base::Unretained(this),
-                 event_position),
+                 base::Unretained(this), event_position),
       async_duration_);
 }
 
 void FakeControllerPairingController::DeviceFound(
     const std::string& device_id) {
   CHECK(current_stage_ == STAGE_DEVICES_DISCOVERY);
   discovered_devices_.insert(device_id);
   FOR_EACH_OBSERVER(Observer, observers_, DiscoveredDevicesListChanged());
 }
 
 void FakeControllerPairingController::DeviceLost(const std::string& device_id) {
   CHECK(current_stage_ == STAGE_DEVICES_DISCOVERY);
   discovered_devices_.erase(device_id);
   FOR_EACH_OBSERVER(Observer, observers_, DiscoveredDevicesListChanged());
 }
 
 void FakeControllerPairingController::PairingStageChanged(Stage new_stage) {
   Stage next_stage = STAGE_NONE;
   switch (new_stage) {
     case STAGE_DEVICES_DISCOVERY: {
       discovered_devices_.clear();
-      base::MessageLoop::current()->PostDelayedTask(
+      base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
           FROM_HERE,
           base::Bind(&FakeControllerPairingController::ExecuteDiscoveryEvent,
-                     base::Unretained(this),
-                     0),
+                     base::Unretained(this), 0),
           async_duration_);
       break;
     }
     case STAGE_ESTABLISHING_CONNECTION: {
       if (should_fail_on_connecting_) {
         next_stage = STAGE_ESTABLISHING_CONNECTION_ERROR;
         should_fail_on_connecting_ = false;
       } else {
         confirmation_code_.clear();
         next_stage = STAGE_WAITING_FOR_CODE_CONFIRMATION;
@@ skipping 26 matching lines @@
     next_stage = STAGE_HOST_CONNECTION_LOST;
   }
   if (next_stage != STAGE_NONE)
     ChangeStageLater(next_stage);
 }
 
 void FakeControllerPairingController::DiscoveredDevicesListChanged() {
 }
 
 }  // namespace pairing_chromeos