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

chrome/browser/ui/app_list/search/app_search_provider.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/app_list/search/app_search_provider.h"
 
 #include <stddef.h>
 #include <string>
 #include <utility>
 
@@ skipping 62 matching lines @@
 
 class AppSearchProvider::DataSource {
  public:
   DataSource(Profile* profile, AppSearchProvider* owner)
       : profile_(profile),
         owner_(owner) {}
   virtual ~DataSource() {}
 
   virtual void AddApps(Apps* apps) = 0;
 
-  virtual scoped_ptr<AppResult> CreateResult(
+  virtual std::unique_ptr<AppResult> CreateResult(
       const std::string& app_id,
       AppListControllerDelegate* list_controller,
       AppListItemList* top_level_item_list,
       bool is_recommended) = 0;
 
  protected:
   Profile* profile() { return profile_; }
   AppSearchProvider* owner() { return owner_; }
 
  private:
@@ skipping 17 matching lines @@
   ~ExtensionDataSource() override {}
 
   // AppSearchProvider::DataSource overrides:
   void AddApps(AppSearchProvider::Apps* apps) override {
     ExtensionRegistry* registry = ExtensionRegistry::Get(profile());
     AddApps(apps, registry->enabled_extensions());
     AddApps(apps, registry->disabled_extensions());
     AddApps(apps, registry->terminated_extensions());
   }
 
-  scoped_ptr<AppResult> CreateResult(
+  std::unique_ptr<AppResult> CreateResult(
       const std::string& app_id,
       AppListControllerDelegate* list_controller,
       AppListItemList* top_level_item_list,
       bool is_recommended) override {
-    return scoped_ptr<AppResult>(new ExtensionAppResult(profile(),
-                                                        app_id,
-                                                        list_controller,
-                                                        is_recommended));
+    return std::unique_ptr<AppResult>(new ExtensionAppResult(
+        profile(), app_id, list_controller, is_recommended));
   }
 
   // extensions::ExtensionRegistryObserver overrides:
   void OnExtensionLoaded(content::BrowserContext* browser_context,
                          const extensions::Extension* extension) override {
     owner()->RefreshAppsAndUpdateResults(false);
   }
 
   void OnExtensionUninstalled(content::BrowserContext* browser_context,
                               const extensions::Extension* extension,
@@ skipping 12 matching lines @@
       if (!extensions::ui_util::ShouldDisplayInAppLauncher(extension,
                                                            profile())) {
         continue;
       }
 
       if (profile()->IsOffTheRecord() &&
           !extensions::util::CanLoadInIncognito(extension, profile())) {
         continue;
       }
 
-      scoped_ptr<AppSearchProvider::App> app(
-          new AppSearchProvider::App(
-              this,
-              extension->id(),
-              extension->short_name(),
-              prefs->GetLastLaunchTime(extension->id())));
+      std::unique_ptr<AppSearchProvider::App> app(new AppSearchProvider::App(
+          this, extension->id(), extension->short_name(),
+          prefs->GetLastLaunchTime(extension->id())));
       apps->push_back(std::move(app));
     }
   }
 
   ScopedObserver<extensions::ExtensionRegistry,
                  extensions::ExtensionRegistryObserver>
       extension_registry_observer_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionDataSource);
 };
@@ skipping 11 matching lines @@
     ArcAppListPrefs::Get(profile())->RemoveObserver(this);
   }
 
   // AppSearchProvider::DataSource overrides:
   void AddApps(AppSearchProvider::Apps* apps) override {
     ArcAppListPrefs* arc_prefs = ArcAppListPrefs::Get(profile());
     CHECK(arc_prefs);
 
     const std::vector<std::string> app_ids = arc_prefs->GetAppIds();
     for (const auto& app_id : app_ids) {
-      scoped_ptr<ArcAppListPrefs::AppInfo> app_info = arc_prefs->GetApp(app_id);
+      std::unique_ptr<ArcAppListPrefs::AppInfo> app_info =
+          arc_prefs->GetApp(app_id);
       if (!app_info) {
         NOTREACHED();
         continue;
       }
 
-      scoped_ptr<AppSearchProvider::App> app(
-          new AppSearchProvider::App(this,
-                                     app_id,
-                                     app_info->name,
-                                     app_info->last_launch_time));
+      std::unique_ptr<AppSearchProvider::App> app(new AppSearchProvider::App(
+          this, app_id, app_info->name, app_info->last_launch_time));
       apps->push_back(std::move(app));
     }
   }
 
