more changes

chrome/common/json_schema_validator_unittest_base.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_validator_unittest_base.h"
 
 #include <cfloat>
 #include <cmath>
 #include <limits>
 
@@ skipping 99 matching lines @@
 void JSONSchemaValidatorTestBase::TestStringPattern() {
   // Regex patterns not supported in CPP validator.
   if (type_ == CPP)
     return;
 
   scoped_ptr<DictionaryValue> schema(new DictionaryValue());
   schema->SetString("type", "string");
   schema->SetString("pattern", "foo+");
 
   ExpectValid(TEST_SOURCE,
-              scoped_ptr<Value>(Value::CreateStringValue("foo")).get(),
+              scoped_ptr<Value>(base::StringValue::New("foo")).get(),
               schema.get(), NULL);
   ExpectValid(TEST_SOURCE,
-              scoped_ptr<Value>(Value::CreateStringValue("foooooo")).get(),
+              scoped_ptr<Value>(base::StringValue::New("foooooo")).get(),
               schema.get(), NULL);
   ExpectNotValid(TEST_SOURCE,
-                 scoped_ptr<Value>(Value::CreateStringValue("bar")).get(),
+                 scoped_ptr<Value>(base::StringValue::New("bar")).get(),
                  schema.get(), NULL, "",
                  JSONSchemaValidator::FormatErrorMessage(
                      JSONSchemaValidator::kStringPattern, "foo+"));
 }
 
 void JSONSchemaValidatorTestBase::TestEnum() {
   scoped_ptr<DictionaryValue> schema(LoadDictionary("enum_schema.json"));
 
   ExpectValid(TEST_SOURCE,
-              scoped_ptr<Value>(Value::CreateStringValue("foo")).get(),
+              scoped_ptr<Value>(base::StringValue::New("foo")).get(),
               schema.get(), NULL);
   ExpectValid(TEST_SOURCE,
-              scoped_ptr<Value>(Value::CreateIntegerValue(42)).get(),
+              scoped_ptr<Value>(base::NumberValue::New(42)).get(),
               schema.get(), NULL);
   ExpectValid(TEST_SOURCE,
-              scoped_ptr<Value>(Value::CreateBooleanValue(false)).get(),
+              scoped_ptr<Value>(base::FalseValue()).get(),
               schema.get(), NULL);
 
   ExpectNotValid(TEST_SOURCE,
-                 scoped_ptr<Value>(Value::CreateStringValue("42")).get(),
+                 scoped_ptr<Value>(base::StringValue::New("42")).get(),
                  schema.get(), NULL, "", JSONSchemaValidator::kInvalidEnum);
   ExpectNotValid(TEST_SOURCE,
-                 scoped_ptr<Value>(Value::CreateNullValue()).get(),
+                 scoped_ptr<Value>(base::NullValue()).get(),
                  schema.get(), NULL, "", JSONSchemaValidator::kInvalidEnum);
 }
 
 void JSONSchemaValidatorTestBase::TestChoices() {
   scoped_ptr<DictionaryValue> schema(LoadDictionary("choices_schema.json"));
 
   ExpectValid(TEST_SOURCE,
-              scoped_ptr<Value>(Value::CreateNullValue()).get(),
+              scoped_ptr<Value>(base::NullValue()).get(),
               schema.get(), NULL);
   ExpectValid(TEST_SOURCE,
-              scoped_ptr<Value>(Value::CreateIntegerValue(42)).get(),
+              scoped_ptr<Value>(base::NumberValue::New(42)).get(),
               schema.get(), NULL);
 
   scoped_ptr<DictionaryValue> instance(new DictionaryValue());
   instance->SetString("foo", "bar");
   ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
 
   ExpectNotValid(TEST_SOURCE,
-                 scoped_ptr<Value>(Value::CreateStringValue("foo")).get(),
+                 scoped_ptr<Value>(base::StringValue::New("foo")).get(),
                  schema.get(), NULL, "", JSONSchemaValidator::kInvalidChoice);
   ExpectNotValid(TEST_SOURCE,
                  scoped_ptr<Value>(new ListValue()).get(),
                  schema.get(), NULL, "", JSONSchemaValidator::kInvalidChoice);
 
   instance->SetInteger("foo", 42);
   ExpectNotValid(TEST_SOURCE, instance.get(),
                  schema.get(), NULL, "", JSONSchemaValidator::kInvalidChoice);
 }
 
