content: Use base::MessageLoop.

content/browser/geolocation/wifi_data_provider_common_unittest.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 <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/string_util.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "base/utf_string_conversions.h"
@@ skipping 43 matching lines @@
   MOCK_METHOD0(PollingInterval, int());
   MOCK_METHOD0(NoWifiInterval, int());
 
   virtual void UpdatePollingInterval(bool) {}
 };
 
 // Stops the specified (nested) message loop when the listener is called back.
 class MessageLoopQuitListener
     : public WifiDataProviderCommon::ListenerInterface {
  public:
-  explicit MessageLoopQuitListener(MessageLoop* message_loop)
+  explicit MessageLoopQuitListener(base::MessageLoop* message_loop)
       : message_loop_to_quit_(message_loop) {
     CHECK(message_loop_to_quit_ != NULL);
   }
   // ListenerInterface
   virtual void DeviceDataUpdateAvailable(
       DeviceDataProvider<WifiData>* provider) OVERRIDE {
     // Provider should call back on client's thread.
-    EXPECT_EQ(MessageLoop::current(), message_loop_to_quit_);
+    EXPECT_EQ(base::MessageLoop::current(), message_loop_to_quit_);
     provider_ = provider;
     message_loop_to_quit_->QuitNow();
   }
-  MessageLoop* message_loop_to_quit_;
+  base::MessageLoop* message_loop_to_quit_;
   DeviceDataProvider<WifiData>* provider_;
 };
 
 
 class WifiDataProviderCommonWithMock : public WifiDataProviderCommon {
  public:
   WifiDataProviderCommonWithMock()
       : new_wlan_api_(new MockWlanApi),
         new_polling_policy_(new MockPollingPolicy) {}
 
@@ skipping 33 matching lines @@
     polling_policy_ = provider_->new_polling_policy_.get();
     provider_->AddListener(&quit_listener_);
   }
   virtual void TearDown() {
     provider_->RemoveListener(&quit_listener_);
     provider_->StopDataProvider();
     provider_ = NULL;
   }
 
  protected:
-  MessageLoop main_message_loop_;
+  base::MessageLoop main_message_loop_;
   MessageLoopQuitListener quit_listener_;
   scoped_refptr<WifiDataProviderCommonWithMock> provider_;
   MockWlanApi* wlan_api_;
   MockPollingPolicy* polling_policy_;
 };
 
 TEST_F(GeolocationWifiDataProviderCommonTest, CreateDestroy) {
   // Test fixture members were SetUp correctly.
-  EXPECT_EQ(&main_message_loop_, MessageLoop::current());
+  EXPECT_EQ(&main_message_loop_, base::MessageLoop::current());
   EXPECT_TRUE(NULL != provider_.get());
   EXPECT_TRUE(NULL != wlan_api_);
 }
 
 TEST_F(GeolocationWifiDataProviderCommonTest, StartThread) {
   EXPECT_CALL(*wlan_api_, GetAccessPointData(_))
       .Times(AtLeast(1));
   EXPECT_CALL(*polling_policy_, PollingInterval())
       .Times(AtLeast(1));
   EXPECT_TRUE(provider_->StartDataProvider());
@@ skipping 74 matching lines @@
        StartThreadViaDeviceDataProvider) {
   MessageLoopQuitListener quit_listener(&main_message_loop_);
   WifiDataProvider::SetFactory(CreateWifiDataProviderCommonWithMock);
   DeviceDataProvider<WifiData>::Register(&quit_listener);
   main_message_loop_.Run();
   DeviceDataProvider<WifiData>::Unregister(&quit_listener);
   DeviceDataProvider<WifiData>::ResetFactory();
 }
 
 }  // namespace content