Update Gears wifi data providers to Chrome style & APIs....

chrome/browser/geolocation/device_data_provider.h

-// Copyright 2008, Google Inc.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are met:
-//
-//  1. Redistributions of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//  2. Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//  3. Neither the name of Google Inc. nor the names of its contributors may be
-//     used to endorse or promote products derived from this software without
-//     specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
-// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
-// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
-// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
-// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
-// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
+// Copyright (c) 2010 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.
+
 // A device data provider provides data from the device that is used by a
 // NetworkLocationProvider to obtain a position fix. This data may be either
 // cell radio data or wifi data. For a given type of data, we use a singleton
 // instance of the device data provider, which is used by multiple
 // NetworkLocationProvider objects.
 //
 // This file providers DeviceDataProvider, which provides static methods to
 // access the singleton instance. The singleton instance uses a private
 // implementation to abstract across platforms and also to allow mock providers
 // to be used for testing.
 //
 // This file also provides DeviceDataProviderImplBase, a base class which
 // provides commom functionality for the private implementations.
 //
 // This file also declares the data structures used to represent cell radio data
 // and wifi data.
 
-#ifndef GEARS_GEOLOCATION_DEVICE_DATA_PROVIDER_H__
-#define GEARS_GEOLOCATION_DEVICE_DATA_PROVIDER_H__
+#ifndef CHROME_BROWSER_GEOLOCATION_DEVICE_DATA_PROVIDER_H_
+#define CHROME_BROWSER_GEOLOCATION_DEVICE_DATA_PROVIDER_H_
 
 #include <algorithm>
+#include <functional>
 #include <set>
+#include <string>
 #include <vector>
-#include "gears/base/common/basictypes.h"  // For int64
-#include "gears/base/common/common.h"
-#include "gears/base/common/mutex.h"
-#include "gears/base/common/scoped_refptr.h"  // For RefCount
-#include "gears/base/common/string16.h"
-#include "third_party/scoped_ptr/scoped_ptr.h"
+
+#include "base/basictypes.h"
+#include "base/lock.h"
+#include "base/string16.h"
+#include "base/string_util.h"
+#include "base/scoped_ptr.h"
 
 // The following data structures are used to store cell radio data and wifi
 // data. See the Geolocation API design document at
 // http://code.google.com/p/google-gears/wiki/LocationAPI for a more complete
 // description.
 //
 // For all integer fields, we use kint32min to represent unknown values.
 
 // Cell radio data relating to a single cell tower.
 struct CellData {
@@ skipping 56 matching lines @@
            radio_type == other.radio_type &&
            carrier == other.carrier;
   }
   // Determines whether a new set of radio data differs significantly from this.
   bool DiffersSignificantly(const RadioData &other) const {
     // This is required by MockDeviceDataProviderImpl.
     // TODO(steveblock): Implement properly.
     return !Matches(other);
   }
 
-  std::string16 device_id;
+  string16 device_id;
   std::vector<CellData> cell_data;
   int home_mobile_network_code;  // For the device's home network.
   int home_mobile_country_code;  // For the device's home network.
   RadioType radio_type;          // Mobile radio type.
