Ensure tests have an active task runner

chromeos/dbus/services/service_provider_test_helper.cc

 // Copyright (c) 2012 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 "chromeos/dbus/services/service_provider_test_helper.h"
 
 #include "base/bind.h"
 #include "dbus/message.h"
 #include "dbus/mock_bus.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 using ::testing::_;
 using ::testing::AllOf;
 using ::testing::Invoke;
 using ::testing::ResultOf;
 using ::testing::Return;
 using ::testing::Unused;
 
 namespace chromeos {
 
 ServiceProviderTestHelper::ServiceProviderTestHelper()
     : response_received_(false) {
+  if (!base::MessageLoop::current())
+    message_loop_.reset(new base::MessageLoop());
 }
 
 ServiceProviderTestHelper::~ServiceProviderTestHelper() {
 }
 
 void ServiceProviderTestHelper::SetUp(
     const std::string& exported_method_name,
     CrosDBusService::ServiceProviderInterface* service_provider) {
   // Create a mock bus.
   dbus::Bus::Options options;
@@ skipping 89 matching lines @@
   // dbus_message_new_method_return() won't emit a warning.
   method_call->SetSerial(1);
   // Run the callback captured in MockExportMethod(). In addition to returning
   // a response that the caller will ignore, this will send a signal, which
   // will be received by |on_signal_callback_|.
   method_callback_.Run(method_call,
                        base::Bind(&ServiceProviderTestHelper::OnResponse,
                                   base::Unretained(this)));
   // Check for a response.
   if (!response_received_)
-    message_loop_.Run();
+    base::MessageLoop::current()->Run();
   // Return response.
   return response_.release();
 }
 
 void ServiceProviderTestHelper::MockConnectToSignal(
     const std::string& interface_name,
     const std::string& signal_name,
     dbus::ObjectProxy::SignalCallback signal_callback,
     dbus::ObjectProxy::OnConnectedCallback connected_callback) {
   // Tell the callback that the object proxy is connected to the signal.
   connected_callback.Run(interface_name, signal_name, true);
   // Capture the callback, so we can run this at a later time.
   on_signal_callback_ = signal_callback;
 }
 
 void ServiceProviderTestHelper::MockSendSignal(dbus::Signal* signal) {
   // Run the callback captured in MockConnectToSignal(). This will call
   // OnSignalReceived().
   on_signal_callback_.Run(signal);
 }
 
 void ServiceProviderTestHelper::OnResponse(
     scoped_ptr<dbus::Response> response) {
   response_ = response.Pass();
   response_received_ = true;
-  if (message_loop_.is_running())
-    message_loop_.Quit();
+  if (base::MessageLoop::current()->is_running())
+    base::MessageLoop::current()->Quit();
 }
 
 }  // namespace chromeos