Use ScopedTaskEnvironment instead of MessageLoopForUI in chromeos tests.

chromeos/network/network_device_handler_unittest.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 <memory>
 
 #include "base/bind.h"
 #include "base/macros.h"
-#include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
+#include "base/test/scoped_task_environment.h"
 #include "base/values.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/fake_shill_device_client.h"
 #include "chromeos/dbus/fake_shill_manager_client.h"
 #include "chromeos/network/network_device_handler_impl.h"
 #include "chromeos/network/network_state_handler.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 namespace {
 
 const char kDefaultCellularDevicePath[] = "stub_cellular_device";
 const char kUnknownCellularDevicePath[] = "unknown_cellular_device";
 const char kDefaultWifiDevicePath[] = "stub_wifi_device";
 const char kResultSuccess[] = "success";
 const char kDefaultPin[] = "1111";
 
 }  // namespace
 
 class NetworkDeviceHandlerTest : public testing::Test {
  public:
-  NetworkDeviceHandlerTest() : fake_device_client_(NULL) {}
+  NetworkDeviceHandlerTest()
+      : scoped_task_environment_(
+            base::test::ScopedTaskEnvironment::MainThreadType::UI) {}
   ~NetworkDeviceHandlerTest() override {}
 
   void SetUp() override {
     fake_device_client_ = new FakeShillDeviceClient;
     DBusThreadManager::GetSetterForTesting()->SetShillDeviceClient(
         std::unique_ptr<ShillDeviceClient>(fake_device_client_));
 
     success_callback_ = base::Bind(&NetworkDeviceHandlerTest::SuccessCallback,
                                    base::Unretained(this));
     properties_success_callback_ =
@@ skipping 47 matching lines @@
     result_ = kResultSuccess;
     properties_.reset(properties.DeepCopy());
   }
 
   void StringSuccessCallback(const std::string& result) {
     VLOG(1) << "StringSuccessCallback: " << result;
     result_ = result;
   }
 
  protected:
+  base::test::ScopedTaskEnvironment scoped_task_environment_;
   std::string result_;
-
-  FakeShillDeviceClient* fake_device_client_;
+  FakeShillDeviceClient* fake_device_client_ = nullptr;
   std::unique_ptr<NetworkDeviceHandler> network_device_handler_;
   std::unique_ptr<NetworkStateHandler> network_state_handler_;
-  base::MessageLoopForUI message_loop_;
   base::Closure success_callback_;
   network_handler::DictionaryResultCallback properties_success_callback_;
   network_handler::StringResultCallback string_success_callback_;
   network_handler::ErrorCallback error_callback_;
   std::unique_ptr<base::DictionaryValue> properties_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NetworkDeviceHandlerTest);
 };
 
@@ skipping 264 matching lines @@
 
   // Test that the shill error propagates to the error callback.
   network_device_handler_->ChangePin(kDefaultCellularDevicePath, kIncorrectPin,
                                      kNewPin, success_callback_,
                                      error_callback_);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(NetworkDeviceHandler::kErrorIncorrectPin, result_);
 }
 
 }  // namespace chromeos