Port the gears geolocation network provider to Chromium...

chrome/browser/geolocation/device_data_provider.h

 // 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.
 //
@@ skipping 106 matching lines @@
   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) {}
-
+  // MAC address, formatted as per MacAddressAsString16.
   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
   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 {
     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;
-
+  bool DiffersSignificantly(const WifiData& other) const {
+    // More than 4 or 50% of access points added or removed is significant.
+    static const size_t kMinChangedAccessPoints = 4;
+    const size_t min_ap_count =
+        std::min(access_point_data.size(), other.access_point_data.size());
+    const size_t max_ap_count =
+        std::max(access_point_data.size(), other.access_point_data.size());
+    const size_t difference_threadhold = std::min(kMinChangedAccessPoints,
+                                                  min_ap_count / 2);
+    if (max_ap_count > min_ap_count + difference_threadhold)
+      return true;
     // Compute size of interesction of old and new sets.
     size_t num_common = 0;
     for (AccessPointDataSet::const_iterator iter = access_point_data.begin();
          iter != access_point_data.end();
          iter++) {
       if (other.access_point_data.find(*iter) !=
           other.access_point_data.end()) {
         ++num_common;
       }
     }
-    assert(num_common <= access_point_data.size());
-    assert(num_common <= other.access_point_data.size());
+    DCHECK(num_common <= min_ap_count);
 
     // Test how many have changed.
-    size_t added_or_removed = std::max(
-        other.access_point_data.size() - num_common,
-        access_point_data.size() - num_common);
-    return added_or_removed >=
-        std::min(kMinChangedAccessPoints, access_point_data.size() / 2);
+    return max_ap_count > num_common + difference_threadhold;
   }
 
   // Store access points as a set, sorted by MAC address. This allows quick
   // comparison of sets for detecting changes and for caching.
   typedef std::set<AccessPointData, AccessPointDataLess> AccessPointDataSet;
   AccessPointDataSet access_point_data;
 };
 
 template<typename DataType>
 class DeviceDataProvider;
@@ skipping 103 matching lines @@
     // 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.
     AutoLock mutex(instance_mutex_);
     if (!instance_) {
       instance_ = new DeviceDataProvider();
     }
-    assert(instance_);
+    DCHECK(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) {
     AutoLock mutex(instance_mutex_);
     if (!instance_->RemoveListener(listener)) {
@@ skipping 10 matching lines @@
   // value indicates whether this is all the data the provider could ever
   // obtain.
   bool GetData(DataType* data) {
     return impl_->GetData(data);
   }
 
  private:
   // Private constructor and destructor, callers access singleton through
   // Register and Unregister.
   DeviceDataProvider() : count_(0) {
-    assert(factory_function_);
+    DCHECK(factory_function_);
     impl_.reset((*factory_function_)());
     impl_->SetContainer(this);
     bool started = impl_->StartDataProvider();
-    assert(started);
+    DCHECK(started);
   }
   virtual ~DeviceDataProvider() {}
 
   void Ref() {
     ++count_;
   }
   // Returns true when the ref count transitions from 1 to 0.
   bool Unref() {
     --count_;
     return count_ == 0;
@@ skipping 34 matching lines @@
 
 // static
 template<typename DataType>
 typename DeviceDataProvider<DataType>::ImplFactoryFunction
     DeviceDataProvider<DataType>::factory_function_ = DefaultFactoryFunction;
 
 typedef DeviceDataProvider<RadioData> RadioDataProvider;
 typedef DeviceDataProvider<WifiData> WifiDataProvider;
 
 #endif  // CHROME_BROWSER_GEOLOCATION_DEVICE_DATA_PROVIDER_H_