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

chrome/browser/extensions/extension_message_bubble_controller_unittest.cc

 // Copyright (c) 2013 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 <stddef.h>
 
 #include <utility>
 
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/extensions/dev_mode_bubble_delegate.h"
 #include "chrome/browser/extensions/extension_function_test_utils.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_web_ui_override_registrar.h"
 #include "chrome/browser/extensions/ntp_overridden_bubble_delegate.h"
@@ skipping 17 matching lines @@
 #include "extensions/common/feature_switch.h"
 #include "extensions/common/value_builder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 const char kId1[] = "iccfkkhkfiphcjdakkmcjmkfboccmndk";
 const char kId2[] = "ajjhifimiemdpmophmkkkcijegphclbl";
 const char kId3[] = "ioibbbfddncmmabjmpokikkeiofalaek";
 
-scoped_ptr<KeyedService> BuildOverrideRegistrar(
+std::unique_ptr<KeyedService> BuildOverrideRegistrar(
     content::BrowserContext* context) {
-  return make_scoped_ptr(
+  return base::WrapUnique(
       new extensions::ExtensionWebUIOverrideRegistrar(context));
 }
 
 }  // namespace
 
 namespace extensions {
 
 class TestExtensionMessageBubbleController :
     public ExtensionMessageBubbleController {
  public:
@@ skipping 261 matching lines @@
     ExtensionMessageBubbleController::set_should_ignore_learn_more_for_testing(
         false);
     BrowserWithTestWindowTest::TearDown();
   }
 
  protected:
   scoped_refptr<Extension> CreateExtension(
       Manifest::Location location,
       const std::string& data,
       const std::string& id) {
-    scoped_ptr<base::DictionaryValue> parsed_manifest(
+    std::unique_ptr<base::DictionaryValue> parsed_manifest(
         api_test_utils::ParseDictionary(data));
     return api_test_utils::CreateExtension(location, parsed_manifest.get(), id);
   }
 
   ExtensionService* service_;
 
  private:
-  scoped_ptr<base::CommandLine> command_line_;
+  std::unique_ptr<base::CommandLine> command_line_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionMessageBubbleTest);
 };
 
 TEST_F(ExtensionMessageBubbleTest, BubbleReshowsOnDeactivationDismissal) {
   Init();
 
   ASSERT_TRUE(LoadExtensionOverridingNtp("1", kId1, Manifest::INTERNAL));
   ASSERT_TRUE(LoadExtensionOverridingNtp("2", kId2, Manifest::INTERNAL));
-  scoped_ptr<TestExtensionMessageBubbleController> controller(
+  std::unique_ptr<TestExtensionMessageBubbleController> controller(
       new TestExtensionMessageBubbleController(
           new NtpOverriddenBubbleDelegate(browser()->profile()), browser()));
 
   // The list will contain one enabled unpacked extension (ext 2).
   EXPECT_TRUE(controller->ShouldShow());
   std::vector<base::string16> override_extensions =
       controller->GetExtensionList();
   ASSERT_EQ(1U, override_extensions.size());
   EXPECT_EQ(base::ASCIIToUTF16("Extension 2"), override_extensions[0]);
   EXPECT_EQ(0U, controller->link_click_count());
@@ skipping 48 matching lines @@
 // The feature this is meant to test is only enacted on Windows, but it should
 // pass on all platforms.
 TEST_F(ExtensionMessageBubbleTest, WipeoutControllerTest) {
   Init();
   // Add three extensions, and control two of them in this test (extension 1
   // and 2).
   ASSERT_TRUE(LoadExtensionWithAction("1", kId1, Manifest::COMMAND_LINE));
   ASSERT_TRUE(LoadGenericExtension("2", kId2, Manifest::UNPACKED));
   ASSERT_TRUE(LoadGenericExtension("3", kId3, Manifest::EXTERNAL_POLICY));
 
-  scoped_ptr<TestExtensionMessageBubbleController> controller(
+  std::unique_ptr<TestExtensionMessageBubbleController> controller(
       new TestExtensionMessageBubbleController(
           new SuspiciousExtensionBubbleDelegate(browser()->profile()),
           browser()));
   FakeExtensionMessageBubble bubble;
   bubble.set_action_on_show(
       FakeExtensionMessageBubble::BUBBLE_ACTION_CLICK_DISMISS_BUTTON);
 
   // Validate that we don't have a suppress value for the extensions.
   EXPECT_FALSE(controller->delegate()->HasBubbleInfoBeenAcknowledged(kId1));
   EXPECT_FALSE(controller->delegate()->HasBubbleInfoBeenAcknowledged(kId1));
@@ skipping 58 matching lines @@
   FeatureSwitch::ScopedOverride force_dev_mode_highlighting(
       FeatureSwitch::force_dev_mode_highlighting(), true);
   Init();
   // Add three extensions, and control two of them in this test (extension 1
   // and 2). Extension 1 is a regular extension, Extension 2 is UNPACKED so it
   // counts as a DevMode extension.
   ASSERT_TRUE(LoadExtensionWithAction("1", kId1, Manifest::COMMAND_LINE));
   ASSERT_TRUE(LoadGenericExtension("2", kId2, Manifest::UNPACKED));
   ASSERT_TRUE(LoadGenericExtension("3", kId3, Manifest::EXTERNAL_POLICY));
 
-  scoped_ptr<TestExtensionMessageBubbleController> controller(
+  std::unique_ptr<TestExtensionMessageBubbleController> controller(
       new TestExtensionMessageBubbleController(
-          new DevModeBubbleDelegate(browser()->profile()),
-          browser()));
+          new DevModeBubbleDelegate(browser()->profile()), browser()));
 
   // The list will contain one enabled unpacked extension.
   EXPECT_TRUE(controller->ShouldShow());
   std::vector<base::string16> dev_mode_extensions =
       controller->GetExtensionList();
   ASSERT_EQ(2U, dev_mode_extensions.size());
   EXPECT_TRUE(base::ASCIIToUTF16("Extension 2") == dev_mode_extensions[0]);
   EXPECT_TRUE(base::ASCIIToUTF16("Extension 1") == dev_mode_extensions[1]);
   EXPECT_EQ(0U, controller->link_click_count());
   EXPECT_EQ(0U, controller->dismiss_click_count());
@@ skipping 110 matching lines @@
         ASSERT_TRUE(
             LoadExtensionOverridingStart("2", kId2, Manifest::UNPACKED));
         ASSERT_TRUE(LoadExtensionOverridingHome("3", kId3, Manifest::UNPACKED));
         break;
       default:
         NOTREACHED();
         break;
     }
 
     SettingsApiOverrideType type = static_cast<SettingsApiOverrideType>(i);
-    scoped_ptr<TestExtensionMessageBubbleController> controller(
+    std::unique_ptr<TestExtensionMessageBubbleController> controller(
         new TestExtensionMessageBubbleController(
             new SettingsApiBubbleDelegate(browser()->profile(), type),
             browser()));
 
     // The list will contain one enabled unpacked extension (ext 2).
     EXPECT_TRUE(controller->ShouldShow());
     std::vector<base::string16> override_extensions =
         controller->GetExtensionList();
     ASSERT_EQ(1U, override_extensions.size());
     EXPECT_TRUE(base::ASCIIToUTF16("Extension 2") ==
@@ skipping 90 matching lines @@
 // pass on all platforms.
 TEST_F(ExtensionMessageBubbleTest, NtpOverriddenControllerTest) {
   Init();
   // Load two extensions overriding new tab page and one overriding something
   // unrelated (to check for interference). Extension 2 should still win
   // on the new tab page setting.
   ASSERT_TRUE(LoadExtensionOverridingNtp("1", kId1, Manifest::UNPACKED));
   ASSERT_TRUE(LoadExtensionOverridingNtp("2", kId2, Manifest::UNPACKED));
   ASSERT_TRUE(LoadExtensionOverridingStart("3", kId3, Manifest::UNPACKED));
 
-  scoped_ptr<TestExtensionMessageBubbleController> controller(
+  std::unique_ptr<TestExtensionMessageBubbleController> controller(
       new TestExtensionMessageBubbleController(
-          new NtpOverriddenBubbleDelegate(browser()->profile()),
-          browser()));
+          new NtpOverriddenBubbleDelegate(browser()->profile()), browser()));
 
   // The list will contain one enabled unpacked extension (ext 2).
   EXPECT_TRUE(controller->ShouldShow());
   std::vector<base::string16> override_extensions =
       controller->GetExtensionList();
   ASSERT_EQ(1U, override_extensions.size());
   EXPECT_TRUE(base::ASCIIToUTF16("Extension 2") ==
               override_extensions[0].c_str());
   EXPECT_EQ(0U, controller->link_click_count());
   EXPECT_EQ(0U, controller->dismiss_click_count());
@@ skipping 112 matching lines @@
   ASSERT_TRUE(LoadExtensionOverridingStart("3", kId3, Manifest::UNPACKED));
 
   // The bubble will not show if the extension was installed in the last 7 days
   // so we artificially set the install time to simulate an old install during
   // testing.
   base::Time old_enough = base::Time::Now() - base::TimeDelta::FromDays(8);
   SetInstallTime(kId1, old_enough, prefs);
   SetInstallTime(kId2, base::Time::Now(), prefs);
   SetInstallTime(kId3, old_enough, prefs);
 
-  scoped_ptr<TestExtensionMessageBubbleController> controller(
+  std::unique_ptr<TestExtensionMessageBubbleController> controller(
       new TestExtensionMessageBubbleController(
-          new ProxyOverriddenBubbleDelegate(browser()->profile()),
-          browser()));
+          new ProxyOverriddenBubbleDelegate(browser()->profile()), browser()));
 
   // The second extension is too new to warn about.
   EXPECT_FALSE(controller->ShouldShow());
   EXPECT_FALSE(controller->ShouldShow());
   // Lets make it old enough.
   SetInstallTime(kId2, old_enough, prefs);
 
   // The list will contain one enabled unpacked extension (ext 2).
   EXPECT_TRUE(controller->ShouldShow());
   EXPECT_FALSE(controller->ShouldShow());
@@ skipping 84 matching lines @@
                                extensions::UNINSTALL_REASON_FOR_TESTING,
                                base::Bind(&base::DoNothing),
                                NULL);
   service_->UninstallExtension(kId3,
                                extensions::UNINSTALL_REASON_FOR_TESTING,
                                base::Bind(&base::DoNothing),
                                NULL);
 }
 
 }  // namespace extensions