@@ skipping 50 matching lines @@
   DictionaryValue* properties = NULL;
   DictionaryValue* bar_property = NULL;
   ASSERT_TRUE(schema->GetDictionary("properties", &properties));
   ASSERT_TRUE(properties->GetDictionary("bar", &bar_property));
 
   bar_property->SetBoolean("optional", true);
   instance->Remove("extra", NULL);
   ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
   instance->Remove("bar", NULL);
   ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
-  instance->Set("bar", Value::CreateNullValue());
+  instance->Set("bar", base::NullValue());
   ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL,
                  "bar", JSONSchemaValidator::FormatErrorMessage(
                      JSONSchemaValidator::kInvalidType, "integer", "null"));
   instance->SetString("bar", "42");
   ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL,
                  "bar", JSONSchemaValidator::FormatErrorMessage(
                      JSONSchemaValidator::kInvalidType, "integer", "string"));
 }
 
 void JSONSchemaValidatorTestBase::TestTypeReference() {
@@ skipping 53 matching lines @@
                  "baz", JSONSchemaValidator::FormatErrorMessage(
                      JSONSchemaValidator::kUnknownTypeReference,
                      "NegativeInt"));
 }
 
 void JSONSchemaValidatorTestBase::TestArrayTuple() {
   scoped_ptr<DictionaryValue> schema(LoadDictionary("array_tuple_schema.json"));
   ASSERT_TRUE(schema.get());
 
   scoped_ptr<ListValue> instance(new ListValue());
-  instance->Append(Value::CreateStringValue("42"));
-  instance->Append(Value::CreateIntegerValue(42));
+  instance->Append(base::StringValue::New("42"));
+  instance->Append(base::NumberValue::New(42));
 
   ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
 
-  instance->Append(Value::CreateStringValue("anything"));
+  instance->Append(base::StringValue::New("anything"));
   ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "",
                  JSONSchemaValidator::FormatErrorMessage(
                      JSONSchemaValidator::kArrayMaxItems, "2"));
 
   instance->Remove(1, NULL);
   instance->Remove(1, NULL);
   ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "1",
                  JSONSchemaValidator::kArrayItemRequired);
 
-  instance->Set(0, Value::CreateIntegerValue(42));
-  instance->Append(Value::CreateIntegerValue(42));
+  instance->Set(0, base::NumberValue::New(42));
+  instance->Append(base::NumberValue::New(42));
   ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "0",
                  JSONSchemaValidator::FormatErrorMessage(
                      JSONSchemaValidator::kInvalidType, "string", "integer"));
 
   DictionaryValue* additional_properties = new DictionaryValue();
   additional_properties->SetString("type", "any");
   schema->Set("additionalProperties", additional_properties);
-  instance->Set(0, Value::CreateStringValue("42"));
-  instance->Append(Value::CreateStringValue("anything"));
+  instance->Set(0, base::StringValue::New("42"));
+  instance->Append(base::StringValue::New("anything"));
   ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
   instance->Set(2, new ListValue());
   ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
 
   additional_properties->SetString("type", "boolean");
   ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "2",
                  JSONSchemaValidator::FormatErrorMessage(
                      JSONSchemaValidator::kInvalidType, "boolean", "array"));
-  instance->Set(2, Value::CreateBooleanValue(false));
+  instance->Set(2, base::FalseValue());
   ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
 
   ListValue* items_schema = NULL;
   DictionaryValue* item0_schema = NULL;
   ASSERT_TRUE(schema->GetList("items", &items_schema));
   ASSERT_TRUE(items_schema->GetDictionary(0, &item0_schema));
   item0_schema->SetBoolean("optional", true);
   instance->Remove(2, NULL);
   ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
   // TODO(aa): I think this is inconsistent with the handling of NULL+optional
   // for objects.
-  instance->Set(0, Value::CreateNullValue());
+  instance->Set(0, base::NullValue());
   ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
