Using the new Network*Handlers in networkingPrivate Extension API.

chromeos/dbus/shill_service_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_service_client_stub.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
@@ skipping 60 matching lines @@
 }
 
 void ShillServiceClientStub::SetProperty(const dbus::ObjectPath& service_path,
                                          const std::string& name,
                                          const base::Value& value,
                                          const base::Closure& callback,
                                          const ErrorCallback& error_callback) {
   base::DictionaryValue* dict = NULL;
   if (!stub_services_.GetDictionaryWithoutPathExpansion(
       service_path.value(), &dict)) {
-    error_callback.Run("StubError", "Service not found");
+    error_callback.Run("Error.InvalidService", "Invalid Service");
     return;
   }
   if (name == flimflam::kStateProperty) {
     // If we connect to a service, then we move it to the top of the list in
     // the manager client.
     std::string state;
     if (value.GetAsString(&state) && state == flimflam::kStateOnline) {
       ShillManagerClient* manager_client =
           DBusThreadManager::Get()->GetShillManagerClient();
       manager_client->GetTestInterface()->RemoveService(service_path.value());
@@ skipping 12 matching lines @@
 }
 
 void ShillServiceClientStub::ClearProperty(
     const dbus::ObjectPath& service_path,
     const std::string& name,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   base::DictionaryValue* dict = NULL;
   if (!stub_services_.GetDictionaryWithoutPathExpansion(
       service_path.value(), &dict)) {
-    error_callback.Run("StubError", "Service not found");
+    error_callback.Run("Error.InvalidService", "Invalid Service");
     return;
   }
   dict->Remove(name, NULL);
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&ShillServiceClientStub::NotifyObserversPropertyChanged,
                  weak_ptr_factory_.GetWeakPtr(), service_path, name));
   if (callback.is_null())
     return;
   MessageLoop::current()->PostTask(FROM_HERE, callback);
 }
 
 void ShillServiceClientStub::ClearProperties(
     const dbus::ObjectPath& service_path,
     const std::vector<std::string>& names,
     const ListValueCallback& callback,
     const ErrorCallback& error_callback) {
   base::DictionaryValue* dict = NULL;
   if (!stub_services_.GetDictionaryWithoutPathExpansion(
       service_path.value(), &dict)) {
-    error_callback.Run("StubError", "Service not found");
+    error_callback.Run("Error.InvalidService", "Invalid Service");
     return;
   }
   scoped_ptr<base::ListValue> results(new base::ListValue);
   for (std::vector<std::string>::const_iterator iter = names.begin();
       iter != names.end(); ++iter) {
     dict->Remove(*iter, NULL);
     results->AppendBoolean(true);
   }
   for (std::vector<std::string>::const_iterator iter = names.begin();
       iter != names.end(); ++iter) {
@@ skipping 36 matching lines @@
                  online_value,
                  base::Bind(&base::DoNothing),
                  error_callback),
                  base::TimeDelta::FromSeconds(kConnectDelaySeconds));
   callback.Run();
 }
 
 void ShillServiceClientStub::Disconnect(const dbus::ObjectPath& service_path,
                                         const base::Closure& callback,
                                         const ErrorCallback& error_callback) {
+  base::Value* service;
+  if (!stub_services_.Get(service_path.value(), &service)) {
+    error_callback.Run("Error.InvalidService", "Invalid Service");
+    return;
+  }
   // Set Idle after a delay
   const int kConnectDelaySeconds = 2;
   base::StringValue idle_value(flimflam::kStateIdle);
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&ShillServiceClientStub::SetProperty,
                  weak_ptr_factory_.GetWeakPtr(),
                  service_path,
                  flimflam::kStateProperty,
                  idle_value,
@@ skipping 100 matching lines @@
     AddService("stub_ethernet", "eth0",
                flimflam::kTypeEthernet,
                flimflam::kStateOnline,
                add_to_watchlist);
   }
 
   AddService("stub_wifi1", "wifi1",
              flimflam::kTypeWifi,
              flimflam::kStateOnline,
              add_to_watchlist);
+  SetServiceProperty("stub_wifi1",
+                     flimflam::kSecurityProperty,
+                     base::StringValue(flimflam::kSecurityWep));
 
   AddService("stub_wifi2", "wifi2_PSK",
              flimflam::kTypeWifi,
              flimflam::kStateIdle,
              add_to_watchlist);
-  base::StringValue psk_value(flimflam::kSecurityPsk);
   SetServiceProperty("stub_wifi2",
                      flimflam::kSecurityProperty,
-                     psk_value);
+                     base::StringValue(flimflam::kSecurityPsk));
   base::FundamentalValue strength_value(80);
   SetServiceProperty("stub_wifi2",
                      flimflam::kSignalStrengthProperty,
                      strength_value);
 
   AddService("stub_cellular1", "cellular1",
              flimflam::kTypeCellular,
              flimflam::kStateIdle,
              add_to_watchlist);
   base::StringValue technology_value(flimflam::kNetworkTechnologyGsm);
   SetServiceProperty("stub_cellular1",
                      flimflam::kNetworkTechnologyProperty,
                      technology_value);
-  base::StringValue activation_value(flimflam::kActivationStateActivated);
   SetServiceProperty("stub_cellular1",
                      flimflam::kActivationStateProperty,
-                     activation_value);
+                     base::StringValue(flimflam::kActivationStateNotActivated));
+  SetServiceProperty("stub_cellular1",
+                     flimflam::kRoamingStateProperty,
+                     base::StringValue(flimflam::kRoamingStateHome));

[stevenjb, 2013/03/05 17:59:18]

These changes are fine, but don't rely on them for tests. Instead, call
ClearServices() then set up the expectations for that test. See unittest changes
in https://codereview.chromium.org/12387065/

[pneubeck (no reviews), 2013/03/07 15:53:02]

Done after that CL was committed.

 }
 
 void ShillServiceClientStub::PassStubServiceProperties(
     const dbus::ObjectPath& service_path,
     const DictionaryValueCallback& callback) {
   base::DictionaryValue* dict = NULL;
   if (!stub_services_.GetDictionaryWithoutPathExpansion(
       service_path.value(), &dict)) {
     base::DictionaryValue empty_dictionary;
     callback.Run(DBUS_METHOD_CALL_FAILURE, empty_dictionary);
@@ skipping 38 matching lines @@
   std::map<dbus::ObjectPath, PropertyObserverList*>::iterator iter =
       observer_list_.find(device_path);
   if (iter != observer_list_.end())
     return *(iter->second);
   PropertyObserverList* observer_list = new PropertyObserverList();
   observer_list_[device_path] = observer_list;
   return *observer_list;
 }
 
 }  // namespace chromeos