Convert chrome/common to std::unique_ptr

chrome/common/extensions/api/common_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 "extensions/common/extension_api.h"
 
 #include <stddef.h>
 
+#include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chrome/common/chrome_paths.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_builder.h"
 #include "extensions/common/features/api_feature.h"
 #include "extensions/common/features/base_feature_provider.h"
 #include "extensions/common/features/simple_feature.h"
 #include "extensions/common/manifest.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/test_util.h"
 #include "extensions/common/value_builder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace extensions {
 
 using test_util::BuildExtension;
 
 SimpleFeature* CreateAPIFeature() {
   return new APIFeature();
 }
 
 TEST(ExtensionAPITest, Creation) {
   ExtensionAPI* shared_instance = ExtensionAPI::GetSharedInstance();
   EXPECT_EQ(shared_instance, ExtensionAPI::GetSharedInstance());
 
-  scoped_ptr<ExtensionAPI> new_instance(
+  std::unique_ptr<ExtensionAPI> new_instance(
       ExtensionAPI::CreateWithDefaultConfiguration());
   EXPECT_NE(new_instance.get(),
-            scoped_ptr<ExtensionAPI>(
-                ExtensionAPI::CreateWithDefaultConfiguration()).get());
+            std::unique_ptr<ExtensionAPI>(
+                ExtensionAPI::CreateWithDefaultConfiguration())
+                .get());
 
   ExtensionAPI empty_instance;
 
   struct {
     ExtensionAPI* api;
     bool expect_populated;
   } test_data[] = {
     { shared_instance, true },
     { new_instance.get(), true },
     { &empty_instance, false }
@@ skipping 104 matching lines @@
   base::FilePath api_features_path;
   PathService::Get(chrome::DIR_TEST_DATA, &api_features_path);
   api_features_path = api_features_path.AppendASCII("extensions")
       .AppendASCII("extension_api_unittest")
       .AppendASCII("api_features.json");
 
   std::string api_features_str;
   ASSERT_TRUE(base::ReadFileToString(
       api_features_path, &api_features_str)) << "api_features.json";
 
-  scoped_ptr<base::DictionaryValue> value(static_cast<base::DictionaryValue*>(
-      base::JSONReader::Read(api_features_str).release()));
+  std::unique_ptr<base::DictionaryValue> value(
+      static_cast<base::DictionaryValue*>(
+          base::JSONReader::Read(api_features_str).release()));
   BaseFeatureProvider api_feature_provider(*value, CreateAPIFeature);
 
   for (size_t i = 0; i < arraysize(test_data); ++i) {
     ExtensionAPI api;
     api.RegisterDependencyProvider("api", &api_feature_provider);
     for (base::DictionaryValue::Iterator iter(*value); !iter.IsAtEnd();
          iter.Advance()) {
       if (iter.key().find(".") == std::string::npos)
         api.RegisterSchemaResource(iter.key(), 0);
     }
@@ skipping 71 matching lines @@
   base::FilePath api_features_path;
   PathService::Get(chrome::DIR_TEST_DATA, &api_features_path);
   api_features_path = api_features_path.AppendASCII("extensions")
       .AppendASCII("extension_api_unittest")
       .AppendASCII("api_features.json");
 
   std::string api_features_str;
   ASSERT_TRUE(base::ReadFileToString(
       api_features_path, &api_features_str)) << "api_features.json";
 
-  scoped_ptr<base::DictionaryValue> value(static_cast<base::DictionaryValue*>(
-      base::JSONReader::Read(api_features_str).release()));
+  std::unique_ptr<base::DictionaryValue> value(
+      static_cast<base::DictionaryValue*>(
+          base::JSONReader::Read(api_features_str).release()));
   BaseFeatureProvider api_feature_provider(*value, CreateAPIFeature);
 
   for (size_t i = 0; i < arraysize(test_data); ++i) {
     ExtensionAPI api;
     api.RegisterDependencyProvider("api", &api_feature_provider);
     for (base::DictionaryValue::Iterator iter(*value); !iter.IsAtEnd();
          iter.Advance()) {
       if (iter.key().find(".") == std::string::npos)
         api.RegisterSchemaResource(iter.key(), 0);
     }
 
     Feature* test_feature =
         api_feature_provider.GetFeature(test_data[i].api_full_name);
     ASSERT_TRUE(test_feature);
     EXPECT_EQ(test_data[i].expect_is_available,
               api.IsAnyFeatureAvailableToContext(*test_feature,
                                                  test_data[i].extension,
                                                  test_data[i].context,
                                                  test_data[i].url))
         << i;
   }
 }
 
 TEST(ExtensionAPITest, LazyGetSchema) {
-  scoped_ptr<ExtensionAPI> apis(ExtensionAPI::CreateWithDefaultConfiguration());
+  std::unique_ptr<ExtensionAPI> apis(
+      ExtensionAPI::CreateWithDefaultConfiguration());
 
   EXPECT_EQ(NULL, apis->GetSchema(std::string()));
   EXPECT_EQ(NULL, apis->GetSchema(std::string()));
   EXPECT_EQ(NULL, apis->GetSchema("experimental"));
   EXPECT_EQ(NULL, apis->GetSchema("experimental"));
   EXPECT_EQ(NULL, apis->GetSchema("foo"));
   EXPECT_EQ(NULL, apis->GetSchema("foo"));
 
   EXPECT_TRUE(apis->GetSchema("dns"));
   EXPECT_TRUE(apis->GetSchema("dns"));
   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) {
   base::DictionaryValue manifest;
   manifest.SetString("name", "extension");
   manifest.SetString("version", "1.0");
   manifest.SetInteger("manifest_version", 2);
   {
-    scoped_ptr<base::ListValue> permissions_list(new base::ListValue());
+    std::unique_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(new base::StringValue(*i));
     }
     manifest.Set("permissions", permissions_list.release());
   }
 
   std::string error;
   scoped_refptr<Extension> extension(Extension::Create(
       base::FilePath(), Manifest::UNPACKED,
@@ skipping 13 matching lines @@
 
 TEST(ExtensionAPITest, ExtensionWithUnprivilegedAPIs) {
   scoped_refptr<Extension> extension;
   {
     std::set<std::string> permissions;
     permissions.insert("storage");
     permissions.insert("history");
     extension = CreateExtensionWithPermissions(permissions);
   }
 
-  scoped_ptr<ExtensionAPI> extension_api(
+  std::unique_ptr<ExtensionAPI> extension_api(
       ExtensionAPI::CreateWithDefaultConfiguration());
 
   const FeatureProvider& api_features = *FeatureProvider::GetAPIFeatures();
 
   // "storage" is completely unprivileged.
   EXPECT_TRUE(extension_api->IsAnyFeatureAvailableToContext(
       *api_features.GetFeature("storage"),
       NULL,
       Feature::BLESSED_EXTENSION_CONTEXT,
       GURL()));
@@ skipping 72 matching lines @@
       "http://www.example.com");
 
   base::DictionaryValue* app = new base::DictionaryValue();
   base::DictionaryValue* background = new base::DictionaryValue();
   base::ListValue* scripts = new base::ListValue();
   scripts->Append(new base::StringValue("test.js"));
   background->Set("scripts", scripts);
   app->Set("background", background);
   values.Set(manifest_keys::kApp, app);
   {
-    scoped_ptr<base::ListValue> permissions_list(new base::ListValue());
+    std::unique_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(new base::StringValue(*i));
     }
     values.Set("permissions", permissions_list.release());
   }
 
   std::string error;
   scoped_refptr<Extension> extension(Extension::Create(
       base::FilePath(), Manifest::INTERNAL, values, Extension::NO_FLAGS,
       &error));
   CHECK(extension.get()) << error;
   return extension;
 }
 
 TEST(ExtensionAPITest, HostedAppPermissions) {
   scoped_refptr<Extension> extension = CreateHostedApp();
 
-  scoped_ptr<ExtensionAPI> extension_api(
+  std::unique_ptr<ExtensionAPI> extension_api(
       ExtensionAPI::CreateWithDefaultConfiguration());
 
   // "runtime" and "tabs" should not be available in hosted apps.
   EXPECT_FALSE(extension_api->IsAvailable("runtime",
                                           extension.get(),
                                           Feature::BLESSED_EXTENSION_CONTEXT,
                                           GURL()).is_available());
   EXPECT_FALSE(extension_api->IsAvailable("runtime.id",
                                           extension.get(),
                                           Feature::BLESSED_EXTENSION_CONTEXT,
                                           GURL()).is_available());
   EXPECT_FALSE(extension_api->IsAvailable("runtime.sendMessage",
                                           extension.get(),
                                           Feature::BLESSED_EXTENSION_CONTEXT,
                                           GURL()).is_available());
   EXPECT_FALSE(extension_api->IsAvailable("runtime.sendNativeMessage",
                                           extension.get(),
                                           Feature::BLESSED_EXTENSION_CONTEXT,
                                           GURL()).is_available());
   EXPECT_FALSE(extension_api->IsAvailable("tabs.create",
                                           extension.get(),
                                           Feature::BLESSED_EXTENSION_CONTEXT,
                                           GURL()).is_available());
 }
 
 TEST(ExtensionAPITest, AppAndFriendsAvailability) {
-
-  scoped_ptr<ExtensionAPI> extension_api(
+  std::unique_ptr<ExtensionAPI> extension_api(
       ExtensionAPI::CreateWithDefaultConfiguration());
 
   // Make sure chrome.app.runtime and chrome.app.window are available to apps,
   // and chrome.app is not.
   {
     std::set<std::string> permissions;
     permissions.insert("app.runtime");
     permissions.insert("app.window");
     scoped_refptr<Extension> extension =
         CreatePackagedAppWithPermissions(permissions);
@@ skipping 36 matching lines @@
         GURL("http://foo.com")).is_available());
   }
 }
 
 TEST(ExtensionAPITest, ExtensionWithDependencies) {
   // Extension with the "ttsEngine" permission but not the "tts" permission; it
   // should not automatically get "tts" permission.
   {
     scoped_refptr<Extension> extension =
         CreateExtensionWithPermission("ttsEngine");
-    scoped_ptr<ExtensionAPI> api(
+    std::unique_ptr<ExtensionAPI> api(
         ExtensionAPI::CreateWithDefaultConfiguration());
     EXPECT_TRUE(api->IsAvailable("ttsEngine",
                                  extension.get(),
                                  Feature::BLESSED_EXTENSION_CONTEXT,
                                  GURL()).is_available());
     EXPECT_FALSE(api->IsAvailable("tts",
                                   extension.get(),
                                   Feature::BLESSED_EXTENSION_CONTEXT,
                                   GURL()).is_available());
   }
 
   // Conversely, extension with the "tts" permission but not the "ttsEngine"
   // permission shouldn't get the "ttsEngine" permission.
   {
     scoped_refptr<Extension> extension =
         CreateExtensionWithPermission("tts");
-    scoped_ptr<ExtensionAPI> api(
+    std::unique_ptr<ExtensionAPI> api(
         ExtensionAPI::CreateWithDefaultConfiguration());
     EXPECT_FALSE(api->IsAvailable("ttsEngine",
                                   extension.get(),
                                   Feature::BLESSED_EXTENSION_CONTEXT,
                                   GURL()).is_available());
     EXPECT_TRUE(api->IsAvailable("tts",
                                  extension.get(),
                                  Feature::BLESSED_EXTENSION_CONTEXT,
                                  GURL()).is_available());
   }
 }
 
 bool MatchesURL(
     ExtensionAPI* api, const std::string& api_name, const std::string& url) {
   return api->IsAvailable(
       api_name, NULL, Feature::WEB_PAGE_CONTEXT, GURL(url)).is_available();
 }
 
 TEST(ExtensionAPITest, URLMatching) {
-  scoped_ptr<ExtensionAPI> api(ExtensionAPI::CreateWithDefaultConfiguration());
+  std::unique_ptr<ExtensionAPI> api(
+      ExtensionAPI::CreateWithDefaultConfiguration());
 
   // "app" API is available to all URLs that content scripts can be injected.
   EXPECT_TRUE(MatchesURL(api.get(), "app", "http://example.com/example.html"));
   EXPECT_TRUE(MatchesURL(api.get(), "app", "https://blah.net"));
   EXPECT_TRUE(MatchesURL(api.get(), "app", "file://somefile.html"));
 
   // Also to internal URLs.
   EXPECT_TRUE(MatchesURL(api.get(), "app", "about:flags"));
   EXPECT_TRUE(MatchesURL(api.get(), "app", "chrome://flags"));
 
@@ skipping 23 matching lines @@
     { "bookmarks", "bookmarks", "" },
     { "bookmarks.", "bookmarks", "" },
     { ".bookmarks", "", "" },
     { "bookmarks.create", "bookmarks", "create" },
     { "bookmarks.create.", "bookmarks", "create." },
     { "bookmarks.create.monkey", "bookmarks", "create.monkey" },
     { "bookmarkManagerPrivate", "bookmarkManagerPrivate", "" },
     { "bookmarkManagerPrivate.copy", "bookmarkManagerPrivate", "copy" }
   };
 
-  scoped_ptr<ExtensionAPI> api(ExtensionAPI::CreateWithDefaultConfiguration());
+  std::unique_ptr<ExtensionAPI> api(
+      ExtensionAPI::CreateWithDefaultConfiguration());
   for (size_t i = 0; i < arraysize(test_data); ++i) {
     std::string child_name;
     std::string api_name = api->GetAPINameFromFullName(test_data[i].input,
                                                        &child_name);
     EXPECT_EQ(test_data[i].api_name, api_name) << test_data[i].input;
     EXPECT_EQ(test_data[i].child_name, child_name) << test_data[i].input;
   }
 }
 
 TEST(ExtensionAPITest, DefaultConfigurationFeatures) {
-  scoped_ptr<ExtensionAPI> api(ExtensionAPI::CreateWithDefaultConfiguration());
+  std::unique_ptr<ExtensionAPI> api(
+      ExtensionAPI::CreateWithDefaultConfiguration());
 
   SimpleFeature* bookmarks = static_cast<SimpleFeature*>(
       api->GetFeatureDependency("api:bookmarks"));
   SimpleFeature* bookmarks_create = static_cast<SimpleFeature*>(
       api->GetFeatureDependency("api:bookmarks.create"));
 
   struct {
     SimpleFeature* feature;
     // TODO(aa): More stuff to test over time.
   } test_data[] = {
@@ skipping 10 matching lines @@
 
     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(ExtensionAPITest, FeaturesRequireContexts) {
   // TODO(cduvall): Make this check API featues.
-  scoped_ptr<base::DictionaryValue> api_features1(new base::DictionaryValue());
-  scoped_ptr<base::DictionaryValue> api_features2(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> api_features1(
+      new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> api_features2(
+      new base::DictionaryValue());
   base::DictionaryValue* test1 = new base::DictionaryValue();
   base::DictionaryValue* test2 = new base::DictionaryValue();
   base::ListValue* contexts = new base::ListValue();
   contexts->Append(new base::StringValue("content_script"));
   test1->Set("contexts", contexts);
   test1->SetString("channel", "stable");
   test2->SetString("channel", "stable");
   api_features1->Set("test", test1);
   api_features2->Set("test", test2);
 
@@ skipping 121 matching lines @@
     { "app.getIsInstalled",       true },
     { "app.installState",         true },
     { "app.runningState",         true },
     { "management.getPermissionWarningsByManifest", true },
     { "management.uninstallSelf", true },
     // But other functions in those modules do.
     { "management.getPermissionWarningsById", false },
     { "runtime.connectNative", false },
   };
 
-  scoped_ptr<ExtensionAPI> extension_api(
+  std::unique_ptr<ExtensionAPI> extension_api(
       ExtensionAPI::CreateWithDefaultConfiguration());
   scoped_refptr<Extension> extension =
       BuildExtension(ExtensionBuilder()).Build();
 
   for (size_t i = 0; i < arraysize(kTests); ++i) {
     EXPECT_EQ(kTests[i].expect_success,
               extension_api->IsAvailable(kTests[i].permission_name,
                                          extension.get(),
                                          Feature::BLESSED_EXTENSION_CONTEXT,
                                          GURL()).is_available())
         << "Permission being tested: " << kTests[i].permission_name;
   }
 }
 
 // Tests that permissions that require manifest keys are available when those
 // keys are present.
 TEST(ExtensionAPITest, ManifestKeys) {
-  scoped_ptr<ExtensionAPI> extension_api(
+  std::unique_ptr<ExtensionAPI> extension_api(
       ExtensionAPI::CreateWithDefaultConfiguration());
 
   scoped_refptr<Extension> extension =
       BuildExtension(ExtensionBuilder())
           .MergeManifest(DictionaryBuilder()
                              .Set("browser_action", DictionaryBuilder().Build())
                              .Build())
           .Build();
 
   EXPECT_TRUE(extension_api->IsAvailable("browserAction",
                                          extension.get(),
                                          Feature::BLESSED_EXTENSION_CONTEXT,
                                          GURL()).is_available());
   EXPECT_FALSE(extension_api->IsAvailable("pageAction",
                                           extension.get(),
                                           Feature::BLESSED_EXTENSION_CONTEXT,
                                           GURL()).is_available());
 }
 
 }  // namespace extensions