-  instance->Set(0, Value::CreateIntegerValue(42));
+  instance->Set(0, base::NumberValue::New(42));
   ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "0",
                  JSONSchemaValidator::FormatErrorMessage(
                      JSONSchemaValidator::kInvalidType, "string", "integer"));
 }
 
 void JSONSchemaValidatorTestBase::TestArrayNonTuple() {
   scoped_ptr<DictionaryValue> schema(new DictionaryValue());
   schema->SetString("type", "array");
   schema->SetString("items.type", "string");
   schema->SetInteger("minItems", 2);
   schema->SetInteger("maxItems", 3);
 
   scoped_ptr<ListValue> instance(new ListValue());
-  instance->Append(Value::CreateStringValue("x"));
-  instance->Append(Value::CreateStringValue("x"));
+  instance->Append(base::StringValue::New("x"));
+  instance->Append(base::StringValue::New("x"));
 
   ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
-  instance->Append(Value::CreateStringValue("x"));
+  instance->Append(base::StringValue::New("x"));
   ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
 
-  instance->Append(Value::CreateStringValue("x"));
+  instance->Append(base::StringValue::New("x"));
   ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "",
                  JSONSchemaValidator::FormatErrorMessage(
                      JSONSchemaValidator::kArrayMaxItems, "3"));
   instance->Remove(1, NULL);
   instance->Remove(1, NULL);
   instance->Remove(1, NULL);
   ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "",
                  JSONSchemaValidator::FormatErrorMessage(
                      JSONSchemaValidator::kArrayMinItems, "2"));
 
   instance->Remove(1, NULL);
