Cleanup: Remove deprecated base::Value methods from chrome/common. Use base::Value too.

chrome/common/extensions/api/extension_api_unittest.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 "chrome/common/extensions/api/extension_api.h"
 
 #include <string>
 #include <vector>
 
 #include "base/file_path.h"
@@ skipping 175 matching lines @@
   EXPECT_TRUE(apis->GetSchema("extension"));
   EXPECT_TRUE(apis->GetSchema("extension"));
   EXPECT_TRUE(apis->GetSchema("omnibox"));
   EXPECT_TRUE(apis->GetSchema("omnibox"));
   EXPECT_TRUE(apis->GetSchema("storage"));
   EXPECT_TRUE(apis->GetSchema("storage"));
 }
 
 scoped_refptr<Extension> CreateExtensionWithPermissions(
     const std::set<std::string>& permissions) {
-  DictionaryValue manifest;
+  base::DictionaryValue manifest;
   manifest.SetString("name", "extension");
   manifest.SetString("version", "1.0");
   manifest.SetInteger("manifest_version", 2);
   {
-    scoped_ptr<ListValue> permissions_list(new ListValue());
+    scoped_ptr<base::ListValue> permissions_list(new base::ListValue());
     for (std::set<std::string>::const_iterator i = permissions.begin();
         i != permissions.end(); ++i) {
-      permissions_list->Append(Value::CreateStringValue(*i));
+      permissions_list->Append(new base::StringValue(*i));
     }
     manifest.Set("permissions", permissions_list.release());
   }
 
   std::string error;
   scoped_refptr<Extension> extension(Extension::Create(
       base::FilePath(), Manifest::LOAD, manifest, Extension::NO_FLAGS, &error));
   CHECK(extension.get());
   CHECK(error.empty());
 
@@ skipping 164 matching lines @@
         Feature::BLESSED_EXTENSION_CONTEXT));
 
     EXPECT_EQ(Feature::UNSPECIFIED_LOCATION, feature->location());
     EXPECT_EQ(Feature::UNSPECIFIED_PLATFORM, feature->platform());
     EXPECT_EQ(0, feature->min_manifest_version());
     EXPECT_EQ(0, feature->max_manifest_version());
   }
 }
 
 TEST(ExtensionAPI, FeaturesRequireContexts) {
-  scoped_ptr<ListValue> schema1(new ListValue());
-  DictionaryValue* feature_definition = new DictionaryValue();
+  scoped_ptr<base::ListValue> schema1(new base::ListValue());
+  base::DictionaryValue* feature_definition = new base::DictionaryValue();
   schema1->Append(feature_definition);
   feature_definition->SetString("namespace", "test");
   feature_definition->SetBoolean("uses_feature_system", true);
 
-  scoped_ptr<ListValue> schema2(schema1->DeepCopy());
+  scoped_ptr<base::ListValue> schema2(schema1->DeepCopy());
 
-  ListValue* contexts = new ListValue();
-  contexts->Append(Value::CreateStringValue("content_script"));
+  base::ListValue* contexts = new base::ListValue();
+  contexts->Append(new base::StringValue("content_script"));
   feature_definition->Set("contexts", contexts);
 
   struct {
-    ListValue* schema;
+    base::ListValue* schema;
     bool expect_success;
   } test_data[] = {
     { schema1.get(), true },
     { schema2.get(), false }
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
     std::string schema_source;
     base::JSONWriter::Write(test_data[i].schema, &schema_source);
 
     ExtensionAPI api;
     api.RegisterSchema("test", base::StringPiece(schema_source));
     api.LoadAllSchemas();
 
     Feature* feature = api.GetFeature("test");
     EXPECT_EQ(test_data[i].expect_success, feature != NULL) << i;
   }
 }
 
-static void GetDictionaryFromList(const DictionaryValue* schema,
+static void GetDictionaryFromList(const base::DictionaryValue* schema,
                                   const std::string& list_name,
                                   const int list_index,
-                                  const DictionaryValue** out) {
-  const ListValue* list;
+                                  const base::DictionaryValue** out) {
+  const base::ListValue* list;
   EXPECT_TRUE(schema->GetList(list_name, &list));
   EXPECT_TRUE(list->GetDictionary(list_index, out));
 }
 
 TEST(ExtensionAPI, TypesHaveNamespace) {
   base::FilePath manifest_path;
   PathService::Get(chrome::DIR_TEST_DATA, &manifest_path);
   manifest_path = manifest_path.AppendASCII("extensions")
       .AppendASCII("extension_api_unittest")
       .AppendASCII("types_have_namespace.json");
 
   std::string manifest_str;
   ASSERT_TRUE(file_util::ReadFileToString(manifest_path, &manifest_str))
       << "Failed to load: " << manifest_path.value();
 
   ExtensionAPI api;
   api.RegisterSchema("test.foo", manifest_str);
   api.LoadAllSchemas();
 
-  const DictionaryValue* schema = api.GetSchema("test.foo");
+  const base::DictionaryValue* schema = api.GetSchema("test.foo");
 
-  const DictionaryValue* dict;
-  const DictionaryValue* sub_dict;
+  const base::DictionaryValue* dict;
+  const base::DictionaryValue* sub_dict;
   std::string type;
 
   GetDictionaryFromList(schema, "types", 0, &dict);
   EXPECT_TRUE(dict->GetString("id", &type));
   EXPECT_EQ("test.foo.TestType", type);
   EXPECT_TRUE(dict->GetString("customBindings", &type));
   EXPECT_EQ("test.foo.TestType", type);
   EXPECT_TRUE(dict->GetDictionary("properties", &sub_dict));
-  const DictionaryValue* property;
+  const base::DictionaryValue* property;
   EXPECT_TRUE(sub_dict->GetDictionary("foo", &property));
   EXPECT_TRUE(property->GetString("$ref", &type));
   EXPECT_EQ("test.foo.OtherType", type);
   EXPECT_TRUE(sub_dict->GetDictionary("bar", &property));
   EXPECT_TRUE(property->GetString("$ref", &type));
   EXPECT_EQ("fully.qualified.Type", type);
 
   GetDictionaryFromList(schema, "functions", 0, &dict);
   GetDictionaryFromList(dict, "parameters", 0, &sub_dict);
   EXPECT_TRUE(sub_dict->GetString("$ref", &type));
@@ skipping 14 matching lines @@
   GetDictionaryFromList(dict, "parameters", 0, &sub_dict);
   EXPECT_TRUE(sub_dict->GetString("$ref", &type));
   EXPECT_EQ("test.foo.TestType", type);
   GetDictionaryFromList(dict, "parameters", 1, &sub_dict);
   EXPECT_TRUE(sub_dict->GetString("$ref", &type));
   EXPECT_EQ("fully.qualified.Type", type);
 }
 
 }  // namespace
 }  // namespace extensions