Convert //chrome/browser/extensions from scoped_ptr to std::unique_ptr

chrome/browser/extensions/api/developer_private/developer_private_api_unittest.cc

 // Copyright 2015 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/browser/extensions/api/developer_private/developer_private_api.h"
+
+#include <memory>
 #include <utility>
 
 #include "base/files/file_util.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
-#include "chrome/browser/extensions/api/developer_private/developer_private_api.h"
 #include "chrome/browser/extensions/error_console/error_console.h"
 #include "chrome/browser/extensions/extension_function_test_utils.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_service_test_base.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/extensions/test_extension_dir.h"
 #include "chrome/browser/extensions/test_extension_system.h"
 #include "chrome/browser/extensions/unpacked_installer.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/extensions/api/developer_private.h"
@@ skipping 12 matching lines @@
 #include "extensions/common/extension_set.h"
 #include "extensions/common/feature_switch.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/test_util.h"
 #include "extensions/common/value_builder.h"
 
 namespace extensions {
 
 namespace {
 
-scoped_ptr<KeyedService> BuildAPI(content::BrowserContext* context) {
-  return make_scoped_ptr(new DeveloperPrivateAPI(context));
+std::unique_ptr<KeyedService> BuildAPI(content::BrowserContext* context) {
+  return base::WrapUnique(new DeveloperPrivateAPI(context));
 }
 
-scoped_ptr<KeyedService> BuildEventRouter(content::BrowserContext* profile) {
-  return make_scoped_ptr(
+std::unique_ptr<KeyedService> BuildEventRouter(
+    content::BrowserContext* profile) {
+  return base::WrapUnique(
       new EventRouter(profile, ExtensionPrefs::Get(profile)));
 }
 
 }  // namespace
 
 class DeveloperPrivateApiUnitTest : public ExtensionServiceTestBase {
  protected:
   DeveloperPrivateApiUnitTest() {}
   ~DeveloperPrivateApiUnitTest() override {}
 
@@ skipping 22 matching lines @@
       int expected_flags);
 
   Browser* browser() { return browser_.get(); }
 
  private:
   // ExtensionServiceTestBase:
   void SetUp() override;
   void TearDown() override;
 
   // The browser (and accompanying window).
-  scoped_ptr<TestBrowserWindow> browser_window_;
-  scoped_ptr<Browser> browser_;
+  std::unique_ptr<TestBrowserWindow> browser_window_;
+  std::unique_ptr<Browser> browser_;
 
   ScopedVector<TestExtensionDir> test_extension_dirs_;
 
   DISALLOW_COPY_AND_ASSIGN(DeveloperPrivateApiUnitTest);
 };
 
 bool DeveloperPrivateApiUnitTest::RunFunction(
     const scoped_refptr<UIThreadExtensionFunction>& function,
     const base::ListValue& args) {
   return extension_function_test_utils::RunFunction(
-      function.get(),
-      make_scoped_ptr(args.DeepCopy()),
-      browser(),
+      function.get(), base::WrapUnique(args.DeepCopy()), browser(),
       extension_function_test_utils::NONE);
 }
 
 const Extension* DeveloperPrivateApiUnitTest::LoadUnpackedExtension() {
   const char kManifest[] =
       "{"
       " \"name\": \"foo\","
       " \"version\": \"1.0\","
       " \"manifest_version\": 2,"
       " \"permissions\": [\"*://*/*\"]"
@@ skipping 78 matching lines @@
     int expected_flags) {
   scoped_refptr<UIThreadExtensionFunction> function(
       new api::DeveloperPrivatePackDirectoryFunction());
   if (!RunFunction(function, args))
     return testing::AssertionFailure() << "Could not run function.";
 
   // Extract the result. We don't have to test this here, since it's verified as
   // part of the general extension api system.
   const base::Value* response_value = nullptr;
   CHECK(function->GetResultList()->Get(0u, &response_value));
-  scoped_ptr<api::developer_private::PackDirectoryResponse> response =
+  std::unique_ptr<api::developer_private::PackDirectoryResponse> response =
       api::developer_private::PackDirectoryResponse::FromValue(*response_value);
   CHECK(response);
 
   if (response->status != expected_status) {
     return testing::AssertionFailure() << "Expected status: " <<
         expected_status << ", found status: " << response->status <<
         ", message: " << response->message;
   }
 
   if (response->override_flags != expected_flags) {
@@ skipping 181 matching lines @@
       path,
       registry()->enabled_extensions().GetByID(*id_difference.begin())->path());
 
   path = data_dir().AppendASCII("empty_manifest");
   api::EntryPicker::SkipPickerAndAlwaysSelectPathForTest(&path);
 
   // Try loading a bad extension (it should fail, and we should get an error).
   function = new api::DeveloperPrivateLoadUnpackedFunction();
   function->SetRenderFrameHost(web_contents->GetMainFrame());
   base::ListValue unpacked_args;
-  scoped_ptr<base::DictionaryValue> options(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> options(new base::DictionaryValue());
   options->SetBoolean("failQuietly", true);
   unpacked_args.Append(options.release());
   current_ids = registry()->enabled_extensions().GetIDs();
   EXPECT_FALSE(RunFunction(function, unpacked_args));
   EXPECT_EQ(manifest_errors::kManifestUnreadable, function->GetError());
   // We should have no new extensions installed.
   EXPECT_EQ(0u, base::STLSetDifference<ExtensionIdSet>(
                     registry()->enabled_extensions().GetIDs(),
                     current_ids).size());
 }
@@ skipping 15 matching lines @@
   properties.manifest_key.reset(new std::string("name"));
 
   scoped_refptr<UIThreadExtensionFunction> function(
       new api::DeveloperPrivateRequestFileSourceFunction());
   base::ListValue file_source_args;
   file_source_args.Append(properties.ToValue().release());
   EXPECT_TRUE(RunFunction(function, file_source_args)) << function->GetError();
 
   const base::Value* response_value = nullptr;
   ASSERT_TRUE(function->GetResultList()->Get(0u, &response_value));
-  scoped_ptr<api::developer_private::RequestFileSourceResponse> response =
+  std::unique_ptr<api::developer_private::RequestFileSourceResponse> response =
       api::developer_private::RequestFileSourceResponse::FromValue(
           *response_value);
   EXPECT_FALSE(response->before_highlight.empty());
   EXPECT_EQ("\"name\": \"foo\"", response->highlight);
   EXPECT_FALSE(response->after_highlight.empty());
   EXPECT_EQ("foo: manifest.json", response->title);
   EXPECT_EQ(kErrorMessage, response->message);
 }
 
 // Test developerPrivate.getExtensionsInfo.
@@ skipping 10 matching lines @@
   scoped_refptr<UIThreadExtensionFunction> function(
       new api::DeveloperPrivateGetExtensionsInfoFunction());
   EXPECT_TRUE(RunFunction(function, base::ListValue())) << function->GetError();
   const base::ListValue* results = function->GetResultList();
   ASSERT_EQ(1u, results->GetSize());
   const base::ListValue* list = nullptr;
   ASSERT_TRUE(results->GetList(0u, &list));
   ASSERT_EQ(1u, list->GetSize());
   const base::Value* value = nullptr;
   ASSERT_TRUE(list->Get(0u, &value));
-  scoped_ptr<api::developer_private::ExtensionInfo> info =
+  std::unique_ptr<api::developer_private::ExtensionInfo> info =
       api::developer_private::ExtensionInfo::FromValue(*value);
   ASSERT_TRUE(info);
 
   // As a sanity check, also run the GetItemsInfo and make sure it returns a
   // sane value.
   function = new api::DeveloperPrivateGetItemsInfoFunction();
   base::ListValue args;
   args.AppendBoolean(false);
   args.AppendBoolean(false);
   EXPECT_TRUE(RunFunction(function, args)) << function->GetError();
   results = function->GetResultList();
   ASSERT_EQ(1u, results->GetSize());
   ASSERT_TRUE(results->GetList(0u, &list));
   ASSERT_EQ(1u, list->GetSize());
   ASSERT_TRUE(list->Get(0u, &value));
-  scoped_ptr<api::developer_private::ItemInfo> item_info =
+  std::unique_ptr<api::developer_private::ItemInfo> item_info =
       api::developer_private::ItemInfo::FromValue(*value);
   ASSERT_TRUE(item_info);
 }
 
 // Test developerPrivate.deleteExtensionErrors.
 TEST_F(DeveloperPrivateApiUnitTest, DeveloperPrivateDeleteExtensionErrors) {
   FeatureSwitch::ScopedOverride error_console_override(
       FeatureSwitch::error_console(), true);
   profile()->GetPrefs()->SetBoolean(prefs::kExtensionsUIDeveloperMode, true);
   const Extension* extension = LoadSimpleExtension();
 
   // Report some errors.
   ErrorConsole* error_console = ErrorConsole::Get(profile());
   error_console->SetReportingAllForExtension(extension->id(), true);
   error_console->ReportError(
       error_test_util::CreateNewRuntimeError(extension->id(), "foo"));
   error_console->ReportError(
       error_test_util::CreateNewRuntimeError(extension->id(), "bar"));
   error_console->ReportError(
       error_test_util::CreateNewManifestError(extension->id(), "baz"));
   EXPECT_EQ(3u, error_console->GetErrorsForExtension(extension->id()).size());
 
   // Start by removing all errors for the extension of a given type (manifest).
   std::string type_string = api::developer_private::ToString(
       api::developer_private::ERROR_TYPE_MANIFEST);
-  scoped_ptr<base::ListValue> args =
+  std::unique_ptr<base::ListValue> args =
       ListBuilder()
           .Append(DictionaryBuilder()
                       .Set("extensionId", extension->id())
                       .Set("type", type_string)
                       .Build())
           .Build();
   scoped_refptr<UIThreadExtensionFunction> function =
       new api::DeveloperPrivateDeleteExtensionErrorsFunction();
   EXPECT_TRUE(RunFunction(function, *args)) << function->GetError();
   // Two errors should remain.
@@ skipping 21 matching lines @@
           .Append(
               DictionaryBuilder().Set("extensionId", extension->id()).Build())
           .Build();
   function = new api::DeveloperPrivateDeleteExtensionErrorsFunction();
   EXPECT_TRUE(RunFunction(function, *args)) << function->GetError();
   // No more errors!
   EXPECT_TRUE(error_console->GetErrorsForExtension(extension->id()).empty());
 }
 
 }  // namespace extensions