-  instance->Append(Value::CreateIntegerValue(42));
+  instance->Append(base::NumberValue::New(42));
   ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "1",
                  JSONSchemaValidator::FormatErrorMessage(
                      JSONSchemaValidator::kInvalidType, "string", "integer"));
 }
 
 void JSONSchemaValidatorTestBase::TestString() {
   scoped_ptr<DictionaryValue> schema(new DictionaryValue());
   schema->SetString("type", "string");
   schema->SetInteger("minLength", 1);
   schema->SetInteger("maxLength", 10);
 
   ExpectValid(TEST_SOURCE,
-              scoped_ptr<Value>(Value::CreateStringValue("x")).get(),
+              scoped_ptr<Value>(base::StringValue::New("x")).get(),
               schema.get(), NULL);
   ExpectValid(TEST_SOURCE,
-              scoped_ptr<Value>(Value::CreateStringValue("xxxxxxxxxx")).get(),
+              scoped_ptr<Value>(base::StringValue::New("xxxxxxxxxx")).get(),
               schema.get(), NULL);
 
   ExpectNotValid(TEST_SOURCE,
-                 scoped_ptr<Value>(Value::CreateStringValue("")).get(),
+                 scoped_ptr<Value>(base::StringValue::New("")).get(),
                  schema.get(), NULL, "",
                  JSONSchemaValidator::FormatErrorMessage(
                      JSONSchemaValidator::kStringMinLength, "1"));
   ExpectNotValid(
       TEST_SOURCE,
-      scoped_ptr<Value>(Value::CreateStringValue("xxxxxxxxxxx")).get(),
+      scoped_ptr<Value>(base::StringValue::New("xxxxxxxxxxx")).get(),
       schema.get(), NULL, "",
       JSONSchemaValidator::FormatErrorMessage(
           JSONSchemaValidator::kStringMaxLength, "10"));
 
 }
 
 void JSONSchemaValidatorTestBase::TestNumber() {
   scoped_ptr<DictionaryValue> schema(new DictionaryValue());
   schema->SetString("type", "number");
   schema->SetInteger("minimum", 1);
   schema->SetInteger("maximum", 100);
   schema->SetInteger("maxDecimal", 2);
 
   ExpectValid(TEST_SOURCE,
-              scoped_ptr<Value>(Value::CreateIntegerValue(1)).get(),
+              scoped_ptr<Value>(base::NumberValue::New(1)).get(),
               schema.get(), NULL);
   ExpectValid(TEST_SOURCE,
-              scoped_ptr<Value>(Value::CreateIntegerValue(50)).get(),
+              scoped_ptr<Value>(base::NumberValue::New(50)).get(),
               schema.get(), NULL);
   ExpectValid(TEST_SOURCE,
-              scoped_ptr<Value>(Value::CreateIntegerValue(100)).get(),
+              scoped_ptr<Value>(base::NumberValue::New(100)).get(),
               schema.get(), NULL);
   ExpectValid(TEST_SOURCE,
-              scoped_ptr<Value>(Value::CreateDoubleValue(88.88)).get(),
+              scoped_ptr<Value>(base::NumberValue::New(88.88)).get(),
               schema.get(), NULL);
 
   ExpectNotValid(
       TEST_SOURCE,
-      scoped_ptr<Value>(Value::CreateDoubleValue(0.5)).get(),
+      scoped_ptr<Value>(base::NumberValue::New(0.5)).get(),
       schema.get(), NULL, "",
       JSONSchemaValidator::FormatErrorMessage(
           JSONSchemaValidator::kNumberMinimum, "1"));
   ExpectNotValid(
       TEST_SOURCE,
-      scoped_ptr<Value>(Value::CreateDoubleValue(100.1)).get(),
+      scoped_ptr<Value>(base::NumberValue::New(100.1)).get(),
       schema.get(), NULL, "",
       JSONSchemaValidator::FormatErrorMessage(
           JSONSchemaValidator::kNumberMaximum, "100"));
 }
 
 void JSONSchemaValidatorTestBase::TestTypeClassifier() {
   EXPECT_EQ("boolean", JSONSchemaValidator::GetJSONSchemaType(
-      scoped_ptr<Value>(Value::CreateBooleanValue(true)).get()));
+      scoped_ptr<Value>(base::TrueValue()).get()));
   EXPECT_EQ("boolean", JSONSchemaValidator::GetJSONSchemaType(
-      scoped_ptr<Value>(Value::CreateBooleanValue(false)).get()));
+      scoped_ptr<Value>(base::FalseValue()).get()));
 
   // It doesn't matter whether the C++ type is 'integer' or 'real'. If the
   // number is integral and within the representable range of integers in
   // double, it's classified as 'integer'.
   EXPECT_EQ("integer", JSONSchemaValidator::GetJSONSchemaType(
-      scoped_ptr<Value>(Value::CreateIntegerValue(42)).get()));
+      scoped_ptr<Value>(base::NumberValue::New(42)).get()));
   EXPECT_EQ("integer", JSONSchemaValidator::GetJSONSchemaType(
-      scoped_ptr<Value>(Value::CreateIntegerValue(0)).get()));
+      scoped_ptr<Value>(base::NumberValue::New(0)).get()));
   EXPECT_EQ("integer", JSONSchemaValidator::GetJSONSchemaType(
-      scoped_ptr<Value>(Value::CreateDoubleValue(42)).get()));
+      scoped_ptr<Value>(base::NumberValue::New(42)).get()));
   EXPECT_EQ("integer", JSONSchemaValidator::GetJSONSchemaType(
       scoped_ptr<Value>(
-          Value::CreateDoubleValue(pow(2.0, DBL_MANT_DIG))).get()));
+          base::NumberValue::New(pow(2.0, DBL_MANT_DIG))).get()));
   EXPECT_EQ("integer", JSONSchemaValidator::GetJSONSchemaType(
       scoped_ptr<Value>(
-          Value::CreateDoubleValue(pow(-2.0, DBL_MANT_DIG))).get()));
+          base::NumberValue::New(pow(-2.0, DBL_MANT_DIG))).get()));
 
   // "number" is only used for non-integral numbers, or numbers beyond what
   // double can accurately represent.
   EXPECT_EQ("number", JSONSchemaValidator::GetJSONSchemaType(
-      scoped_ptr<Value>(Value::CreateDoubleValue(88.8)).get()));
+      scoped_ptr<Value>(base::NumberValue::New(88.8)).get()));
   EXPECT_EQ("number", JSONSchemaValidator::GetJSONSchemaType(
-      scoped_ptr<Value>(Value::CreateDoubleValue(
+      scoped_ptr<Value>(base::NumberValue::New(
           pow(2.0, DBL_MANT_DIG) * 2)).get()));
   EXPECT_EQ("number", JSONSchemaValidator::GetJSONSchemaType(
-      scoped_ptr<Value>(Value::CreateDoubleValue(
+      scoped_ptr<Value>(base::NumberValue::New(
           pow(-2.0, DBL_MANT_DIG) * 2)).get()));
 
   EXPECT_EQ("string", JSONSchemaValidator::GetJSONSchemaType(
-      scoped_ptr<Value>(Value::CreateStringValue("foo")).get()));
+      scoped_ptr<Value>(base::StringValue::New("foo")).get()));
   EXPECT_EQ("array", JSONSchemaValidator::GetJSONSchemaType(
       scoped_ptr<Value>(new ListValue()).get()));
   EXPECT_EQ("object", JSONSchemaValidator::GetJSONSchemaType(
       scoped_ptr<Value>(new DictionaryValue()).get()));
   EXPECT_EQ("null", JSONSchemaValidator::GetJSONSchemaType(
-      scoped_ptr<Value>(Value::CreateNullValue()).get()));
+      scoped_ptr<Value>(base::NullValue()).get()));
 }
 
 void JSONSchemaValidatorTestBase::TestTypes() {
   scoped_ptr<DictionaryValue> schema(new DictionaryValue());
 
   // valid
   schema->SetString("type", "object");
   ExpectValid(TEST_SOURCE, scoped_ptr<Value>(new DictionaryValue()).get(),
               schema.get(), NULL);
 
   schema->SetString("type", "array");
   ExpectValid(TEST_SOURCE, scoped_ptr<Value>(new ListValue()).get(),
               schema.get(), NULL);
 
   schema->SetString("type", "string");
   ExpectValid(TEST_SOURCE,
-              scoped_ptr<Value>(Value::CreateStringValue("foobar")).get(),
+              scoped_ptr<Value>(base::StringValue::New("foobar")).get(),
               schema.get(), NULL);
 
   schema->SetString("type", "number");
   ExpectValid(TEST_SOURCE,
-              scoped_ptr<Value>(Value::CreateDoubleValue(88.8)).get(),
+              scoped_ptr<Value>(base::NumberValue::New(88.8)).get(),
               schema.get(), NULL);
   ExpectValid(TEST_SOURCE,
-              scoped_ptr<Value>(Value::CreateDoubleValue(42)).get(),
+              scoped_ptr<Value>(base::NumberValue::New(42)).get(),
               schema.get(), NULL);
   ExpectValid(TEST_SOURCE,
-              scoped_ptr<Value>(Value::CreateIntegerValue(42)).get(),
+              scoped_ptr<Value>(base::NumberValue::New(42)).get(),
               schema.get(), NULL);
   ExpectValid(TEST_SOURCE,
-              scoped_ptr<Value>(Value::CreateIntegerValue(0)).get(),
+              scoped_ptr<Value>(base::NumberValue::New(0)).get(),
               schema.get(), NULL);
 
   schema->SetString("type", "integer");
   ExpectValid(TEST_SOURCE,
-              scoped_ptr<Value>(Value::CreateIntegerValue(42)).get(),
+              scoped_ptr<Value>(base::NumberValue::New(42)).get(),
               schema.get(), NULL);
   ExpectValid(TEST_SOURCE,
-              scoped_ptr<Value>(Value::CreateDoubleValue(42)).get(),
+              scoped_ptr<Value>(base::NumberValue::New(42)).get(),
               schema.get(), NULL);
   ExpectValid(TEST_SOURCE,
-              scoped_ptr<Value>(Value::CreateIntegerValue(0)).get(),
+              scoped_ptr<Value>(base::NumberValue::New(0)).get(),
               schema.get(), NULL);
   ExpectValid(TEST_SOURCE,
               scoped_ptr<Value>(
-                  Value::CreateDoubleValue(pow(2.0, DBL_MANT_DIG))).get(),
+                  base::NumberValue::New(pow(2.0, DBL_MANT_DIG))).get(),
               schema.get(), NULL);
   ExpectValid(TEST_SOURCE,
               scoped_ptr<Value>(
-                  Value::CreateDoubleValue(pow(-2.0, DBL_MANT_DIG))).get(),
+                  base::NumberValue::New(pow(-2.0, DBL_MANT_DIG))).get(),
               schema.get(), NULL);
 
   schema->SetString("type", "boolean");
   ExpectValid(TEST_SOURCE,
-              scoped_ptr<Value>(Value::CreateBooleanValue(false)).get(),
+              scoped_ptr<Value>(base::FalseValue()).get(),
               schema.get(), NULL);
   ExpectValid(TEST_SOURCE,
-              scoped_ptr<Value>(Value::CreateBooleanValue(true)).get(),
+              scoped_ptr<Value>(base::TrueValue()).get(),
               schema.get(), NULL);
 
   schema->SetString("type", "null");
   ExpectValid(TEST_SOURCE,
-              scoped_ptr<Value>(Value::CreateNullValue()).get(),
+              scoped_ptr<Value>(base::NullValue()).get(),
               schema.get(), NULL);
 
   // not valid
   schema->SetString("type", "object");
   ExpectNotValid(TEST_SOURCE, scoped_ptr<Value>(new ListValue()).get(),
                  schema.get(), NULL, "",
                  JSONSchemaValidator::FormatErrorMessage(
                      JSONSchemaValidator::kInvalidType, "object", "array"));
 
   schema->SetString("type", "object");