-  scoped_ptr<AppResult> CreateResult(
+  std::unique_ptr<AppResult> CreateResult(
       const std::string& app_id,
       AppListControllerDelegate* list_controller,
       AppListItemList* top_level_item_list,
       bool is_recommended) override {
-    return scoped_ptr<AppResult>(new ArcAppResult(profile(),
-                                                  app_id,
-                                                  list_controller,
-                                                  is_recommended));
+    return std::unique_ptr<AppResult>(
+        new ArcAppResult(profile(), app_id, list_controller, is_recommended));
   }
 
   // ArcAppListPrefs::Observer overrides:
   void OnAppRegistered(const std::string& app_id,
                        const ArcAppListPrefs::AppInfo& app_info) override {
     owner()->RefreshAppsAndUpdateResults(false);
   }
 
   void OnAppRemoved(const std::string& id) override {
     owner()->RefreshAppsAndUpdateResults(true);
   }
 
   void OnAppNameUpdated(const std::string& id,
                         const std::string& name) override {
     owner()->RefreshAppsAndUpdateResults(false);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ArcDataSource);
 };
 #endif
 
 }  // namespace
 
 AppSearchProvider::AppSearchProvider(Profile* profile,
                                      AppListControllerDelegate* list_controller,
-                                     scoped_ptr<base::Clock> clock,
+                                     std::unique_ptr<base::Clock> clock,
                                      AppListItemList* top_level_item_list)
     : profile_(profile),
       list_controller_(list_controller),
       top_level_item_list_(top_level_item_list),
       clock_(std::move(clock)),
       update_results_factory_(this) {
-  data_sources_.push_back(scoped_ptr<DataSource>(
-      new ExtensionDataSource(profile, this)));
+  data_sources_.push_back(
+      std::unique_ptr<DataSource>(new ExtensionDataSource(profile, this)));
 #if defined(OS_CHROMEOS)
-  data_sources_.push_back(scoped_ptr<DataSource>(
-      new ArcDataSource(profile, this)));
+  data_sources_.push_back(
+      std::unique_ptr<DataSource>(new ArcDataSource(profile, this)));
 #endif
 
   RefreshApps();
 }
 
 AppSearchProvider::~AppSearchProvider() {}
 
 void AppSearchProvider::Start(bool /*is_voice_query*/,
                               const base::string16& query) {
   query_ = query;
@@ skipping 27 matching lines @@
   ClearResults();
 
   if (show_recommendations) {
     // Build a map of app ids to their position in the app list.
     std::map<std::string, size_t> id_to_app_list_index;
     for (size_t i = 0; i < top_level_item_list_->item_count(); ++i) {
       id_to_app_list_index[top_level_item_list_->item_at(i)->id()] = i;
     }
 
     for (auto& app : apps_) {
-      scoped_ptr<AppResult> result = app->data_source()->CreateResult(
+      std::unique_ptr<AppResult> result = app->data_source()->CreateResult(
           app->id(), list_controller_, top_level_item_list_, true);
       result->set_title(app->indexed_name().text());
 
       // Use the app list order to tiebreak apps that have never been launched.
       if (app->last_launch_time().is_null()) {
         auto it = id_to_app_list_index.find(app->id());
         // If it's in a folder, it won't be in |id_to_app_list_index|. Rank
         // those as if they are at the end of the list.
         size_t app_list_index =
             it == id_to_app_list_index.end() ? apps_.size() : (*it).second;
         if (app_list_index > apps_.size())
           app_list_index = apps_.size();
 
         result->set_relevance(kUnlaunchedAppRelevanceStepSize *
                               (apps_.size() - app_list_index));
       } else {
         result->UpdateFromLastLaunched(clock_->Now(), app->last_launch_time());
       }
       Add(std::move(result));
     }
   } else {
     for (auto& app : apps_) {
-      scoped_ptr<AppResult> result = app->data_source()->CreateResult(
+      std::unique_ptr<AppResult> result = app->data_source()->CreateResult(
           app->id(), list_controller_, top_level_item_list_, false);
       TokenizedStringMatch match;
       if (!match.Calculate(query_terms, app->indexed_name()))
         continue;
 
       result->UpdateFromMatch(app->indexed_name(), match);
       Add(std::move(result));
     }
   }
 
   update_results_factory_.InvalidateWeakPtrs();
 }
 
 void AppSearchProvider::RefreshAppsAndUpdateResults(bool force_inline) {
   RefreshApps();
 
   if (force_inline) {
     UpdateResults();
   } else {
     if (!update_results_factory_.HasWeakPtrs()) {
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE, base::Bind(&AppSearchProvider::UpdateResults,
                                 update_results_factory_.GetWeakPtr()));
     }
   }
 }
 
 }  // namespace app_list