Add NetworkConnectionHandler class

chromeos/dbus/shill_manager_client_stub.cc

 // Copyright (c) 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 "chromeos/dbus/shill_manager_client_stub.h"
 
 #include "base/bind.h"
 #include "base/chromeos/chromeos_version.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
@@ skipping 21 matching lines @@
   explicit ValueEquals(const Value* first) : first_(first) {}
   bool operator()(const Value* second) const {
     return first_->Equals(second);
   }
   const Value* first_;
 };
 
 }  // namespace
 
 ShillManagerClientStub::ShillManagerClientStub()
-: weak_ptr_factory_(this) {
+    : weak_ptr_factory_(this) {
   SetDefaultProperties();
 }
 
 ShillManagerClientStub::~ShillManagerClientStub() {}
 
 // ShillManagerClient overrides.
 
 void ShillManagerClientStub::AddPropertyChangedObserver(
     ShillPropertyChangedObserver* observer) {
   observer_list_.AddObserver(observer);
@@ skipping 120 matching lines @@
         base::TimeDelta::FromSeconds(kDisableTechnologyDelaySeconds));
   } else {
     SetTechnologyEnabled(type, callback, false);
   }
 }
 
 void ShillManagerClientStub::ConfigureService(
     const base::DictionaryValue& properties,
     const ObjectPathCallback& callback,
     const ErrorCallback& error_callback) {
-  if (callback.is_null())
-    return;
-
   ShillServiceClient::TestInterface* service_client =
       DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface();
 
   std::string guid;
   std::string type;
   if (!properties.GetString(flimflam::kGuidProperty, &guid) ||
       !properties.GetString(flimflam::kTypeProperty, &type)) {
+    LOG(ERROR) << "ConfigureService requies GUID and Type to be defined";
     // If the properties aren't filled out completely, then just return an empty
     // object path.
-    MessageLoop::current()->PostTask(
-        FROM_HERE, base::Bind(callback, dbus::ObjectPath()));
+    if (!callback.is_null()) {
+      MessageLoop::current()->PostTask(
+          FROM_HERE, base::Bind(callback, dbus::ObjectPath()));
+    }
     return;
   }
 
   // For the purposes of this stub, we're going to assume that the GUID property
   // is set to the service path because we don't want to re-implement Shill's
   // property matching magic here.
   std::string service_path = guid;
 
   std::string ipconfig_path;
   properties.GetString(shill::kIPConfigProperty, &ipconfig_path);
@@ skipping 17 matching lines @@
   // Now set all the properties.
   for (base::DictionaryValue::Iterator iter(*merged_properties);
        !iter.IsAtEnd(); iter.Advance()) {
     service_client->SetServiceProperty(service_path, iter.key(), iter.value());
   }
 
   ShillProfileClient::TestInterface* profile_test =
       DBusThreadManager::Get()->GetShillProfileClient()->GetTestInterface();
   profile_test->AddService(service_path);
 
-  MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(callback, dbus::ObjectPath(service_path)));
+  if (!callback.is_null()) {
+    MessageLoop::current()->PostTask(
+        FROM_HERE, base::Bind(callback, dbus::ObjectPath(service_path)));
+  }
 }
 
 void ShillManagerClientStub::ConfigureServiceForProfile(
     const dbus::ObjectPath& profile_path,
     const base::DictionaryValue& properties,
     const ObjectPathCallback& callback,
     const ErrorCallback& error_callback) {
   std::string profile_property;
   properties.GetStringWithoutPathExpansion(flimflam::kProfileProperty,
                                            &profile_property);
@@ skipping 67 matching lines @@
       device_path_value, NULL)) {
     CallNotifyObserversPropertyChanged(flimflam::kDevicesProperty, 0);
   }
 }
 
 void ShillManagerClientStub::ClearDevices() {
   GetListProperty(flimflam::kDevicesProperty)->Clear();
   CallNotifyObserversPropertyChanged(flimflam::kDevicesProperty, 0);
 }
 
