This moves the ONC parsing code into chromeos/network/onc

chrome/browser/chromeos/cros/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 "chrome/browser/chromeos/cros/network_ui_data.h"
 
 #include "base/logging.h"
 #include "chrome/browser/chromeos/cros/network_library.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";
 
 // Property names for per-property data stored under |kKeyProperties|.
-const EnumMapper<NetworkUIData::ONCSource>::Pair
+const EnumMapper<onc::ONCSource>::Pair
     NetworkUIData::kONCSourceTable[] =  {
-  { "user_import", NetworkUIData::ONC_SOURCE_USER_IMPORT },
-  { "device_policy", NetworkUIData::ONC_SOURCE_DEVICE_POLICY },
-  { "user_policy", NetworkUIData::ONC_SOURCE_USER_POLICY },
+  { "user_import", onc::ONC_SOURCE_USER_IMPORT },
+  { "device_policy", onc::ONC_SOURCE_DEVICE_POLICY },
+  { "user_policy", onc::ONC_SOURCE_USER_POLICY },
 };
 
 // Property names for per-property data stored under |kKeyProperties|.
 const EnumMapper<ClientCertType>::Pair
     NetworkUIData::kClientCertTable[] =  {
   { "none", CLIENT_CERT_TYPE_NONE },
   { "pattern", CLIENT_CERT_TYPE_PATTERN },
   { "ref", CLIENT_CERT_TYPE_REF },
 };
 
 // Property names for the per-property dictionary.
 const char NetworkPropertyUIData::kKeyController[] = "controller";
 const char NetworkPropertyUIData::kKeyDefaultValue[] = "default_value";
 
 NetworkUIData::NetworkUIData()
-    : onc_source_(ONC_SOURCE_NONE),
+    : onc_source_(onc::ONC_SOURCE_NONE),
       certificate_type_(CLIENT_CERT_TYPE_NONE) {
 }
 
 NetworkUIData::NetworkUIData(const DictionaryValue& dict) {
   std::string source;
   if (dict.GetString(kKeyONCSource, &source)) {
     onc_source_ = GetONCSourceMapper().Get(source);
   } else {
-    onc_source_ = ONC_SOURCE_NONE;
+    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_ = GetClientCertMapper().Get(type_string);
   } else {
     certificate_type_ = CLIENT_CERT_TYPE_NONE;
   }
@@ skipping 22 matching lines @@
         dict->Set(kKeyCertificatePattern,
                   certificate_pattern_.CreateAsDictionary());
       }
     case CLIENT_CERT_TYPE_NONE:
     default:
       break;
   }
 }
 
 // static
-EnumMapper<NetworkUIData::ONCSource>& NetworkUIData::GetONCSourceMapper() {
-  CR_DEFINE_STATIC_LOCAL(EnumMapper<ONCSource>, mapper,
+EnumMapper<onc::ONCSource>& NetworkUIData::GetONCSourceMapper() {
+  CR_DEFINE_STATIC_LOCAL(EnumMapper<onc::ONCSource>, mapper,
                          (kONCSourceTable, arraysize(kONCSourceTable),
-                          ONC_SOURCE_NONE));
+                          onc::ONC_SOURCE_NONE));
   return mapper;
 }
 
 // static
 EnumMapper<ClientCertType>& NetworkUIData::GetClientCertMapper() {
   CR_DEFINE_STATIC_LOCAL(EnumMapper<ClientCertType>, mapper,
                          (kClientCertTable, arraysize(kClientCertTable),
                           CLIENT_CERT_TYPE_NONE));
   return mapper;
 }
@@ skipping 38 matching lines @@
     if (recommended_keys->Find(basename_value) != recommended_keys->end()) {
       controller_ = CONTROLLER_USER;
       const base::Value* default_value = NULL;
       if (onc->Get(property_key, &default_value))
         default_value_.reset(default_value->DeepCopy());
     }
   }
 }
 
 }  // namespace chromeos