Convert //extensions/{common,shell} from scoped_ptr to std::unique_ptr

extensions/common/features/simple_feature_unittest.cc

 // Copyright 2014 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 "extensions/common/features/simple_feature.h"
 
 #include <stddef.h>
 
 #include <string>
 
@@ skipping 490 matching lines @@
   EXPECT_EQ(
       Feature::IS_AVAILABLE,
       feature.IsAvailableToManifest(std::string(),
                                     Manifest::TYPE_UNKNOWN,
                                     Manifest::INVALID_LOCATION,
                                     7,
                                     Feature::UNSPECIFIED_PLATFORM).result());
 }
 
 TEST_F(SimpleFeatureTest, ParseNull) {
-  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
-  scoped_ptr<SimpleFeature> feature(new SimpleFeature());
+  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+  std::unique_ptr<SimpleFeature> feature(new SimpleFeature());
   feature->Parse(value.get());
   EXPECT_TRUE(feature->whitelist()->empty());
   EXPECT_TRUE(feature->extension_types()->empty());
   EXPECT_TRUE(feature->contexts()->empty());
   EXPECT_EQ(SimpleFeature::UNSPECIFIED_LOCATION, feature->location());
   EXPECT_TRUE(feature->platforms()->empty());
   EXPECT_EQ(0, feature->min_manifest_version());
   EXPECT_EQ(0, feature->max_manifest_version());
 }
 
 TEST_F(SimpleFeatureTest, ParseWhitelist) {
-  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> value(new base::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());
+  std::unique_ptr<SimpleFeature> feature(new SimpleFeature());
   feature->Parse(value.get());
   EXPECT_EQ(2u, feature->whitelist()->size());
   EXPECT_TRUE(STLCount(*(feature->whitelist()), "foo"));
   EXPECT_TRUE(STLCount(*(feature->whitelist()), "bar"));
 }
 
 TEST_F(SimpleFeatureTest, ParsePackageTypes) {
-  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+  std::unique_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("legacy_packaged_app"));
   extension_types->Append(new base::StringValue("hosted_app"));
   extension_types->Append(new base::StringValue("platform_app"));
   extension_types->Append(new base::StringValue("shared_module"));
   value->Set("extension_types", extension_types);
-  scoped_ptr<SimpleFeature> feature(new SimpleFeature());
+  std::unique_ptr<SimpleFeature> feature(new SimpleFeature());
   feature->Parse(value.get());
   EXPECT_EQ(6u, feature->extension_types()->size());
   EXPECT_TRUE(
       STLCount(*(feature->extension_types()), Manifest::TYPE_EXTENSION));
   EXPECT_TRUE(
       STLCount(*(feature->extension_types()), Manifest::TYPE_THEME));
   EXPECT_TRUE(
       STLCount(
           *(feature->extension_types()), Manifest::TYPE_LEGACY_PACKAGED_APP));
   EXPECT_TRUE(
       STLCount(*(feature->extension_types()), Manifest::TYPE_HOSTED_APP));
   EXPECT_TRUE(
       STLCount(*(feature->extension_types()), Manifest::TYPE_PLATFORM_APP));
   EXPECT_TRUE(
       STLCount(*(feature->extension_types()), Manifest::TYPE_SHARED_MODULE));
 
   value->SetString("extension_types", "all");
