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 362 matching lines @@
     LOG(ERROR) << ErrorHeader() << "Client certificate patterns are "
                << "prohibited in ONC device policies.";
     return true;
   }
   return false;
 }
 
 bool Validator::ValidateToplevelConfiguration(
     const base::DictionaryValue& onc_object,
     base::DictionaryValue* result) {
+  using namespace onc::toplevel_config;
+
   if (!ValidateObjectDefault(kToplevelConfigurationSignature,
                              onc_object, result)) {
     return false;
   }
 
   static const char* kValidTypes[] =
-      { kUnencryptedConfiguration, kEncryptedConfiguration, NULL };
-  if (FieldExistsAndHasNoValidValue(*result, kType, kValidTypes))
+      { kUnencryptedConfiguration,
+        kEncryptedConfiguration,
+        NULL };
+  if (FieldExistsAndHasNoValidValue(*result,
+                                    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)) {
     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 '" + kNetworkConfigurations +
+        "' nor '" + 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) {
+  using namespace onc::network_config;
+
   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,
+                                    kType,
+                                    kValidTypes))
     return false;
 
   bool allRequiredExist = RequireField(*result, kGUID);
 
   bool remove = false;
   result->GetBooleanWithoutPathExpansion(kRemove, &remove);
   if (!remove) {
     allRequiredExist &= RequireField(*result, kName);
     allRequiredExist &= RequireField(*result, kType);
 
     std::string type;
     result->GetStringWithoutPathExpansion(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);
+
+    if (type == network_type::kWiFi)
+      allRequiredExist &= RequireField(*result, network_config::kWiFi);
+    else if (type == network_type::kEthernet)
+      allRequiredExist &= RequireField(*result, network_config::kEthernet);
+    else if (type == network_type::kCellular)
+      allRequiredExist &= RequireField(*result, network_config::kCellular);
+    else if (type == network_type::kVPN)
+      allRequiredExist &= RequireField(*result, network_config::kVPN);
+    else
+      LOG(ERROR) << "Unknown network type " << type << " encountered";
   }
 
   return !error_on_missing_field_ || allRequiredExist;
 }
 
 bool Validator::ValidateEthernet(
     const base::DictionaryValue& onc_object,
     base::DictionaryValue* result) {
   using namespace onc::ethernet;
   if (!ValidateObjectDefault(kEthernetSignature, onc_object, result))
@@ skipping 269 matching lines @@
 }
 
 bool Validator::ValidateCertificate(
     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))
+  if (FieldExistsAndHasNoValidValue(*result, kType, kValidTypes))
     return false;
 
   bool allRequiredExist = RequireField(*result, kGUID);
 
   bool remove = false;
   result->GetBooleanWithoutPathExpansion(kRemove, &remove);
   if (!remove) {
-    allRequiredExist &= RequireField(*result, certificate::kType);
+    allRequiredExist &= RequireField(*result, kType);
 
     std::string type;
-    result->GetStringWithoutPathExpansion(certificate::kType, &type);
+    result->GetStringWithoutPathExpansion(kType, &type);
     if (type == kClient)
       allRequiredExist &= RequireField(*result, kPKCS12);
     else if (type == kServer || type == kAuthority)
       allRequiredExist &= RequireField(*result, kX509);
   }
 
   return !error_on_missing_field_ || allRequiredExist;
 }
 
 std::string Validator::WarningHeader() {
   return MessageHeader(false);
 }
 
 std::string Validator::ErrorHeader() {
   return MessageHeader(true);
 }
 
 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