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

chrome/common/extensions/features/simple_feature_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/features/simple_feature.h"
 
 #include "chrome/common/extensions/value_builder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using chrome::VersionInfo;
@@ skipping 109 matching lines @@
 }
 
 TEST_F(ExtensionSimpleFeatureTest, Context) {
   SimpleFeature feature;
   feature.GetContexts()->insert(Feature::BLESSED_EXTENSION_CONTEXT);
   feature.extension_types()->insert(Manifest::TYPE_LEGACY_PACKAGED_APP);
   feature.set_platform(Feature::CHROMEOS_PLATFORM);
   feature.set_min_manifest_version(21);
   feature.set_max_manifest_version(25);
 
-  DictionaryValue manifest;
+  base::DictionaryValue manifest;
   manifest.SetString("name", "test");
   manifest.SetString("version", "1");
   manifest.SetInteger("manifest_version", 21);
   manifest.SetString("app.launch.local_path", "foo.html");
 
   std::string error;
   scoped_refptr<const Extension> extension(Extension::Create(
       base::FilePath(), Manifest::INTERNAL, manifest, Extension::NO_FLAGS,
       &error));
   EXPECT_EQ("", error);
@@ skipping 104 matching lines @@
   EXPECT_EQ(Feature::IS_AVAILABLE,
             feature.IsAvailableToManifest(
                 "", Manifest::TYPE_UNKNOWN, Feature::UNSPECIFIED_LOCATION,
                 8, Feature::UNSPECIFIED_PLATFORM).result());
   EXPECT_EQ(Feature::IS_AVAILABLE, feature.IsAvailableToManifest(
       "", Manifest::TYPE_UNKNOWN, Feature::UNSPECIFIED_LOCATION,
       7, Feature::UNSPECIFIED_PLATFORM).result());
 }
 
 TEST_F(ExtensionSimpleFeatureTest, ParseNull) {
-  scoped_ptr<DictionaryValue> value(new DictionaryValue());
+  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
   scoped_ptr<SimpleFeature> feature(new SimpleFeature());
   feature->Parse(value.get());
   EXPECT_TRUE(feature->whitelist()->empty());
   EXPECT_TRUE(feature->extension_types()->empty());
   EXPECT_TRUE(feature->GetContexts()->empty());
   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_F(ExtensionSimpleFeatureTest, ParseWhitelist) {
-  scoped_ptr<DictionaryValue> value(new DictionaryValue());
-  ListValue* whitelist = new ListValue();
-  whitelist->Append(Value::CreateStringValue("foo"));
-  whitelist->Append(Value::CreateStringValue("bar"));
+  scoped_ptr<base::DictionaryValue> value(new DictionaryValue());
+  base::ListValue* whitelist = new base::ListValue();
+  whitelist->Append(new base::StringValue("foo"));
+  whitelist->Append(new base::StringValue("bar"));
   value->Set("whitelist", whitelist);
   scoped_ptr<SimpleFeature> feature(new SimpleFeature());
   feature->Parse(value.get());
   EXPECT_EQ(2u, feature->whitelist()->size());
   EXPECT_TRUE(feature->whitelist()->count("foo"));
   EXPECT_TRUE(feature->whitelist()->count("bar"));
 }
 
 TEST_F(ExtensionSimpleFeatureTest, ParsePackageTypes) {
-  scoped_ptr<DictionaryValue> value(new DictionaryValue());
-  ListValue* extension_types = new ListValue();
-  extension_types->Append(Value::CreateStringValue("extension"));
-  extension_types->Append(Value::CreateStringValue("theme"));
-  extension_types->Append(Value::CreateStringValue("packaged_app"));
-  extension_types->Append(Value::CreateStringValue("hosted_app"));
-  extension_types->Append(Value::CreateStringValue("platform_app"));
+  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+  base::ListValue* extension_types = new base::ListValue();
+  extension_types->Append(new base::StringValue("extension"));
+  extension_types->Append(new base::StringValue("theme"));
+  extension_types->Append(new base::StringValue("packaged_app"));
+  extension_types->Append(new base::StringValue("hosted_app"));
+  extension_types->Append(new base::StringValue("platform_app"));
   value->Set("extension_types", extension_types);
   scoped_ptr<SimpleFeature> feature(new SimpleFeature());
   feature->Parse(value.get());
   EXPECT_EQ(5u, feature->extension_types()->size());
   EXPECT_TRUE(feature->extension_types()->count(Manifest::TYPE_EXTENSION));
   EXPECT_TRUE(feature->extension_types()->count(Manifest::TYPE_THEME));
   EXPECT_TRUE(feature->extension_types()->count(
       Manifest::TYPE_LEGACY_PACKAGED_APP));
   EXPECT_TRUE(feature->extension_types()->count(Manifest::TYPE_HOSTED_APP));
   EXPECT_TRUE(feature->extension_types()->count(Manifest::TYPE_PLATFORM_APP));
 
   value->SetString("extension_types", "all");
   scoped_ptr<SimpleFeature> feature2(new SimpleFeature());
   feature2->Parse(value.get());
   EXPECT_EQ(*(feature->extension_types()), *(feature2->extension_types()));
 }
 
 TEST_F(ExtensionSimpleFeatureTest, ParseContexts) {
-  scoped_ptr<DictionaryValue> value(new DictionaryValue());
-  ListValue* contexts = new ListValue();
-  contexts->Append(Value::CreateStringValue("blessed_extension"));
-  contexts->Append(Value::CreateStringValue("unblessed_extension"));
-  contexts->Append(Value::CreateStringValue("content_script"));
-  contexts->Append(Value::CreateStringValue("web_page"));
+  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+  base::ListValue* contexts = new base::ListValue();
+  contexts->Append(new base::StringValue("blessed_extension"));
+  contexts->Append(new base::StringValue("unblessed_extension"));
+  contexts->Append(new base::StringValue("content_script"));
+  contexts->Append(new base::StringValue("web_page"));
   value->Set("contexts", contexts);
   scoped_ptr<SimpleFeature> feature(new SimpleFeature());
   feature->Parse(value.get());
   EXPECT_EQ(4u, feature->GetContexts()->size());
   EXPECT_TRUE(
       feature->GetContexts()->count(Feature::BLESSED_EXTENSION_CONTEXT));
   EXPECT_TRUE(
       feature->GetContexts()->count(Feature::UNBLESSED_EXTENSION_CONTEXT));
   EXPECT_TRUE(
       feature->GetContexts()->count(Feature::CONTENT_SCRIPT_CONTEXT));
   EXPECT_TRUE(
       feature->GetContexts()->count(Feature::WEB_PAGE_CONTEXT));
 
   value->SetString("contexts", "all");
   scoped_ptr<SimpleFeature> feature2(new SimpleFeature());
   feature2->Parse(value.get());
   EXPECT_EQ(*(feature->GetContexts()), *(feature2->GetContexts()));
 }
 
 TEST_F(ExtensionSimpleFeatureTest, ParseLocation) {
-  scoped_ptr<DictionaryValue> value(new DictionaryValue());
+  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
   value->SetString("location", "component");
   scoped_ptr<SimpleFeature> feature(new SimpleFeature());
   feature->Parse(value.get());
   EXPECT_EQ(Feature::COMPONENT_LOCATION, feature->location());
 }
 
 TEST_F(ExtensionSimpleFeatureTest, ParsePlatform) {
-  scoped_ptr<DictionaryValue> value(new DictionaryValue());
+  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
   value->SetString("platform", "chromeos");
   scoped_ptr<SimpleFeature> feature(new SimpleFeature());
   feature->Parse(value.get());
   EXPECT_EQ(Feature::CHROMEOS_PLATFORM, feature->platform());
 }
 
 TEST_F(ExtensionSimpleFeatureTest, ManifestVersion) {
-  scoped_ptr<DictionaryValue> value(new DictionaryValue());
+  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
   value->SetInteger("min_manifest_version", 1);
   value->SetInteger("max_manifest_version", 5);
   scoped_ptr<SimpleFeature> feature(new SimpleFeature());
   feature->Parse(value.get());
   EXPECT_EQ(1, feature->min_manifest_version());
   EXPECT_EQ(5, feature->max_manifest_version());
 }
 
 TEST_F(ExtensionSimpleFeatureTest, Inheritance) {
   SimpleFeature feature;
   feature.whitelist()->insert("foo");
   feature.extension_types()->insert(Manifest::TYPE_THEME);
   feature.GetContexts()->insert(Feature::BLESSED_EXTENSION_CONTEXT);
   feature.set_location(Feature::COMPONENT_LOCATION);
   feature.set_platform(Feature::CHROMEOS_PLATFORM);
   feature.set_min_manifest_version(1);
   feature.set_max_manifest_version(2);
 
   SimpleFeature feature2 = feature;
   EXPECT_TRUE(feature2.Equals(feature));
 
-  DictionaryValue definition;
+  base::DictionaryValue definition;
   feature2.Parse(&definition);
   EXPECT_TRUE(feature2.Equals(feature));
 
-  ListValue* whitelist = new ListValue();
-  ListValue* extension_types = new ListValue();
-  ListValue* contexts = new ListValue();
-  whitelist->Append(Value::CreateStringValue("bar"));
-  extension_types->Append(Value::CreateStringValue("extension"));
-  contexts->Append(Value::CreateStringValue("unblessed_extension"));
+  base::ListValue* whitelist = new base::ListValue();
+  base::ListValue* extension_types = new base::ListValue();
+  base::ListValue* contexts = new base::ListValue();
+  whitelist->Append(new base::StringValue("bar"));
+  extension_types->Append(new base::StringValue("extension"));
+  contexts->Append(new base::StringValue("unblessed_extension"));
   definition.Set("whitelist", whitelist);
   definition.Set("extension_types", extension_types);
   definition.Set("contexts", contexts);
   // Can't test location or platform because we only have one value so far.
-  definition.Set("min_manifest_version", Value::CreateIntegerValue(2));
-  definition.Set("max_manifest_version", Value::CreateIntegerValue(3));
+  definition.Set("min_manifest_version", new base::FundamentalValue(2));
+  definition.Set("max_manifest_version", new base::FundamentalValue(3));
 
   feature2.Parse(&definition);
   EXPECT_FALSE(feature2.Equals(feature));
   EXPECT_EQ(1u, feature2.whitelist()->size());
   EXPECT_EQ(1u, feature2.extension_types()->size());
   EXPECT_EQ(1u, feature2.GetContexts()->size());
   EXPECT_EQ(1u, feature2.whitelist()->count("bar"));
   EXPECT_EQ(1u, feature2.extension_types()->count(Manifest::TYPE_EXTENSION));
   EXPECT_EQ(1u, feature2.GetContexts()->count(
       Feature::UNBLESSED_EXTENSION_CONTEXT));
@@ skipping 41 matching lines @@
   feature2.set_max_manifest_version(0);
   EXPECT_FALSE(feature2.Equals(feature));
 }
 
 Feature::AvailabilityResult IsAvailableInChannel(
     const std::string& channel, VersionInfo::Channel channel_for_testing) {
   Feature::ScopedCurrentChannel current_channel(channel_for_testing);
 
   SimpleFeature feature;
   if (!channel.empty()) {
-    DictionaryValue feature_value;
+    base::DictionaryValue feature_value;
     feature_value.SetString("channel", channel);
     feature.Parse(&feature_value);
   }
 
   return feature.IsAvailableToManifest(
       "random-extension",
       Manifest::TYPE_UNKNOWN,
       Feature::UNSPECIFIED_LOCATION,
       -1,
       Feature::GetCurrentPlatform()).result();
@@ skipping 67 matching lines @@
       IsAvailableInChannel("", VersionInfo::CHANNEL_CANARY));
   EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
       IsAvailableInChannel("", VersionInfo::CHANNEL_DEV));
   EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
       IsAvailableInChannel("", VersionInfo::CHANNEL_BETA));
   EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
       IsAvailableInChannel("", VersionInfo::CHANNEL_STABLE));
 }
 
 }  // namespace