-void ShillManagerClientStub::ClearServices() {
-  GetListProperty(flimflam::kServicesProperty)->Clear();
-  GetListProperty(flimflam::kServiceWatchListProperty)->Clear();
-  CallNotifyObserversPropertyChanged(flimflam::kServicesProperty, 0);
-  CallNotifyObserversPropertyChanged(flimflam::kServiceWatchListProperty, 0);
-}
-
-void ShillManagerClientStub::AddService(const std::string& service_path,
-                                        bool add_to_watch_list) {
-  if (GetListProperty(flimflam::kServicesProperty)->AppendIfNotPresent(
-      base::Value::CreateStringValue(service_path))) {
-    CallNotifyObserversPropertyChanged(flimflam::kServicesProperty, 0);
-  }
-  if (add_to_watch_list)
-    AddServiceToWatchList(service_path);
-}
-
-void ShillManagerClientStub::AddServiceAtIndex(const std::string& service_path,
-                                               size_t index,
-                                               bool add_to_watch_list) {
-  base::StringValue path_value(service_path);
-  base::ListValue* service_list =
-      GetListProperty(flimflam::kServicesProperty);
-  base::ListValue::iterator iter =
-      std::find_if(service_list->begin(), service_list->end(),
-                   ValueEquals(&path_value));
-  if (iter != service_list->end())
-    service_list->Erase(iter, NULL);
-  service_list->Insert(index, path_value.DeepCopy());
-  CallNotifyObserversPropertyChanged(flimflam::kServicesProperty, 0);
-  if (add_to_watch_list)
-    AddServiceToWatchList(service_path);
-}
-
-void ShillManagerClientStub::RemoveService(const std::string& service_path) {
-  base::StringValue service_path_value(service_path);
-  if (GetListProperty(flimflam::kServicesProperty)->Remove(
-      service_path_value, NULL)) {
-    CallNotifyObserversPropertyChanged(flimflam::kServicesProperty, 0);
-  }
-  if (GetListProperty(flimflam::kServiceWatchListProperty)->Remove(
-      service_path_value, NULL)) {
-    CallNotifyObserversPropertyChanged(
-        flimflam::kServiceWatchListProperty, 0);
-  }
-}
-
 void ShillManagerClientStub::AddTechnology(const std::string& type,
                                            bool enabled) {
   if (GetListProperty(flimflam::kAvailableTechnologiesProperty)->
       AppendIfNotPresent(base::Value::CreateStringValue(type))) {
     CallNotifyObserversPropertyChanged(
         flimflam::kAvailableTechnologiesProperty, 0);
   }
   if (enabled &&
       GetListProperty(flimflam::kEnabledTechnologiesProperty)->
       AppendIfNotPresent(base::Value::CreateStringValue(type))) {
@@ skipping 30 matching lines @@
       CallNotifyObserversPropertyChanged(
           shill::kUninitializedTechnologiesProperty, 0);
     }
   }
 }
 
 void ShillManagerClientStub::ClearProperties() {
   stub_properties_.Clear();
 }
 
