Add base::Value::GetTypeName().

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 12 matching lines @@
 namespace {
 
 // According to the IEEE 802.11 standard the SSID is a series of 0 to 32 octets.
 const int kMaximumSSIDLengthInBytes = 32;
 
 template <typename T, size_t N>
 std::vector<T> toVector(T const (&array)[N]) {
   return std::vector<T>(array, array + N);
 }
 
-// Copied from policy/configuration_policy_handler.cc.
-// TODO(pneubeck): move to a common place like base/.
-std::string ValueTypeToString(base::Value::Type type) {
-  const char* const strings[] = {"null",   "boolean", "integer",    "double",
-                                 "string", "binary",  "dictionary", "list"};
-  CHECK(static_cast<size_t>(type) < arraysize(strings));
-  return strings[type];
-}
-
 }  // namespace
 
 Validator::Validator(bool error_on_unknown_field,
                      bool error_on_wrong_recommended,
                      bool error_on_missing_field,
                      bool managed_onc)
     : error_on_unknown_field_(error_on_unknown_field),
       error_on_wrong_recommended_(error_on_wrong_recommended),
       error_on_missing_field_(error_on_missing_field),
       managed_onc_(managed_onc),
@@ skipping 11 matching lines @@
   bool error = false;
   std::unique_ptr<base::Value> result_value =
       MapValue(*object_signature, onc_object, &error);
   if (error) {
     *result = INVALID;
     result_value.reset();
   } else if (error_or_warning_found_) {
     *result = VALID_WITH_WARNINGS;
   }
   // The return value should be NULL if, and only if, |result| equals INVALID.
-  DCHECK_EQ(result_value.get() == NULL, *result == INVALID);
-
-  base::DictionaryValue* result_dict = NULL;
-  if (result_value) {
-    result_value.release()->GetAsDictionary(&result_dict);
-    CHECK(result_dict);
-  }
-
-  return base::WrapUnique(result_dict);
+  DCHECK_EQ(!result_value, *result == INVALID);
+  return base::DictionaryValue::From(result_value);

[Lei Zhang, 2016/07/14 10:26:41]

forgot a std::move(), will load new patch set later.

[pneubeck (no reviews), 2016/07/14 18:51:37]

Slight difference to the old version is the dropped CHECK(result_dict).
Probably OK to drop.

[Lei Zhang, 2016/07/15 01:27:18]

base::DictionaryValue::From() internally does the same thing, and understands
the CHECK is not necessary.

 }
 
 std::unique_ptr<base::Value> Validator::MapValue(
     const OncValueSignature& signature,
     const base::Value& onc_value,
     bool* error) {
   if (onc_value.GetType() != signature.onc_type) {
     LOG(ERROR) << MessageHeader() << "Found value '" << onc_value
-               << "' of type '" << ValueTypeToString(onc_value.GetType())
-               << "', but type '" << ValueTypeToString(signature.onc_type)
+               << "' of type '" << base::Value::GetTypeName(onc_value.GetType())
+               << "', but type '"
+               << base::Value::GetTypeName(signature.onc_type)
                << "' is required.";
     error_or_warning_found_ = *error = true;
     return std::unique_ptr<base::Value>();
   }
 
   std::unique_ptr<base::Value> repaired =
       Mapper::MapValue(signature, onc_value, error);
   if (repaired)
     CHECK_EQ(repaired->GetType(), signature.onc_type);
   return repaired;
@@ skipping 37 matching lines @@
       valid = ValidateProxySettings(repaired.get());
     } else if (&signature == &kProxyLocationSignature) {
       valid = ValidateProxyLocation(repaired.get());
     } else if (&signature == &kEAPSignature) {
       valid = ValidateEAP(repaired.get());
     } else if (&signature == &kCertificateSignature) {
       valid = ValidateCertificate(repaired.get());
     }
   }
 
-  if (valid) {
+  if (valid)
     return repaired;
-  } else {
-    DCHECK(error_or_warning_found_);
-    error_or_warning_found_ = *error = true;
-    return std::unique_ptr<base::DictionaryValue>();
-  }
+
+  DCHECK(error_or_warning_found_);
+  error_or_warning_found_ = *error = true;
+  return std::unique_ptr<base::DictionaryValue>();
 }
 
 std::unique_ptr<base::Value> Validator::MapField(
     const std::string& field_name,
     const OncValueSignature& object_signature,
     const base::Value& onc_value,
     bool* found_unknown_field,
     bool* error) {
   path_.push_back(field_name);
   bool current_field_unknown = false;
@@ skipping 115 matching lines @@
 
     if (found_error) {
       error_or_warning_found_ = true;
       path_.push_back(::onc::kRecommended);
       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;
       }
+
+      LOG(WARNING) << message;
+      continue;
     }
 
     repaired_recommended->AppendString(field_name);
   }
 
   result->Set(::onc::kRecommended, repaired_recommended.release());
   return true;
 }
 
 bool Validator::ValidateClientCertFields(bool allow_cert_type_none,
@@ skipping 134 matching lines @@
   std::string ssid_string;
   if (object->GetStringWithoutPathExpansion(::onc::wifi::kSSID, &ssid_string) &&
       (ssid_string.size() <= 0 ||
        ssid_string.size() > kMaximumSSIDLengthInBytes)) {
     error_or_warning_found_ = true;
     const std::string msg =
         MessageHeader() + ::onc::wifi::kSSID + " has an invalid length.";
     // If the HexSSID field is present, ignore errors in SSID because these
     // might be caused by the usage of a non-UTF-8 encoding when the SSID
     // field was automatically added (see FillInHexSSIDField).
-    if (object->HasKey(::onc::wifi::kHexSSID)) {
-      LOG(WARNING) << msg;
-    } else {
+    if (!object->HasKey(::onc::wifi::kHexSSID)) {
       LOG(ERROR) << msg;
       return false;
     }
+    LOG(WARNING) << msg;
   }
 
   // Check HexSSID validity.
   std::string hex_ssid_string;
   if (object->GetStringWithoutPathExpansion(::onc::wifi::kHexSSID,
                                             &hex_ssid_string)) {
     std::vector<uint8_t> decoded_ssid;
     if (!base::HexStringToBytes(hex_ssid_string, &decoded_ssid)) {
       LOG(ERROR) << MessageHeader() << "Field " << ::onc::wifi::kHexSSID
                  << " is not a valid hex representation: \"" << hex_ssid_string
@@ skipping 568 matching lines @@
 }
 
 std::string Validator::MessageHeader() {
   std::string path = path_.empty() ? "toplevel" : base::JoinString(path_, ".");
   std::string message = "At " + path + ": ";
   return message;
 }
 
 }  // namespace onc
 }  // namespace chromeos