Remove NetworkStateInformer's dependency on ProxyConfigServiceImpl.

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/i18n/icu_encoding_detection.h"
 #include "base/i18n/icu_string_conversions.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversion_utils.h"
-#include "base/values.h"
 #include "chromeos/network/network_event_log.h"
+#include "chromeos/network/onc/onc_utils.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace {
 
 bool ConvertListValueToStringVector(const base::ListValue& string_list,
                                     std::vector<std::string>* result) {
   for (size_t i = 0; i < string_list.GetSize(); ++i) {
     std::string str;
     if (!string_list.GetString(i, &str))
       return false;
@@ skipping 54 matching lines @@
     return GetBooleanValue(key, value, &connectable_);
   } else if (key == flimflam::kPassphraseRequiredProperty) {
     return GetBooleanValue(key, value, &passphrase_required_);
   } else if (key == flimflam::kErrorProperty) {
     return GetStringValue(key, value, &error_);
   } else if (key == IPConfigProperty(flimflam::kAddressProperty)) {
     return GetStringValue(key, value, &ip_address_);
   } else if (key == IPConfigProperty(flimflam::kNameServersProperty)) {
     dns_servers_.clear();
     const base::ListValue* dns_servers;
-    if (value.GetAsList(&dns_servers) &&
-        ConvertListValueToStringVector(*dns_servers, &dns_servers_))
-      return true;
+    if (value.GetAsList(&dns_servers))
+      ConvertListValueToStringVector(*dns_servers, &dns_servers_);
+    return true;
   } else if (key == flimflam::kActivationStateProperty) {
     return GetStringValue(key, value, &activation_state_);
   } else if (key == flimflam::kRoamingStateProperty) {
     return GetStringValue(key, value, &roaming_);
   } else if (key == flimflam::kSecurityProperty) {
     return GetStringValue(key, value, &security_);
   } else if (key == flimflam::kAutoConnectProperty) {
     return GetBooleanValue(key, value, &auto_connect_);
   } else if (key == flimflam::kFavoriteProperty) {
     return GetBooleanValue(key, value, &favorite_);
   } else if (key == flimflam::kPriorityProperty) {
     return GetIntegerValue(key, value, &priority_);
+  } else if (key == flimflam::kProxyConfigProperty) {
+    std::string proxy_config_str;
+    if (!value.GetAsString(&proxy_config_str)) {
+      LOG(WARNING) << "Failed to parse string value for:" << key;
+      return false;
+    }
+
+    proxy_config_.Clear();
+    if (proxy_config_str.empty())
+      return true;
+
+    scoped_ptr<base::DictionaryValue> proxy_config_dict(
+        onc::ReadDictionaryFromJson(proxy_config_str));
+    if (proxy_config_dict)
+      proxy_config_.Swap(proxy_config_dict.get());
+    else
+      LOG(WARNING) << "Failed to parse dictionary value for: " << key;
+    return true;
   } else if (key == flimflam::kNetworkTechnologyProperty) {
     return GetStringValue(key, value, &technology_);
   } else if (key == flimflam::kDeviceProperty) {
     return GetStringValue(key, value, &device_path_);
   } else if (key == flimflam::kGuidProperty) {
     return GetStringValue(key, value, &guid_);
   } else if (key == flimflam::kProfileProperty) {
     return GetStringValue(key, value, &profile_path_);
-  } else if (key == flimflam::kProxyConfigProperty) {
-    return GetStringValue(key, value, &proxy_config_);
   } else if (key == shill::kActivateOverNonCellularNetworkProperty) {
     return GetBooleanValue(key, value, &activate_over_non_cellular_networks_);
   } else if (key == shill::kOutOfCreditsProperty) {
     return GetBooleanValue(key, value, &cellular_out_of_credits_);
   } else if (key == flimflam::kWifiHexSsid) {
     return GetStringValue(key, value, &hex_ssid_);
   } else if (key == flimflam::kCountryProperty) {
     // TODO(stevenjb): This is currently experimental. If we find a case where
     // base::DetectEncoding() fails in UpdateName(), where country_code_ is
     // set, figure out whether we can use country_code_ with ConvertToUtf8().
@@ skipping 36 matching lines @@
   dictionary->SetStringWithoutPathExpansion(flimflam::kRoamingStateProperty,
                                             roaming_);
   dictionary->SetStringWithoutPathExpansion(flimflam::kSecurityProperty,
                                             security_);
   dictionary->SetBooleanWithoutPathExpansion(flimflam::kAutoConnectProperty,
                                              auto_connect_);
   dictionary->SetBooleanWithoutPathExpansion(flimflam::kFavoriteProperty,
                                              favorite_);
   dictionary->SetIntegerWithoutPathExpansion(flimflam::kPriorityProperty,
                                              priority_);
+  // Proxy config is intentionally omitted: This property is
+  // placed in NetworkState to transition proxy configuration from
+  // NetworkLibrary to the new network stack. The networking extension API
+  // shouldn't depend on this member. Once ManagedNetworkConfigurationHandler
+  // is used instead of NetworkLibrary, we can remove them again.
   dictionary->SetStringWithoutPathExpansion(
       flimflam::kNetworkTechnologyProperty,
       technology_);
   dictionary->SetStringWithoutPathExpansion(flimflam::kDeviceProperty,
                                             device_path_);
   dictionary->SetStringWithoutPathExpansion(flimflam::kGuidProperty, guid_);
   dictionary->SetStringWithoutPathExpansion(flimflam::kProfileProperty,
                                             profile_path_);
-  dictionary->SetStringWithoutPathExpansion(flimflam::kProxyConfigProperty,
-                                            proxy_config_);
   dictionary->SetBooleanWithoutPathExpansion(
       shill::kActivateOverNonCellularNetworkProperty,
       activate_over_non_cellular_networks_);
   dictionary->SetBooleanWithoutPathExpansion(shill::kOutOfCreditsProperty,
                                              cellular_out_of_credits_);
 }
 
 bool NetworkState::IsConnectedState() const {
   return StateIsConnected(connection_state_);
 }
@@ skipping 83 matching lines @@
           connection_state == flimflam::kStateConfiguration ||
           connection_state == flimflam::kStateCarrier);
 }
 
 // static
 std::string NetworkState::IPConfigProperty(const char* key) {
   return base::StringPrintf("%s.%s", shill::kIPConfigProperty, key);
 }
 
 }  // namespace chromeos