-  scoped_ptr<SimpleFeature> feature2(new SimpleFeature());
+  std::unique_ptr<SimpleFeature> feature2(new SimpleFeature());
   feature2->Parse(value.get());
   EXPECT_EQ(*(feature->extension_types()), *(feature2->extension_types()));
 }
 
 TEST_F(SimpleFeatureTest, ParseContexts) {
-  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+  std::unique_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"));
   contexts->Append(new base::StringValue("blessed_web_page"));
   contexts->Append(new base::StringValue("webui"));
   value->Set("contexts", contexts);
-  scoped_ptr<SimpleFeature> feature(new SimpleFeature());
+  std::unique_ptr<SimpleFeature> feature(new SimpleFeature());
   feature->Parse(value.get());
   EXPECT_EQ(6u, feature->contexts()->size());
   EXPECT_TRUE(
       STLCount(*(feature->contexts()), Feature::BLESSED_EXTENSION_CONTEXT));
   EXPECT_TRUE(
       STLCount(*(feature->contexts()), Feature::UNBLESSED_EXTENSION_CONTEXT));
   EXPECT_TRUE(
       STLCount(*(feature->contexts()), Feature::CONTENT_SCRIPT_CONTEXT));
   EXPECT_TRUE(
       STLCount(*(feature->contexts()), Feature::WEB_PAGE_CONTEXT));
   EXPECT_TRUE(
       STLCount(*(feature->contexts()), Feature::BLESSED_WEB_PAGE_CONTEXT));
 
   value->SetString("contexts", "all");
-  scoped_ptr<SimpleFeature> feature2(new SimpleFeature());
+  std::unique_ptr<SimpleFeature> feature2(new SimpleFeature());
   feature2->Parse(value.get());
   EXPECT_EQ(*(feature->contexts()), *(feature2->contexts()));
 }
 
 TEST_F(SimpleFeatureTest, ParseLocation) {
-  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
   value->SetString("location", "component");
-  scoped_ptr<SimpleFeature> feature(new SimpleFeature());
+  std::unique_ptr<SimpleFeature> feature(new SimpleFeature());
   feature->Parse(value.get());
   EXPECT_EQ(SimpleFeature::COMPONENT_LOCATION, feature->location());
 }
 
 TEST_F(SimpleFeatureTest, ParsePlatforms) {
-  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
-  scoped_ptr<SimpleFeature> feature(new SimpleFeature());
+  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+  std::unique_ptr<SimpleFeature> feature(new SimpleFeature());
   base::ListValue* platforms = new base::ListValue();
   value->Set("platforms", platforms);
   feature->Parse(value.get());
   EXPECT_TRUE(feature->platforms()->empty());
 
   platforms->AppendString("chromeos");
   feature->Parse(value.get());
   EXPECT_FALSE(feature->platforms()->empty());
   EXPECT_EQ(Feature::CHROMEOS_PLATFORM, *feature->platforms()->begin());
 
   platforms->Clear();
   platforms->AppendString("win");
   feature->Parse(value.get());
   EXPECT_FALSE(feature->platforms()->empty());
   EXPECT_EQ(Feature::WIN_PLATFORM, *feature->platforms()->begin());
 
   platforms->Clear();
   platforms->AppendString("win");
   platforms->AppendString("chromeos");
   feature->Parse(value.get());
   std::vector<Feature::Platform> expected_platforms;
   expected_platforms.push_back(Feature::CHROMEOS_PLATFORM);
   expected_platforms.push_back(Feature::WIN_PLATFORM);
 
   EXPECT_FALSE(feature->platforms()->empty());
   EXPECT_EQ(expected_platforms, *feature->platforms());
 }
 
 TEST_F(SimpleFeatureTest, ParseManifestVersion) {
-  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+  std::unique_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());
+  std::unique_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(SimpleFeatureTest, Inheritance) {
   SimpleFeature feature;
   feature.whitelist()->push_back("foo");
   feature.extension_types()->push_back(Manifest::TYPE_THEME);
   feature.contexts()->push_back(Feature::BLESSED_EXTENSION_CONTEXT);
@@ skipping 90 matching lines @@
   EXPECT_FALSE(SimpleFeature::IsIdInArray("", kIdArray, arraysize(kIdArray)));
   EXPECT_FALSE(SimpleFeature::IsIdInArray(
       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", kIdArray, arraysize(kIdArray)));
   EXPECT_TRUE(SimpleFeature::IsIdInArray(
       "bbbbccccdddddddddeeeeeeffffgghhh", kIdArray, arraysize(kIdArray)));
   EXPECT_TRUE(SimpleFeature::IsIdInArray(
       "aaaabbbbccccddddeeeeffffgggghhhh", kIdArray, arraysize(kIdArray)));
 }
 
 }  // namespace extensions