Cleaner organization of WifiDataProvider code.

content/browser/geolocation/wifi_data_provider_manager.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 "content/browser/geolocation/wifi_data_provider_manager.h"
+
 #include "content/browser/geolocation/wifi_data_provider.h"
 
 namespace content {
 
 // static
-WifiDataProvider* WifiDataProvider::instance_ = NULL;
+WifiDataProviderManager* WifiDataProviderManager::instance_ = NULL;
 
 // static
-WifiDataProvider::ImplFactoryFunction WifiDataProvider::factory_function_ =
-    DefaultFactoryFunction;
+WifiDataProviderManager::ImplFactoryFunction
+    WifiDataProviderManager::factory_function_ = DefaultFactoryFunction;
 
 // static
-void WifiDataProvider::SetFactory(ImplFactoryFunction factory_function_in) {
+void WifiDataProviderManager::SetFactory(
+    ImplFactoryFunction factory_function_in) {
   factory_function_ = factory_function_in;
 }
 
 // static
-void WifiDataProvider::ResetFactory() {
+void WifiDataProviderManager::ResetFactory() {
   factory_function_ = DefaultFactoryFunction;
 }
 
 // static
-WifiDataProvider* WifiDataProvider::Register(WifiDataUpdateCallback* callback) {
+WifiDataProviderManager* WifiDataProviderManager::Register(
+    WifiDataUpdateCallback* callback) {
   bool need_to_start_data_provider = false;
   if (!instance_) {
-    instance_ = new WifiDataProvider();
+    instance_ = new WifiDataProviderManager();
     need_to_start_data_provider = true;
   }
   DCHECK(instance_);
   instance_->AddCallback(callback);
   // Start the provider after adding the callback, to avoid any race in
   // it running early.
   if (need_to_start_data_provider)
     instance_->StartDataProvider();
   return instance_;
 }
 
 // static
-bool WifiDataProvider::Unregister(WifiDataUpdateCallback* callback) {
+bool WifiDataProviderManager::Unregister(WifiDataUpdateCallback* callback) {
   DCHECK(instance_);
   DCHECK(instance_->has_callbacks());
   if (!instance_->RemoveCallback(callback)) {
     return false;
   }
   if (!instance_->has_callbacks()) {
     // Must stop the data provider (and any implementation threads) before
     // destroying to avoid any race conditions in access to the provider in
     // the destructor chain.
     instance_->StopDataProvider();
     delete instance_;
     instance_ = NULL;
   }
   return true;
 }
 
-WifiDataProviderImplBase::WifiDataProviderImplBase()
-    : container_(NULL),
-      client_loop_(base::MessageLoop::current()) {
-  DCHECK(client_loop_);
-}
-
-WifiDataProviderImplBase::~WifiDataProviderImplBase() {
-}
-
-void WifiDataProviderImplBase::SetContainer(WifiDataProvider* container) {
-  container_ = container;
-}
-
-void WifiDataProviderImplBase::AddCallback(WifiDataUpdateCallback* callback) {
-  callbacks_.insert(callback);
-}
-
-bool WifiDataProviderImplBase::RemoveCallback(
-    WifiDataUpdateCallback* callback) {
-  return callbacks_.erase(callback) == 1;
-}
-
-bool WifiDataProviderImplBase::has_callbacks() const {
-  return !callbacks_.empty();
-}
-
-void WifiDataProviderImplBase::RunCallbacks() {
-  client_loop_->PostTask(FROM_HERE, base::Bind(
-      &WifiDataProviderImplBase::DoRunCallbacks,
-      this));
-}
-
-bool WifiDataProviderImplBase::CalledOnClientThread() const {
-  return base::MessageLoop::current() == this->client_loop_;
-}
-
-base::MessageLoop* WifiDataProviderImplBase::client_loop() const {
-  return client_loop_;
-}
-
-void WifiDataProviderImplBase::DoRunCallbacks() {
-  // It's possible that all the callbacks (and the container) went away
-  // whilst this task was pending. This is fine; the loop will be a no-op.
-  CallbackSet::const_iterator iter = callbacks_.begin();
-  while (iter != callbacks_.end()) {
-    WifiDataUpdateCallback* callback = *iter;
-    ++iter;  // Advance iter before running, in case callback unregisters.
-    callback->Run(container_);
-  }
-}
-
-WifiDataProvider::WifiDataProvider() {
+WifiDataProviderManager::WifiDataProviderManager() {
   DCHECK(factory_function_);
   impl_ = (*factory_function_)();
   DCHECK(impl_.get());
   impl_->SetContainer(this);
 }
 
-WifiDataProvider::~WifiDataProvider() {
+WifiDataProviderManager::~WifiDataProviderManager() {
   DCHECK(impl_.get());
   impl_->SetContainer(NULL);
 }
 
-bool WifiDataProvider::GetData(WifiData* data) {
+bool WifiDataProviderManager::GetData(WifiData* data) {
   return impl_->GetData(data);
 }
 
-void WifiDataProvider::AddCallback(WifiDataUpdateCallback* callback) {
+void WifiDataProviderManager::AddCallback(WifiDataUpdateCallback* callback) {
   impl_->AddCallback(callback);
 }
 
-bool WifiDataProvider::RemoveCallback(WifiDataUpdateCallback* callback) {
+bool WifiDataProviderManager::RemoveCallback(WifiDataUpdateCallback* callback) {
   return impl_->RemoveCallback(callback);
 }
 
-bool WifiDataProvider::has_callbacks() const {
+bool WifiDataProviderManager::has_callbacks() const {
   return impl_->has_callbacks();
 }
 
-void WifiDataProvider::StartDataProvider() {
+void WifiDataProviderManager::StartDataProvider() {
   impl_->StartDataProvider();
 }
 
-void WifiDataProvider::StopDataProvider() {
+void WifiDataProviderManager::StopDataProvider() {
   impl_->StopDataProvider();
 }
 
 }  // namespace content