Add an ONC property for the third-party VPN provider extension ID

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 "base/json/json_writer.h"
 #include "base/logging.h"
@@ skipping 104 matching lines @@
                &signature == &kStaticIPConfigSignature) {
       valid = ValidateIPConfig(repaired.get());
     } else if (&signature == &kWiFiSignature) {
       valid = ValidateWiFi(repaired.get());
     } else if (&signature == &kVPNSignature) {
       valid = ValidateVPN(repaired.get());
     } else if (&signature == &kIPsecSignature) {
       valid = ValidateIPsec(repaired.get());
     } else if (&signature == &kOpenVPNSignature) {
       valid = ValidateOpenVPN(repaired.get());
+    } else if (&signature == &kThirdPartyVPNSignature) {
+      valid = ValidateThirdPartyVPN(repaired.get());
     } else if (&signature == &kVerifyX509Signature) {
       valid = ValidateVerifyX509(repaired.get());
     } else if (&signature == &kCertificatePatternSignature) {
       valid = ValidateCertificatePattern(repaired.get());
     } else if (&signature == &kProxySettingsSignature) {
       valid = ValidateProxySettings(repaired.get());
     } else if (&signature == &kProxyLocationSignature) {
       valid = ValidateProxyLocation(repaired.get());
     } else if (&signature == &kEAPSignature) {
       valid = ValidateEAP(repaired.get());
@@ skipping 541 matching lines @@
     all_required_exist &= RequireField(*result, kEAP);
   else if (security == kWEP_PSK || security == kWPA_PSK)
     all_required_exist &= RequireField(*result, kPassphrase);
 
   return !error_on_missing_field_ || all_required_exist;
 }
 
 bool Validator::ValidateVPN(base::DictionaryValue* result) {
   using namespace ::onc::vpn;
 
-  const char* const kValidTypes[] = {kIPsec, kTypeL2TP_IPsec, kOpenVPN};
+  const char* const kValidTypes[] = {
+      kIPsec, kTypeL2TP_IPsec, kOpenVPN, kThirdPartyVpn};
   const std::vector<const char*> valid_types(toVector(kValidTypes));
   if (FieldExistsAndHasNoValidValue(*result, ::onc::vpn::kType, valid_types))
     return false;
 
   bool all_required_exist = RequireField(*result, ::onc::vpn::kType);
   std::string type;
   result->GetStringWithoutPathExpansion(::onc::vpn::kType, &type);
   if (type == kOpenVPN) {
     all_required_exist &= RequireField(*result, kOpenVPN);
   } else if (type == kIPsec) {
     all_required_exist &= RequireField(*result, kIPsec);
   } else if (type == kTypeL2TP_IPsec) {
     all_required_exist &=
         RequireField(*result, kIPsec) && RequireField(*result, kL2TP);
+  } else if (type == kThirdPartyVpn) {
+    all_required_exist &= RequireField(*result, kThirdPartyVpn);
   }
 
   return !error_on_missing_field_ || all_required_exist;
 }
 
 bool Validator::ValidateIPsec(base::DictionaryValue* result) {
   using namespace ::onc::ipsec;
 
   const char* const kValidAuthentications[] = {kPSK, kCert};
   const std::vector<const char*> valid_authentications(
@@ skipping 84 matching lines @@
 
   if (!ValidateClientCertFields(true /* allow ClientCertType None */, result))
     return false;
 
   bool all_required_exist =
       RequireField(*result, ::onc::client_cert::kClientCertType);
 
   return !error_on_missing_field_ || all_required_exist;
 }
 
+bool Validator::ValidateThirdPartyVPN(base::DictionaryValue* result) {
+  const bool all_required_exist =
+      RequireField(*result, ::onc::third_party_vpn::kExtensionID);
+
+  return !error_on_missing_field_ || all_required_exist;
+}
+
 bool Validator::ValidateVerifyX509(base::DictionaryValue* result) {
   using namespace ::onc::verify_x509;
 
   const char* const kValidTypes[] = {types::kName, types::kNamePrefix,
                                      types::kSubject};
   const std::vector<const char*> valid_types(toVector(kValidTypes));
 
   if (FieldExistsAndHasNoValidValue(*result, kType, valid_types))
     return false;
 
@@ skipping 124 matching lines @@
 }
 
 std::string Validator::MessageHeader() {
   std::string path = path_.empty() ? "toplevel" : JoinString(path_, ".");
   std::string message = "At " + path + ": ";
   return message;
 }
 
 }  // namespace onc
 }  // namespace chromeos