Adding a NetworkProfileHandler used by ManagedNetworkConfigurationHandler.

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 74 matching lines @@
   }
 
   return make_scoped_ptr(result_dict);
 }
 
 scoped_ptr<base::Value> Validator::MapValue(
     const OncValueSignature& signature,
     const base::Value& onc_value,
     bool* error) {
   if (onc_value.GetType() != signature.onc_type) {
-    LOG(ERROR) << ErrorHeader() << "Found value '" << onc_value
+    LOG(ERROR) << MessageHeader() << "Found value '" << onc_value
                << "' of type '" << ValueTypeToString(onc_value.GetType())
                << "', but type '" << ValueTypeToString(signature.onc_type)
                << "' is required.";
     error_or_warning_found_ = *error = true;
     return scoped_ptr<base::Value>();
   }
 
   scoped_ptr<base::Value> repaired =
       Mapper::MapValue(signature, onc_value, error);
   if (repaired.get() != NULL)
@@ skipping 55 matching lines @@
   path_.push_back(field_name);
   bool current_field_unknown = false;
   scoped_ptr<base::Value> result = Mapper::MapField(
       field_name, object_signature, onc_value, &current_field_unknown, error);
 
   DCHECK_EQ(field_name, path_.back());
   path_.pop_back();
 
   if (current_field_unknown) {
     error_or_warning_found_ = *found_unknown_field = true;
-    std::string message = MessageHeader(error_on_unknown_field_)
-        + "Field name '" + field_name + "' is unknown.";
+    std::string message = MessageHeader() + "Field name '" + field_name +
+        "' is unknown.";
     if (error_on_unknown_field_)
       LOG(ERROR) << message;
     else
       LOG(WARNING) << message;
   }
 
   return result.Pass();
 }
 
 scoped_ptr<base::ListValue> Validator::MapArray(
@@ skipping 60 matching lines @@
     return true;
   }
   base::ListValue* recommended_list = NULL;
   recommended_value->GetAsList(&recommended_list);
   CHECK(recommended_list != NULL);
 
   recommended.reset(recommended_list);
 
   if (!managed_onc_) {
     error_or_warning_found_ = true;
-    LOG(WARNING) << WarningHeader() << "Found the field '" << onc::kRecommended
+    LOG(WARNING) << MessageHeader() << "Found the field '" << onc::kRecommended
                  << "' in an unmanaged ONC. Removing it.";
     return true;
   }
 
   scoped_ptr<base::ListValue> repaired_recommended(new base::ListValue);
   for (base::ListValue::iterator it = recommended->begin();
        it != recommended->end(); ++it) {
     std::string field_name;
     if (!(*it)->GetAsString(&field_name)) {
       NOTREACHED();
@@ skipping 10 matching lines @@
       error_cause = "unknown";
     } else if (field_signature->value_signature->onc_type ==
                base::Value::TYPE_DICTIONARY) {
       found_error = true;
       error_cause = "dictionary-typed";
     }
 
     if (found_error) {
       error_or_warning_found_ = true;
       path_.push_back(onc::kRecommended);
-      std::string message = MessageHeader(error_on_wrong_recommended_) +
-          "The " + error_cause + " field '" + field_name +
-          "' cannot be recommended.";
+      std::string message = MessageHeader() + "The " + error_cause +
+          " field '" + field_name + "' cannot be recommended.";
       path_.pop_back();
       if (error_on_wrong_recommended_) {
         LOG(ERROR) << message;
         return false;
       } else {
         LOG(WARNING) << message;
         continue;
       }
     }
 
@@ skipping 26 matching lines @@
 
   const char** it = valid_values;
   for (; *it != NULL; ++it) {
     if (actual_value == *it)
       return false;
   }
   error_or_warning_found_ = true;
   std::string valid_values_str =
       "[" + JoinStringRange(valid_values, it, ", ") + "]";
   path_.push_back(field_name);
-  LOG(ERROR) << ErrorHeader() << "Found value '" << actual_value <<
+  LOG(ERROR) << MessageHeader() << "Found value '" << actual_value <<
       "', but expected one of the values " << valid_values_str;
   path_.pop_back();
   return true;
 }
 
 bool Validator::FieldExistsAndIsNotInRange(const base::DictionaryValue& object,
                                            const std::string &field_name,
                                            int lower_bound,
                                            int upper_bound) {
   int actual_value;
   if (!object.GetIntegerWithoutPathExpansion(field_name, &actual_value) ||
       (lower_bound <= actual_value && actual_value <= upper_bound)) {
     return false;
   }
   error_or_warning_found_ = true;
   path_.push_back(field_name);
-  LOG(ERROR) << ErrorHeader() << "Found value '" << actual_value
+  LOG(ERROR) << MessageHeader() << "Found value '" << actual_value
              << "', but expected a value in the range [" << lower_bound
              << ", " << upper_bound << "] (boundaries inclusive)";
   path_.pop_back();
   return true;
 }
 
 bool Validator::FieldExistsAndIsEmpty(const base::DictionaryValue& object,
                                       const std::string& field_name) {
   std::string value;
   if (!object.GetStringWithoutPathExpansion(field_name, &value) ||
       !value.empty()) {
     return false;
   }
 
   error_or_warning_found_ = true;
   path_.push_back(field_name);
-  LOG(ERROR) << ErrorHeader() << "Found an empty string, but expected a "
+  LOG(ERROR) << MessageHeader() << "Found an empty string, but expected a "
              << "non-empty string.";
   path_.pop_back();
   return true;
 }
 
 bool Validator::RequireField(const base::DictionaryValue& dict,
                              const std::string& field_name) {
   if (dict.HasKey(field_name))
     return true;
   error_or_warning_found_ = true;
-  LOG(ERROR) << ErrorHeader() << "The required field '" << field_name
-             << "' is missing.";
+  std::string message = MessageHeader() + "The required field '" + field_name +
+      "' is missing.";
+  if (error_on_missing_field_)
+    LOG(ERROR) << message;
+  else
+    LOG(WARNING) << message;
   return false;
 }
 
 // Prohibit certificate patterns for device policy ONC so that an unmanaged user
 // won't have a certificate presented for them involuntarily.
 bool Validator::CertPatternInDevicePolicy(const std::string& cert_type) {
   if (cert_type == certificate::kPattern &&
       onc_source_ == ONC_SOURCE_DEVICE_POLICY) {
     error_or_warning_found_ = true;
-    LOG(ERROR) << ErrorHeader() << "Client certificate patterns are "
+    LOG(ERROR) << MessageHeader() << "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;
 
   static const char* 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.";
+    std::string message = MessageHeader() + "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;
 }
 
@@ skipping 22 matching lines @@
 
     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 != network_type::kWiFi &&
         type != network_type::kEthernet) {
       error_or_warning_found_ = true;
-      LOG(ERROR) << ErrorHeader() << "Networks of type '"
+      LOG(ERROR) << MessageHeader() << "Networks of type '"
                  << type << "' are prohibited in ONC device policies.";
       return false;
     }
 
     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);