+void ShillManagerClientStub::MoveServiceToIndex(
+    const std::string& service_path,
+    size_t index,
+    bool add_to_watch_list) {
+  base::StringValue path_value(service_path);
+  base::ListValue* service_list = GetListProperty(flimflam::kServicesProperty);
+  base::ListValue::iterator iter =
+      std::find_if(service_list->begin(), service_list->end(),
+                   ValueEquals(&path_value));
+  if (iter == service_list->end()) {
+    LOG(ERROR) << "Service not found to move: " << service_path;
+    return;
+  }
+  service_list->Erase(iter, NULL);
+  service_list->Insert(index, path_value.DeepCopy());
+  CallNotifyObserversPropertyChanged(flimflam::kServicesProperty, 0);
+  if (add_to_watch_list)
+    AddServiceToWatchList(service_path);
+}
+
+void ShillManagerClientStub::AddManagerService(const std::string& service_path,
+                                               bool add_to_watch_list) {
+  if (GetListProperty(flimflam::kServicesProperty)->AppendIfNotPresent(
+      base::Value::CreateStringValue(service_path))) {
+    CallNotifyObserversPropertyChanged(flimflam::kServicesProperty, 0);
+  }
+  if (add_to_watch_list)
+    AddServiceToWatchList(service_path);
+}
+
+void ShillManagerClientStub::RemoveManagerService(
+    const std::string& service_path) {
+  base::StringValue service_path_value(service_path);
+  if (GetListProperty(flimflam::kServicesProperty)->Remove(
+      service_path_value, NULL)) {
+    CallNotifyObserversPropertyChanged(flimflam::kServicesProperty, 0);
+  }
+  if (GetListProperty(flimflam::kServiceWatchListProperty)->Remove(
+      service_path_value, NULL)) {
+    CallNotifyObserversPropertyChanged(
+        flimflam::kServiceWatchListProperty, 0);
+  }
+}
+
+void ShillManagerClientStub::ClearManagerServices() {
+  GetListProperty(flimflam::kServicesProperty)->Clear();
+  GetListProperty(flimflam::kServiceWatchListProperty)->Clear();
+  CallNotifyObserversPropertyChanged(flimflam::kServicesProperty, 0);
+  CallNotifyObserversPropertyChanged(flimflam::kServiceWatchListProperty, 0);
+}
+
 void ShillManagerClientStub::AddGeoNetwork(
     const std::string& technology,
     const base::DictionaryValue& network) {
   base::ListValue* list_value = NULL;
   if (!stub_geo_networks_.GetListWithoutPathExpansion(
       technology, &list_value)) {
     list_value = new base::ListValue;
     stub_geo_networks_.SetWithoutPathExpansion(technology, list_value);
   }
   list_value->Append(network.DeepCopy());
 }
 
 void ShillManagerClientStub::AddProfile(const std::string& profile_path) {
   const char* key = flimflam::kProfilesProperty;
   if (GetListProperty(key)->AppendIfNotPresent(
           new base::StringValue(profile_path))) {
     CallNotifyObserversPropertyChanged(key, 0);
   }
 }
 
 void ShillManagerClientStub::AddServiceToWatchList(
     const std::string& service_path) {
-  if (GetListProperty(
-      flimflam::kServiceWatchListProperty)->AppendIfNotPresent(
-          base::Value::CreateStringValue(service_path))) {
-    CallNotifyObserversPropertyChanged(
-        flimflam::kServiceWatchListProperty, 0);
-  }
+  // Remove and insert the service, moving it to the front of the watch list.
+  GetListProperty(flimflam::kServiceWatchListProperty)->Remove(
+      base::StringValue(service_path), NULL);
+  GetListProperty(flimflam::kServiceWatchListProperty)->Insert(
+      0, base::Value::CreateStringValue(service_path));
+  CallNotifyObserversPropertyChanged(
+      flimflam::kServiceWatchListProperty, 0);
 }
 
 void ShillManagerClientStub::SetDefaultProperties() {
   // Stub Technologies.
   if (!CommandLine::ForCurrentProcess()->HasSwitch(
           chromeos::switches::kDisableStubEthernet)) {
     AddTechnology(flimflam::kTypeEthernet, true);
   }
   AddTechnology(flimflam::kTypeWifi, true);
   AddTechnology(flimflam::kTypeCellular, true);
@@ skipping 14 matching lines @@
 }
 
 void ShillManagerClientStub::PassStubGeoNetworks(
     const DictionaryValueCallback& callback) const {
   callback.Run(DBUS_METHOD_CALL_SUCCESS, stub_geo_networks_);
 }
 
 void ShillManagerClientStub::CallNotifyObserversPropertyChanged(
     const std::string& property,
     int delay_ms) {
-  // Don't actually delay unless we're interactive.
-  if (!CommandLine::ForCurrentProcess()->HasSwitch(
-      chromeos::switches::kEnableStubInteractive)) {
-    delay_ms = 0;
-  }
-
   // Avoid unnecessary delayed task if we have no observers (e.g. during
   // initial setup).
   if (observer_list_.size() == 0)
     return;
   if (!CommandLine::ForCurrentProcess()->HasSwitch(
           chromeos::switches::kEnableStubInteractive)) {
     delay_ms = 0;
   }
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
@@ skipping 107 matching lines @@
                           base::FundamentalValue(false));
   }
   CallNotifyObserversPropertyChanged(flimflam::kServicesProperty, 0);
   CallNotifyObserversPropertyChanged(flimflam::kServiceWatchListProperty,
                                      0);
   if (!callback.is_null())
     MessageLoop::current()->PostTask(FROM_HERE, callback);
 }
 
 }  // namespace chromeos