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) << "ConfugureService requies GUID and Type to be defined";

[pneubeck (no reviews), 2013/05/07 08:46:39]

ConfugureService -> ConfigureService

[stevenjb, 2013/05/08 01:57:22]

Done.

     // 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 79 matching lines @@
   if (GetListProperty(flimflam::kDevicesProperty)->Remove(
       device_path_value, NULL)) {
     CallNotifyObserversPropertyChanged(flimflam::kDevicesProperty, 0);
   }
 }
 
 void ShillManagerClientStub::ClearDevices() {
   stub_properties_.Remove(flimflam::kDevicesProperty, NULL);
 }
 
-void ShillManagerClientStub::ClearServices() {
+void ShillManagerClientStub::ClearManagerServices() {
   stub_properties_.Remove(flimflam::kServicesProperty, NULL);
   stub_properties_.Remove(flimflam::kServiceWatchListProperty, NULL);
 }
 
-void ShillManagerClientStub::AddService(const std::string& service_path,
-                                        bool add_to_watch_list) {
+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::AddServiceAtIndex(const std::string& service_path,
-                                               size_t index,
-                                               bool add_to_watch_list) {
+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* 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);
+  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::RemoveService(const std::string& 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);
   }
@@ skipping 229 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