@@ skipping 179 matching lines @@
 bool Validator::ValidateCertificatePattern(
     const base::DictionaryValue& onc_object,
     base::DictionaryValue* result) {
   using namespace onc::certificate;
 
   bool allRequiredExist = true;
   if (!result->HasKey(kSubject) && !result->HasKey(kIssuer) &&
       !result->HasKey(kIssuerCARef)) {
     error_or_warning_found_ = true;
     allRequiredExist = false;
-    std::string message = MessageHeader(error_on_missing_field_) +
-        "None of the fields '" + kSubject + "', '" + kIssuer + "', and '" +
-        kIssuerCARef + "' is present, but at least one is required.";
+    std::string message = MessageHeader() + "None of the fields '" + kSubject +
+        "', '" + kIssuer + "', and '" + kIssuerCARef +
+        "' is present, but at least one is required.";
     if (error_on_missing_field_)
       LOG(ERROR) << message;
     else
       LOG(WARNING) << message;
   }
 
   return !error_on_missing_field_ || allRequiredExist;
 }
 
 bool Validator::ValidateProxySettings(const base::DictionaryValue& onc_object,
@@ skipping 69 matching lines @@
   if (FieldExistsAndHasNoValidValue(*result, kType, kValidTypes) ||
       FieldExistsAndIsEmpty(*result, kGUID)) {
     return false;
   }
 
   std::string type;
   result->GetStringWithoutPathExpansion(kType, &type);
   if (onc_source_ == ONC_SOURCE_DEVICE_POLICY &&
       (type == kServer || type == kAuthority)) {
     error_or_warning_found_ = true;
-    LOG(ERROR) << ErrorHeader() << "Server and authority certificates are "
+    LOG(ERROR) << MessageHeader() << "Server and authority certificates are "
                << "prohibited in ONC device policies.";
     return false;
   }
 
   bool allRequiredExist = RequireField(*result, kGUID);
 
   bool remove = false;
   result->GetBooleanWithoutPathExpansion(kRemove, &remove);
   if (!remove) {
     allRequiredExist &= RequireField(*result, kType);
 
     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 Validator::MessageHeader() {
   std::string path = path_.empty() ? "toplevel" : JoinString(path_, ".");
   std::string message = "At " + path + ": ";
   return message;
 }
 
 }  // namespace onc
 }  // namespace chromeos