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;
+}
+
 }  // namespace
 
 FakeShillManagerClient::FakeShillManagerClient()
     : weak_ptr_factory_(this) {
 }
 
 FakeShillManagerClient::~FakeShillManagerClient() {}
 
 // ShillManagerClient overrides.
 
@@ skipping 298 matching lines @@
       CallNotifyObserversPropertyChanged(
           shill::kUninitializedTechnologiesProperty, 0);
     }
   }
 }
 
 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))) {
@@ skipping 29 matching lines @@
 
 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);
+
+  // 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 (state == shill::kStateOnline ||
+          state == shill::kStatePortal ||
+          state == shill::kStateReady) {
+        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);
@@ skipping 169 matching lines @@
         SetDeviceProperty(device_path,
                           shill::kScanningProperty,
                           base::FundamentalValue(false));
   }
   CallNotifyObserversPropertyChanged(shill::kServicesProperty, 0);
   CallNotifyObserversPropertyChanged(shill::kServiceWatchListProperty, 0);
   base::MessageLoop::current()->PostTask(FROM_HERE, callback);
 }
 
 }  // namespace chromeos