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

chrome/browser/extensions/extension_webui_apitest.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 "base/files/file_path.h"
 #include "base/files/file_util.h"
+#include "base/memory/ptr_util.h"
 #include "base/path_service.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/extensions/extension_apitest.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
@@ skipping 113 matching lines @@
   ASSERT_TRUE(RunTestOnChromeExtensions("sanity_check_available_apis.js"));
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionWebUITest, SanityCheckUnavailableAPIs) {
   ASSERT_TRUE(RunTestOnAbout("sanity_check_available_apis.js"));
 }
 
 // Tests chrome.test.sendMessage, which exercises WebUI making a
 // function call and receiving a response.
 IN_PROC_BROWSER_TEST_F(ExtensionWebUITest, SendMessage) {
-  scoped_ptr<ExtensionTestMessageListener> listener(
+  std::unique_ptr<ExtensionTestMessageListener> listener(
       new ExtensionTestMessageListener("ping", true));
 
   ASSERT_TRUE(RunTestOnExtensionsFrame("send_message.js"));
 
   ASSERT_TRUE(listener->WaitUntilSatisfied());
   listener->Reply("pong");
 
   listener.reset(new ExtensionTestMessageListener(false));
   ASSERT_TRUE(listener->WaitUntilSatisfied());
   EXPECT_EQ("true", listener->message());
 }
 
 // Tests chrome.runtime.onMessage, which exercises WebUI registering and
 // receiving an event.
 IN_PROC_BROWSER_TEST_F(ExtensionWebUITest, OnMessage) {
   ASSERT_TRUE(RunTestOnExtensionsFrame("on_message.js"));
 
   OnMessage::Info info;
   info.data = "hi";
   info.last_message = true;
-  EventRouter::Get(profile())->BroadcastEvent(make_scoped_ptr(
+  EventRouter::Get(profile())->BroadcastEvent(base::WrapUnique(
       new Event(events::RUNTIME_ON_MESSAGE, OnMessage::kEventName,
                 OnMessage::Create(info))));
 
-  scoped_ptr<ExtensionTestMessageListener> listener(
+  std::unique_ptr<ExtensionTestMessageListener> listener(
       new ExtensionTestMessageListener(false));
   ASSERT_TRUE(listener->WaitUntilSatisfied());
   EXPECT_EQ("true", listener->message());
 }
 
 // Tests chrome.runtime.lastError, which exercises WebUI accessing a property
 // on an API which it doesn't actually have access to. A bindings test really.
 IN_PROC_BROWSER_TEST_F(ExtensionWebUITest, RuntimeLastError) {
-  scoped_ptr<ExtensionTestMessageListener> listener(
+  std::unique_ptr<ExtensionTestMessageListener> listener(
       new ExtensionTestMessageListener("ping", true));
 
   ASSERT_TRUE(RunTestOnExtensionsFrame("runtime_last_error.js"));
 
   ASSERT_TRUE(listener->WaitUntilSatisfied());
   listener->ReplyWithError("unknown host");
 
   listener.reset(new ExtensionTestMessageListener(false));
   ASSERT_TRUE(listener->WaitUntilSatisfied());
   EXPECT_EQ("true", listener->message());
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionWebUITest, CanEmbedExtensionOptions) {
-  scoped_ptr<ExtensionTestMessageListener> listener(
+  std::unique_ptr<ExtensionTestMessageListener> listener(
       new ExtensionTestMessageListener("ready", true));
 
   const Extension* extension =
       LoadExtension(test_data_dir_.AppendASCII("extension_options")
                         .AppendASCII("embed_self"));
   ASSERT_TRUE(extension);
 
   ASSERT_TRUE(RunTestOnExtensionsFrame("can_embed_extension_options.js"));
 
   ASSERT_TRUE(listener->WaitUntilSatisfied());
   listener->Reply(extension->id());
   listener.reset(new ExtensionTestMessageListener("load", false));
   ASSERT_TRUE(listener->WaitUntilSatisfied());
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionWebUITest, ReceivesExtensionOptionsOnClose) {
-  scoped_ptr<ExtensionTestMessageListener> listener(
+  std::unique_ptr<ExtensionTestMessageListener> listener(
       new ExtensionTestMessageListener("ready", true));
 
   const Extension* extension =
       InstallExtension(test_data_dir_.AppendASCII("extension_options")
           .AppendASCII("close_self"), 1);
   ASSERT_TRUE(extension);
 
   ASSERT_TRUE(
       RunTestOnExtensionsFrame("receives_extension_options_on_close.js"));
 
   ASSERT_TRUE(listener->WaitUntilSatisfied());
   listener->Reply(extension->id());
   listener.reset(new ExtensionTestMessageListener("onclose received", false));
   ASSERT_TRUE(listener->WaitUntilSatisfied());
 }
 
 // Regression test for crbug.com/414526.
 //
 // Same setup as CanEmbedExtensionOptions but disable the extension before
 // embedding.
 IN_PROC_BROWSER_TEST_F(ExtensionWebUITest, EmbedDisabledExtension) {
-  scoped_ptr<ExtensionTestMessageListener> listener(
+  std::unique_ptr<ExtensionTestMessageListener> listener(
       new ExtensionTestMessageListener("ready", true));
 
   std::string extension_id;
   {
     const Extension* extension =
         LoadExtension(test_data_dir_.AppendASCII("extension_options")
                           .AppendASCII("embed_self"));
     ASSERT_TRUE(extension);
     extension_id = extension->id();
     DisableExtension(extension_id);
   }
 
   ASSERT_TRUE(RunTestOnExtensionsFrame("can_embed_extension_options.js"));
 
   ASSERT_TRUE(listener->WaitUntilSatisfied());
   listener->Reply(extension_id);
   listener.reset(new ExtensionTestMessageListener("createfailed", false));
   ASSERT_TRUE(listener->WaitUntilSatisfied());
 }
 
 #endif
 
 }  // namespace
 
 }  // namespace extensions