Deprecate ShillNetworkClient and add GeolocationHandler

chromeos/dbus/shill_manager_client.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 "chromeos/dbus/shill_manager_client.h"
 
 #include "base/bind.h"
 #include "base/chromeos/chromeos_version.h"
 #include "base/message_loop.h"
 #include "base/values.h"
@@ skipping 64 matching lines @@
                                  flimflam::kGetPropertiesFunction);
     helper_.CallDictionaryValueMethod(&method_call, callback);
   }
 
   virtual base::DictionaryValue* CallGetPropertiesAndBlock() OVERRIDE {
     dbus::MethodCall method_call(flimflam::kFlimflamManagerInterface,
                                  flimflam::kGetPropertiesFunction);
     return helper_.CallDictionaryValueMethodAndBlock(&method_call);
   }
 
+  virtual void GetNetworksForGeolocation(
+      const DictionaryValueCallback& callback) OVERRIDE {
+    dbus::MethodCall method_call(flimflam::kFlimflamManagerInterface,
+                                 shill::kGetNetworksForGeolocation);
+    helper_.CallDictionaryValueMethod(&method_call, callback);
+  }
+
   virtual void SetProperty(const std::string& name,
                            const base::Value& value,
                            const base::Closure& callback,
                            const ErrorCallback& error_callback) OVERRIDE {
     dbus::MethodCall method_call(flimflam::kFlimflamManagerInterface,
                                  flimflam::kSetPropertyFunction);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(name);
     ShillClientHelper::AppendValueDataAsVariant(&writer, value);
     helper_.CallVoidMethodWithErrorCallback(&method_call,
@@ skipping 119 matching lines @@
         FROM_HERE, base::Bind(
             &ShillManagerClientStubImpl::PassStubProperties,
             weak_ptr_factory_.GetWeakPtr(),
             callback));
   }
 
   virtual base::DictionaryValue* CallGetPropertiesAndBlock() OVERRIDE {
     return stub_properties_.DeepCopy();
   }
 
+  virtual void GetNetworksForGeolocation(
+      const DictionaryValueCallback& callback) OVERRIDE {
+    if (callback.is_null())
+      return;
+    MessageLoop::current()->PostTask(
+        FROM_HERE, base::Bind(
+            &ShillManagerClientStubImpl::PassStubGeoNetworks,
+            weak_ptr_factory_.GetWeakPtr(),
+            callback));
+  }
+
   virtual void SetProperty(const std::string& name,
                            const base::Value& value,
                            const base::Closure& callback,
                            const ErrorCallback& error_callback) OVERRIDE {
     stub_properties_.Set(name, value.DeepCopy());
     if (callback.is_null())
       return;
     MessageLoop::current()->PostTask(FROM_HERE, callback);
   }
 
@@ skipping 87 matching lines @@
   }
 
   virtual void RemoveDevice(const std::string& device_path) OVERRIDE {
     base::StringValue device_path_value(device_path);
     if (GetListProperty(flimflam::kDevicesProperty)->Remove(
             device_path_value, NULL)) {
       CallNotifyObserversPropertyChanged(flimflam::kDevicesProperty, 0);
     }
   }
 
+  virtual void ResetDevices() OVERRIDE {
+    stub_properties_.Remove(flimflam::kDevicesProperty, NULL);
+  }
+
   virtual void AddService(const std::string& service_path,
                           bool add_to_watch_list) OVERRIDE {
     if (GetListProperty(flimflam::kServicesProperty)->AppendIfNotPresent(
             base::Value::CreateStringValue(service_path))) {
       CallNotifyObserversPropertyChanged(flimflam::kServicesProperty, 0);
     }
     if (add_to_watch_list)
       AddServiceToWatchList(service_path);
   }
 
@@ skipping 53 matching lines @@
             type_value, NULL)) {
       CallNotifyObserversPropertyChanged(
           flimflam::kEnabledTechnologiesProperty, 0);
     }
   }
 
   virtual void ClearProperties() OVERRIDE {
     stub_properties_.Clear();
   }
 
+  virtual void AddGeoNetwork(const std::string& technology,
+                             const base::DictionaryValue& network) OVERRIDE {
+    base::ListValue* list_value = NULL;
+    if (!stub_geo_networks_.GetListWithoutPathExpansion(
+            technology, &list_value)) {
+      list_value = new base::ListValue;
+      stub_geo_networks_.Set(technology, list_value);
+    }
+    list_value->Append(network.DeepCopy());
+  }
+
  private:
   void AddServiceToWatchList(const std::string& service_path) {
     if (GetListProperty(
             flimflam::kServiceWatchListProperty)->AppendIfNotPresent(
                 base::Value::CreateStringValue(service_path))) {
       CallNotifyObserversPropertyChanged(
           flimflam::kServiceWatchListProperty, 0);
     }
   }
 
@@ skipping 11 matching lines @@
     // Stub Technologies
     AddTechnology(flimflam::kTypeEthernet, true);
     AddTechnology(flimflam::kTypeWifi, true);
     AddTechnology(flimflam::kTypeCellular, true);
   }
 
   void PassStubProperties(const DictionaryValueCallback& callback) const {
     callback.Run(DBUS_METHOD_CALL_SUCCESS, stub_properties_);
   }
 
+  void PassStubGeoNetworks(const DictionaryValueCallback& callback) const {
+    callback.Run(DBUS_METHOD_CALL_SUCCESS, stub_geo_networks_);
+  }
+
   void CallNotifyObserversPropertyChanged(const std::string& property,
                                           int delay_ms) {
     // Avoid unnecessary delayed task if we have no observers (e.g. during
     // initial setup).
     if (observer_list_.size() == 0)
       return;
     MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&ShillManagerClientStubImpl::NotifyObserversPropertyChanged,
                    weak_ptr_factory_.GetWeakPtr(),
@@ skipping 15 matching lines @@
   base::ListValue* GetListProperty(const std::string& property) {
     base::ListValue* list_property = NULL;
     if (!stub_properties_.GetListWithoutPathExpansion(
             property, &list_property)) {
       list_property = new base::ListValue;
       stub_properties_.Set(property, list_property);
     }
     return list_property;
   }
 
+  // Dictionary of property name -> property value
   base::DictionaryValue stub_properties_;
+  // Dictionary of technology -> list of property dictionaries
+  base::DictionaryValue stub_geo_networks_;
+
   ObserverList<ShillPropertyChangedObserver> observer_list_;
 
   // Note: This should remain the last member so it'll be destroyed and
   // invalidate its weak pointers before any other members are destroyed.
   base::WeakPtrFactory<ShillManagerClientStubImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ShillManagerClientStubImpl);
 };
 
 }  // namespace
 
 ShillManagerClient::ShillManagerClient() {}
 
 ShillManagerClient::~ShillManagerClient() {}
 
 // static
 ShillManagerClient* ShillManagerClient::Create(
     DBusClientImplementationType type,
     dbus::Bus* bus) {
   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
     return new ShillManagerClientImpl(bus);
   DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
   return new ShillManagerClientStubImpl();
 }
 
 }  // namespace chromeos