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

chrome/browser/extensions/extension_context_menu_model_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 "chrome/browser/extensions/extension_context_menu_model.h"
 
 #include <utility>
 
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/extensions/api/extension_action/extension_action_api.h"
 #include "chrome/browser/extensions/extension_action_runner.h"
 #include "chrome/browser/extensions/extension_action_test_util.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_service_test_base.h"
 #include "chrome/browser/extensions/menu_manager.h"
 #include "chrome/browser/extensions/menu_manager_factory.h"
 #include "chrome/browser/extensions/scripting_permissions_modifier.h"
@@ skipping 39 matching lines @@
  public:
   MenuBuilder(scoped_refptr<const Extension> extension,
               Browser* browser,
               MenuManager* menu_manager)
       : extension_(extension),
         browser_(browser),
         menu_manager_(menu_manager),
         cur_id_(0) {}
   ~MenuBuilder() {}
 
-  scoped_ptr<ExtensionContextMenuModel> BuildMenu() {
-    return make_scoped_ptr(new ExtensionContextMenuModel(
+  std::unique_ptr<ExtensionContextMenuModel> BuildMenu() {
+    return base::WrapUnique(new ExtensionContextMenuModel(
         extension_.get(), browser_, ExtensionContextMenuModel::VISIBLE,
         nullptr));
   }
 
   void AddContextItem(MenuItem::Context context) {
     MenuItem::Id id(false /* not incognito */,
                     MenuItem::ExtensionKey(extension_->id()));
     id.uid = ++cur_id_;
     menu_manager_->AddContextItem(
         extension_.get(),
@@ skipping 46 matching lines @@
                                 Manifest::Location location);
   const Extension* AddExtensionWithHostPermission(
       const std::string& name,
       const char* action_key,
       Manifest::Location location,
       const std::string& host_permission);
 
   Browser* GetBrowser();
 
  private:
-  scoped_ptr<TestBrowserWindow> test_window_;
-  scoped_ptr<Browser> browser_;
+  std::unique_ptr<TestBrowserWindow> test_window_;
+  std::unique_ptr<Browser> browser_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionContextMenuModelTest);
 };
 
 ExtensionContextMenuModelTest::ExtensionContextMenuModelTest() {}
 
 const Extension* ExtensionContextMenuModelTest::AddExtension(
     const std::string& name,
     const char* action_key,
     Manifest::Location location) {
@@ skipping 71 matching lines @@
 
   // Don't leave |policy_provider| dangling.
   system->management_policy()->UnregisterProvider(&policy_provider);
 }
 
 // Tests the context menu for a component extension.
 TEST_F(ExtensionContextMenuModelTest, ComponentExtensionContextMenu) {
   InitializeEmptyExtensionService();
 
   std::string name("component");
-  scoped_ptr<base::DictionaryValue> manifest =
+  std::unique_ptr<base::DictionaryValue> manifest =
       DictionaryBuilder()
           .Set("name", name)
           .Set("version", "1")
           .Set("manifest_version", 2)
           .Set("browser_action", DictionaryBuilder().Build())
           .Build();
 
   {
     scoped_refptr<const Extension> extension =
         ExtensionBuilder()
-            .SetManifest(make_scoped_ptr(manifest->DeepCopy()))
+            .SetManifest(base::WrapUnique(manifest->DeepCopy()))
             .SetID(crx_file::id_util::GenerateId("component"))
             .SetLocation(Manifest::COMPONENT)
             .Build();
     service()->AddExtension(extension.get());
 
     ExtensionContextMenuModel menu(extension.get(), GetBrowser(),
                                    ExtensionContextMenuModel::VISIBLE, nullptr);
 
     // A component extension's context menu should not include options for
     // managing extensions or removing it, and should only include an option for
@@ skipping 65 matching lines @@
 
   // We shouldn't go above the limit of top-level items.
   EXPECT_EQ(api::context_menus::ACTION_MENU_TOP_LEVEL_LIMIT,
             CountExtensionItems(*builder.BuildMenu()));
 }
 
 // Test that the "show" and "hide" menu items appear correctly in the extension
 // context menu without the toolbar redesign.
 TEST_F(ExtensionContextMenuModelTest, ExtensionContextMenuShowAndHideLegacy) {
   // Start with the toolbar redesign disabled.
-  scoped_ptr<FeatureSwitch::ScopedOverride> toolbar_redesign_override(
+  std::unique_ptr<FeatureSwitch::ScopedOverride> toolbar_redesign_override(
       new FeatureSwitch::ScopedOverride(
           FeatureSwitch::extension_action_redesign(), false));
 
   InitializeEmptyExtensionService();
   Browser* browser = GetBrowser();
   extension_action_test_util::CreateToolbarModelForProfile(profile());
 
   const Extension* page_action = AddExtension(
       "page_action_extension", manifest_keys::kPageAction, Manifest::INTERNAL);
   const Extension* browser_action =
@@ skipping 46 matching lines @@
 
     // Cleanup - make the action visible again.
     action_api->SetBrowserActionVisibility(browser_action->id(), true);
   }
 }
 
 // Test that the "show" and "hide" menu items appear correctly in the extension
 // context menu with the toolbar redesign.
 TEST_F(ExtensionContextMenuModelTest, ExtensionContextMenuShowAndHideRedesign) {
   // Start with the toolbar redesign disabled.
-  scoped_ptr<FeatureSwitch::ScopedOverride> toolbar_redesign_override(
+  std::unique_ptr<FeatureSwitch::ScopedOverride> toolbar_redesign_override(
       new FeatureSwitch::ScopedOverride(
           FeatureSwitch::extension_action_redesign(), true));
 
   InitializeEmptyExtensionService();
   Browser* browser = GetBrowser();
   extension_action_test_util::CreateToolbarModelForProfile(profile());
   const Extension* page_action =
       AddExtension("page_action_extension",
                      manifest_keys::kPageAction,
                      Manifest::INTERNAL);
@@ skipping 77 matching lines @@
                                    ExtensionContextMenuModel::VISIBLE, nullptr);
     menu.ExecuteCommand(ExtensionContextMenuModel::UNINSTALL, 0);
   }
   uninstalled_observer.WaitForExtensionUninstalled();
   EXPECT_FALSE(registry()->GetExtensionById(extension_id,
                                             ExtensionRegistry::EVERYTHING));
 }
 
 TEST_F(ExtensionContextMenuModelTest, TestPageAccessSubmenu) {
   // This test relies on the click-to-script feature.
-  scoped_ptr<FeatureSwitch::ScopedOverride> enable_scripts_require_action(
+  std::unique_ptr<FeatureSwitch::ScopedOverride> enable_scripts_require_action(
       new FeatureSwitch::ScopedOverride(FeatureSwitch::scripts_require_action(),
                                         true));
   InitializeEmptyExtensionService();
 
   // Add an extension with all urls.
   const Extension* extension =
       AddExtensionWithHostPermission("extension", manifest_keys::kBrowserAction,
                                      Manifest::INTERNAL, "*://*/*");
 
   const GURL kActiveUrl("http://www.example.com/");
@@ skipping 147 matching lines @@
       "feature_disabled_extension", manifest_keys::kBrowserAction,
       Manifest::INTERNAL, "http://www.google.com/*");
   ExtensionContextMenuModel feature_disabled_menu(
       feature_disabled_extension, GetBrowser(),
       ExtensionContextMenuModel::VISIBLE, nullptr);
   EXPECT_EQ(-1, feature_disabled_menu.GetIndexOfCommandId(
                     ExtensionContextMenuModel::PAGE_ACCESS_SUBMENU));
 }
 
 }  // namespace extensions