Add migration from CaCert NSS nicknames to PEM.

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/json/json_writer.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 50 matching lines @@
   if (ui_data_str.empty())
     return new chromeos::NetworkUIData();
 
   scoped_ptr<base::DictionaryValue> ui_data_dict(
       chromeos::onc::ReadDictionaryFromJson(ui_data_str));
   if (!ui_data_dict)
     return NULL;
   return new chromeos::NetworkUIData(*ui_data_dict);
 }
 
+bool IsCaCertNssSet(const base::DictionaryValue& properties) {
+  std::string ca_cert_nss;
+  if (properties.GetStringWithoutPathExpansion(flimflam::kEapCaCertNssProperty,
+                                               &ca_cert_nss) &&
+      !ca_cert_nss.empty()) {
+    return true;
+  }
+
+  const base::DictionaryValue* provider = NULL;
+  properties.GetDictionaryWithoutPathExpansion(flimflam::kProviderProperty,
+                                               &provider);
+  if (!provider)
+    return false;
+  if (provider->GetStringWithoutPathExpansion(
+          flimflam::kL2tpIpsecCaCertNssProperty, &ca_cert_nss) &&
+      !ca_cert_nss.empty()) {
+    return true;
+  }
+  if (provider->GetStringWithoutPathExpansion(
+          flimflam::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),
       auto_connect_(false),
       favorite_(false),
       priority_(0),
       onc_source_(onc::ONC_SOURCE_NONE),
       prefix_length_(0),
       signal_strength_(0),
       connectable_(false),
       activate_over_non_cellular_networks_(false),
-      cellular_out_of_credits_(false) {
+      cellular_out_of_credits_(false),
+      has_ca_cert_nss_(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 88 matching lines @@
       return false;
     }
     return true;
   }
   return false;
 }
 
 bool NetworkState::InitialPropertiesReceived(
     const base::DictionaryValue& properties) {
   bool changed = UpdateName(properties);
+  bool had_ca_cert_nss = has_ca_cert_nss_;
+  has_ca_cert_nss_ = IsCaCertNssSet(properties);
+  changed |= had_ca_cert_nss != has_ca_cert_nss_;
   return changed;
 }
 
 void NetworkState::GetProperties(base::DictionaryValue* dictionary) const {
   // Keep care that these properties are the same as in |PropertyChanged|.
   dictionary->SetStringWithoutPathExpansion(flimflam::kNameProperty, name());
   dictionary->SetStringWithoutPathExpansion(flimflam::kTypeProperty, type());
   dictionary->SetIntegerWithoutPathExpansion(flimflam::kSignalStrengthProperty,
                                              signal_strength_);
   dictionary->SetStringWithoutPathExpansion(flimflam::kStateProperty,
@@ skipping 200 matching lines @@
 bool NetworkState::GetOncSource(const base::Value& ui_data_value,
                                 onc::ONCSource* out) {
   scoped_ptr<NetworkUIData> ui_data(CreateUIDataFromValue(ui_data_value));
   if (!ui_data)
     return false;
   *out = ui_data->onc_source();
   return true;
 }
 
 }  // namespace chromeos