Cleaner organization of WifiDataProvider code.

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/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "content/browser/geolocation/wifi_data_provider_common.h"
+#include "content/browser/geolocation/wifi_data_provider_manager.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::AtLeast;
 using testing::DoDefault;
 using testing::Invoke;
 using testing::Return;
 
 namespace content {
@@ skipping 38 matching lines @@
 // Stops the specified (nested) message loop when the callback is called.
 class MessageLoopQuitter {
  public:
   explicit MessageLoopQuitter(base::MessageLoop* message_loop)
       : message_loop_to_quit_(message_loop),
         callback_(base::Bind(&MessageLoopQuitter::OnWifiDataUpdate,
                              base::Unretained(this))) {
     CHECK(message_loop_to_quit_ != NULL);
   }
 
-  void OnWifiDataUpdate(WifiDataProvider* provider) {
+  void OnWifiDataUpdate(WifiDataProviderManager* manager) {
     // Provider should call back on client's thread.
     EXPECT_EQ(base::MessageLoop::current(), message_loop_to_quit_);
     message_loop_to_quit_->QuitNow();
   }
   base::MessageLoop* message_loop_to_quit_;
-  WifiDataProvider::WifiDataUpdateCallback callback_;
+  WifiDataProviderManager::WifiDataUpdateCallback callback_;
 };
 
 class WifiDataProviderCommonWithMock : public WifiDataProviderCommon {
  public:
   WifiDataProviderCommonWithMock()
       : new_wlan_api_(new MockWlanApi),
         new_polling_policy_(new MockPollingPolicy) {}
 
   // WifiDataProviderCommon
   virtual WlanApiInterface* NewWlanApi() OVERRIDE {
     CHECK(new_wlan_api_ != NULL);
     return new_wlan_api_.release();
   }
   virtual WifiPollingPolicy* NewPollingPolicy() OVERRIDE {
     CHECK(new_polling_policy_ != NULL);
     return new_polling_policy_.release();
   }
 
   scoped_ptr<MockWlanApi> new_wlan_api_;
   scoped_ptr<MockPollingPolicy> new_polling_policy_;
 
  private:
   virtual ~WifiDataProviderCommonWithMock() {}
 
   DISALLOW_COPY_AND_ASSIGN(WifiDataProviderCommonWithMock);
 };
 
-WifiDataProviderImplBase* CreateWifiDataProviderCommonWithMock() {
+WifiDataProvider* CreateWifiDataProviderCommonWithMock() {
   return new WifiDataProviderCommonWithMock;
 }
 
 // Main test fixture
 class GeolocationWifiDataProviderCommonTest : public testing::Test {
  public:
   GeolocationWifiDataProviderCommonTest()
       : loop_quitter_(&main_message_loop_) {
   }
 
@@ skipping 96 matching lines @@
   main_message_loop_.Run();
   EXPECT_EQ(wlan_api_->calls_, 1);
   WifiData data;
   EXPECT_TRUE(provider_->GetData(&data));
   EXPECT_EQ(1, static_cast<int>(data.access_point_data.size()));
   EXPECT_EQ(single_access_point.ssid, data.access_point_data.begin()->ssid);
 }
 
 TEST_F(GeolocationWifiDataProviderCommonTest, RegisterUnregister) {
   MessageLoopQuitter loop_quitter(&main_message_loop_);
-  WifiDataProvider::SetFactory(CreateWifiDataProviderCommonWithMock);
-  WifiDataProvider::Register(&loop_quitter.callback_);
+  WifiDataProviderManager::SetFactory(CreateWifiDataProviderCommonWithMock);
+  WifiDataProviderManager::Register(&loop_quitter.callback_);
   main_message_loop_.Run();
-  WifiDataProvider::Unregister(&loop_quitter.callback_);
-  WifiDataProvider::ResetFactory();
+  WifiDataProviderManager::Unregister(&loop_quitter.callback_);
+  WifiDataProviderManager::ResetFactory();
 }
 
 }  // namespace content