Provide IPConfigs in networkingPrivate.GetProperties

chromeos/network/network_state.cc

 // Copyright (c) 2012 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/network/network_state.h"
 
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chromeos/network/network_event_log.h"
 #include "chromeos/network/network_profile_handler.h"
@@ skipping 72 matching lines @@
   } else if (key == shill::kConnectableProperty) {
     return GetBooleanValue(key, value, &connectable_);
   } else if (key == shill::kErrorProperty) {
     if (!GetStringValue(key, value, &error_))
       return false;
     if (ErrorIsValid(error_))
       last_error_ = error_;
     else
       error_.clear();
     return true;
-  } else if (key == IPConfigProperty(shill::kAddressProperty)) {
-    return GetStringValue(key, value, &ip_address_);
-  } else if (key == IPConfigProperty(shill::kGatewayProperty)) {
-    return GetStringValue(key, value, &gateway_);
-  } else if (key == IPConfigProperty(shill::kNameServersProperty)) {
-    const base::ListValue* dns_servers;
-    if (!value.GetAsList(&dns_servers))
-      return false;
-    dns_servers_.clear();
-    ConvertListValueToStringVector(*dns_servers, &dns_servers_);
-    return true;
-  } else if (key == IPConfigProperty(shill::kPrefixlenProperty)) {
-    return GetIntegerValue(key, value, &prefix_length_);
-  } else if (key == IPConfigProperty(
-      shill::kWebProxyAutoDiscoveryUrlProperty)) {
-    std::string url_string;
-    if (!GetStringValue(key, value, &url_string))
-      return false;
-    if (url_string.empty()) {
-      web_proxy_auto_discovery_url_ = GURL();
-    } else {
-      GURL gurl(url_string);
-      if (!gurl.is_valid()) {
-        web_proxy_auto_discovery_url_ = gurl;
-      } else {
-        NET_LOG_ERROR("Invalid WebProxyAutoDiscoveryUrl: " + url_string,
-                      path());
-        web_proxy_auto_discovery_url_ = GURL();
-      }
-    }
-    return true;
   } else if (key == shill::kActivationStateProperty) {
     return GetStringValue(key, value, &activation_state_);
   } else if (key == shill::kRoamingStateProperty) {
     return GetStringValue(key, value, &roaming_);
   } else if (key == shill::kSecurityProperty) {
     return GetStringValue(key, value, &security_);
   } else if (key == shill::kEapMethodProperty) {
     return GetStringValue(key, value, &eap_method_);
   } else if (key == shill::kUIDataProperty) {
     scoped_ptr<NetworkUIData> new_ui_data =
@@ skipping 69 matching lines @@
         network_technology());
     dictionary->SetStringWithoutPathExpansion(shill::kActivationStateProperty,
                                               activation_state());
     dictionary->SetStringWithoutPathExpansion(shill::kRoamingStateProperty,
                                               roaming());
     dictionary->SetBooleanWithoutPathExpansion(shill::kOutOfCreditsProperty,
                                                cellular_out_of_credits());
   }
 }
 
+void NetworkState::IPConfigPropertiesChanged(
+    const base::DictionaryValue& properties) {
+  for (base::DictionaryValue::Iterator iter(properties);
+       !iter.IsAtEnd(); iter.Advance()) {
+    std::string key = iter.key();
+    const base::Value& value = iter.value();
+
+    if (key == shill::kAddressProperty) {
+      GetStringValue(key, value, &ip_address_);
+    } else if (key == shill::kGatewayProperty) {
+      GetStringValue(key, value, &gateway_);
+    } else if (key == shill::kNameServersProperty) {
+      const base::ListValue* dns_servers;
+      if (value.GetAsList(&dns_servers)) {
+        dns_servers_.clear();
+        ConvertListValueToStringVector(*dns_servers, &dns_servers_);
+      }
+    } else if (key == shill::kPrefixlenProperty) {
+      GetIntegerValue(key, value, &prefix_length_);
+    } else if (key == shill::kWebProxyAutoDiscoveryUrlProperty) {
+      std::string url_string;
+      if (GetStringValue(key, value, &url_string)) {
+        if (url_string.empty()) {
+          web_proxy_auto_discovery_url_ = GURL();
+        } else {
+          GURL gurl(url_string);
+          if (!gurl.is_valid()) {
+            web_proxy_auto_discovery_url_ = gurl;
+          } else {
+            NET_LOG_ERROR("Invalid WebProxyAutoDiscoveryUrl: " + url_string,
+                          path());
+            web_proxy_auto_discovery_url_ = GURL();
+          }
+        }
+      }
+    }
+  }
+}
+
 bool NetworkState::RequiresActivation() const {
   return (type() == shill::kTypeCellular &&
           activation_state() != shill::kActivationStateActivated &&
           activation_state() != shill::kActivationStateUnknown);
 }
 
 bool NetworkState::IsConnectedState() const {
   return StateIsConnected(connection_state_);
 }
 
@@ skipping 43 matching lines @@
           connection_state == shill::kStateConfiguration ||
           connection_state == shill::kStateCarrier);
 }
 
 // static
 bool NetworkState::ErrorIsValid(const std::string& error) {
   // Shill uses "Unknown" to indicate an unset or cleared error state.
   return !error.empty() && error != kErrorUnknown;
 }
 
-// static
-std::string NetworkState::IPConfigProperty(const char* key) {
-  return base::StringPrintf("%s.%s", shill::kIPConfigProperty, key);
-}
-
 }  // namespace chromeos