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

chrome/browser/ui/app_list/arc/arc_app_unittest.cc

 // Copyright 2015 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 <stdint.h>
 
 #include <algorithm>
 #include <map>
 #include <string>
@@ skipping 130 matching lines @@
   // Validate that prefs and model have right content.
   void ValidateHaveApps(const std::vector<arc::AppInfo> apps) {
     ArcAppListPrefs* prefs = ArcAppListPrefs::Get(profile_.get());
     const std::vector<std::string> ids = prefs->GetAppIds();
     ASSERT_EQ(apps.size(), ids.size());
     ASSERT_EQ(apps.size(), GetArcItemCount());
     // In principle, order of items is not defined.
     for (auto& app : apps) {
       const std::string id = ArcAppTest::GetAppId(app);
       EXPECT_NE(std::find(ids.begin(), ids.end(), id), ids.end());
-      scoped_ptr<ArcAppListPrefs::AppInfo> app_info = prefs->GetApp(id);
+      std::unique_ptr<ArcAppListPrefs::AppInfo> app_info = prefs->GetApp(id);
       ASSERT_NE(nullptr, app_info.get());
       EXPECT_EQ(app.name, app_info->name);
       EXPECT_EQ(app.package_name, app_info->package_name);
       EXPECT_EQ(app.activity, app_info->activity);
 
       const ArcAppItem* app_item = FindArcItem(id);
       ASSERT_NE(nullptr, app_item);
       EXPECT_EQ(app.name, app_item->GetDisplayName());
     }
   }
 
   // Validate that requested apps have required ready state and other apps have
   // opposite state.
   void ValidateAppReadyState(const std::vector<arc::AppInfo> apps, bool ready) {
     ArcAppListPrefs* prefs = ArcAppListPrefs::Get(profile_.get());
     ASSERT_NE(nullptr, prefs);
 
     std::vector<std::string> ids = prefs->GetAppIds();
     EXPECT_EQ(ids.size(), GetArcItemCount());
 
     // Process requested apps.
     for (auto& app : apps) {
       const std::string id = ArcAppTest::GetAppId(app);
       std::vector<std::string>::iterator it_id = std::find(ids.begin(),
                                                            ids.end(),
                                                            id);
       ASSERT_NE(it_id, ids.end());
       ids.erase(it_id);
 
-      scoped_ptr<ArcAppListPrefs::AppInfo> app_info = prefs->GetApp(id);
+      std::unique_ptr<ArcAppListPrefs::AppInfo> app_info = prefs->GetApp(id);
       ASSERT_NE(nullptr, app_info.get());
       EXPECT_EQ(ready, app_info->ready);
       const ArcAppItem* app_item = FindArcItem(id);
       ASSERT_NE(nullptr, app_item);
       EXPECT_EQ(ready, app_item->ready());
     }
 
     // Process the rest of the apps.
     for (auto& id : ids) {
-      scoped_ptr<ArcAppListPrefs::AppInfo> app_info = prefs->GetApp(id);
+      std::unique_ptr<ArcAppListPrefs::AppInfo> app_info = prefs->GetApp(id);
       ASSERT_NE(nullptr, app_info.get());
       EXPECT_NE(ready, app_info->ready);
       const ArcAppItem* app_item = FindArcItem(id);
       ASSERT_NE(nullptr, app_item);
       EXPECT_NE(ready, app_item->ready());
     }
   }
 
   // Validates that provided image is acceptable as Arc app icon.
   void ValidateIcon(const gfx::ImageSkia& image) {
@@ skipping 25 matching lines @@
   arc::FakeArcBridgeService* bridge_service() {
     return arc_test_.bridge_service();
   }
 
   arc::FakeAppInstance* app_instance() {
     return arc_test_.app_instance();
   }
 
  private:
   ArcAppTest arc_test_;
-  scoped_ptr<app_list::AppListModel> model_;
-  scoped_ptr<test::TestAppListControllerDelegate> controller_;
-  scoped_ptr<ArcAppModelBuilder> builder_;
+  std::unique_ptr<app_list::AppListModel> model_;
+  std::unique_ptr<test::TestAppListControllerDelegate> controller_;
+  std::unique_ptr<ArcAppModelBuilder> builder_;
 
   DISALLOW_COPY_AND_ASSIGN(ArcAppModelBuilderTest);
 };
 
 TEST_F(ArcAppModelBuilderTest, RefreshAllOnReady) {
   // There should already have been one call, when the interface was
   // registered.
   EXPECT_EQ(1, app_instance()->refresh_app_list_count());
   bridge_service()->SetReady();
   app_instance()->RefreshAppList();
@@ skipping 287 matching lines @@
   app_instance()->SendRefreshAppList(
       std::vector<arc::AppInfo>(fake_apps().begin(), fake_apps().begin() + 2));
   const arc::AppInfo& app1 = fake_apps()[0];
   const arc::AppInfo& app2 = fake_apps()[1];
   const std::string id1 = ArcAppTest::GetAppId(app1);
   const std::string id2 = ArcAppTest::GetAppId(app2);
 
   ArcAppListPrefs* prefs = ArcAppListPrefs::Get(profile_.get());
   ASSERT_NE(nullptr, prefs);
 
-  scoped_ptr<ArcAppListPrefs::AppInfo> app_info = prefs->GetApp(id1);
+  std::unique_ptr<ArcAppListPrefs::AppInfo> app_info = prefs->GetApp(id1);
   ASSERT_NE(nullptr, app_info.get());
 
   EXPECT_EQ(base::Time(), app_info->last_launch_time);
 
   // Test direct setting last launch time.
   base::Time now_time = base::Time::Now();
   prefs->SetLastLaunchTime(id1, now_time);
 
   app_info = prefs->GetApp(id1);
   ASSERT_NE(nullptr, app_info.get());
@@ skipping 51 matching lines @@
 
   // Allow one more circle to read and decode installed icons.
   content::BrowserThread::GetBlockingPool()->FlushForTesting();
   base::RunLoop().RunUntilIdle();
 
   // Validate loaded image.
   EXPECT_EQ(1 + scale_factors.size(), delegate.update_image_cnt());
   EXPECT_EQ(app_id, delegate.app_id());
   ValidateIcon(delegate.image());
 }