Adding policy support to the new network configuration stack.

chromeos/network/network_ui_data.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_ui_data.h"
 
 #include "base/logging.h"
 #include "base/values.h"
 #include "chromeos/network/onc/onc_signature.h"
 
 namespace chromeos {
 
 // Top-level UI data dictionary keys.
 const char NetworkUIData::kKeyONCSource[] = "onc_source";
 const char NetworkUIData::kKeyCertificatePattern[] = "certificate_pattern";
 const char NetworkUIData::kKeyCertificateType[] = "certificate_type";
+const char NetworkUIData::kKeyUserSettings[] = "user_settings";
 
 namespace {
 
 template <typename Enum>
 struct StringEnumEntry {
   const char* string;
   Enum enum_value;
 };
 
 const StringEnumEntry<onc::ONCSource> kONCSourceTable[] = {
@@ skipping 22 matching lines @@
 Enum StringToEnum(const StringEnumEntry<Enum>(& table)[N],
                   const std::string& str,
                   Enum fallback) {
   for (int i = 0; i < N; ++i) {
     if (table[i].string == str)
       return table[i].enum_value;
   }
   return fallback;
 }
 
-}
+}  // namespace
 
 NetworkUIData::NetworkUIData()
     : onc_source_(onc::ONC_SOURCE_NONE),
       certificate_type_(CLIENT_CERT_TYPE_NONE) {
 }
 
+NetworkUIData::NetworkUIData(const NetworkUIData& other) {
+  *this = other;
+}
+
+NetworkUIData& NetworkUIData::operator=(const NetworkUIData& other) {
+  certificate_pattern_ = other.certificate_pattern_;
+  onc_source_ = other.onc_source_;
+  certificate_type_ = other.certificate_type_;
+  if (other.user_settings_)
+    user_settings_.reset(other.user_settings_->DeepCopy());
+  policy_guid_ = other.policy_guid_;
+  return *this;
+}
+
 NetworkUIData::NetworkUIData(const DictionaryValue& dict) {
   std::string source;
   if (dict.GetString(kKeyONCSource, &source)) {
     onc_source_ =
         StringToEnum(kONCSourceTable, source, onc::ONC_SOURCE_NONE);
   } else {
     onc_source_ = onc::ONC_SOURCE_NONE;
   }
   const DictionaryValue* cert_dict = NULL;
   if (dict.GetDictionary(kKeyCertificatePattern, &cert_dict) && cert_dict)
     certificate_pattern_.CopyFromDictionary(*cert_dict);
   std::string type_string;
   if (dict.GetString(kKeyCertificateType, &type_string)) {
     certificate_type_ =
         StringToEnum(kClientCertTable, type_string, CLIENT_CERT_TYPE_NONE);
   } else {
     certificate_type_ = CLIENT_CERT_TYPE_NONE;
   }
   DCHECK(certificate_type_ != CLIENT_CERT_TYPE_PATTERN ||
          (certificate_type_ == CLIENT_CERT_TYPE_PATTERN &&
           !certificate_pattern_.Empty()));
+  const DictionaryValue* user_settings = NULL;
+  if (dict.GetDictionary(kKeyUserSettings, &user_settings))
+    user_settings_.reset(user_settings->DeepCopy());
 }
 
 NetworkUIData::~NetworkUIData() {
 }
 
 void NetworkUIData::FillDictionary(base::DictionaryValue* dict) const {
   dict->Clear();
 
   std::string source_string = EnumToString(kONCSourceTable, onc_source_);
   if (!source_string.empty())
     dict->SetString(kKeyONCSource, source_string);
 
   if (certificate_type_ != CLIENT_CERT_TYPE_NONE) {
     std::string type_string = EnumToString(kClientCertTable, certificate_type_);
     dict->SetString(kKeyCertificateType, type_string);
 
     if (certificate_type_ == CLIENT_CERT_TYPE_PATTERN &&
         !certificate_pattern_.Empty()) {
       dict->Set(kKeyCertificatePattern,
                 certificate_pattern_.CreateAsDictionary());
     }
   }
+  if (user_settings_)
+    dict->SetWithoutPathExpansion(kKeyUserSettings,
+                                  user_settings_->DeepCopy());
 }
 
 namespace {
 
 void TranslateClientCertType(const std::string& client_cert_type,
                              NetworkUIData* ui_data) {
   using namespace onc::certificate;
   ClientCertType type;
   if (client_cert_type == kNone) {
     type = CLIENT_CERT_TYPE_NONE;
@@ skipping 79 matching lines @@
   scoped_ptr<NetworkUIData> ui_data(new NetworkUIData());
   TranslateONCHierarchy(onc::kNetworkConfigurationSignature, onc_network,
                         ui_data.get());
 
   ui_data->set_onc_source(onc_source);
 
   return ui_data.Pass();
 }
 
 }  // namespace chromeos