NetworkChangeNotifierChromeos: Handle IPConfig property changes on the default network

chromeos/dbus/shill_service_client_stub.cc

 // Copyright (c) 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/shill_service_client_stub.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
@@ skipping 235 matching lines @@
 ShillServiceClient::TestInterface* ShillServiceClientStub::GetTestInterface() {
   return this;
 }
 
 // ShillServiceClient::TestInterface overrides.
 
 void ShillServiceClientStub::AddService(const std::string& service_path,
                                         const std::string& name,
                                         const std::string& type,
                                         const std::string& state,
+                                        const std::string& ipconfig_path,
                                         bool add_to_watch_list) {
   DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface()->
       AddService(service_path, add_to_watch_list);
 
   base::DictionaryValue* properties =
       GetModifiableServiceProperties(service_path);
   properties->SetWithoutPathExpansion(
       flimflam::kSSIDProperty,
       base::Value::CreateStringValue(service_path));
   properties->SetWithoutPathExpansion(
       flimflam::kNameProperty,
       base::Value::CreateStringValue(name));
   properties->SetWithoutPathExpansion(
       flimflam::kTypeProperty,
       base::Value::CreateStringValue(type));
   properties->SetWithoutPathExpansion(
       flimflam::kStateProperty,
       base::Value::CreateStringValue(state));
+  if (!ipconfig_path.empty())
+    properties->SetWithoutPathExpansion(
+        flimflam::kStateProperty,
+        base::Value::CreateStringValue(state));
 }
 
 void ShillServiceClientStub::RemoveService(const std::string& service_path) {
   DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface()->
       RemoveService(service_path);
 
   stub_services_.RemoveWithoutPathExpansion(service_path, NULL);
 }
 
 void ShillServiceClientStub::SetServiceProperty(const std::string& service_path,
@@ skipping 19 matching lines @@
 }
 
 void ShillServiceClientStub::SetDefaultProperties() {
   const bool add_to_watchlist = true;
 
   if (!CommandLine::ForCurrentProcess()->HasSwitch(
           chromeos::switches::kDisableStubEthernet)) {
     AddService("stub_ethernet", "eth0",
                flimflam::kTypeEthernet,
                flimflam::kStateOnline,
+               "",
                add_to_watchlist);
   }
 
   AddService("stub_wifi1", "wifi1",
              flimflam::kTypeWifi,
              flimflam::kStateOnline,
+             "",
              add_to_watchlist);
   SetServiceProperty("stub_wifi1",
                      flimflam::kSecurityProperty,
                      base::StringValue(flimflam::kSecurityWep));
 
   AddService("stub_wifi2", "wifi2_PSK",
              flimflam::kTypeWifi,
              flimflam::kStateIdle,
+             "",
              add_to_watchlist);
   SetServiceProperty("stub_wifi2",
                      flimflam::kSecurityProperty,
                      base::StringValue(flimflam::kSecurityPsk));
   base::FundamentalValue strength_value(80);
   SetServiceProperty("stub_wifi2",
                      flimflam::kSignalStrengthProperty,
                      strength_value);
 
   AddService("stub_cellular1", "cellular1",
              flimflam::kTypeCellular,
              flimflam::kStateIdle,
+             "",
              add_to_watchlist);
   base::StringValue technology_value(flimflam::kNetworkTechnologyGsm);
   SetServiceProperty("stub_cellular1",
                      flimflam::kNetworkTechnologyProperty,
                      technology_value);
   SetServiceProperty("stub_cellular1",
                      flimflam::kActivationStateProperty,
                      base::StringValue(flimflam::kActivationStateNotActivated));
   SetServiceProperty("stub_cellular1",
                      flimflam::kRoamingStateProperty,
                      base::StringValue(flimflam::kRoamingStateHome));
 
   AddService("stub_vpn1", "vpn1",
              flimflam::kTypeVPN,
              flimflam::kStateOnline,
+             "",
              add_to_watchlist);
 
   AddService("stub_vpn2", "vpn2",
              flimflam::kTypeVPN,
              flimflam::kStateOffline,
+             "",
              add_to_watchlist);
 }
 
 void ShillServiceClientStub::PassStubServiceProperties(
     const dbus::ObjectPath& service_path,
     const DictionaryValueCallback& callback) {
   base::DictionaryValue* dict = NULL;
   if (!stub_services_.GetDictionaryWithoutPathExpansion(
       service_path.value(), &dict)) {
     base::DictionaryValue empty_dictionary;
@@ skipping 39 matching lines @@
   std::map<dbus::ObjectPath, PropertyObserverList*>::iterator iter =
       observer_list_.find(device_path);
   if (iter != observer_list_.end())
     return *(iter->second);
   PropertyObserverList* observer_list = new PropertyObserverList();
   observer_list_[device_path] = observer_list;
   return *observer_list;
 }
 
 }  // namespace chromeos