Clean up NetworkState members

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 "chromeos/network/network_event_log.h"
 #include "chromeos/network/network_profile_handler.h"
 #include "chromeos/network/network_util.h"
@@ skipping 42 matching lines @@
 
   return false;
 }
 
 }  // namespace
 
 namespace chromeos {
 
 NetworkState::NetworkState(const std::string& path)
     : ManagedState(MANAGED_TYPE_NETWORK, path),
-      auto_connect_(false),
-      favorite_(false),
-      priority_(0),
+      connectable_(false),
       prefix_length_(0),
       signal_strength_(0),
-      connectable_(false),
       activate_over_non_cellular_networks_(false),
       cellular_out_of_credits_(false),
       has_ca_cert_nss_(false) {
 }
 
 NetworkState::~NetworkState() {
 }
 
 bool NetworkState::PropertyChanged(const std::string& key,
                                    const base::Value& value) {
@@ skipping 43 matching lines @@
         web_proxy_auto_discovery_url_ = GURL();
       }
     }
     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)) {
       NET_LOG_ERROR("Failed to parse " + key, path());
       return false;
     }
 
     proxy_config_.Clear();
     if (proxy_config_str.empty())
       return true;
@@ skipping 24 matching lines @@
   } 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 == 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::kUsageURLProperty) {
-    return GetStringValue(key, value, &usage_url_);
-  } else if (key == flimflam::kPaymentPortalProperty) {
-    const DictionaryValue* dict;
-    if (!value.GetAsDictionary(&dict))
-      return false;
-    if (!dict->GetStringWithoutPathExpansion(
-            flimflam::kPaymentPortalURL, &payment_url_) ||
-        !dict->GetStringWithoutPathExpansion(
-            flimflam::kPaymentPortalMethod, &post_method_) ||
-        !dict->GetStringWithoutPathExpansion(
-            flimflam::kPaymentPortalPostData, &post_data_)) {
-      return false;
-    }
-    return true;
   }
   return false;
 }
 
 bool NetworkState::InitialPropertiesReceived(
     const base::DictionaryValue& properties) {
   NET_LOG_DEBUG("InitialPropertiesReceived", path());
   bool changed = UpdateName(properties);
   bool had_ca_cert_nss = has_ca_cert_nss_;
   has_ca_cert_nss_ = IsCaCertNssSet(properties);
@@ skipping 18 matching lines @@
   // IPConfig properties
   base::DictionaryValue* ipconfig_properties = new base::DictionaryValue;
   ipconfig_properties->SetStringWithoutPathExpansion(flimflam::kAddressProperty,
                                                      ip_address_);
   ipconfig_properties->SetStringWithoutPathExpansion(flimflam::kGatewayProperty,
                                                      gateway_);
   base::ListValue* name_servers = new base::ListValue;
   name_servers->AppendStrings(dns_servers_);
   ipconfig_properties->SetWithoutPathExpansion(flimflam::kNameServersProperty,
                                                name_servers);
-  ipconfig_properties->SetIntegerWithoutPathExpansion(
-      flimflam::kPrefixlenProperty, prefix_length_);
   ipconfig_properties->SetStringWithoutPathExpansion(
       shill::kWebProxyAutoDiscoveryUrlProperty,
       web_proxy_auto_discovery_url_.spec());
   dictionary->SetWithoutPathExpansion(shill::kIPConfigProperty,
                                       ipconfig_properties);
 
   dictionary->SetStringWithoutPathExpansion(flimflam::kActivationStateProperty,
                                             activation_state_);
   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 and ONC source are intentionally omitted: These properties are
   // placed in NetworkState to transition ProxyConfigServiceImpl 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,
       network_technology_);
   dictionary->SetStringWithoutPathExpansion(flimflam::kDeviceProperty,
                                             device_path_);
   dictionary->SetStringWithoutPathExpansion(flimflam::kGuidProperty, guid_);
   dictionary->SetStringWithoutPathExpansion(flimflam::kProfileProperty,
                                             profile_path_);
   dictionary->SetBooleanWithoutPathExpansion(
       shill::kActivateOverNonCellularNetworkProperty,
       activate_over_non_cellular_networks_);
   dictionary->SetBooleanWithoutPathExpansion(shill::kOutOfCreditsProperty,
                                              cellular_out_of_credits_);
-  base::DictionaryValue* payment_portal_properties = new DictionaryValue;
-  payment_portal_properties->SetStringWithoutPathExpansion(
-      flimflam::kPaymentPortalURL,
-      payment_url_);
-  payment_portal_properties->SetStringWithoutPathExpansion(
-      flimflam::kPaymentPortalMethod,
-      post_method_);
-  payment_portal_properties->SetStringWithoutPathExpansion(
-      flimflam::kPaymentPortalPostData,
-      post_data_);
-  dictionary->SetWithoutPathExpansion(flimflam::kPaymentPortalProperty,
-                                      payment_portal_properties);
 }
 
 bool NetworkState::IsConnectedState() const {
   return StateIsConnected(connection_state_);
 }
 
 bool NetworkState::IsConnectingState() const {
   return StateIsConnecting(connection_state_);
 }
 
@@ skipping 44 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