Rely on Service.Visible instead of Manager.Services

chromeos/dbus/fake_shill_service_client.cc

 // Copyright 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/fake_shill_service_client.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
@@ skipping 290 matching lines @@
 ShillServiceClient::TestInterface* FakeShillServiceClient::GetTestInterface() {
   return this;
 }
 
 // ShillServiceClient::TestInterface overrides.
 
 void FakeShillServiceClient::AddService(const std::string& service_path,
                                         const std::string& name,
                                         const std::string& type,
                                         const std::string& state,
-                                        bool add_to_visible_list) {
+                                        bool visible) {
   AddServiceWithIPConfig(service_path, "" /* guid */, name,
                          type, state, "" /* ipconfig_path */,
-                         add_to_visible_list);
+                         visible);
 }
 
 void FakeShillServiceClient::AddServiceWithIPConfig(
     const std::string& service_path,
     const std::string& guid,
     const std::string& name,
     const std::string& type,
     const std::string& state,
     const std::string& ipconfig_path,
-    bool add_to_visible_list) {
-  std::string device_path =
-      DBusThreadManager::Get()->GetShillDeviceClient()->GetTestInterface()->
-      GetDevicePathForType(type);
+    bool visible) {
+  base::DictionaryValue* properties = SetServiceProperties(
+      service_path, guid, name, type, state, visible);
 
+  std::string profile_path;
+  if (properties->GetStringWithoutPathExpansion(shill::kProfileProperty,
+                                                &profile_path) &&
+      !profile_path.empty()) {
+    DBusThreadManager::Get()->GetShillProfileClient()->GetTestInterface()->
+        UpdateService(profile_path, service_path);
+  }
+
+  if (!ipconfig_path.empty()) {
+    properties->SetWithoutPathExpansion(
+        shill::kIPConfigProperty,
+        new base::StringValue(ipconfig_path));
+  }
+
+  DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface()->
+      AddManagerService(service_path, true);
+}
+
+
+base::DictionaryValue* FakeShillServiceClient::SetServiceProperties(
+    const std::string& service_path,
+    const std::string& guid,
+    const std::string& name,
+    const std::string& type,
+    const std::string& state,
+    bool visible) {
   base::DictionaryValue* properties =
       GetModifiableServiceProperties(service_path, true);
   connect_behavior_.erase(service_path);
 
   std::string profile_path;
   base::DictionaryValue profile_properties;
   if (DBusThreadManager::Get()->GetShillProfileClient()->GetTestInterface()->
       GetService(service_path, &profile_path, &profile_properties)) {
     properties->SetWithoutPathExpansion(
         shill::kProfileProperty,
         new base::StringValue(profile_path));
   }
 
   // If |guid| is provided, set Service.GUID to that. Otherwise if a GUID is
   // stored in a profile entry, use that. Otherwise leave it blank. Shill does
   // not enforce a valid guid, we do that at the NetworkStateHandler layer.
   std::string guid_to_set = guid;
   if (guid_to_set.empty()) {
     profile_properties.GetStringWithoutPathExpansion(
         shill::kGuidProperty, &guid_to_set);
   }
   if (!guid_to_set.empty()) {
     properties->SetWithoutPathExpansion(shill::kGuidProperty,
                                         new base::StringValue(guid_to_set));
   }
   shill_property_util::SetSSID(name, properties);
   properties->SetWithoutPathExpansion(
       shill::kNameProperty,
       new base::StringValue(name));
+  std::string device_path =
+      DBusThreadManager::Get()->GetShillDeviceClient()->GetTestInterface()->
+      GetDevicePathForType(type);
   properties->SetWithoutPathExpansion(
       shill::kDeviceProperty,
       new base::StringValue(device_path));
   properties->SetWithoutPathExpansion(
       shill::kTypeProperty,
       new base::StringValue(type));
   properties->SetWithoutPathExpansion(
       shill::kStateProperty,
       new base::StringValue(state));
   properties->SetWithoutPathExpansion(
       shill::kVisibleProperty,
-      new base::FundamentalValue(add_to_visible_list));
-  if (!ipconfig_path.empty()) {
-    properties->SetWithoutPathExpansion(
-        shill::kIPConfigProperty,
-        new base::StringValue(ipconfig_path));
-  }
+      new base::FundamentalValue(visible));
   if (type == shill::kTypeWifi) {
     properties->SetWithoutPathExpansion(
         shill::kSecurityProperty,
         new base::StringValue(shill::kSecurityNone));
   }
-
-  if (!profile_path.empty()) {
-    DBusThreadManager::Get()->GetShillProfileClient()->GetTestInterface()->
-        UpdateService(profile_path, service_path);
-  }
-
-  DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface()->
-      AddManagerService(service_path);
+  return properties;
 }
 
 void FakeShillServiceClient::RemoveService(const std::string& service_path) {
   stub_services_.RemoveWithoutPathExpansion(service_path, NULL);
   connect_behavior_.erase(service_path);
   DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface()->
       RemoveManagerService(service_path);
 }
 
 bool FakeShillServiceClient::SetServiceProperty(const std::string& service_path,
@@ skipping 211 matching lines @@
             base::StringValue(shill::kErrorBadPassphrase)));
   } else {
     // Set Online.
     SetServiceProperty(service_path,
                        shill::kStateProperty,
                        base::StringValue(shill::kStateOnline));
   }
 }
 
 }  // namespace chromeos