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

chrome/browser/extensions/extension_context_menu_browsertest.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 <stddef.h>
 
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/extensions/extension_browsertest.h"
@@ skipping 88 matching lines @@
     return result;
   }
 
   // This creates a test menu for a page with |page_url| and |link_url|, looks
   // for an extension item with the given |label|, and returns true if the item
   // was found.
   bool MenuHasItemWithLabel(const GURL& page_url,
                             const GURL& link_url,
                             const GURL& frame_url,
                             const std::string& label) {
-    scoped_ptr<TestRenderViewContextMenu> menu(
-        TestRenderViewContextMenu::Create(
-            GetWebContents(), page_url, link_url, frame_url));
+    std::unique_ptr<TestRenderViewContextMenu> menu(
+        TestRenderViewContextMenu::Create(GetWebContents(), page_url, link_url,
+                                          frame_url));
     return MenuHasExtensionItemWithLabel(menu.get(), label);
   }
 
   // Click on a context menu identified by |target_menu_item_id|, and returns
   // the result of chrome.test.sendMessage. The .js test file that sets up the
   // context menu should call chrome.test.sendMessage in its onclick event.
   std::string ClickMenuInFrame(content::RenderFrameHost* frame,
                                const std::string& target_menu_item_id) {
     content::ContextMenuParams params;
     if (frame->GetParent())
@@ skipping 33 matching lines @@
     else
       begin.Reply("start disabled");
 
     // Wait for the extension to tell us it's created an item.
     ASSERT_TRUE(create.WaitUntilSatisfied());
     create.Reply("go");
 
     GURL page_url("http://www.google.com");
 
     // Create and build our test context menu.
-    scoped_ptr<TestRenderViewContextMenu> menu(
-        TestRenderViewContextMenu::Create(
-            GetWebContents(), page_url, GURL(), GURL()));
+    std::unique_ptr<TestRenderViewContextMenu> menu(
+        TestRenderViewContextMenu::Create(GetWebContents(), page_url, GURL(),
+                                          GURL()));
 
     // Look for the extension item in the menu, and make sure it's |enabled|.
     int command_id = ContextMenuMatcher::ConvertToExtensionsCustomCommandId(0);
     ASSERT_EQ(enabled, menu->IsCommandIdEnabled(command_id));
 
     // Update the item and make sure it is now |!enabled|.
     ASSERT_TRUE(update.WaitUntilSatisfied());
     ASSERT_EQ(!enabled, menu->IsCommandIdEnabled(command_id));
   }
 
@@ skipping 53 matching lines @@
   ExtensionTestMessageListener listener1("created item", false);
   ExtensionTestMessageListener listener2("onclick fired", false);
   ASSERT_TRUE(LoadContextMenuExtension("simple"));
 
   // Wait for the extension to tell us it's created an item.
   ASSERT_TRUE(listener1.WaitUntilSatisfied());
 
   GURL page_url("http://www.google.com");
 
   // Create and build our test context menu.
