Merge FavoriteState into NetworkState

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"
 #include "chromeos/network/network_type_pattern.h"
 #include "chromeos/network/network_util.h"
+#include "chromeos/network/onc/onc_utils.h"
 #include "chromeos/network/shill_property_util.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace {
 
 const char kErrorUnknown[] = "Unknown";
 
 bool ConvertListValueToStringVector(const base::ListValue& string_list,
                                     std::vector<std::string>* result) {
   for (size_t i = 0; i < string_list.GetSize(); ++i) {
@@ skipping 31 matching lines @@
 
   return false;
 }
 
 }  // namespace
 
 namespace chromeos {
 
 NetworkState::NetworkState(const std::string& path)
     : ManagedState(MANAGED_TYPE_NETWORK, path),
+      visible_(false),
       connectable_(false),
       prefix_length_(0),
       signal_strength_(0),
       activate_over_non_cellular_networks_(false),
       cellular_out_of_credits_(false),
       has_ca_cert_nss_(false) {
 }
 
 NetworkState::~NetworkState() {
 }
@@ skipping 39 matching lines @@
   } else if (key == shill::kDeviceProperty) {
     return GetStringValue(key, value, &device_path_);
   } else if (key == shill::kGuidProperty) {
     return GetStringValue(key, value, &guid_);
   } else if (key == shill::kProfileProperty) {
     return GetStringValue(key, value, &profile_path_);
   } 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 == shill::kProxyConfigProperty) {
+    std::string proxy_config_str;
+    if (!value.GetAsString(&proxy_config_str)) {
+      NET_LOG_ERROR("Failed to parse " + key, path());
+      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) {
+      // Warning: The DictionaryValue returned from
+      // ReadDictionaryFromJson/JSONParser is an optimized derived class that
+      // doesn't allow releasing ownership of nested values. A Swap in the wrong
+      // order leads to memory access errors.
+      proxy_config_.MergeDictionary(proxy_config_dict.get());
+    } else {
+      NET_LOG_ERROR("Failed to parse " + key, path());
+    }
+    return true;
   }
   return false;
 }
 
 bool NetworkState::InitialPropertiesReceived(
     const base::DictionaryValue& properties) {
   NET_LOG_DEBUG("InitialPropertiesReceived", path());
   bool changed = false;
   if (!properties.HasKey(shill::kTypeProperty)) {
     NET_LOG_ERROR("NetworkState has no type",
                   shill_property_util::GetNetworkIdFromProperties(properties));
     return false;
   }
   // Ensure that the network has a valid name.
   changed |= UpdateName(properties);
 
   // Set the has_ca_cert_nss_ property.
   bool had_ca_cert_nss = has_ca_cert_nss_;
   has_ca_cert_nss_ = IsCaCertNssSet(properties);
   changed |= had_ca_cert_nss != has_ca_cert_nss_;
 
   // By convention, all visible WiFi networks have a SignalStrength > 0.
-  if (type() == shill::kTypeWifi) {
+  if (visible() && type() == shill::kTypeWifi) {
     if (signal_strength_ <= 0)
       signal_strength_ = 1;
   }
 
   return changed;
 }
 
 void NetworkState::GetStateProperties(base::DictionaryValue* dictionary) const {
   ManagedState::GetStateProperties(dictionary);
 
   // Properties shared by all types.
   dictionary->SetStringWithoutPathExpansion(shill::kGuidProperty, guid());
-  dictionary->SetStringWithoutPathExpansion(shill::kStateProperty,
-                                            connection_state());
   dictionary->SetStringWithoutPathExpansion(shill::kSecurityProperty,
                                             security());
-  if (!error().empty())
-    dictionary->SetStringWithoutPathExpansion(shill::kErrorProperty, error());
 
+  if (visible()) {
+    if (!error().empty())
+      dictionary->SetStringWithoutPathExpansion(shill::kErrorProperty, error());
+    dictionary->SetStringWithoutPathExpansion(shill::kStateProperty,
+                                              connection_state());
+  }
+
+  // Wireless properties
   if (!NetworkTypePattern::Wireless().MatchesType(type()))
     return;
 
-  // Wireless properties
-  dictionary->SetBooleanWithoutPathExpansion(shill::kConnectableProperty,
-                                             connectable());
-  dictionary->SetIntegerWithoutPathExpansion(shill::kSignalStrengthProperty,
-                                             signal_strength());
+  if (visible()) {
+    dictionary->SetBooleanWithoutPathExpansion(shill::kConnectableProperty,
+                                               connectable());
+    dictionary->SetIntegerWithoutPathExpansion(shill::kSignalStrengthProperty,
+                                               signal_strength());
+  }
 
   // Wifi properties
   if (NetworkTypePattern::WiFi().MatchesType(type())) {
     dictionary->SetStringWithoutPathExpansion(shill::kEapMethodProperty,
                                               eap_method());
   }
 
   // Mobile properties
   if (NetworkTypePattern::Mobile().MatchesType(type())) {
     dictionary->SetStringWithoutPathExpansion(
@@ skipping 46 matching lines @@
     }
   }
 }
 
 bool NetworkState::RequiresActivation() const {
   return (type() == shill::kTypeCellular &&
           activation_state() != shill::kActivationStateActivated &&
           activation_state() != shill::kActivationStateUnknown);
 }
 
+std::string NetworkState::connection_state() const {
+  if (!visible())
+    return shill::kStateDisconnect;
+  return connection_state_;
+}
+
 bool NetworkState::IsConnectedState() const {
-  return StateIsConnected(connection_state_);
+  return visible() && StateIsConnected(connection_state_);
 }
 
 bool NetworkState::IsConnectingState() const {
-  return StateIsConnecting(connection_state_);
+  return visible() && StateIsConnecting(connection_state_);
+}
+
+bool NetworkState::IsInProfile() const {
+  // kTypeEthernetEap is always saved. We need this check because it does
+  // not show up in the visible list, but its properties may not be available
+  // when it first shows up in ServiceCompleteList. See crbug.com/355117.
+  return !profile_path_.empty() || type() == shill::kTypeEthernetEap;
 }
 
 bool NetworkState::IsPrivate() const {
   return !profile_path_.empty() &&
       profile_path_ != NetworkProfileHandler::GetSharedProfilePath();
 }
 
 std::string NetworkState::GetDnsServersAsString() const {
   std::string result;
   for (size_t i = 0; i < dns_servers_.size(); ++i) {
     if (i != 0)
       result += ",";
     result += dns_servers_[i];
   }
   return result;
 }
 
 std::string NetworkState::GetNetmask() const {
   return network_util::PrefixLengthToNetmask(prefix_length_);
 }
 
+std::string NetworkState::GetSpecifier() const {
+  if (!update_received()) {
+    NET_LOG_ERROR("GetSpecifier called before update", path());
+    return std::string();
+  }
+  if (type() == shill::kTypeWifi)
+    return name() + "_" + security_;
+  if (!name().empty())
+    return name();
+  return type();  // For unnamed networks such as ethernet.
+}
+
 void NetworkState::SetGuid(const std::string& guid) {
   guid_ = guid;
 }
 
 bool NetworkState::UpdateName(const base::DictionaryValue& properties) {
   std::string updated_name =
       shill_property_util::GetNameFromProperties(path(), properties);
   if (updated_name != name()) {
     set_name(updated_name);
     return true;
@@ skipping 15 matching lines @@
           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;
 }
 
 }  // namespace chromeos