Remove CACert NSS nickname to PEM migration.

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/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "chromeos/device_event_log.h"
 #include "chromeos/network/network_profile_handler.h"
@@ skipping 11 matching lines @@
                                     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;
     result->push_back(str);
   }
   return true;
 }
 
-bool IsCaCertNssSet(const base::DictionaryValue& properties) {
-  std::string ca_cert_nss;
-  if (properties.GetStringWithoutPathExpansion(shill::kEapCaCertNssProperty,
-                                               &ca_cert_nss) &&
-      !ca_cert_nss.empty()) {
-    return true;
-  }
-
-  const base::DictionaryValue* provider = NULL;
-  properties.GetDictionaryWithoutPathExpansion(shill::kProviderProperty,
-                                               &provider);
-  if (!provider)
-    return false;
-  if (provider->GetStringWithoutPathExpansion(
-          shill::kL2tpIpsecCaCertNssProperty, &ca_cert_nss) &&
-      !ca_cert_nss.empty()) {
-    return true;
-  }
-  if (provider->GetStringWithoutPathExpansion(
-          shill::kOpenVPNCaCertNSSProperty, &ca_cert_nss) &&
-      !ca_cert_nss.empty()) {
-    return true;
-  }
-
-  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),
-      cellular_out_of_credits_(false),
-      has_ca_cert_nss_(false) {
+      cellular_out_of_credits_(false) {
 }
 
 NetworkState::~NetworkState() {
 }
 
 bool NetworkState::PropertyChanged(const std::string& key,
                                    const base::Value& value) {
   // Keep care that these properties are the same as in |GetProperties|.
   if (ManagedStatePropertyChanged(key, value))
     return true;
@@ skipping 70 matching lines @@
     }
     return true;
   }
   return false;
 }
 
 bool NetworkState::InitialPropertiesReceived(
     const base::DictionaryValue& properties) {
   NET_LOG(EVENT) << "InitialPropertiesReceived: " << path() << ": " << name()
                  << " State: " << connection_state_ << " Visible: " << visible_;
-  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 and WiMAX networks have a
   // SignalStrength > 0.
   if ((type() == shill::kTypeWifi || type() == shill::kTypeWimax) &&
       visible() && signal_strength_ <= 0) {
       signal_strength_ = 1;
   }
 
-  return changed;
+  // Ensure that the network has a valid name.
+  return UpdateName(properties);
 }
 
 void NetworkState::GetStateProperties(base::DictionaryValue* dictionary) const {
   ManagedState::GetStateProperties(dictionary);
 
   // Properties shared by all types.
   dictionary->SetStringWithoutPathExpansion(shill::kGuidProperty, guid());
   dictionary->SetStringWithoutPathExpansion(shill::kSecurityProperty,
                                             security());
 
@@ skipping 160 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