| // 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.h" |
| |
| namespace content { |
| |
| // static |
| WifiDataProvider* WifiDataProvider::instance_ = NULL; |
| |
| // static |
| WifiDataProvider::ImplFactoryFunction WifiDataProvider::factory_function_ = |
| DefaultFactoryFunction; |
| |
| // static |
| void WifiDataProvider::SetFactory(ImplFactoryFunction factory_function_in) { |
| factory_function_ = factory_function_in; |
| } |
| |
| // static |
| void WifiDataProvider::ResetFactory() { |
| factory_function_ = DefaultFactoryFunction; |
| } |
| |
| // static |
| WifiDataProvider* WifiDataProvider::Register(WifiDataUpdateCallback* callback) { |
| bool need_to_start_data_provider = false; |
| if (!instance_) { |
| instance_ = new WifiDataProvider(); |
| 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) { |
| 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() { |
| DCHECK(factory_function_); |
| impl_ = (*factory_function_)(); |
| DCHECK(impl_.get()); |
| impl_->SetContainer(this); |
| } |
| |
| WifiDataProvider::~WifiDataProvider() { |
| DCHECK(impl_.get()); |
| impl_->SetContainer(NULL); |
| } |
| |
| bool WifiDataProvider::GetData(WifiData* data) { |
| return impl_->GetData(data); |
| } |
| |
| void WifiDataProvider::AddCallback(WifiDataUpdateCallback* callback) { |
| impl_->AddCallback(callback); |
| } |
| |
| bool WifiDataProvider::RemoveCallback(WifiDataUpdateCallback* callback) { |
| return impl_->RemoveCallback(callback); |
| } |
| |
| bool WifiDataProvider::has_callbacks() const { |
| return impl_->has_callbacks(); |
| } |
| |
| void WifiDataProvider::StartDataProvider() { |
| impl_->StartDataProvider(); |
| } |
| |
| void WifiDataProvider::StopDataProvider() { |
| impl_->StopDataProvider(); |
| } |
| |
| } // namespace content |