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

chrome/browser/ui/app_list/arc/arc_app_list_prefs.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 "chrome/browser/ui/app_list/arc/arc_app_list_prefs.h"
 
 #include <stddef.h>
 
 #include <string>
 
@@ skipping 174 matching lines @@
     NOTREACHED();
     return;
   }
   arc::AppInstance* app_instance = bridge_service->app_instance();
   if (!app_instance) {
     VLOG(2) << "Request to load icon when bridge service is not ready: "
             <<  app_id << ".";
     return;
   }
 
-  scoped_ptr<AppInfo> app_info = GetApp(app_id);
+  std::unique_ptr<AppInfo> app_info = GetApp(app_id);
   if (!app_info) {
     VLOG(2) << "Failed to get app info: " <<  app_id << ".";
     return;
   }
 
   app_instance->RequestAppIcon(app_info->package_name, app_info->activity,
                                static_cast<arc::ScaleFactor>(scale_factor));
 }
 
 void ArcAppListPrefs::AddObserver(Observer* observer) {
@@ skipping 13 matching lines @@
        !app_id.IsAtEnd(); app_id.Advance()) {
     if (!crx_file::id_util::IdIsValid(app_id.key()))
       continue;
 
     ids.push_back(app_id.key());
   }
 
   return ids;
 }
 
-scoped_ptr<ArcAppListPrefs::AppInfo> ArcAppListPrefs::GetApp(
+std::unique_ptr<ArcAppListPrefs::AppInfo> ArcAppListPrefs::GetApp(
     const std::string& app_id) const {
   const base::DictionaryValue* app = nullptr;
   const base::DictionaryValue* apps = prefs_->GetDictionary(prefs::kArcApps);
   if (!apps || !apps->GetDictionaryWithoutPathExpansion(app_id, &app))
-    return scoped_ptr<AppInfo>();
+    return std::unique_ptr<AppInfo>();
 
   std::string name;
   std::string package_name;
   std::string activity;
   bool sticky = false;
   app->GetString(kName, &name);
   app->GetString(kPackageName, &package_name);
   app->GetString(kActivity, &activity);
   app->GetBoolean(kSticky, &sticky);
 
   base::Time last_launch_time;
   std::string last_launch_time_str;
   if (app->GetString(kLastLaunchTime, &last_launch_time_str)) {
     int64_t last_launch_time_i64 = 0;
     if (base::StringToInt64(last_launch_time_str, &last_launch_time_i64)) {
       last_launch_time = base::Time::FromInternalValue(last_launch_time_i64);
     } else {
       NOTREACHED();
     }
   }
 
-  scoped_ptr<AppInfo> app_info(new AppInfo(name,
-                                           package_name,
-                                           activity,
-                                           last_launch_time,
-                                           sticky,
-                                           ready_apps_.count(app_id) > 0));
+  std::unique_ptr<AppInfo> app_info(new AppInfo(name, package_name, activity,
+                                                last_launch_time, sticky,
+                                                ready_apps_.count(app_id) > 0));
   return app_info;
 }
 
 bool ArcAppListPrefs::IsRegistered(const std::string& app_id) const {
   const base::DictionaryValue* app = nullptr;
   const base::DictionaryValue* apps = prefs_->GetDictionary(prefs::kArcApps);
   if (!apps || !apps->GetDictionary(app_id, &app))
     return false;
 
   return true;
@@ skipping 46 matching lines @@
 void ArcAppListPrefs::AddApp(const arc::AppInfo& app) {
   if (app.name.get().empty() || app.package_name.get().empty() ||
       app.activity.get().empty()) {
     VLOG(2) << "Name, package name, and activity cannot be empty.";
     return;
   }
   std::string app_id = GetAppId(app.package_name, app.activity);
   bool was_registered = IsRegistered(app_id);
 
   if (was_registered) {
-    scoped_ptr<ArcAppListPrefs::AppInfo> app_old_info = GetApp(app_id);
+    std::unique_ptr<ArcAppListPrefs::AppInfo> app_old_info = GetApp(app_id);
     if (app.name != app_old_info->name) {
       FOR_EACH_OBSERVER(Observer, observer_list_,
                         OnAppNameUpdated(app_id, app.name));
     }
   }
 
   ScopedArcAppListPrefUpdate update(prefs_, app_id);
   base::DictionaryValue* app_dict = update.Get();
   app_dict->SetString(kName, app.name);
   app_dict->SetString(kPackageName, app.package_name);
@@ skipping 155 matching lines @@
                                   const std::string& activity,
                                   const base::Time& last_launch_time,
                                   bool sticky,
                                   bool ready)
     : name(name),
       package_name(package_name),
       activity(activity),
       last_launch_time(last_launch_time),
       sticky(sticky),
       ready(ready) {}