Implement networkingPrivate.getNetworks

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 435 matching lines @@
   if (add_to_visible_list &&
       GetListProperty(shill::kServicesProperty)->AppendIfNotPresent(
           base::Value::CreateStringValue(service_path))) {
     CallNotifyObserversPropertyChanged(shill::kServicesProperty);
   }
   if (add_to_watch_list)
     AddServiceToWatchList(service_path);
 }
 
 void FakeShillManagerClient::RemoveManagerService(
-    const std::string& service_path) {
+    const std::string& service_path,
+    bool remove_from_complete_list) {
   base::StringValue service_path_value(service_path);
+  if (remove_from_complete_list &&
+      GetListProperty(shill::kServiceCompleteListProperty)->Remove(
+          service_path_value, NULL)) {
+    CallNotifyObserversPropertyChanged(shill::kServiceCompleteListProperty);

[pneubeck (no reviews), 2014/05/16 13:18:55]

I think the reason for this notification missing was that Shill doesn't send
notifications for it.

https://code.google.com/p/chromium/codesearch#chromium-os/src/platform/shill/...

[stevenjb, 2014/05/16 17:35:23]

Ah, you are correct, I'll remove these. Done.

+  }
   if (GetListProperty(shill::kServicesProperty)->Remove(
       service_path_value, NULL)) {
     CallNotifyObserversPropertyChanged(shill::kServicesProperty);
   }
-  GetListProperty(shill::kServiceCompleteListProperty)->Remove(
-      service_path_value, NULL);
   if (GetListProperty(shill::kServiceWatchListProperty)->Remove(
       service_path_value, NULL)) {
-    CallNotifyObserversPropertyChanged(
-        shill::kServiceWatchListProperty);
+    CallNotifyObserversPropertyChanged(shill::kServiceWatchListProperty);
   }
 }
 
 void FakeShillManagerClient::ClearManagerServices() {
+  GetListProperty(shill::kServiceCompleteListProperty)->Clear();
   GetListProperty(shill::kServicesProperty)->Clear();
-  GetListProperty(shill::kServiceCompleteListProperty)->Clear();
   GetListProperty(shill::kServiceWatchListProperty)->Clear();
+  CallNotifyObserversPropertyChanged(shill::kServiceCompleteListProperty);

[pneubeck (no reviews), 2014/05/16 13:18:55]

ditto

[stevenjb, 2014/05/16 17:35:23]

Done.

   CallNotifyObserversPropertyChanged(shill::kServicesProperty);
   CallNotifyObserversPropertyChanged(shill::kServiceWatchListProperty);
 }
 
 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() {
+  SortServiceList(shill::kServicesProperty);
+  SortServiceList(shill::kServiceCompleteListProperty);
+}
+
+void FakeShillManagerClient::SortServiceList(const std::string& property) {
   static const char* ordered_types[] = {
     shill::kTypeEthernet,
     shill::kTypeWifi,
     shill::kTypeCellular,
     shill::kTypeWimax,
     shill::kTypeVPN
   };
-  base::ListValue* service_list = GetListProperty(shill::kServicesProperty);
-  if (!service_list || service_list->empty()) {
-    if (!default_service_.empty()) {
-      default_service_.clear();
-      base::StringValue empty_value("");
-      SetManagerProperty(shill::kDefaultServiceProperty, empty_value);
-    }
-    return;
-  }
+
+  base::ListValue* service_list = GetListProperty(property);
   std::vector<std::string> active_services;
   std::vector<std::string> inactive_services;
-  for (size_t i = 0; i < arraysize(ordered_types); ++i) {
-    AppendServicesForType(service_list, ordered_types[i],
+  if (service_list && !service_list->empty()) {
+    for (size_t i = 0; i < arraysize(ordered_types); ++i) {
+      AppendServicesForType(service_list, ordered_types[i],
                           &active_services, &inactive_services);
+    }
+    service_list->Clear();
+    for (size_t i = 0; i < active_services.size(); ++i)
+      service_list->AppendString(active_services[i]);
+    for (size_t i = 0; i < inactive_services.size(); ++i)
+      service_list->AppendString(inactive_services[i]);
+
+    CallNotifyObserversPropertyChanged(property);
   }
-  service_list->Clear();
-  for (size_t i = 0; i < active_services.size(); ++i)
-    service_list->AppendString(active_services[i]);
-  for (size_t i = 0; i < inactive_services.size(); ++i)
-    service_list->AppendString(inactive_services[i]);
 
-  CallNotifyObserversPropertyChanged(shill::kServicesProperty);
+  if (property != shill::kServicesProperty)
+    return;
 
   // 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) {
       LOG(ERROR) << "Properties not found for service: " << service_path;
     } else {
       std::string state;
       properties->GetString(shill::kStateProperty, &state);
       if (IsConnectedState(state))
         new_default_service = service_path;
     }
   }
   if (default_service_ != new_default_service) {
     default_service_ = new_default_service;
     base::StringValue default_service_value(default_service_);
     SetManagerProperty(shill::kDefaultServiceProperty, default_service_value);
   }
+
+  return;
 }
 
 
 int FakeShillManagerClient::GetInteractiveDelay() const {
   return interactive_delay_;
 }
 
 void FakeShillManagerClient::SetupDefaultEnvironment() {
   DBusThreadManager* dbus_manager = DBusThreadManager::Get();
   ShillServiceClient::TestInterface* services =
@@ skipping 478 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