Rely on Service.Visible instead of Manager.Services

chromeos/dbus/fake_shill_manager_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_manager_client.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 46 matching lines @@
     const base::DictionaryValue* properties =
         service_client->GetServiceProperties(service_path);
     if (!properties) {
       LOG(ERROR) << "Properties not found for service: " << service_path;
       continue;
     }
     std::string type;
     properties->GetString(shill::kTypeProperty, &type);
     if (type != match_type)
       continue;
-    if (!technology_enabled) {
-      std::string profile;
-      properties->GetString(shill::kProfileProperty, &profile);
-      if (profile.empty())
-        continue;
-    }
     bool visible = false;
     if (technology_enabled)
       properties->GetBoolean(shill::kVisibleProperty, &visible);
     if (!visible) {
       disabled_service_list_out->push_back(service_path);
       continue;
     }
     std::string state;
     properties->GetString(shill::kStateProperty, &state);
     if (state == shill::kStateOnline ||
@@ skipping 372 matching lines @@
   stub_properties_.Clear();
 }
 
 void FakeShillManagerClient::SetManagerProperty(const std::string& key,
                                                 const base::Value& value) {
   SetProperty(key, value,
               base::Bind(&base::DoNothing), base::Bind(&LogErrorCallback));
 }
 
 void FakeShillManagerClient::AddManagerService(
-    const std::string& service_path) {
+    const std::string& service_path,
+    bool notify_observers) {
   DVLOG(2) << "AddManagerService: " << service_path;
   GetListProperty(shill::kServiceCompleteListProperty)->AppendIfNotPresent(
       base::Value::CreateStringValue(service_path));
   SortManagerServices(false);
-  CallNotifyObserversPropertyChanged(shill::kServiceCompleteListProperty);
-  // SortManagerServices will add the service to Services if it is visible.
-  const base::ListValue* services = GetListProperty(shill::kServicesProperty);
-  if (services->Find(base::StringValue(service_path)) != services->end())
-    CallNotifyObserversPropertyChanged(shill::kServicesProperty);
+  if (notify_observers)
+    CallNotifyObserversPropertyChanged(shill::kServiceCompleteListProperty);
 }
 
 void FakeShillManagerClient::RemoveManagerService(
     const std::string& service_path) {
   DVLOG(2) << "RemoveManagerService: " << service_path;
   base::StringValue service_path_value(service_path);
   GetListProperty(shill::kServiceCompleteListProperty)->Remove(
       service_path_value, NULL);
   CallNotifyObserversPropertyChanged(shill::kServiceCompleteListProperty);
-  if (GetListProperty(shill::kServicesProperty)->Remove(
-          service_path_value, NULL)) {
-    CallNotifyObserversPropertyChanged(shill::kServicesProperty);
-  }
 }
 
 void FakeShillManagerClient::ClearManagerServices() {
   DVLOG(1) << "ClearManagerServices";
   GetListProperty(shill::kServiceCompleteListProperty)->Clear();
-  GetListProperty(shill::kServicesProperty)->Clear();
   CallNotifyObserversPropertyChanged(shill::kServiceCompleteListProperty);
-  CallNotifyObserversPropertyChanged(shill::kServicesProperty);
 }
 
 void FakeShillManagerClient::ServiceStateChanged(
     const std::string& service_path,
     const std::string& state) {
   if (service_path == default_service_ && !IsConnectedState(state)) {
     // Default service is no longer connected; clear.
     default_service_.clear();
     base::StringValue default_service_value(default_service_);
     SetManagerProperty(shill::kDefaultServiceProperty, default_service_value);
   }
 }
 
 void FakeShillManagerClient::SortManagerServices(bool notify) {
   DVLOG(1) << "SortManagerServices";
   static const char* ordered_types[] = {shill::kTypeEthernet,
                                         shill::kTypeWifi,
                                         shill::kTypeCellular,
                                         shill::kTypeWimax,
                                         shill::kTypeVPN};
 
-  base::ListValue* service_list = GetListProperty(shill::kServicesProperty);
-  scoped_ptr<base::ListValue> prev_service_list(service_list->DeepCopy());
   base::ListValue* complete_list =
       GetListProperty(shill::kServiceCompleteListProperty);
   if (complete_list->empty())
     return;
   scoped_ptr<base::ListValue> prev_complete_list(complete_list->DeepCopy());
 
   std::vector<std::string> active_services;
   std::vector<std::string> inactive_services;
   std::vector<std::string> disabled_services;
   for (size_t i = 0; i < arraysize(ordered_types); ++i) {
     AppendServicesForType(complete_list,
                           ordered_types[i],
                           TechnologyEnabled(ordered_types[i]),
                           &active_services,
                           &inactive_services,
                           &disabled_services);
   }
-  service_list->Clear();
   complete_list->Clear();
-  for (size_t i = 0; i < active_services.size(); ++i) {
+  for (size_t i = 0; i < active_services.size(); ++i)
     complete_list->AppendString(active_services[i]);
-    service_list->AppendString(active_services[i]);
-  }
-  for (size_t i = 0; i < inactive_services.size(); ++i) {
+  for (size_t i = 0; i < inactive_services.size(); ++i)
     complete_list->AppendString(inactive_services[i]);
-    service_list->AppendString(inactive_services[i]);
-  }
-  for (size_t i = 0; i < disabled_services.size(); ++i) {
+  for (size_t i = 0; i < disabled_services.size(); ++i)
     complete_list->AppendString(disabled_services[i]);
-  }
 
-  if (notify) {
-    if (!service_list->Equals(prev_service_list.get()))
-      CallNotifyObserversPropertyChanged(shill::kServicesProperty);
-    if (!complete_list->Equals(prev_complete_list.get()))
-      CallNotifyObserversPropertyChanged(shill::kServiceCompleteListProperty);
-  }
+  if (notify && !complete_list->Equals(prev_complete_list.get()))
+    CallNotifyObserversPropertyChanged(shill::kServiceCompleteListProperty);
 
   // Set the first active service as the Default service.
   std::string new_default_service;
   if (!active_services.empty()) {
     ShillServiceClient::TestInterface* service_client =
         DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface();
     std::string service_path = active_services[0];
     const base::DictionaryValue* properties =
         service_client->GetServiceProperties(service_path);
     if (!properties) {
@@ skipping 242 matching lines @@
 
   SortManagerServices(true);
 }
 
 // Private methods
 
 void FakeShillManagerClient::PassStubProperties(
     const DictionaryValueCallback& callback) const {
   scoped_ptr<base::DictionaryValue> stub_properties(
       stub_properties_.DeepCopy());
+  stub_properties->SetWithoutPathExpansion(
+      shill::kServiceCompleteListProperty,
+      GetEnabledServiceList(shill::kServiceCompleteListProperty));
   callback.Run(DBUS_METHOD_CALL_SUCCESS, *stub_properties);
 }
 
 void FakeShillManagerClient::PassStubGeoNetworks(
     const DictionaryValueCallback& callback) const {
   callback.Run(DBUS_METHOD_CALL_SUCCESS, stub_geo_networks_);
 }
 
 void FakeShillManagerClient::CallNotifyObserversPropertyChanged(
     const std::string& property) {
   // Avoid unnecessary delayed task if we have no observers (e.g. during
   // initial setup).
   if (!observer_list_.might_have_observers())
     return;
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&FakeShillManagerClient::NotifyObserversPropertyChanged,
                  weak_ptr_factory_.GetWeakPtr(),
                  property));
 }
 
 void FakeShillManagerClient::NotifyObserversPropertyChanged(
     const std::string& property) {
   DVLOG(1) << "NotifyObserversPropertyChanged: " << property;
   base::Value* value = NULL;
   if (!stub_properties_.GetWithoutPathExpansion(property, &value)) {
     LOG(ERROR) << "Notify for unknown property: " << property;
     return;
   }
+  if (property == shill::kServiceCompleteListProperty) {
+    scoped_ptr<base::ListValue> services(GetEnabledServiceList(property));
+    FOR_EACH_OBSERVER(ShillPropertyChangedObserver,
+                      observer_list_,
+                      OnPropertyChanged(property, *(services.get())));
+    return;
+  }
   FOR_EACH_OBSERVER(ShillPropertyChangedObserver,
                     observer_list_,
                     OnPropertyChanged(property, *value));
 }
 
 base::ListValue* FakeShillManagerClient::GetListProperty(
     const std::string& property) {
   base::ListValue* list_property = NULL;
   if (!stub_properties_.GetListWithoutPathExpansion(
       property, &list_property)) {
@@ skipping 27 matching lines @@
     enabled_list->AppendIfNotPresent(new base::StringValue(type));
   else
     enabled_list->Remove(base::StringValue(type), NULL);
   CallNotifyObserversPropertyChanged(
       shill::kEnabledTechnologiesProperty);
   base::MessageLoop::current()->PostTask(FROM_HERE, callback);
   // May affect available services.
   SortManagerServices(true);
 }
 
+base::ListValue* FakeShillManagerClient::GetEnabledServiceList(
+    const std::string& property) const {
+  base::ListValue* new_service_list = new base::ListValue;
+  const base::ListValue* service_list;
+  if (stub_properties_.GetListWithoutPathExpansion(property, &service_list)) {
+    ShillServiceClient::TestInterface* service_client =
+        DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface();
+    for (base::ListValue::const_iterator iter = service_list->begin();
+         iter != service_list->end(); ++iter) {
+      std::string service_path;
+      if (!(*iter)->GetAsString(&service_path))
+        continue;
+      const base::DictionaryValue* properties =
+          service_client->GetServiceProperties(service_path);
+      if (!properties) {
+        LOG(ERROR) << "Properties not found for service: " << service_path;
+        continue;
+      }
+      std::string type;
+      properties->GetString(shill::kTypeProperty, &type);
+      if (TechnologyEnabled(type))
+        new_service_list->Append((*iter)->DeepCopy());
+    }
+  }
+  return new_service_list;
+}
+
 void FakeShillManagerClient::ScanCompleted(const std::string& device_path,
                                            const base::Closure& callback) {
   if (!device_path.empty()) {
     DBusThreadManager::Get()->GetShillDeviceClient()->GetTestInterface()->
         SetDeviceProperty(device_path,
                           shill::kScanningProperty,
                           base::FundamentalValue(false));
   }
   DVLOG(2) << "ScanCompleted";
   CallNotifyObserversPropertyChanged(shill::kServiceCompleteListProperty);
-  CallNotifyObserversPropertyChanged(shill::kServicesProperty);
   base::MessageLoop::current()->PostTask(FROM_HERE, callback);
 }
 
 void FakeShillManagerClient::ParseCommandLineSwitch() {
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kShillStub)) {
     std::string option_str =
         command_line->GetSwitchValueASCII(switches::kShillStub);
     base::StringPairs string_pairs;
     base::SplitStringIntoKeyValuePairs(option_str, '=', ',', &string_pairs);
@@ skipping 99 matching lines @@
   *enabled = true;
   if ((state == shill::kStatePortal && type != shill::kTypeWifi) ||
       (state == kNetworkActivated && type != shill::kTypeCellular)) {
     LOG(WARNING) << "Invalid state: " << state << " for " << type;
     return shill::kStateIdle;
   }
   return state;
 }
 
 }  // namespace chromeos