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

chrome/browser/extensions/api/tabs/tabs_test.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 <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 
+#include <memory>
 #include <string>
 
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/strings/pattern.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/apps/app_browsertest_util.h"
 #include "chrome/browser/devtools/devtools_window_testing.h"
 #include "chrome/browser/extensions/api/tabs/tabs_api.h"
 #include "chrome/browser/extensions/api/tabs/tabs_constants.h"
@@ skipping 91 matching lines @@
 
   // Basic window details.
   gfx::Rect bounds;
   if (browser()->window()->IsMinimized())
     bounds = browser()->window()->GetRestoredBounds();
   else
     bounds = browser()->window()->GetBounds();
 
   function = new WindowsGetFunction();
   function->set_extension(extension.get());
-  scoped_ptr<base::DictionaryValue> result(utils::ToDictionary(
-      utils::RunFunctionAndReturnSingleResult(
-          function.get(),
-          base::StringPrintf("[%u]", window_id),
-          browser())));
+  std::unique_ptr<base::DictionaryValue> result(
+      utils::ToDictionary(utils::RunFunctionAndReturnSingleResult(
+          function.get(), base::StringPrintf("[%u]", window_id), browser())));
   EXPECT_EQ(window_id, GetWindowId(result.get()));
   EXPECT_FALSE(api_test_utils::GetBoolean(result.get(), "incognito"));
   EXPECT_EQ("normal", api_test_utils::GetString(result.get(), "type"));
   EXPECT_EQ(bounds.x(), api_test_utils::GetInteger(result.get(), "left"));
   EXPECT_EQ(bounds.y(), api_test_utils::GetInteger(result.get(), "top"));
   EXPECT_EQ(bounds.width(), api_test_utils::GetInteger(result.get(), "width"));
   EXPECT_EQ(bounds.height(),
             api_test_utils::GetInteger(result.get(), "height"));
 
   // With "populate" enabled.