-  std::string16 carrier;         // Carrier name.
+  string16 carrier;         // Carrier name.
 };
 
 // Wifi data relating to a single access point.
 struct AccessPointData {
   AccessPointData()
       : radio_signal_strength(kint32min),
         age(kint32min),
         channel(kint32min),
         signal_to_noise(kint32min) {}
 
-  std::string16 mac_address;
+  string16 mac_address;
   int radio_signal_strength;  // Measured in dBm
   int age;              // Milliseconds since this access point was detected
   int channel;
   int signal_to_noise;  // Ratio in dB
-  std::string16 ssid;   // Network identifier
+  string16 ssid;   // Network identifier
 };
 
 // This is to allow AccessPointData to be used in std::set. We order
 // lexicographically by MAC address.
 struct AccessPointDataLess : public std::less<AccessPointData> {
-  bool operator()(const AccessPointData &data1,
-                  const AccessPointData &data2) const {
+  bool operator()(const AccessPointData& data1,
+                  const AccessPointData& data2) const {
     return data1.mac_address < data2.mac_address;
   }
 };
 
 // All data for wifi.
 struct WifiData {
   // Determines whether a new set of WiFi data differs significantly from this.
   bool DiffersSignificantly(const WifiData &other) const {
     // At least 5 or 50% of access points added or removed is significant.
     static const size_t kMinChangedAccessPoints = 5;
@@ skipping 30 matching lines @@
 
 // DeviceDataProvider uses containment to hide platform-specific implementation
 // details from common code. This class provides common functionality for these
 // contained implementation classes.
 template<typename DataType>
 class DeviceDataProviderImplBase {
  public:
   DeviceDataProviderImplBase() : container_(NULL) {}
   virtual ~DeviceDataProviderImplBase() {}
 
-  virtual bool GetData(DataType *data) = 0;
+  virtual bool StartDataProvider() = 0;
+
+  virtual bool GetData(DataType* data) = 0;
 
   // Sets the container of this class, which is of type DeviceDataProvider.
   // This is required to pass as a parameter when making the callback to
   // listeners.
-  void SetContainer(DeviceDataProvider<DataType> *container) {
+  void SetContainer(DeviceDataProvider<DataType>* container) {
     container_ = container;
   }
 
   typedef typename DeviceDataProvider<DataType>::ListenerInterface
           ListenerInterface;
-  void AddListener(ListenerInterface *listener) {
-    MutexLock mutex(&listeners_mutex_);
+  void AddListener(ListenerInterface* listener) {
+    AutoLock mutex(listeners_mutex_);
     listeners_.insert(listener);
   }
-  bool RemoveListener(ListenerInterface *listener) {
-    MutexLock mutex(&listeners_mutex_);
+  bool RemoveListener(ListenerInterface* listener) {
+    AutoLock mutex(listeners_mutex_);
     typename ListenersSet::iterator iter = find(listeners_.begin(),
                                                 listeners_.end(),
                                                 listener);
     if (iter == listeners_.end()) {
       return false;
     }
     listeners_.erase(iter);
     return true;
   }
 
  protected:
   // Calls DeviceDataUpdateAvailable() on all registered listeners.
   typedef std::set<ListenerInterface*> ListenersSet;
   void NotifyListeners() {
-    MutexLock lock(&listeners_mutex_);
+    AutoLock lock(listeners_mutex_);
     for (typename ListenersSet::const_iterator iter = listeners_.begin();
          iter != listeners_.end();
          ++iter) {
       (*iter)->DeviceDataUpdateAvailable(container_);
     }
   }
 
  private:
-  DeviceDataProvider<DataType> *container_;
+  DeviceDataProvider<DataType>* container_;
 
   // The listeners to this class and their mutex.
+  // TODO(joth): Once we've established the client is always single threaded,
+  // remove mutex and instead capture client's MessageLoop to stage the
+  // NotifyListeners callback via.
   ListenersSet listeners_;
-  Mutex listeners_mutex_;
+  Lock listeners_mutex_;
 
-  DISALLOW_EVIL_CONSTRUCTORS(DeviceDataProviderImplBase);
+  DISALLOW_COPY_AND_ASSIGN(DeviceDataProviderImplBase);
 };
 
 typedef DeviceDataProviderImplBase<RadioData> RadioDataProviderImplBase;
 typedef DeviceDataProviderImplBase<WifiData> WifiDataProviderImplBase;
 
 // A device data provider
 //
 // We use a singleton instance of this class which is shared by multiple network
 // location providers. These location providers access the instance through the
 // Register and Unregister methods.
 template<typename DataType>
 class DeviceDataProvider {
  public:
   // Interface to be implemented by listeners to a device data provider.
   class ListenerInterface {
    public:
+    // NOTE this may be called back in the context of the implementation private
+    // worker thread. (TODO Is there a naming convention to use for this?)
     virtual void DeviceDataUpdateAvailable(
-        DeviceDataProvider<DataType> *provider) = 0;
+        DeviceDataProvider<DataType>* provider) = 0;
     virtual ~ListenerInterface() {}
   };
 
   // Sets the factory function which will be used by Register to create the
   // implementation used by the singleton instance. This factory approach is
   // used to abastract accross both platform-specific implementation and to
   // inject mock implementations for testing.
-  typedef DeviceDataProviderImplBase<DataType> *(*ImplFactoryFunction)(void);
+  typedef DeviceDataProviderImplBase<DataType>* (*ImplFactoryFunction)(void);
   static void SetFactory(ImplFactoryFunction factory_function_in) {
     factory_function_ = factory_function_in;
   }
 
   static void ResetFactory() {
     factory_function_ = DefaultFactoryFunction;
   }
 
   // Adds a listener, which will be called back with DeviceDataUpdateAvailable
   // whenever new data is available. Returns the singleton instance.
-  static DeviceDataProvider *Register(ListenerInterface *listener) {
+  static DeviceDataProvider* Register(ListenerInterface* listener) {
+    // TODO(joth): The following comment applied when this was used in Gears;
+    // revisit if this is still needed once usage is established in Chromium.
     // We protect against Register and Unregister being called asynchronously
     // from different threads. This is the case when a device data provider is
     // used by a NetworkLocationProvider object. Register is always called from
     // the JavaScript thread. Unregister is called when NetworkLocationProvider
     // objects are destructed, which happens asynchronously once the
     // NetworkLocationProvider HTTP request has completed.
-    MutexLock mutex(&instance_mutex_);
+    AutoLock mutex(instance_mutex_);
     if (!instance_) {
       instance_ = new DeviceDataProvider();
     }
     assert(instance_);
     instance_->Ref();
     instance_->AddListener(listener);
     return instance_;
   }
 
   // Removes a listener. If this is the last listener, deletes the singleton
   // instance. Return value indicates success.
-  static bool Unregister(ListenerInterface *listener) {
-    MutexLock mutex(&instance_mutex_);
+  static bool Unregister(ListenerInterface* listener) {
+    AutoLock mutex(instance_mutex_);
     if (!instance_->RemoveListener(listener)) {
       return false;
     }
     if (instance_->Unref()) {
       delete instance_;
       instance_ = NULL;
     }
     return true;
   }
 
   // Provides whatever data the provider has, which may be nothing. Return
   // value indicates whether this is all the data the provider could ever
   // obtain.
-  bool GetData(DataType *data) {
+  bool GetData(DataType* data) {
     return impl_->GetData(data);
   }
 
  private:
   // Private constructor and destructor, callers access singleton through
   // Register and Unregister.
-  DeviceDataProvider() {
+  DeviceDataProvider() : count_(0) {
     assert(factory_function_);
     impl_.reset((*factory_function_)());
     impl_->SetContainer(this);
+    bool started = impl_->StartDataProvider();
+    assert(started);
   }
   virtual ~DeviceDataProvider() {}
 
   void Ref() {
-    count_.Ref();
+    ++count_;
   }
   // Returns true when the ref count transitions from 1 to 0.
   bool Unref() {
-    return count_.Unref();
+    --count_;
+    return count_ == 0;
   }
 
-  void AddListener(ListenerInterface *listener) {
+  void AddListener(ListenerInterface* listener) {
     impl_->AddListener(listener);
   }
 
-  bool RemoveListener(ListenerInterface *listener) {
+  bool RemoveListener(ListenerInterface* listener) {
     return impl_->RemoveListener(listener);
   }
 
-  static DeviceDataProviderImplBase<DataType> *DefaultFactoryFunction();
+  static DeviceDataProviderImplBase<DataType>* DefaultFactoryFunction();
 
   // The singleton instance of this class and its mutex.
-  static DeviceDataProvider *instance_;
-  static Mutex instance_mutex_;
+  static DeviceDataProvider* instance_;
+  static Lock instance_mutex_;
 
   // The factory function used to create the singleton instance.
   static ImplFactoryFunction factory_function_;
 
   // The internal implementation.
   scoped_ptr<DeviceDataProviderImplBase<DataType> > impl_;
 
-  RefCount count_;
+  int count_;
 
   DISALLOW_EVIL_CONSTRUCTORS(DeviceDataProvider);
 };
 
 // static
 template<typename DataType>
-Mutex DeviceDataProvider<DataType>::instance_mutex_;
+Lock DeviceDataProvider<DataType>::instance_mutex_;
 
 // static
 template<typename DataType>
-DeviceDataProvider<DataType> *DeviceDataProvider<DataType>::instance_ =
-    NULL;
+DeviceDataProvider<DataType>* DeviceDataProvider<DataType>::instance_ = NULL;
 
 // static
 template<typename DataType>
 typename DeviceDataProvider<DataType>::ImplFactoryFunction
     DeviceDataProvider<DataType>::factory_function_ = DefaultFactoryFunction;
 
 typedef DeviceDataProvider<RadioData> RadioDataProvider;
 typedef DeviceDataProvider<WifiData> WifiDataProvider;
 
-#endif  // GEARS_GEOLOCATION_DEVICE_DATA_PROVIDER_H__
+#endif  // CHROME_BROWSER_GEOLOCATION_DEVICE_DATA_PROVIDER_H_