Moved chrome/common/json_schema to components/json_schema.

components/json_schema/json_schema_validator.cc

 // Copyright (c) 2011 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 "chrome/common/json_schema/json_schema_validator.h"
+#include "components/json_schema/json_schema_validator.h"
 
 #include <algorithm>
 #include <cfloat>
 #include <cmath>
 
 #include "base/json/json_reader.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
-#include "chrome/common/json_schema/json_schema_constants.h"
+#include "components/json_schema/json_schema_constants.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace schema = json_schema_constants;
 
 namespace {
 
 double GetNumberValue(const base::Value* value) {
   double result = 0;
   CHECK(value->GetAsDouble(&result))
       << "Unexpected value type: " << value->GetType();
@@ skipping 545 matching lines @@
         errors_.push_back(Error(path, FormatErrorMessage(
             kArrayMaxItems, base::IntToString(max_items))));
       }
     }
 
     // If the items property is a single schema, each item in the array must
     // validate against that schema.
     for (size_t i = 0; i < instance_size; ++i) {
       const base::Value* item = NULL;
       CHECK(instance->Get(i, &item));
-      std::string i_str = base::UintToString(i);
+      std::string i_str = base::Uint64ToString(i);
       std::string item_path = path.empty() ? i_str : (path + "." + i_str);
       Validate(item, single_type, item_path);
     }
 
     return;
   }
 
   // Otherwise, the list must be a tuple type, where each item in the list has a
   // particular schema.
   ValidateTuple(instance, schema, path);
 }
 
 void JSONSchemaValidator::ValidateTuple(const base::ListValue* instance,
                                         const base::DictionaryValue* schema,
                                         const std::string& path) {
   const base::ListValue* tuple_type = NULL;
   schema->GetList(schema::kItems, &tuple_type);
   size_t tuple_size = tuple_type ? tuple_type->GetSize() : 0;
   if (tuple_type) {
     for (size_t i = 0; i < tuple_size; ++i) {
-      std::string i_str = base::UintToString(i);
+      std::string i_str = base::Uint64ToString(i);
       std::string item_path = path.empty() ? i_str : (path + "." + i_str);
       const base::DictionaryValue* item_schema = NULL;
       CHECK(tuple_type->GetDictionary(i, &item_schema));
       const base::Value* item_value = NULL;
       instance->Get(i, &item_value);
       if (item_value && item_value->GetType() != base::Value::TYPE_NULL) {
         Validate(item_value, item_schema, item_path);
       } else {
         bool is_optional = false;
         item_schema->GetBoolean(schema::kOptional, &is_optional);
         if (!is_optional) {
           errors_.push_back(Error(item_path, kArrayItemRequired));
           return;
         }
       }
     }
   }
 
   const base::DictionaryValue* additional_properties_schema = NULL;
   if (SchemaAllowsAnyAdditionalItems(schema, &additional_properties_schema))
     return;
 
   size_t instance_size = instance->GetSize();
   if (additional_properties_schema) {
     // Any additional properties must validate against the additionalProperties
     // schema.
     for (size_t i = tuple_size; i < instance_size; ++i) {
-      std::string i_str = base::UintToString(i);
+      std::string i_str = base::Uint64ToString(i);
       std::string item_path = path.empty() ? i_str : (path + "." + i_str);
       const base::Value* item_value = NULL;
       CHECK(instance->Get(i, &item_value));
       Validate(item_value, additional_properties_schema, item_path);
     }
   } else if (instance_size > tuple_size) {
     errors_.push_back(Error(path, FormatErrorMessage(
-        kArrayMaxItems, base::UintToString(tuple_size))));
+        kArrayMaxItems, base::Uint64ToString(tuple_size))));
   }
 }
 
 void JSONSchemaValidator::ValidateString(const base::Value* instance,
                                          const base::DictionaryValue* schema,
                                          const std::string& path) {
   std::string value;
   CHECK(instance->GetAsString(&value));
 
   int min_length = 0;
@@ skipping 68 matching lines @@
 
   if (*additional_properties_schema) {
     std::string additional_properties_type(schema::kAny);
     CHECK((*additional_properties_schema)->GetString(
         schema::kType, &additional_properties_type));
     return additional_properties_type == schema::kAny;
   } else {
     return default_allow_additional_properties_;
   }
 }