@@ skipping 80 matching lines @@
 IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, GetCurrentWindow) {
   int window_id = ExtensionTabUtil::GetWindowId(browser());
   Browser* new_browser = CreateBrowser(browser()->profile());
   int new_id = ExtensionTabUtil::GetWindowId(new_browser);
 
   // Get the current window using new_browser.
   scoped_refptr<WindowsGetCurrentFunction> function =
       new WindowsGetCurrentFunction();
   scoped_refptr<Extension> extension(test_util::CreateEmptyExtension());
   function->set_extension(extension.get());
-  scoped_ptr<base::DictionaryValue> result(utils::ToDictionary(
-      utils::RunFunctionAndReturnSingleResult(function.get(),
-                                              "[]",
-                                              new_browser)));
+  std::unique_ptr<base::DictionaryValue> result(
+      utils::ToDictionary(utils::RunFunctionAndReturnSingleResult(
+          function.get(), "[]", new_browser)));
 
   // The id should match the window id of the browser instance that was passed
   // to RunFunctionAndReturnSingleResult.
   EXPECT_EQ(new_id, GetWindowId(result.get()));
   base::ListValue* tabs = nullptr;
   EXPECT_FALSE(result.get()->GetList(keys::kTabsKey, &tabs));
 
   // Get the current window using the old window and make the tabs populated.
   function = new WindowsGetCurrentFunction();
   function->set_extension(extension.get());
@@ skipping 30 matching lines @@
   AppWindow* app_window = CreateTestAppWindow("{}");
 
   // Undocked DevTools window should not be accessible, unless allWindowTypes is
   // set to true.
   DevToolsWindow* devtools = DevToolsWindowTesting::OpenDevToolsWindowSync(
       browser()->tab_strip_model()->GetWebContentsAt(0), false /* is_docked */);
 
   scoped_refptr<WindowsGetAllFunction> function = new WindowsGetAllFunction();
   scoped_refptr<Extension> extension(test_util::CreateEmptyExtension());
   function->set_extension(extension.get());
-  scoped_ptr<base::ListValue> result(utils::ToList(
-      utils::RunFunctionAndReturnSingleResult(function.get(),
-                                              "[]",
-                                              browser())));
+  std::unique_ptr<base::ListValue> result(
+      utils::ToList(utils::RunFunctionAndReturnSingleResult(function.get(),
+                                                            "[]", browser())));
 
   base::ListValue* windows = result.get();
   EXPECT_EQ(window_ids.size(), windows->GetSize());
   for (size_t i = 0; i < windows->GetSize(); ++i) {
     base::DictionaryValue* result_window = nullptr;
     EXPECT_TRUE(windows->GetDictionary(i, &result_window));
     result_ids.insert(GetWindowId(result_window));
 
     // "populate" was not passed in so tabs are not populated.
     base::ListValue* tabs = nullptr;
@@ skipping 47 matching lines @@
 
   // Undocked DevTools window should be accessible too.
   DevToolsWindow* devtools = DevToolsWindowTesting::OpenDevToolsWindowSync(
       browser()->tab_strip_model()->GetWebContentsAt(0), false /* is_docked */);
   window_ids.insert(ExtensionTabUtil::GetWindowId(
       DevToolsWindowTesting::Get(devtools)->browser()));
 
   scoped_refptr<WindowsGetAllFunction> function = new WindowsGetAllFunction();
   scoped_refptr<Extension> extension(test_util::CreateEmptyExtension());
   function->set_extension(extension.get());
-  scoped_ptr<base::ListValue> result(
+  std::unique_ptr<base::ListValue> result(
       utils::ToList(utils::RunFunctionAndReturnSingleResult(
           function.get(),
           "[{\"windowTypes\": [\"app\", \"devtools\", \"normal\", \"panel\", "
           "\"popup\"]}]",
           browser())));
 
   base::ListValue* windows = result.get();
   EXPECT_EQ(window_ids.size(), windows->GetSize());
   for (size_t i = 0; i < windows->GetSize(); ++i) {
     base::DictionaryValue* result_window = nullptr;
@@ skipping 40 matching lines @@
 IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, UpdateNoPermissions) {
   // The test empty extension has no permissions, therefore it should not get
   // tab data in the function result.
   scoped_refptr<TabsUpdateFunction> update_tab_function(
       new TabsUpdateFunction());
   scoped_refptr<Extension> empty_extension(test_util::CreateEmptyExtension());
   update_tab_function->set_extension(empty_extension.get());
   // Without a callback the function will not generate a result.
   update_tab_function->set_has_callback(true);
 
-  scoped_ptr<base::DictionaryValue> result(utils::ToDictionary(
-      utils::RunFunctionAndReturnSingleResult(
+  std::unique_ptr<base::DictionaryValue> result(
+      utils::ToDictionary(utils::RunFunctionAndReturnSingleResult(
           update_tab_function.get(),
-          "[null, {\"url\": \"about:blank\", \"pinned\": true}]",
-          browser())));
+          "[null, {\"url\": \"about:blank\", \"pinned\": true}]", browser())));
   // The url is stripped since the extension does not have tab permissions.
   EXPECT_FALSE(result->HasKey("url"));
   EXPECT_TRUE(api_test_utils::GetBoolean(result.get(), "pinned"));
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionTabsTest,
                        DefaultToIncognitoWhenItIsForced) {
   static const char kArgsWithoutExplicitIncognitoParam[] =
       "[{\"url\": \"about:blank\"}]";
   // Force Incognito mode.
   IncognitoModePrefs::SetAvailability(browser()->profile()->GetPrefs(),
                                       IncognitoModePrefs::FORCED);
   // Run without an explicit "incognito" param.
   scoped_refptr<WindowsCreateFunction> function(new WindowsCreateFunction());
   function->SetRenderFrameHost(
       browser()->tab_strip_model()->GetActiveWebContents()->GetMainFrame());
   scoped_refptr<Extension> extension(test_util::CreateEmptyExtension());
   function->set_extension(extension.get());
-  scoped_ptr<base::DictionaryValue> result(utils::ToDictionary(
-      utils::RunFunctionAndReturnSingleResult(
-          function.get(),
-          kArgsWithoutExplicitIncognitoParam,
-          browser(),
+  std::unique_ptr<base::DictionaryValue> result(
+      utils::ToDictionary(utils::RunFunctionAndReturnSingleResult(
+          function.get(), kArgsWithoutExplicitIncognitoParam, browser(),
           utils::INCLUDE_INCOGNITO)));
 
   // Make sure it is a new(different) window.
   EXPECT_NE(ExtensionTabUtil::GetWindowId(browser()),
             GetWindowId(result.get()));
   // ... and it is incognito.
   EXPECT_TRUE(api_test_utils::GetBoolean(result.get(), "incognito"));
 
   // Now try creating a window from incognito window.
   Browser* incognito_browser = CreateIncognitoBrowser();
@@ skipping 18 matching lines @@
 IN_PROC_BROWSER_TEST_F(ExtensionTabsTest,
                        DefaultToIncognitoWhenItIsForcedAndNoArgs) {
   static const char kEmptyArgs[] = "[]";
   // Force Incognito mode.
   IncognitoModePrefs::SetAvailability(browser()->profile()->GetPrefs(),
                                       IncognitoModePrefs::FORCED);
   // Run without an explicit "incognito" param.
   scoped_refptr<WindowsCreateFunction> function = new WindowsCreateFunction();
   scoped_refptr<Extension> extension(test_util::CreateEmptyExtension());
   function->set_extension(extension.get());
-  scoped_ptr<base::DictionaryValue> result(utils::ToDictionary(
-      utils::RunFunctionAndReturnSingleResult(function.get(),
-                                              kEmptyArgs,
-                                              browser(),
-                                              utils::INCLUDE_INCOGNITO)));
+  std::unique_ptr<base::DictionaryValue> result(
+      utils::ToDictionary(utils::RunFunctionAndReturnSingleResult(
+          function.get(), kEmptyArgs, browser(), utils::INCLUDE_INCOGNITO)));
 
   // Make sure it is a new(different) window.
   EXPECT_NE(ExtensionTabUtil::GetWindowId(browser()),
             GetWindowId(result.get()));
   // ... and it is incognito.
   EXPECT_TRUE(api_test_utils::GetBoolean(result.get(), "incognito"));
 
   // Now try creating a window from incognito window.
   Browser* incognito_browser = CreateIncognitoBrowser();
   // Run without an explicit "incognito" param.
@@ skipping 69 matching lines @@
   for (size_t i = 0; i < kExtraWindows; ++i)
     CreateBrowser(browser()->profile());
 
   GURL url(url::kAboutBlankURL);
   AddTabAtIndex(0, url, ui::PAGE_TRANSITION_LINK);
   int window_id = ExtensionTabUtil::GetWindowId(browser());
 
   // Get tabs in the 'current' window called from non-focused browser.
   scoped_refptr<TabsQueryFunction> function = new TabsQueryFunction();
   function->set_extension(test_util::CreateEmptyExtension().get());
-  scoped_ptr<base::ListValue> result(utils::ToList(
-      utils::RunFunctionAndReturnSingleResult(function.get(),
-                                              "[{\"currentWindow\":true}]",
-                                              browser())));
+  std::unique_ptr<base::ListValue> result(
+      utils::ToList(utils::RunFunctionAndReturnSingleResult(
+          function.get(), "[{\"currentWindow\":true}]", browser())));
 
   base::ListValue* result_tabs = result.get();
   // We should have one initial tab and one added tab.
   EXPECT_EQ(2u, result_tabs->GetSize());
   for (size_t i = 0; i < result_tabs->GetSize(); ++i) {
     base::DictionaryValue* result_tab = nullptr;
     EXPECT_TRUE(result_tabs->GetDictionary(i, &result_tab));
     EXPECT_EQ(window_id, GetTabWindowId(result_tab));
   }
 
@@ skipping 24 matching lines @@
     window_ids.insert(ExtensionTabUtil::GetWindowId(new_browser));
   }
 
   // Undocked DevTools window should not be accessible.
   DevToolsWindow* devtools = DevToolsWindowTesting::OpenDevToolsWindowSync(
       browser()->tab_strip_model()->GetWebContentsAt(0), false /* is_docked */);
 
   // Get tabs in the 'current' window called from non-focused browser.
   scoped_refptr<TabsQueryFunction> function = new TabsQueryFunction();
   function->set_extension(test_util::CreateEmptyExtension().get());
-  scoped_ptr<base::ListValue> result(utils::ToList(
-      utils::RunFunctionAndReturnSingleResult(function.get(),
-                                              "[{}]",
-                                              browser())));
+  std::unique_ptr<base::ListValue> result(
+      utils::ToList(utils::RunFunctionAndReturnSingleResult(
+          function.get(), "[{}]", browser())));
 
   std::set<int> result_ids;
   base::ListValue* result_tabs = result.get();
   // We should have one tab per browser except for DevTools.
   EXPECT_EQ(kNumWindows, result_tabs->GetSize());
   for (size_t i = 0; i < result_tabs->GetSize(); ++i) {
     base::DictionaryValue* result_tab = nullptr;
     EXPECT_TRUE(result_tabs->GetDictionary(i, &result_tab));
     result_ids.insert(GetTabWindowId(result_tab));
   }
@@ skipping 13 matching lines @@
 
   scoped_refptr<TabsCreateFunction> create_tab_function(
       new TabsCreateFunction());
   create_tab_function->set_extension(test_util::CreateEmptyExtension().get());
   // Without a callback the function will not generate a result.
   create_tab_function->set_has_callback(true);
 
   static const char kNewBlankTabArgs[] =
       "[{\"url\": \"about:blank\", \"windowId\": %u}]";
 
-  scoped_ptr<base::DictionaryValue> result(utils::ToDictionary(
-      utils::RunFunctionAndReturnSingleResult(
+  std::unique_ptr<base::DictionaryValue> result(
+      utils::ToDictionary(utils::RunFunctionAndReturnSingleResult(
           create_tab_function.get(),
-          base::StringPrintf(kNewBlankTabArgs, window_id),
-          browser())));
+          base::StringPrintf(kNewBlankTabArgs, window_id), browser())));
 
   EXPECT_NE(window_id, GetTabWindowId(result.get()));
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, InvalidUpdateWindowState) {
   int window_id = ExtensionTabUtil::GetWindowId(browser());
 
   static const char kArgsMinimizedWithFocus[] =
       "[%u, {\"state\": \"minimized\", \"focused\": true}]";
   scoped_refptr<WindowsUpdateFunction> function = new WindowsUpdateFunction();
@@ skipping 39 matching lines @@
 IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, UpdateAppWindowSizeConstraint) {
   AppWindow* app_window = CreateTestAppWindow(
       "{\"outerBounds\": "
       "{\"width\": 300, \"height\": 300,"
       " \"minWidth\": 200, \"minHeight\": 200,"
       " \"maxWidth\": 400, \"maxHeight\": 400}}");
 
   scoped_refptr<WindowsGetFunction> get_function = new WindowsGetFunction();
   scoped_refptr<Extension> extension(test_util::CreateEmptyExtension().get());
   get_function->set_extension(extension.get());
-  scoped_ptr<base::DictionaryValue> result(
+  std::unique_ptr<base::DictionaryValue> result(
       utils::ToDictionary(utils::RunFunctionAndReturnSingleResult(
           get_function.get(),
           base::StringPrintf("[%u, {\"windowTypes\": [\"app\"]}]",
                              app_window->session_id().id()),
           browser())));
 
   EXPECT_EQ(300, api_test_utils::GetInteger(result.get(), "width"));
   EXPECT_EQ(300, api_test_utils::GetInteger(result.get(), "height"));
 
   // Verify the min width/height of the application window are
@@ skipping 25 matching lines @@
   CloseAppWindow(app_window);
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, UpdateDevToolsWindow) {
   DevToolsWindow* devtools = DevToolsWindowTesting::OpenDevToolsWindowSync(
       browser()->tab_strip_model()->GetWebContentsAt(0), false /* is_docked */);
 
   scoped_refptr<WindowsGetFunction> get_function = new WindowsGetFunction();
   scoped_refptr<Extension> extension(test_util::CreateEmptyExtension().get());
   get_function->set_extension(extension.get());
-  scoped_ptr<base::DictionaryValue> result(
+  std::unique_ptr<base::DictionaryValue> result(
       utils::ToDictionary(utils::RunFunctionAndReturnSingleResult(
           get_function.get(),
           base::StringPrintf(
               "[%u, {\"windowTypes\": [\"devtools\"]}]",
               ExtensionTabUtil::GetWindowId(
                   DevToolsWindowTesting::Get(devtools)->browser())),
           browser())));
 
   // Verify the updating width/height works.
   int32_t new_width = api_test_utils::GetInteger(result.get(), "width") - 50;
@@ skipping 166 matching lines @@
                        NoDevtoolsAndAppWindows) {
   DevToolsWindow* devtools = DevToolsWindowTesting::OpenDevToolsWindowSync(
       browser()->tab_strip_model()->GetWebContentsAt(0), false /* is_docked */);
   {
     int devtools_window_id = ExtensionTabUtil::GetWindowId(
         DevToolsWindowTesting::Get(devtools)->browser());
     ActivateBrowserWindow(DevToolsWindowTesting::Get(devtools)->browser());
 
     scoped_refptr<WindowsGetLastFocusedFunction> function =
         new WindowsGetLastFocusedFunction();
-    scoped_ptr<base::DictionaryValue> result(utils::ToDictionary(
+    std::unique_ptr<base::DictionaryValue> result(utils::ToDictionary(
         RunFunction(function.get(), "[{\"populate\": true}]")));
     EXPECT_NE(devtools_window_id,
               api_test_utils::GetInteger(result.get(), "id"));
   }
 
   AppWindow* app_window = CreateTestAppWindow(
       "{\"outerBounds\": "
       "{\"width\": 300, \"height\": 300,"
       " \"minWidth\": 200, \"minHeight\": 200,"
       " \"maxWidth\": 400, \"maxHeight\": 400}}");
   {
     ActivateAppWindow(app_window);
 
     scoped_refptr<WindowsGetLastFocusedFunction> get_current_app_function =
         new WindowsGetLastFocusedFunction();
-    scoped_ptr<base::DictionaryValue> result(utils::ToDictionary(
+    std::unique_ptr<base::DictionaryValue> result(utils::ToDictionary(
         RunFunction(get_current_app_function.get(), "[{\"populate\": true}]")));
     int app_window_id = app_window->session_id().id();
     EXPECT_NE(app_window_id, api_test_utils::GetInteger(result.get(), "id"));
   }
 
   DevToolsWindowTesting::CloseDevToolsWindowSync(devtools);
   CloseAppWindow(app_window);
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionWindowLastFocusedTest,
                        NoTabIdForDevToolsAndAppWindows) {
   Browser* normal_browser = CreateBrowserWithEmptyTab(false);
   {
     ActivateBrowserWindow(normal_browser);
 
     scoped_refptr<WindowsGetLastFocusedFunction> function =
         new WindowsGetLastFocusedFunction();
-    scoped_ptr<base::DictionaryValue> result(utils::ToDictionary(
+    std::unique_ptr<base::DictionaryValue> result(utils::ToDictionary(
         RunFunction(function.get(), "[{\"populate\": true}]")));
     int normal_browser_window_id =
         ExtensionTabUtil::GetWindowId(normal_browser);
     EXPECT_EQ(normal_browser_window_id,
               api_test_utils::GetInteger(result.get(), "id"));
     EXPECT_NE(-1, GetTabId(result.get()));
     EXPECT_EQ("normal", api_test_utils::GetString(result.get(), "type"));
   }
 
   Browser* popup_browser = CreateBrowserWithEmptyTab(true);
   {
     ActivateBrowserWindow(popup_browser);
 
     scoped_refptr<WindowsGetLastFocusedFunction> function =
         new WindowsGetLastFocusedFunction();
-    scoped_ptr<base::DictionaryValue> result(utils::ToDictionary(
+    std::unique_ptr<base::DictionaryValue> result(utils::ToDictionary(
         RunFunction(function.get(), "[{\"populate\": true}]")));
     int popup_browser_window_id = ExtensionTabUtil::GetWindowId(popup_browser);
     EXPECT_EQ(popup_browser_window_id,
               api_test_utils::GetInteger(result.get(), "id"));
     EXPECT_NE(-1, GetTabId(result.get()));
     EXPECT_EQ("popup", api_test_utils::GetString(result.get(), "type"));
   }
 
   DevToolsWindow* devtools = DevToolsWindowTesting::OpenDevToolsWindowSync(
       browser()->tab_strip_model()->GetWebContentsAt(0), false /* is_docked */);
   {
     ActivateBrowserWindow(DevToolsWindowTesting::Get(devtools)->browser());
 
     scoped_refptr<WindowsGetLastFocusedFunction> function =
         new WindowsGetLastFocusedFunction();
-    scoped_ptr<base::DictionaryValue> result(utils::ToDictionary(RunFunction(
-        function.get(),
-        "[{\"populate\": true, \"windowTypes\": [ \"devtools\" ]}]")));
+    std::unique_ptr<base::DictionaryValue> result(
+        utils::ToDictionary(RunFunction(
+            function.get(),
+            "[{\"populate\": true, \"windowTypes\": [ \"devtools\" ]}]")));
     int devtools_window_id = ExtensionTabUtil::GetWindowId(
         DevToolsWindowTesting::Get(devtools)->browser());
     EXPECT_EQ(devtools_window_id,
               api_test_utils::GetInteger(result.get(), "id"));
     EXPECT_EQ(-1, GetTabId(result.get()));
     EXPECT_EQ("devtools", api_test_utils::GetString(result.get(), "type"));
   }
 
   AppWindow* app_window = CreateTestAppWindow(
       "{\"outerBounds\": "
       "{\"width\": 300, \"height\": 300,"
       " \"minWidth\": 200, \"minHeight\": 200,"
       " \"maxWidth\": 400, \"maxHeight\": 400}}");
   {
     ActivateAppWindow(app_window);
 
     scoped_refptr<WindowsGetLastFocusedFunction> get_current_app_function =
         new WindowsGetLastFocusedFunction();
-    scoped_ptr<base::DictionaryValue> result(utils::ToDictionary(
+    std::unique_ptr<base::DictionaryValue> result(utils::ToDictionary(
         RunFunction(get_current_app_function.get(),
                     "[{\"populate\": true, \"windowTypes\": [ \"app\" ]}]")));
     int app_window_id = app_window->session_id().id();
     EXPECT_EQ(app_window_id, api_test_utils::GetInteger(result.get(), "id"));
     EXPECT_EQ(-1, GetTabId(result.get()));
     EXPECT_EQ("app", api_test_utils::GetString(result.get(), "type"));
   }
 
   chrome::CloseWindow(normal_browser);
   chrome::CloseWindow(popup_browser);
   DevToolsWindowTesting::CloseDevToolsWindowSync(devtools);
   CloseAppWindow(app_window);
 }
 #endif  // !defined(OS_MACOSX)
 
 IN_PROC_BROWSER_TEST_F(ExtensionWindowCreateTest, AcceptState) {
 #if defined(OS_MACOSX)
   ui::test::ScopedFakeNSWindowFullscreen fake_fullscreen;
 #endif
 
   scoped_refptr<WindowsCreateFunction> function(new WindowsCreateFunction());
   scoped_refptr<Extension> extension(test_util::CreateEmptyExtension());
   function->set_extension(extension.get());
 
-  scoped_ptr<base::DictionaryValue> result(
+  std::unique_ptr<base::DictionaryValue> result(
       utils::ToDictionary(utils::RunFunctionAndReturnSingleResult(
           function.get(), "[{\"state\": \"minimized\"}]", browser(),
           utils::INCLUDE_INCOGNITO)));
   int window_id = GetWindowId(result.get());
   std::string error;
   Browser* new_window = ExtensionTabUtil::GetBrowserFromWindowID(
       function.get(), window_id, &error);
   EXPECT_TRUE(error.empty());
 #if !defined(OS_LINUX) || defined(OS_CHROMEOS)
   // DesktopWindowTreeHostX11::IsMinimized() relies on an asynchronous update
@@ skipping 63 matching lines @@
                                 false);
   content::WebContents* web_contents = browser()->OpenURL(params);
   int tab_id = ExtensionTabUtil::GetTabId(web_contents);
   int window_id = ExtensionTabUtil::GetWindowIdOfTab(web_contents);
   int tab_index = -1;
   TabStripModel* tab_strip;
   ExtensionTabUtil::GetTabStripModel(web_contents, &tab_strip, &tab_index);
 
   scoped_refptr<TabsDuplicateFunction> duplicate_tab_function(
       new TabsDuplicateFunction());
-  scoped_ptr<base::DictionaryValue> test_extension_value(
+  std::unique_ptr<base::DictionaryValue> test_extension_value(
       api_test_utils::ParseDictionary(
           "{\"name\": \"Test\", \"version\": \"1.0\", \"permissions\": "
           "[\"tabs\"]}"));
   scoped_refptr<Extension> empty_tab_extension(
       api_test_utils::CreateExtension(test_extension_value.get()));
   duplicate_tab_function->set_extension(empty_tab_extension.get());
   duplicate_tab_function->set_has_callback(true);
 
-  scoped_ptr<base::DictionaryValue> duplicate_result(utils::ToDictionary(
-      utils::RunFunctionAndReturnSingleResult(
+  std::unique_ptr<base::DictionaryValue> duplicate_result(
+      utils::ToDictionary(utils::RunFunctionAndReturnSingleResult(
           duplicate_tab_function.get(), base::StringPrintf("[%u]", tab_id),
           browser())));
 
   int duplicate_tab_id = GetTabId(duplicate_result.get());
   int duplicate_tab_window_id = GetTabWindowId(duplicate_result.get());
   int duplicate_tab_index =
       api_test_utils::GetInteger(duplicate_result.get(), "index");
   EXPECT_EQ(base::Value::TYPE_DICTIONARY, duplicate_result->GetType());
   // Duplicate tab id should be different from the original tab id.
   EXPECT_NE(tab_id, duplicate_tab_id);
@@ skipping 17 matching lines @@
   int tab_index = -1;
   TabStripModel* tab_strip;
   ExtensionTabUtil::GetTabStripModel(web_contents, &tab_strip, &tab_index);
 
   scoped_refptr<TabsDuplicateFunction> duplicate_tab_function(
       new TabsDuplicateFunction());
   scoped_refptr<Extension> empty_extension(test_util::CreateEmptyExtension());
   duplicate_tab_function->set_extension(empty_extension.get());
   duplicate_tab_function->set_has_callback(true);
 
-  scoped_ptr<base::DictionaryValue> duplicate_result(utils::ToDictionary(
-      utils::RunFunctionAndReturnSingleResult(
+  std::unique_ptr<base::DictionaryValue> duplicate_result(
+      utils::ToDictionary(utils::RunFunctionAndReturnSingleResult(
           duplicate_tab_function.get(), base::StringPrintf("[%u]", tab_id),
           browser())));
 
   int duplicate_tab_id = GetTabId(duplicate_result.get());
   int duplicate_tab_window_id = GetTabWindowId(duplicate_result.get());
   int duplicate_tab_index =
       api_test_utils::GetInteger(duplicate_result.get(), "index");
   EXPECT_EQ(base::Value::TYPE_DICTIONARY, duplicate_result->GetType());
   // Duplicate tab id should be different from the original tab id.
   EXPECT_NE(tab_id, duplicate_tab_id);
@@ skipping 73 matching lines @@
 #if defined(OS_MACOSX)
   listener.Reply("");
 #else
   listener.Reply("focus");
 #endif
 
   ASSERT_TRUE(catcher.GetNextResult());
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, ExecuteScriptOnDevTools) {
-  scoped_ptr<base::DictionaryValue> test_extension_value(
+  std::unique_ptr<base::DictionaryValue> test_extension_value(
       api_test_utils::ParseDictionary(
           "{\"name\": \"Test\", \"version\": \"1.0\", \"permissions\": "
           "[\"tabs\"]}"));
   scoped_refptr<Extension> extension(
       api_test_utils::CreateExtension(test_extension_value.get()));
 
   DevToolsWindow* devtools = DevToolsWindowTesting::OpenDevToolsWindowSync(
       browser()->tab_strip_model()->GetWebContentsAt(0), false /* is_docked */);
 
   scoped_refptr<TabsExecuteScriptFunction> function =
@@ skipping 66 matching lines @@
 }
 
 testing::AssertionResult ExtensionTabsZoomTest::RunGetZoom(
     int tab_id,
     double* zoom_factor) {
   scoped_refptr<TabsGetZoomFunction> get_zoom_function(
       new TabsGetZoomFunction());
   get_zoom_function->set_extension(extension_.get());
   get_zoom_function->set_has_callback(true);
 
-  scoped_ptr<base::Value> get_zoom_result(
+  std::unique_ptr<base::Value> get_zoom_result(
       utils::RunFunctionAndReturnSingleResult(
-          get_zoom_function.get(),
-          base::StringPrintf("[%u]", tab_id),
+          get_zoom_function.get(), base::StringPrintf("[%u]", tab_id),
           browser()));
 
   if (!get_zoom_result)
     return testing::AssertionFailure() << "no result";
   if (!get_zoom_result->GetAsDouble(zoom_factor))
     return testing::AssertionFailure() << "result was not a double";
 
   return testing::AssertionSuccess();
 }
 
@@ skipping 22 matching lines @@
     int tab_id,
     std::string* mode,
     std::string* scope) {
   DCHECK(mode);
   DCHECK(scope);
   scoped_refptr<TabsGetZoomSettingsFunction> get_zoom_settings_function(
       new TabsGetZoomSettingsFunction());
   get_zoom_settings_function->set_extension(extension_.get());
   get_zoom_settings_function->set_has_callback(true);
 
-  scoped_ptr<base::DictionaryValue> get_zoom_settings_result(
+  std::unique_ptr<base::DictionaryValue> get_zoom_settings_result(
       utils::ToDictionary(utils::RunFunctionAndReturnSingleResult(
-          get_zoom_settings_function.get(),
-          base::StringPrintf("[%u]", tab_id),
+          get_zoom_settings_function.get(), base::StringPrintf("[%u]", tab_id),
           browser())));
 
   if (!get_zoom_settings_result)
     return testing::AssertionFailure() << "no result";
 
   *mode = api_test_utils::GetString(get_zoom_settings_result.get(), "mode");
   *scope = api_test_utils::GetString(get_zoom_settings_result.get(), "scope");
 
   return testing::AssertionSuccess();
 }
 
 testing::AssertionResult ExtensionTabsZoomTest::RunGetDefaultZoom(
     int tab_id,
     double* default_zoom_factor) {
   DCHECK(default_zoom_factor);
   scoped_refptr<TabsGetZoomSettingsFunction> get_zoom_settings_function(
       new TabsGetZoomSettingsFunction());
   get_zoom_settings_function->set_extension(extension_.get());
   get_zoom_settings_function->set_has_callback(true);
 
-  scoped_ptr<base::DictionaryValue> get_zoom_settings_result(
+  std::unique_ptr<base::DictionaryValue> get_zoom_settings_result(
       utils::ToDictionary(utils::RunFunctionAndReturnSingleResult(
-          get_zoom_settings_function.get(),
-          base::StringPrintf("[%u]", tab_id),
+          get_zoom_settings_function.get(), base::StringPrintf("[%u]", tab_id),
           browser())));
 
   if (!get_zoom_settings_result)
     return testing::AssertionFailure() << "no result";
 
   if (!get_zoom_settings_result->GetDouble("defaultZoomFactor",
                                            default_zoom_factor)) {
     return testing::AssertionFailure()
            << "default zoom factor not found in result";
   }
@@ skipping 279 matching lines @@
   EXPECT_TRUE(
       base::MatchPattern(error, manifest_errors::kCannotAccessChromeUrl));
 
   // chrome.tabs.setZoomSettings().
   error = RunSetZoomSettingsExpectError(tab_id, "manual", "per-tab");
   EXPECT_TRUE(
       base::MatchPattern(error, manifest_errors::kCannotAccessChromeUrl));
 }
 
 }  // namespace extensions