Chrome OS: Use Manager.DefaultService for Default Network

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/values.h"
@@ skipping 55 matching lines @@
         state == shill::kStateConfiguration ||
         state == shill::kStatePortal ||
         state == shill::kStateReady) {
       active_service_list_out->push_back(service_path);
     } else {
       inactive_service_list_out->push_back(service_path);
     }
   }
 }
 
+void LogErrorCallback(const std::string& error_name,
+                      const std::string& error_message) {
+  LOG(ERROR) << error_name << ": " << error_message;
+}
+
+bool IsConnectedState(const std::string& state) {
+  return state == shill::kStateOnline || state == shill::kStatePortal ||
+         state == shill::kStateReady;
+}
+
 }  // namespace
 
 FakeShillManagerClient::FakeShillManagerClient()
     : weak_ptr_factory_(this) {
 }
 
 FakeShillManagerClient::~FakeShillManagerClient() {}
 
 // ShillManagerClient overrides.
 
@@ skipping 25 matching lines @@
           &FakeShillManagerClient::PassStubGeoNetworks,
           weak_ptr_factory_.GetWeakPtr(),
           callback));
 }
 
 void FakeShillManagerClient::SetProperty(const std::string& name,
                                          const base::Value& value,
                                          const base::Closure& callback,
                                          const ErrorCallback& error_callback) {
   stub_properties_.SetWithoutPathExpansion(name, value.DeepCopy());
-  CallNotifyObserversPropertyChanged(name, 0);
+  CallNotifyObserversPropertyChanged(name);
   base::MessageLoop::current()->PostTask(FROM_HERE, callback);
 }
 
 void FakeShillManagerClient::RequestScan(const std::string& type,
                                          const base::Closure& callback,
                                          const ErrorCallback& error_callback) {
   // For Stub purposes, default to a Wifi scan.
   std::string device_type = shill::kTypeWifi;
   if (!type.empty())
     device_type = type;
@@ skipping 185 matching lines @@
 
 ShillManagerClient::TestInterface* FakeShillManagerClient::GetTestInterface() {
   return this;
 }
 
 // ShillManagerClient::TestInterface overrides.
 
 void FakeShillManagerClient::AddDevice(const std::string& device_path) {
   if (GetListProperty(shill::kDevicesProperty)->AppendIfNotPresent(
       base::Value::CreateStringValue(device_path))) {
-    CallNotifyObserversPropertyChanged(shill::kDevicesProperty, 0);
+    CallNotifyObserversPropertyChanged(shill::kDevicesProperty);
   }
 }
 
 void FakeShillManagerClient::RemoveDevice(const std::string& device_path) {
   base::StringValue device_path_value(device_path);
   if (GetListProperty(shill::kDevicesProperty)->Remove(
       device_path_value, NULL)) {
-    CallNotifyObserversPropertyChanged(shill::kDevicesProperty, 0);
+    CallNotifyObserversPropertyChanged(shill::kDevicesProperty);
   }
 }
 
 void FakeShillManagerClient::ClearDevices() {
   GetListProperty(shill::kDevicesProperty)->Clear();
-  CallNotifyObserversPropertyChanged(shill::kDevicesProperty, 0);
+  CallNotifyObserversPropertyChanged(shill::kDevicesProperty);
 }
 
 void FakeShillManagerClient::AddTechnology(const std::string& type,
                                            bool enabled) {
   if (GetListProperty(shill::kAvailableTechnologiesProperty)->
       AppendIfNotPresent(base::Value::CreateStringValue(type))) {
     CallNotifyObserversPropertyChanged(
-        shill::kAvailableTechnologiesProperty, 0);
+        shill::kAvailableTechnologiesProperty);
   }
   if (enabled &&
       GetListProperty(shill::kEnabledTechnologiesProperty)->
       AppendIfNotPresent(base::Value::CreateStringValue(type))) {
     CallNotifyObserversPropertyChanged(
-        shill::kEnabledTechnologiesProperty, 0);
+        shill::kEnabledTechnologiesProperty);
   }
 }
 
 void FakeShillManagerClient::RemoveTechnology(const std::string& type) {
   base::StringValue type_value(type);
   if (GetListProperty(shill::kAvailableTechnologiesProperty)->Remove(
       type_value, NULL)) {
     CallNotifyObserversPropertyChanged(
-        shill::kAvailableTechnologiesProperty, 0);
+        shill::kAvailableTechnologiesProperty);
   }
   if (GetListProperty(shill::kEnabledTechnologiesProperty)->Remove(
       type_value, NULL)) {
     CallNotifyObserversPropertyChanged(
-        shill::kEnabledTechnologiesProperty, 0);
+        shill::kEnabledTechnologiesProperty);
   }
 }
 
 void FakeShillManagerClient::SetTechnologyInitializing(const std::string& type,
                                                        bool initializing) {
   if (initializing) {
     if (GetListProperty(shill::kUninitializedTechnologiesProperty)->
         AppendIfNotPresent(base::Value::CreateStringValue(type))) {
       CallNotifyObserversPropertyChanged(
-          shill::kUninitializedTechnologiesProperty, 0);
+          shill::kUninitializedTechnologiesProperty);
     }
   } else {
     if (GetListProperty(shill::kUninitializedTechnologiesProperty)->Remove(
             base::StringValue(type), NULL)) {
       CallNotifyObserversPropertyChanged(
-          shill::kUninitializedTechnologiesProperty, 0);
+          shill::kUninitializedTechnologiesProperty);
     }
   }
 }
 
 void FakeShillManagerClient::ClearProperties() {
   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,
                                                bool add_to_visible_list,
                                                bool add_to_watch_list) {
   // Always add to ServiceCompleteListProperty.
   GetListProperty(shill::kServiceCompleteListProperty)->AppendIfNotPresent(
       base::Value::CreateStringValue(service_path));
   // If visible, add to Services and notify if new.
   if (add_to_visible_list &&
       GetListProperty(shill::kServicesProperty)->AppendIfNotPresent(
-      base::Value::CreateStringValue(service_path))) {
-    CallNotifyObserversPropertyChanged(shill::kServicesProperty, 0);
+          base::Value::CreateStringValue(service_path))) {
+    CallNotifyObserversPropertyChanged(shill::kServicesProperty);
   }
   if (add_to_watch_list)
     AddServiceToWatchList(service_path);
 }
 
 void FakeShillManagerClient::RemoveManagerService(
     const std::string& service_path) {
   base::StringValue service_path_value(service_path);
   if (GetListProperty(shill::kServicesProperty)->Remove(
       service_path_value, NULL)) {
-    CallNotifyObserversPropertyChanged(shill::kServicesProperty, 0);
+    CallNotifyObserversPropertyChanged(shill::kServicesProperty);
   }
   GetListProperty(shill::kServiceCompleteListProperty)->Remove(
       service_path_value, NULL);
   if (GetListProperty(shill::kServiceWatchListProperty)->Remove(
       service_path_value, NULL)) {
     CallNotifyObserversPropertyChanged(
-        shill::kServiceWatchListProperty, 0);
+        shill::kServiceWatchListProperty);
   }
 }
 
 void FakeShillManagerClient::ClearManagerServices() {
   GetListProperty(shill::kServicesProperty)->Clear();
   GetListProperty(shill::kServiceCompleteListProperty)->Clear();
   GetListProperty(shill::kServiceWatchListProperty)->Clear();
-  CallNotifyObserversPropertyChanged(shill::kServicesProperty, 0);
-  CallNotifyObserversPropertyChanged(shill::kServiceWatchListProperty, 0);
+  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() {
   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 (!service_list || service_list->empty()) {
+    if (!default_service_.empty()) {
+      default_service_.clear();
+      base::StringValue empty_value("");
+      SetManagerProperty(shill::kDefaultServiceProperty, empty_value);
+    }
     return;
+  }
   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],
                           &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(shill::kServicesProperty, 0);
+  CallNotifyObserversPropertyChanged(shill::kServicesProperty);
+
+  // 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);
+  }
 }
 
 void FakeShillManagerClient::AddGeoNetwork(
     const std::string& technology,
     const base::DictionaryValue& network) {
   base::ListValue* list_value = NULL;
   if (!stub_geo_networks_.GetListWithoutPathExpansion(
       technology, &list_value)) {
     list_value = new base::ListValue;
     stub_geo_networks_.SetWithoutPathExpansion(technology, list_value);
   }
   list_value->Append(network.DeepCopy());
 }
 
 void FakeShillManagerClient::AddProfile(const std::string& profile_path) {
   const char* key = shill::kProfilesProperty;
   if (GetListProperty(key)->AppendIfNotPresent(
           new base::StringValue(profile_path))) {
-    CallNotifyObserversPropertyChanged(key, 0);
+    CallNotifyObserversPropertyChanged(key);
   }
 }
 
 void FakeShillManagerClient::AddServiceToWatchList(
     const std::string& service_path) {
   // Remove and insert the service, moving it to the front of the watch list.
   GetListProperty(shill::kServiceWatchListProperty)->Remove(
       base::StringValue(service_path), NULL);
   GetListProperty(shill::kServiceWatchListProperty)->Insert(
       0, base::Value::CreateStringValue(service_path));
   CallNotifyObserversPropertyChanged(
-      shill::kServiceWatchListProperty, 0);
+      shill::kServiceWatchListProperty);
 }
 
 void FakeShillManagerClient::PassStubProperties(
     const DictionaryValueCallback& callback) const {
   scoped_ptr<base::DictionaryValue> stub_properties(
       stub_properties_.DeepCopy());
   // Remove disabled services from the list.
   stub_properties->SetWithoutPathExpansion(
       shill::kServicesProperty,
       GetEnabledServiceList(shill::kServicesProperty));
   stub_properties->SetWithoutPathExpansion(
       shill::kServiceWatchListProperty,
       GetEnabledServiceList(shill::kServiceWatchListProperty));
   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,
-    int delay_ms) {
+    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;
-  if (!CommandLine::ForCurrentProcess()->HasSwitch(
-          chromeos::switches::kEnableStubInteractive)) {
-    delay_ms = 0;
-  }
-  base::MessageLoop::current()->PostDelayedTask(
+  base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&FakeShillManagerClient::NotifyObserversPropertyChanged,
                  weak_ptr_factory_.GetWeakPtr(),
-                 property),
-                 base::TimeDelta::FromMilliseconds(delay_ms));
+                 property));
 }
 
 void FakeShillManagerClient::NotifyObserversPropertyChanged(
     const std::string& property) {
   if (property == shill::kServicesProperty ||
       property == shill::kServiceWatchListProperty) {
     scoped_ptr<base::ListValue> services(GetEnabledServiceList(property));
     FOR_EACH_OBSERVER(ShillPropertyChangedObserver,
                       observer_list_,
                       OnPropertyChanged(property, *(services.get())));
@@ skipping 50 matching lines @@
     bool enabled) {
   base::ListValue* enabled_list = NULL;
   stub_properties_.GetListWithoutPathExpansion(
       shill::kEnabledTechnologiesProperty, &enabled_list);
   DCHECK(enabled_list);
   if (enabled)
     enabled_list->AppendIfNotPresent(new base::StringValue(type));
   else
     enabled_list->Remove(base::StringValue(type), NULL);
   CallNotifyObserversPropertyChanged(
-      shill::kEnabledTechnologiesProperty, 0 /* already delayed */);
+      shill::kEnabledTechnologiesProperty);
   base::MessageLoop::current()->PostTask(FROM_HERE, callback);
   // May affect available services
-  CallNotifyObserversPropertyChanged(shill::kServicesProperty, 0);
-  CallNotifyObserversPropertyChanged(shill::kServiceWatchListProperty, 0);
+  CallNotifyObserversPropertyChanged(shill::kServicesProperty);
+  CallNotifyObserversPropertyChanged(shill::kServiceWatchListProperty);
 }
 
 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();
@@ skipping 19 matching lines @@
 }
 
 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));
   }
-  CallNotifyObserversPropertyChanged(shill::kServicesProperty, 0);
-  CallNotifyObserversPropertyChanged(shill::kServiceWatchListProperty, 0);
+  CallNotifyObserversPropertyChanged(shill::kServicesProperty);
+  CallNotifyObserversPropertyChanged(shill::kServiceWatchListProperty);
   base::MessageLoop::current()->PostTask(FROM_HERE, callback);
 }
 
 }  // namespace chromeos