-  ExpectNotValid(TEST_SOURCE, scoped_ptr<Value>(Value::CreateNullValue()).get(),
+  ExpectNotValid(TEST_SOURCE, scoped_ptr<Value>(base::NullValue()).get(),
                  schema.get(), NULL, "",
                  JSONSchemaValidator::FormatErrorMessage(
                      JSONSchemaValidator::kInvalidType, "object", "null"));
 
   schema->SetString("type", "array");
   ExpectNotValid(TEST_SOURCE,
-                 scoped_ptr<Value>(Value::CreateIntegerValue(42)).get(),
+                 scoped_ptr<Value>(base::NumberValue::New(42)).get(),
                  schema.get(), NULL, "",
                  JSONSchemaValidator::FormatErrorMessage(
                      JSONSchemaValidator::kInvalidType, "array", "integer"));
 
   schema->SetString("type", "string");
   ExpectNotValid(TEST_SOURCE,
-                 scoped_ptr<Value>(Value::CreateIntegerValue(42)).get(),
+                 scoped_ptr<Value>(base::NumberValue::New(42)).get(),
                  schema.get(), NULL, "",
                  JSONSchemaValidator::FormatErrorMessage(
                      JSONSchemaValidator::kInvalidType, "string", "integer"));
 
   schema->SetString("type", "number");
   ExpectNotValid(TEST_SOURCE,
-                 scoped_ptr<Value>(Value::CreateStringValue("42")).get(),
+                 scoped_ptr<Value>(base::StringValue::New("42")).get(),
                  schema.get(), NULL, "",
                  JSONSchemaValidator::FormatErrorMessage(
                      JSONSchemaValidator::kInvalidType, "number", "string"));
 
   schema->SetString("type", "integer");
   ExpectNotValid(TEST_SOURCE,
-                 scoped_ptr<Value>(Value::CreateDoubleValue(88.8)).get(),
+                 scoped_ptr<Value>(base::NumberValue::New(88.8)).get(),
                  schema.get(), NULL, "",
                  JSONSchemaValidator::FormatErrorMessage(
                      JSONSchemaValidator::kInvalidType, "integer", "number"));
 
   schema->SetString("type", "integer");
   ExpectNotValid(TEST_SOURCE,
-                 scoped_ptr<Value>(Value::CreateDoubleValue(88.8)).get(),
+                 scoped_ptr<Value>(base::NumberValue::New(88.8)).get(),
                  schema.get(), NULL, "",
                  JSONSchemaValidator::FormatErrorMessage(
                      JSONSchemaValidator::kInvalidType, "integer", "number"));
 
   schema->SetString("type", "boolean");
   ExpectNotValid(TEST_SOURCE,
-                 scoped_ptr<Value>(Value::CreateIntegerValue(1)).get(),
+                 scoped_ptr<Value>(base::NumberValue::New(1)).get(),
                  schema.get(), NULL, "",
                  JSONSchemaValidator::FormatErrorMessage(
                      JSONSchemaValidator::kInvalidType, "boolean", "integer"));
 
   schema->SetString("type", "null");
   ExpectNotValid(TEST_SOURCE,
-                 scoped_ptr<Value>(Value::CreateBooleanValue(false)).get(),
+                 scoped_ptr<Value>(base::FalseValue()).get(),
                  schema.get(), NULL, "",
                  JSONSchemaValidator::FormatErrorMessage(
                      JSONSchemaValidator::kInvalidType, "null", "boolean"));
 }