This adds Cellular to the Shill to ONC translation.

chromeos/network/onc/onc_validator.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/onc/onc_validator.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/json/json_writer.h"
@@ skipping 368 matching lines @@
 
 bool Validator::ValidateToplevelConfiguration(
     const base::DictionaryValue& onc_object,
     base::DictionaryValue* result) {
   if (!ValidateObjectDefault(kToplevelConfigurationSignature,
                              onc_object, result)) {
     return false;
   }
 
   static const char* kValidTypes[] =
-      { kUnencryptedConfiguration, kEncryptedConfiguration, NULL };
-  if (FieldExistsAndHasNoValidValue(*result, kType, kValidTypes))
+      { toplevel_config::kUnencryptedConfiguration,
+        toplevel_config::kEncryptedConfiguration,
+        NULL };
+  if (FieldExistsAndHasNoValidValue(*result,
+                                    network_config::kType,
+                                    kValidTypes))
     return false;
 
   bool allRequiredExist = true;
 
   // Not part of the ONC spec yet:
   // We don't require the type field and default to UnencryptedConfiguration.
-  std::string type = kUnencryptedConfiguration;
-  result->GetStringWithoutPathExpansion(kType, &type);
-  if (type == kUnencryptedConfiguration &&
-      !result->HasKey(kNetworkConfigurations) &&
-      !result->HasKey(kCertificates)) {
+  std::string type = toplevel_config::kUnencryptedConfiguration;
+  result->GetStringWithoutPathExpansion(network_config::kType, &type);
+  if (type == toplevel_config::kUnencryptedConfiguration &&
+      !result->HasKey(toplevel_config::kNetworkConfigurations) &&
+      !result->HasKey(toplevel_config::kCertificates)) {
     error_or_warning_found_ = true;
     std::string message = MessageHeader(error_on_missing_field_) +
-        "Neither the field '" + kNetworkConfigurations + "' nor '" +
-        kCertificates + "is present, but at least one is required.";
+        "Neither the field '" + toplevel_config::kNetworkConfigurations +
+        "' nor '" + toplevel_config::kCertificates +
+        "is present, but at least one is required.";
     if (error_on_missing_field_)
       LOG(ERROR) << message;
     else
       LOG(WARNING) << message;
     allRequiredExist = false;
   }
 
   return !error_on_missing_field_ || allRequiredExist;
 }
 
 bool Validator::ValidateNetworkConfiguration(
     const base::DictionaryValue& onc_object,
     base::DictionaryValue* result) {
   if (!ValidateObjectDefault(kNetworkConfigurationSignature,
                              onc_object, result)) {
     return false;
   }
 
-  static const char* kValidTypes[] = { kEthernet, kVPN, kWiFi, NULL };
-  if (FieldExistsAndHasNoValidValue(*result, kType, kValidTypes))
+  static const char* kValidTypes[] = { network_type::kEthernet,
+                                       network_type::kVPN,
+                                       network_type::kWiFi,
+                                       NULL };
+  if (FieldExistsAndHasNoValidValue(*result,
+                                    network_config::kType,
+                                    kValidTypes))
     return false;
 
-  bool allRequiredExist = RequireField(*result, kGUID);
+  bool allRequiredExist = RequireField(*result, network_config::kGUID);
 
   bool remove = false;
   result->GetBooleanWithoutPathExpansion(kRemove, &remove);
   if (!remove) {
-    allRequiredExist &= RequireField(*result, kName);
-    allRequiredExist &= RequireField(*result, kType);
+    allRequiredExist &= RequireField(*result, network_config::kName);
+    allRequiredExist &= RequireField(*result, network_config::kType);
 
     std::string type;
-    result->GetStringWithoutPathExpansion(kType, &type);
+    result->GetStringWithoutPathExpansion(network_config::kType, &type);
 
     // Prohibit anything but WiFi and Ethernet for device-level policy (which
     // corresponds to shared networks). See also http://crosbug.com/28741.
     if (onc_source_ == ONC_SOURCE_DEVICE_POLICY &&
-        type != kWiFi &&
-        type != kEthernet) {
+        type != network_type::kWiFi &&
+        type != network_type::kEthernet) {
       error_or_warning_found_ = true;
       LOG(ERROR) << ErrorHeader() << "Networks of type '"
                  << type << "' are prohibited in ONC device policies.";
       return false;
     }
     allRequiredExist &= type.empty() || RequireField(*result, type);
   }
 
   return !error_on_missing_field_ || allRequiredExist;
 }
@@ skipping 278 matching lines @@
     const base::DictionaryValue& onc_object,
     base::DictionaryValue* result) {
   using namespace onc::certificate;
   if (!ValidateObjectDefault(kCertificateSignature, onc_object, result))
     return false;
 
   static const char* kValidTypes[] = { kClient, kServer, kAuthority, NULL };
   if (FieldExistsAndHasNoValidValue(*result, certificate::kType, kValidTypes))
     return false;
 
-  bool allRequiredExist = RequireField(*result, kGUID);
+  bool allRequiredExist = RequireField(*result, certificate::kGUID);
 
   bool remove = false;
   result->GetBooleanWithoutPathExpansion(kRemove, &remove);
   if (!remove) {
     allRequiredExist &= RequireField(*result, certificate::kType);
 
     std::string type;
     result->GetStringWithoutPathExpansion(certificate::kType, &type);
     if (type == kClient)
       allRequiredExist &= RequireField(*result, kPKCS12);
@@ skipping 13 matching lines @@
 }
 
 std::string Validator::MessageHeader(bool is_error) {
   std::string path = path_.empty() ? "toplevel" : JoinString(path_, ".");
   std::string message = "At " + path + ": ";
   return message;
 }
 
 }  // namespace onc
 }  // namespace chromeos