-  scoped_ptr<TestRenderViewContextMenu> menu(TestRenderViewContextMenu::Create(
-      GetWebContents(), page_url, GURL(), GURL()));
+  std::unique_ptr<TestRenderViewContextMenu> menu(
+      TestRenderViewContextMenu::Create(GetWebContents(), page_url, GURL(),
+                                        GURL()));
 
   // Look for the extension item in the menu, and execute it.
   int command_id = ContextMenuMatcher::ConvertToExtensionsCustomCommandId(0);
   ASSERT_TRUE(menu->IsCommandIdEnabled(command_id));
   menu->ExecuteCommand(command_id, 0);
 
   // Wait for the extension's script to tell us its onclick fired.
   ASSERT_TRUE(listener2.WaitUntilSatisfied());
 }
 
 // Tests that previous onclick is not fired after updating the menu's onclick,
 // and whether setting onclick to null removes the handler.
 IN_PROC_BROWSER_TEST_F(ExtensionContextMenuBrowserTest, UpdateOnclick) {
   ExtensionTestMessageListener listener_error1("onclick1-unexpected", false);
   ExtensionTestMessageListener listener_error2("onclick2-unexpected", false);
   ExtensionTestMessageListener listener_update1("update1", true);
   ExtensionTestMessageListener listener_update2("update2", false);
   ExtensionTestMessageListener listener_done("onclick2", false);
 
   const extensions::Extension* extension =
       LoadContextMenuExtension("onclick_null");
   ASSERT_TRUE(extension);
 
   // Wait till item has been created and updated.
   ASSERT_TRUE(listener_update1.WaitUntilSatisfied());
 
   GURL page_url("http://www.google.com");
 
   // Create and build our test context menu.
-  scoped_ptr<TestRenderViewContextMenu> menu(TestRenderViewContextMenu::Create(
-      GetWebContents(), page_url, GURL(), GURL()));
+  std::unique_ptr<TestRenderViewContextMenu> menu(
+      TestRenderViewContextMenu::Create(GetWebContents(), page_url, GURL(),
+                                        GURL()));
 
   // Look for the extension item in the menu, and execute it.
   MenuItem::Id id(false, MenuItem::ExtensionKey(extension->id()));
   id.string_uid = "id1";
   int command_id = -1;
   ASSERT_TRUE(FindCommandId(menu.get(), id, &command_id));
   menu->ExecuteCommand(command_id, 0);
 
   // Let the test proceed.
   listener_update1.Reply("");
@@ skipping 59 matching lines @@
   // Make sure we have an item registered with a long title.
   size_t limit = extensions::ContextMenuMatcher::kMaxExtensionItemTitleLength;
   MenuItem::List items = GetItems();
   ASSERT_EQ(1u, items.size());
   MenuItem* item = items.at(0);
   ASSERT_GT(item->title().size(), limit);
 
   // Create a context menu, then find the item's label. It should be properly
   // truncated.
   GURL url("http://foo.com/");
-  scoped_ptr<TestRenderViewContextMenu> menu(
+  std::unique_ptr<TestRenderViewContextMenu> menu(
       TestRenderViewContextMenu::Create(GetWebContents(), url, GURL(), GURL()));
 
   base::string16 label;
   ASSERT_TRUE(GetItemLabel(menu.get(), item->id(), &label));
   ASSERT_TRUE(label.size() <= limit);
 }
 
 // Flaky on Windows debug bots. http://crbug.com/251590
 #if defined(OS_WIN)
 #define MAYBE_TopLevel DISABLED_TopLevel
@@ skipping 31 matching lines @@
   // Load extensions and wait until it's created two menu items.
   ExtensionTestMessageListener listener4("created items", false);
   ASSERT_TRUE(LoadTopLevelContextMenuExtension("multi4"));
   ASSERT_TRUE(listener4.WaitUntilSatisfied());
 
   ExtensionTestMessageListener listener5("created items", false);
   ASSERT_TRUE(LoadTopLevelContextMenuExtension("multi5"));
   ASSERT_TRUE(listener5.WaitUntilSatisfied());
 
   GURL url("http://foo.com/");
-  scoped_ptr<TestRenderViewContextMenu> menu(
+  std::unique_ptr<TestRenderViewContextMenu> menu(
       TestRenderViewContextMenu::Create(GetWebContents(), url, GURL(), GURL()));
 
   int index = 0;
   MenuModel* model = NULL;
 
   ASSERT_TRUE(menu->GetMenuModelAndItemIndex(
       ContextMenuMatcher::ConvertToExtensionsCustomCommandId(0),
       &model,
       &index));
   EXPECT_EQ(base::UTF8ToUTF16("An Extension with multiple Context Menus"),
@@ skipping 64 matching lines @@
 
   // Navigate to test1.html inside the extension, which should create a bunch
   // of items at the top-level (but they'll get pushed into an auto-generated
   // parent).
   ExtensionTestMessageListener listener1("test1 create finished", false);
   ui_test_utils::NavigateToURL(browser(),
                                GURL(extension->GetResourceURL("test1.html")));
   listener1.WaitUntilSatisfied();
 
   GURL url("http://www.google.com/");
-  scoped_ptr<TestRenderViewContextMenu> menu(
+  std::unique_ptr<TestRenderViewContextMenu> menu(
       TestRenderViewContextMenu::Create(GetWebContents(), url, GURL(), GURL()));
 
   // The top-level item should be an "automagic parent" with the extension's
   // name.
   MenuModel* model = NULL;
   int index = 0;
   base::string16 label;
   ASSERT_TRUE(menu->GetMenuModelAndItemIndex(
       ContextMenuMatcher::ConvertToExtensionsCustomCommandId(0),
       &model,
@@ skipping 73 matching lines @@
 
   ASSERT_TRUE(LoadContextMenuExtensionIncognito("incognito"));
 
   // Wait for the extension's processes to tell us they've created an item.
   ASSERT_TRUE(created.WaitUntilSatisfied());
   ASSERT_TRUE(created_incognito.WaitUntilSatisfied());
 
   GURL page_url("http://www.google.com");
 
   // Create and build our test context menu.
-  scoped_ptr<TestRenderViewContextMenu> menu(TestRenderViewContextMenu::Create(
-      GetWebContents(), page_url, GURL(), GURL()));
+  std::unique_ptr<TestRenderViewContextMenu> menu(
+      TestRenderViewContextMenu::Create(GetWebContents(), page_url, GURL(),
+                                        GURL()));
   WebContents* incognito_web_contents =
       browser_incognito->tab_strip_model()->GetActiveWebContents();
-  scoped_ptr<TestRenderViewContextMenu> menu_incognito(
-      TestRenderViewContextMenu::Create(
-          incognito_web_contents, page_url, GURL(), GURL()));
+  std::unique_ptr<TestRenderViewContextMenu> menu_incognito(
+      TestRenderViewContextMenu::Create(incognito_web_contents, page_url,
+                                        GURL(), GURL()));
 
   // Look for the extension item in the menu, and execute it.
   int command_id = ContextMenuMatcher::ConvertToExtensionsCustomCommandId(0);
   ASSERT_TRUE(menu->IsCommandIdEnabled(command_id));
   menu->ExecuteCommand(command_id, 0);
 
   // Wait for the extension's script to tell us its onclick fired. Ensure
   // that the incognito version doesn't fire until we explicitly click the
   // incognito menu item.
   ASSERT_TRUE(onclick.WaitUntilSatisfied());
@@ skipping 76 matching lines @@
   page_complete.Wait();
 
   // Test that menu items appear while the page is unloaded.
   ASSERT_TRUE(MenuHasItemWithLabel(
       about_blank, GURL(), GURL(), std::string("Item 1")));
   ASSERT_TRUE(MenuHasItemWithLabel(
       about_blank, GURL(), GURL(), std::string("Checkbox 1")));
 
   // Test that checked menu items retain their checkedness.
   LazyBackgroundObserver checkbox_checked;
-  scoped_ptr<TestRenderViewContextMenu> menu(TestRenderViewContextMenu::Create(
-      GetWebContents(), about_blank, GURL(), GURL()));
+  std::unique_ptr<TestRenderViewContextMenu> menu(
+      TestRenderViewContextMenu::Create(GetWebContents(), about_blank, GURL(),
+                                        GURL()));
 
   MenuItem::Id id(false, MenuItem::ExtensionKey(extension->id()));
   id.string_uid = "checkbox1";
   int command_id = -1;
   ASSERT_TRUE(FindCommandId(menu.get(), id, &command_id));
   EXPECT_FALSE(menu->IsCommandIdChecked(command_id));
 
   // Executing the checkbox also fires the onClicked event.
   ExtensionTestMessageListener listener("onClicked fired for checkbox1", false);
   menu->ExecuteCommand(command_id, 0);
@@ skipping 14 matching lines @@
   ASSERT_TRUE(LoadContextMenuExtensionIncognito("incognito"));
 
   // Wait for the extension's processes to tell us they've created an item.
   ASSERT_TRUE(created.WaitUntilSatisfied());
   ASSERT_TRUE(created_incognito.WaitUntilSatisfied());
   ASSERT_EQ(2u, GetItems().size());
 
   browser()->profile()->DestroyOffTheRecordProfile();
   ASSERT_EQ(1u, GetItems().size());
 }