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

chrome/browser/ui/ash/launcher/chrome_launcher_controller_unittest.cc

 // Copyright 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 "chrome/browser/ui/ash/launcher/chrome_launcher_controller.h"
 
 #include <stddef.h>
+
 #include <algorithm>
+#include <memory>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "ash/ash_switches.h"
 #include "ash/shelf/shelf_item_delegate_manager.h"
 #include "ash/shelf/shelf_model.h"
 #include "ash/shelf/shelf_model_observer.h"
 #include "ash/shell.h"
 #include "ash/test/shelf_item_delegate_manager_test_api.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/test_extension_system.h"
 #include "chrome/browser/ui/ash/chrome_launcher_prefs.h"
 #include "chrome/browser/ui/ash/launcher/extension_app_window_launcher_item_controller.h"
 #include "chrome/browser/ui/ash/launcher/launcher_application_menu_item_model.h"
 #include "chrome/browser/ui/ash/launcher/launcher_item_controller.h"
@@ skipping 413 matching lines @@
 
     model_.reset();
 
     BrowserWithTestWindowTest::TearDown();
   }
 
   BrowserWindow* CreateBrowserWindow() override {
     return CreateTestBrowserWindowAura();
   }
 
-  scoped_ptr<Browser> CreateBrowserWithTestWindowForProfile(Profile* profile) {
+  std::unique_ptr<Browser> CreateBrowserWithTestWindowForProfile(
+      Profile* profile) {
     TestBrowserWindow* browser_window = CreateTestBrowserWindowAura();
     new TestBrowserWindowOwner(browser_window);
-    return make_scoped_ptr(
+    return base::WrapUnique(
         CreateBrowser(profile, Browser::TYPE_TABBED, false, browser_window));
   }
 
   void AddAppListLauncherItem() {
     ash::ShelfItem app_list;
     app_list.type = ash::TYPE_APP_LIST;
     model_->Add(app_list);
   }
 
   void InitLauncherController() {
     AddAppListLauncherItem();
     launcher_controller_.reset(
         new ChromeLauncherController(profile(), model_.get()));
     if (!ash::Shell::HasInstance())
       SetShelfItemDelegateManager(item_delegate_manager_);
     launcher_controller_->Init();
   }
 
   void InitLauncherControllerWithBrowser() {
     InitLauncherController();
     chrome::NewTab(browser());
     browser()->window()->Show();
   }
 
-  void SetAppIconLoader(scoped_ptr<AppIconLoader> loader) {
-    std::vector<scoped_ptr<AppIconLoader>> loaders;
+  void SetAppIconLoader(std::unique_ptr<AppIconLoader> loader) {
+    std::vector<std::unique_ptr<AppIconLoader>> loaders;
     loaders.push_back(std::move(loader));
     launcher_controller_->SetAppIconLoadersForTest(loaders);
   }
 
-  void SetAppIconLoaders(scoped_ptr<AppIconLoader> loader1,
-                         scoped_ptr<AppIconLoader> loader2) {
-    std::vector<scoped_ptr<AppIconLoader>> loaders;
+  void SetAppIconLoaders(std::unique_ptr<AppIconLoader> loader1,
+                         std::unique_ptr<AppIconLoader> loader2) {
+    std::vector<std::unique_ptr<AppIconLoader>> loaders;
     loaders.push_back(std::move(loader1));
     loaders.push_back(std::move(loader2));
     launcher_controller_->SetAppIconLoadersForTest(loaders);
   }
 
   void SetAppTabHelper(ChromeLauncherController::AppTabHelper* helper) {
     launcher_controller_->SetAppTabHelperForTest(helper);
   }
 
   void SetShelfItemDelegateManager(ash::ShelfItemDelegateManager* manager) {
@@ skipping 177 matching lines @@
   scoped_refptr<Extension> extension2_;
   scoped_refptr<Extension> extension3_;
   scoped_refptr<Extension> extension4_;
   scoped_refptr<Extension> extension5_;
   scoped_refptr<Extension> extension6_;
   scoped_refptr<Extension> extension7_;
   scoped_refptr<Extension> extension8_;
 #if defined(OS_CHROMEOS)
   ArcAppTest arc_test_;
 #endif  // defined(OS_CHROMEOS)
-  scoped_ptr<ChromeLauncherController> launcher_controller_;
-  scoped_ptr<TestShelfModelObserver> model_observer_;
-  scoped_ptr<ash::ShelfModel> model_;
+  std::unique_ptr<ChromeLauncherController> launcher_controller_;
+  std::unique_ptr<TestShelfModelObserver> model_observer_;
+  std::unique_ptr<ash::ShelfModel> model_;
 
   // |item_delegate_manager_| owns |test_controller_|.
   LauncherItemController* test_controller_;
 
   ExtensionService* extension_service_;
 
   ash::ShelfItemDelegateManager* item_delegate_manager_;
 
  private:
   TestBrowserWindow* CreateTestBrowserWindowAura() {
-    scoped_ptr<aura::Window> window(new aura::Window(nullptr));
+    std::unique_ptr<aura::Window> window(new aura::Window(nullptr));
     window->set_id(0);
     window->SetType(ui::wm::WINDOW_TYPE_NORMAL);
     window->Init(ui::LAYER_TEXTURED);
     aura::client::ParentWindowWithContext(window.get(), GetContext(),
                                           gfx::Rect(200, 200));
 
     return new TestBrowserWindowAura(std::move(window));
   }
 
   DISALLOW_COPY_AND_ASSIGN(ChromeLauncherControllerTest);
@@ skipping 54 matching lines @@
 
   Browser* browser() { return browser_.get(); }
 
   // TestBrowserWindow override:
   gfx::NativeWindow GetNativeWindow() const override {
     return native_window_.get();
   }
 
  private:
   // The associated browser with this app.
-  scoped_ptr<Browser> browser_;
+  std::unique_ptr<Browser> browser_;
 
   // The native window we use.
-  scoped_ptr<aura::Window> native_window_;
+  std::unique_ptr<aura::Window> native_window_;
 
   DISALLOW_COPY_AND_ASSIGN(V1App);
 };
 
 // A V2 application which gets created with an |extension| and for a |profile|.
 // Upon destruction it will properly close the application.
 class V2App {
  public:
   V2App(Profile* profile, const extensions::Extension* extension)
       : creator_web_contents_(
@@ skipping 14 matching lines @@
 
   virtual ~V2App() {
     WebContentsDestroyedWatcher destroyed_watcher(window_->web_contents());
     window_->GetBaseWindow()->Close();
     destroyed_watcher.Wait();
   }
 
   extensions::AppWindow* window() { return window_; }
 
  private:
-  scoped_ptr<content::WebContents> creator_web_contents_;
+  std::unique_ptr<content::WebContents> creator_web_contents_;
 
   // The app window which represents the application. Note that the window
   // deletes itself asynchronously after window_->GetBaseWindow()->Close() gets
   // called.
   extensions::AppWindow* window_;
 
   DISALLOW_COPY_AND_ASSIGN(V2App);
 };
 
 // The testing framework to test multi profile scenarios.
@@ skipping 84 matching lines @@
     manager->SetAnimationSpeedForTest(
         chrome::MultiUserWindowManagerChromeOS::ANIMATION_SPEED_DISABLED);
     manager->ActiveUserChanged(account_id);
     launcher_controller_->browser_status_monitor_for_test()->ActiveUserChanged(
         account_id.GetUserEmail());
     launcher_controller_->app_window_controller_for_test()->ActiveUserChanged(
         account_id.GetUserEmail());
   }
 
   // Creates a browser with a |profile| and load a tab with a |title| and |url|.
-  scoped_ptr<Browser> CreateBrowserAndTabWithProfile(Profile* profile,
-                                                     const std::string& title,
-                                                     const std::string& url) {
-    scoped_ptr<Browser> browser(CreateBrowserWithTestWindowForProfile(profile));
+  std::unique_ptr<Browser> CreateBrowserAndTabWithProfile(
+      Profile* profile,
+      const std::string& title,
+      const std::string& url) {
+    std::unique_ptr<Browser> browser(
+        CreateBrowserWithTestWindowForProfile(profile));
     chrome::NewTab(browser.get());
 
     browser->window()->Show();
     NavigateAndCommitActiveTabWithTitle(browser.get(), GURL(url),
                                         ASCIIToUTF16(title));
     return browser;
   }
 
   // Creates a running V1 application.
   // Note that with the use of the app_tab_helper as done below, this is only
@@ skipping 37 matching lines @@
 
  private:
   typedef std::map<Profile*, std::string> ProfileToNameMap;
   TestingProfileManager* profile_manager() { return profile_manager_.get(); }
 
   chromeos::FakeChromeUserManager* GetFakeUserManager() {
     return static_cast<chromeos::FakeChromeUserManager*>(
         user_manager::UserManager::Get());
   }
 
-  scoped_ptr<TestingProfileManager> profile_manager_;
-  scoped_ptr<chromeos::ScopedUserManagerEnabler> user_manager_enabler_;
+  std::unique_ptr<TestingProfileManager> profile_manager_;
+  std::unique_ptr<chromeos::ScopedUserManagerEnabler> user_manager_enabler_;
 
   ash::test::TestShellDelegate* shell_delegate_;
 
   ProfileToNameMap created_profiles_;
 
   DISALLOW_COPY_AND_ASSIGN(
       MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest);
 };
 #endif  // defined(OS_CHROMEOS)
 
@@ skipping 529 matching lines @@
 
 // Check that with multi profile V1 apps are properly added / removed from the
 // shelf.
 TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
        V1AppUpdateOnUserSwitch) {
   // Create a browser item in the LauncherController.
   InitLauncherController();
   EXPECT_EQ(2, model_->item_count());
   {
     // Create a "windowed gmail app".
-    scoped_ptr<V1App> v1_app(CreateRunningV1App(
-        profile(), extension_misc::kGmailAppId, gmail_url));
+    std::unique_ptr<V1App> v1_app(
+        CreateRunningV1App(profile(), extension_misc::kGmailAppId, gmail_url));
     EXPECT_EQ(3, model_->item_count());
 
     // After switching to a second user the item should be gone.
     std::string user2 = "user2";
     TestingProfile* profile2 = CreateMultiUserProfile(user2);
     const AccountId account_id2(
         multi_user_util::GetAccountIdFromProfile(profile2));
     const AccountId account_id(
         multi_user_util::GetAccountIdFromProfile(profile()));
     SwitchActiveUser(account_id2);
@@ skipping 15 matching lines @@
 
   // First test: Create an app when the user is not active.
   std::string user2 = "user2";
   TestingProfile* profile2 = CreateMultiUserProfile(user2);
   const AccountId account_id2(
       multi_user_util::GetAccountIdFromProfile(profile2));
   const AccountId account_id(
       multi_user_util::GetAccountIdFromProfile(profile()));
   {
     // Create a "windowed gmail app".
-    scoped_ptr<V1App> v1_app(CreateRunningV1App(
-        profile2, extension_misc::kGmailAppId, gmail_url));
+    std::unique_ptr<V1App> v1_app(
+        CreateRunningV1App(profile2, extension_misc::kGmailAppId, gmail_url));
     EXPECT_EQ(2, model_->item_count());
 
     // However - switching to the user should show it.
     SwitchActiveUser(account_id2);
     EXPECT_EQ(3, model_->item_count());
 
     // Second test: Remove the app when the user is not active and see that it
     // works.
     SwitchActiveUser(account_id);
     EXPECT_EQ(2, model_->item_count());
@@ skipping 17 matching lines @@
 
   // First create an app when the user is active.
   std::string user2 = "user2";
   TestingProfile* profile2 = CreateMultiUserProfile(user2);
   const AccountId account_id(
       multi_user_util::GetAccountIdFromProfile(profile()));
   const AccountId account_id2(
       multi_user_util::GetAccountIdFromProfile(profile2));
   {
     // Create a "windowed gmail app".
-    scoped_ptr<V1App> v1_app(CreateRunningV1App(
-        profile(),
-        extension_misc::kGmailAppId,
-        kGmailLaunchURL));
+    std::unique_ptr<V1App> v1_app(CreateRunningV1App(
+        profile(), extension_misc::kGmailAppId, kGmailLaunchURL));
     EXPECT_EQ(3, model_->item_count());
 
     // Transfer the app to the other screen and switch users.
     manager->ShowWindowForUser(v1_app->browser()->window()->GetNativeWindow(),
                                account_id2);
     EXPECT_EQ(3, model_->item_count());
     SwitchActiveUser(account_id2);
     EXPECT_EQ(2, model_->item_count());
   }
   // After the app was destroyed, switch back. (which caused already a crash).
   SwitchActiveUser(account_id);
 
   // Create the same app again - which was also causing the crash.
   EXPECT_EQ(2, model_->item_count());
   {
     // Create a "windowed gmail app".
-    scoped_ptr<V1App> v1_app(CreateRunningV1App(
-        profile(),
-        extension_misc::kGmailAppId,
-        kGmailLaunchURL));
+    std::unique_ptr<V1App> v1_app(CreateRunningV1App(
+        profile(), extension_misc::kGmailAppId, kGmailLaunchURL));
     EXPECT_EQ(3, model_->item_count());
   }
   SwitchActiveUser(account_id2);
   EXPECT_EQ(2, model_->item_count());
 }
 
 // Check edge cases with multi profile V1 apps in the shelf.
 TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
        V1AppUpdateOnUserSwitchEdgecases2) {
   // Create a browser item in the LauncherController.
   InitLauncherController();
   TestAppTabHelperImpl* app_tab_helper = new TestAppTabHelperImpl;
   SetAppTabHelper(app_tab_helper);
 
   // First test: Create an app when the user is not active.
   std::string user2 = "user2";
   TestingProfile* profile2 = CreateMultiUserProfile(user2);
   const AccountId account_id(
       multi_user_util::GetAccountIdFromProfile(profile()));
   const AccountId account_id2(
       multi_user_util::GetAccountIdFromProfile(profile2));
   SwitchActiveUser(account_id2);
   {
     // Create a "windowed gmail app".
-    scoped_ptr<V1App> v1_app(CreateRunningV1App(
-        profile(), extension_misc::kGmailAppId, gmail_url));
+    std::unique_ptr<V1App> v1_app(
+        CreateRunningV1App(profile(), extension_misc::kGmailAppId, gmail_url));
     EXPECT_EQ(2, model_->item_count());
 
     // However - switching to the user should show it.
     SwitchActiveUser(account_id);
     EXPECT_EQ(3, model_->item_count());
 
     // Second test: Remove the app when the user is not active and see that it
     // works.
     SwitchActiveUser(account_id2);
     EXPECT_EQ(2, model_->item_count());
@@ skipping 18 matching lines @@
   // Create a second test profile. The first is the one in profile() created in
   // BrowserWithTestWindowTest::SetUp().
   // No need to add the profiles to the MultiUserWindowManager here.
   // CreateMultiUserProfile() already does that.
   TestingProfile* profile2 = CreateMultiUserProfile("user2");
   const AccountId current_user =
       multi_user_util::GetAccountIdFromProfile(profile());
 
   // Create a browser window with a native window for the current user.
   Browser::CreateParams params(profile());
-  scoped_ptr<Browser> browser(
+  std::unique_ptr<Browser> browser(
       chrome::CreateBrowserWithAuraTestWindowForParams(nullptr, &params));
   BrowserWindow* browser_window = browser->window();
   aura::Window* window = browser_window->GetNativeWindow();
   manager->SetWindowOwner(window, current_user);
 
   // Check that an activation of the window on its owner's desktop does not
   // change the visibility to another user.
   launcher_controller_->ActivateWindowOrMinimizeIfActive(browser_window, false);
   EXPECT_TRUE(manager->IsWindowOnDesktopOfUser(window, current_user));
 
@@ skipping 419 matching lines @@
   EXPECT_FALSE(items[0]->IsEnabled());
   for (size_t i = 0; i < expected_items; i++) {
     EXPECT_EQ(title[i], items[1 + i]->title());
     // Check that the first real item has a leading separator.
     if (i == 1)
       EXPECT_TRUE(items[i]->HasLeadingSeparator());
     else
       EXPECT_FALSE(items[i]->HasLeadingSeparator());
   }
 
-  scoped_ptr<ash::ShelfMenuModel> menu(new LauncherApplicationMenuItemModel(
-      controller->GetApplicationList(item, 0)));
+  std::unique_ptr<ash::ShelfMenuModel> menu(
+      new LauncherApplicationMenuItemModel(
+          controller->GetApplicationList(item, 0)));
   // The first element in the menu is a spacing separator. On some systems
   // (e.g. Windows) such things do not exist. As such we check the existence
   // and adjust dynamically.
   int first_item = menu->GetTypeAt(0) == ui::MenuModel::TYPE_SEPARATOR ? 1 : 0;
   int expected_menu_items = first_item +
                             (expected_items ? (expected_items + 3) : 2);
   EXPECT_EQ(expected_menu_items, menu->GetItemCount());
   EXPECT_FALSE(menu->IsEnabledAt(first_item));
   if (expected_items) {
     EXPECT_EQ(ui::MenuModel::TYPE_SEPARATOR,
@@ skipping 20 matching lines @@
   // Now make the created browser() visible by showing its browser window.
   browser()->window()->Show();
   base::string16 title1 = ASCIIToUTF16("Test1");
   NavigateAndCommitActiveTabWithTitle(browser(), GURL("http://test1"), title1);
   base::string16 one_menu_item[] = { title1 };
 
   EXPECT_TRUE(CheckMenuCreation(
       launcher_controller_.get(), item_browser, 1, one_menu_item, true));
 
   // Create one more browser/window and check that one more was added.
-  scoped_ptr<Browser> browser2(
+  std::unique_ptr<Browser> browser2(
       CreateBrowserWithTestWindowForProfile(profile()));
   chrome::NewTab(browser2.get());
   browser2->window()->Show();
   base::string16 title2 = ASCIIToUTF16("Test2");
   NavigateAndCommitActiveTabWithTitle(browser2.get(), GURL("http://test2"),
                                       title2);
 
   // Check that the list contains now two entries - make furthermore sure that
   // the active item is the first entry.
   base::string16 two_menu_items[] = {title1, title2};
@@ skipping 29 matching lines @@
   base::string16 one_menu_item1[] = { title1 };
   EXPECT_TRUE(CheckMenuCreation(
       launcher_controller_.get(), item_browser, 1, one_menu_item1, true));
 
   // Create a browser for another user and check that it is not included in the
   // users running browser list.
   std::string user2 = "user2";
   TestingProfile* profile2 = CreateMultiUserProfile(user2);
   const AccountId account_id2(
       multi_user_util::GetAccountIdFromProfile(profile2));
-  scoped_ptr<Browser> browser2(
+  std::unique_ptr<Browser> browser2(
       CreateBrowserAndTabWithProfile(profile2, user2, "http://test2"));
   base::string16 one_menu_item2[] = { ASCIIToUTF16(user2) };
   EXPECT_TRUE(CheckMenuCreation(
       launcher_controller_.get(), item_browser, 1, one_menu_item1, true));
 
   // Switch to the other user and make sure that only that browser window gets
   // shown.
   SwitchActiveUser(account_id2);
   EXPECT_TRUE(CheckMenuCreation(
       launcher_controller_.get(), item_browser, 1, one_menu_item2, true));
@@ skipping 375 matching lines @@
   ash::ShelfItem item_gmail;
   item_gmail.type = ash::TYPE_APP_SHORTCUT;
   item_gmail.id = gmail_id;
   base::string16 two_menu_items[] = {title1, title2};
   EXPECT_TRUE(CheckMenuCreation(
       launcher_controller_.get(), item_gmail, 2, two_menu_items, false));
   EXPECT_EQ(1, browser()->tab_strip_model()->active_index());
   // Execute the second item in the list (which shouldn't do anything since that
   // item is per definition already the active tab).
   {
-    scoped_ptr<ash::ShelfMenuModel> menu(new LauncherApplicationMenuItemModel(
-        launcher_controller_->GetApplicationList(item_gmail, 0)));
+    std::unique_ptr<ash::ShelfMenuModel> menu(
+        new LauncherApplicationMenuItemModel(
+            launcher_controller_->GetApplicationList(item_gmail, 0)));
     // The first element in the menu is a spacing separator. On some systems
     // (e.g. Windows) such things do not exist. As such we check the existence
     // and adjust dynamically.
     int first_item =
         (menu->GetTypeAt(0) == ui::MenuModel::TYPE_SEPARATOR) ? 1 : 0;
     menu->ActivatedAt(first_item + 3);
   }
   EXPECT_EQ(1, browser()->tab_strip_model()->active_index());
 
   // Execute the first item.
   {
-    scoped_ptr<ash::ShelfMenuModel> menu(new LauncherApplicationMenuItemModel(
-        launcher_controller_->GetApplicationList(item_gmail, 0)));
+    std::unique_ptr<ash::ShelfMenuModel> menu(
+        new LauncherApplicationMenuItemModel(
+            launcher_controller_->GetApplicationList(item_gmail, 0)));
     int first_item =
         (menu->GetTypeAt(0) == ui::MenuModel::TYPE_SEPARATOR) ? 1 : 0;
     menu->ActivatedAt(first_item + 2);
   }
   // Now the active tab should be the second item.
   EXPECT_EQ(0, browser()->tab_strip_model()->active_index());
 }
 
 // Checks that the generated menu list properly deletes items.
 TEST_F(ChromeLauncherControllerTest, V1AppMenuDeletionExecution) {
@@ skipping 39 matching lines @@
 // Tests that panels create launcher items correctly
 TEST_F(ChromeLauncherControllerTest, AppPanels) {
   InitLauncherControllerWithBrowser();
   // App list and Browser shortcut ShelfItems are added.
   EXPECT_EQ(2, model_observer_->added());
 
   const std::string app_id = extension1_->id();
   // app_icon_loader is owned by ChromeLauncherController.
   TestAppIconLoaderImpl* app_icon_loader = new TestAppIconLoaderImpl();
   app_icon_loader->AddSupportedApp(app_id);
-  SetAppIconLoader(scoped_ptr<AppIconLoader>(app_icon_loader));
+  SetAppIconLoader(std::unique_ptr<AppIconLoader>(app_icon_loader));
 
   // Test adding an app panel
   AppWindowLauncherItemController* app_panel_controller =
       new ExtensionAppWindowLauncherItemController(
           LauncherItemController::TYPE_APP_PANEL, "id", app_id,
           launcher_controller_.get());
   ash::ShelfID shelf_id1 = launcher_controller_->CreateAppLauncherItem(
       app_panel_controller, app_id, ash::STATUS_RUNNING);
   int panel_index = model_observer_->last_index();
   EXPECT_EQ(3, model_observer_->added());
@@ skipping 161 matching lines @@
   TabStripModel* tab_strip_model = browser()->tab_strip_model();
   EXPECT_EQ(1, tab_strip_model->count());
 
   TestAppTabHelperImpl* app_tab_helper = new TestAppTabHelperImpl;
   app_tab_helper->SetAppID(tab_strip_model->GetWebContentsAt(0), "1");
   SetAppTabHelper(app_tab_helper);
 
   // app_icon_loader is owned by ChromeLauncherController.
   TestAppIconLoaderImpl* app_icon_loader = new TestAppIconLoaderImpl;
   app_icon_loader->AddSupportedApp("1");
-  SetAppIconLoader(scoped_ptr<AppIconLoader>(app_icon_loader));
+  SetAppIconLoader(std::unique_ptr<AppIconLoader>(app_icon_loader));
   EXPECT_EQ(0, app_icon_loader->fetch_count());
 
   launcher_controller_->PinAppWithID("1");
   ash::ShelfID id = launcher_controller_->GetShelfIDForAppID("1");
   int app_index = model_->ItemIndexByID(id);
   EXPECT_EQ(1, app_icon_loader->fetch_count());
   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[app_index].type);
   EXPECT_TRUE(launcher_controller_->IsAppPinned("1"));
   EXPECT_FALSE(launcher_controller_->IsAppPinned("0"));
   EXPECT_EQ(initial_size + 1, model_->items().size());
@@ skipping 11 matching lines @@
 
   AddAppListLauncherItem();
   launcher_controller_.reset(
       ChromeLauncherController::CreateInstance(profile(), model_.get()));
   app_tab_helper = new TestAppTabHelperImpl;
   app_tab_helper->SetAppID(tab_strip_model->GetWebContentsAt(0), "1");
   SetAppTabHelper(app_tab_helper);
   // app_icon_loader is owned by ChromeLauncherController.
   app_icon_loader = new TestAppIconLoaderImpl;
   app_icon_loader->AddSupportedApp("1");
-  SetAppIconLoader(scoped_ptr<AppIconLoader>(app_icon_loader));
+  SetAppIconLoader(std::unique_ptr<AppIconLoader>(app_icon_loader));
   if (!ash::Shell::HasInstance()) {
     item_delegate_manager_ = new ash::ShelfItemDelegateManager(model_.get());
     SetShelfItemDelegateManager(item_delegate_manager_);
   }
   launcher_controller_->Init();
 
   EXPECT_EQ(1, app_icon_loader->fetch_count());
   ASSERT_EQ(initial_size + 1, model_->items().size());
   EXPECT_TRUE(launcher_controller_->IsAppPinned("1"));
   EXPECT_FALSE(launcher_controller_->IsAppPinned("0"));
   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[app_index].type);
 
   launcher_controller_->UnpinAppWithID("1");
   ASSERT_EQ(initial_size, model_->items().size());
 }
 
 TEST_F(ChromeLauncherControllerTest, MultipleAppIconLoaders) {
   InitLauncherControllerWithBrowser();
 
   const std::string app_id1 = extension1_->id();
   const std::string app_id2 = extension2_->id();
   const std::string app_id3 = extension3_->id();
   // app_icon_loader1 and app_icon_loader2 are owned by
   // ChromeLauncherController.
   TestAppIconLoaderImpl* app_icon_loader1 = new TestAppIconLoaderImpl();
   TestAppIconLoaderImpl* app_icon_loader2 = new TestAppIconLoaderImpl();
   app_icon_loader1->AddSupportedApp(app_id1);
   app_icon_loader2->AddSupportedApp(app_id2);
-  SetAppIconLoaders(scoped_ptr<AppIconLoader>(app_icon_loader1),
-                    scoped_ptr<AppIconLoader>(app_icon_loader2));
+  SetAppIconLoaders(std::unique_ptr<AppIconLoader>(app_icon_loader1),
+                    std::unique_ptr<AppIconLoader>(app_icon_loader2));
 
   AppWindowLauncherItemController* app_panel_controller3 =
       new ExtensionAppWindowLauncherItemController(
           LauncherItemController::TYPE_APP_PANEL, "id", app_id3,
           launcher_controller_.get());
   const ash::ShelfID shelfId3 = launcher_controller_->CreateAppLauncherItem(
       app_panel_controller3, app_id3, ash::STATUS_RUNNING);
   EXPECT_EQ(0, app_icon_loader1->fetch_count());
   EXPECT_EQ(0, app_icon_loader1->clear_count());
   EXPECT_EQ(0, app_icon_loader2->fetch_count());
@@ skipping 34 matching lines @@
   EXPECT_EQ(1, app_icon_loader1->clear_count());
   EXPECT_EQ(1, app_icon_loader2->fetch_count());
   EXPECT_EQ(1, app_icon_loader2->clear_count());
 
   launcher_controller_->CloseLauncherItem(shelfId3);
   EXPECT_EQ(1, app_icon_loader1->fetch_count());
   EXPECT_EQ(1, app_icon_loader1->clear_count());
   EXPECT_EQ(1, app_icon_loader2->fetch_count());
   EXPECT_EQ(1, app_icon_loader2->clear_count());
 }