Replace scoped_ptr with std::unique_ptr in //ui

ui/app_list/app_list_item_list_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 "ui/app_list/app_list_item_list.h"
 
 #include <stddef.h>
 
+#include <memory>
 #include <utility>
 
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/app_list/app_list_folder_item.h"
 #include "ui/app_list/app_list_item.h"
 #include "ui/app_list/app_list_item_list_observer.h"
 
 namespace app_list {
 
 namespace {
 
@@ skipping 54 matching lines @@
 
  protected:
   AppListItem* FindItem(const std::string& id) {
     return item_list_.FindItem(id);
   }
 
   bool FindItemIndex(const std::string& id, size_t* index) {
     return item_list_.FindItemIndex(id, index);
   }
 
-  scoped_ptr<AppListItem> CreateItem(const std::string& name) {
-    scoped_ptr<AppListItem> item(new AppListItem(name));
+  std::unique_ptr<AppListItem> CreateItem(const std::string& name) {
+    std::unique_ptr<AppListItem> item(new AppListItem(name));
     size_t nitems = item_list_.item_count();
     syncer::StringOrdinal position;
     if (nitems == 0)
       position = syncer::StringOrdinal::CreateInitialOrdinal();
     else
       position = item_list_.item_at(nitems - 1)->position().CreateAfter();
     item->set_position(position);
     return item;
   }
 
   AppListItem* CreateAndAddItem(const std::string& name) {
-    scoped_ptr<AppListItem> item(CreateItem(name));
+    std::unique_ptr<AppListItem> item(CreateItem(name));
     return item_list_.AddItem(std::move(item));
   }
 
-  scoped_ptr<AppListItem> RemoveItem(const std::string& id) {
+  std::unique_ptr<AppListItem> RemoveItem(const std::string& id) {
     return item_list_.RemoveItem(id);
   }
 
-  scoped_ptr<AppListItem> RemoveItemAt(size_t index) {
+  std::unique_ptr<AppListItem> RemoveItemAt(size_t index) {
     return item_list_.RemoveItemAt(index);
   }
 
   syncer::StringOrdinal CreatePositionBefore(
       const syncer::StringOrdinal& position) {
     return item_list_.CreatePositionBefore(position);
   }
 
   bool VerifyItemListOrdinals() {
     bool res = true;
@@ skipping 41 matching lines @@
   EXPECT_TRUE(VerifyItemListOrdinals());
 
   size_t index;
   EXPECT_TRUE(FindItemIndex(item_0->id(), &index));
   EXPECT_EQ(index, 0u);
   EXPECT_TRUE(FindItemIndex(item_1->id(), &index));
   EXPECT_EQ(index, 1u);
   EXPECT_TRUE(FindItemIndex(item_2->id(), &index));
   EXPECT_EQ(index, 2u);
 
-  scoped_ptr<AppListItem> item_3(CreateItem(GetItemId(3)));
+  std::unique_ptr<AppListItem> item_3(CreateItem(GetItemId(3)));
   EXPECT_FALSE(FindItemIndex(item_3->id(), &index));
 }
 
 TEST_F(AppListItemListTest, RemoveItemAt) {
   AppListItem* item_0 = CreateAndAddItem(GetItemId(0));
   AppListItem* item_1 = CreateAndAddItem(GetItemId(1));
   AppListItem* item_2 = CreateAndAddItem(GetItemId(2));
   EXPECT_EQ(item_list_.item_count(), 3u);
   EXPECT_EQ(observer_.items_added(), 3u);
   size_t index;
   EXPECT_TRUE(FindItemIndex(item_1->id(), &index));
   EXPECT_EQ(index, 1u);
   EXPECT_TRUE(VerifyItemListOrdinals());
 
-  scoped_ptr<AppListItem> item_removed = RemoveItemAt(1);
+  std::unique_ptr<AppListItem> item_removed = RemoveItemAt(1);
   EXPECT_EQ(item_removed.get(), item_1);
   EXPECT_FALSE(FindItem(item_1->id()));
   EXPECT_EQ(item_list_.item_count(), 2u);
   EXPECT_EQ(observer_.items_removed(), 1u);
   EXPECT_EQ(item_list_.item_at(0), item_0);
   EXPECT_EQ(item_list_.item_at(1), item_2);
   EXPECT_TRUE(VerifyItemListOrdinals());
 }
 
 TEST_F(AppListItemListTest, RemoveItem) {
   AppListItem* item_0 = CreateAndAddItem(GetItemId(0));
   AppListItem* item_1 = CreateAndAddItem(GetItemId(1));
   AppListItem* item_2 = CreateAndAddItem(GetItemId(2));
   EXPECT_EQ(item_list_.item_count(), 3u);
   EXPECT_EQ(observer_.items_added(), 3u);
   EXPECT_EQ(item_0, item_list_.item_at(0));
   EXPECT_EQ(item_1, item_list_.item_at(1));
   EXPECT_EQ(item_2, item_list_.item_at(2));
   EXPECT_TRUE(VerifyItemListOrdinals());
 
   size_t index;
   EXPECT_TRUE(FindItemIndex(item_1->id(), &index));
   EXPECT_EQ(index, 1u);
 
-  scoped_ptr<AppListItem> item_removed = RemoveItem(item_1->id());
+  std::unique_ptr<AppListItem> item_removed = RemoveItem(item_1->id());
   EXPECT_EQ(item_removed.get(), item_1);
   EXPECT_FALSE(FindItem(item_1->id()));
   EXPECT_EQ(item_list_.item_count(), 2u);
   EXPECT_EQ(observer_.items_removed(), 1u);
   EXPECT_TRUE(VerifyItemListOrdinals());
 }
 
 TEST_F(AppListItemListTest, MoveItem) {
   CreateAndAddItem(GetItemId(0));
   CreateAndAddItem(GetItemId(1));
@@ skipping 139 matching lines @@
   EXPECT_TRUE(VerifyItemListOrdinals());
   EXPECT_TRUE(VerifyItemOrder4(2, 0, 3, 1));
   // last -> last
   item_list_.SetItemPosition(item_list_.item_at(3),
                              item_list_.item_at(3)->position().CreateAfter());
   EXPECT_TRUE(VerifyItemListOrdinals());
   EXPECT_TRUE(VerifyItemOrder4(2, 0, 3, 1));
 }
 
 }  // namespace app_list