[Merge to M53][Chrome OS] Change layout of the launcher.

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 33 matching lines @@
 const double kUnlaunchedAppRelevanceStepSize = 0.0001;
 }
 
 namespace app_list {
 
 class AppSearchProvider::App {
  public:
   App(AppSearchProvider::DataSource* data_source,
       const std::string& id,
       const std::string& name,
-      const base::Time& last_launch_time)
+      const base::Time& last_launch_time,
+      const base::Time& install_time)
       : data_source_(data_source),
         id_(id),
         indexed_name_(base::UTF8ToUTF16(name)),
-        last_launch_time_(last_launch_time) {}
+        last_launch_time_(last_launch_time),
+        install_time_(install_time) {}
   ~App() {}
 
   AppSearchProvider::DataSource* data_source() { return data_source_; }
   const std::string& id() const { return id_; }
   const TokenizedString& indexed_name() const { return indexed_name_; }
   const base::Time& last_launch_time() const { return last_launch_time_; }
+  const base::Time& install_time() const { return install_time_; }
 
  private:
   AppSearchProvider::DataSource* data_source_;
   const std::string id_;
   const TokenizedString indexed_name_;
   const base::Time last_launch_time_;
+  const base::Time install_time_;
 
   DISALLOW_COPY_AND_ASSIGN(App);
 };
 
 class AppSearchProvider::DataSource {
  public:
   DataSource(Profile* profile, AppSearchProvider* owner)
       : profile_(profile),
         owner_(owner) {}
   virtual ~DataSource() {}
@@ skipping 72 matching lines @@
         continue;
       }
 
       if (profile()->IsOffTheRecord() &&
           !extensions::util::CanLoadInIncognito(extension, profile())) {
         continue;
       }
 
       std::unique_ptr<AppSearchProvider::App> app(new AppSearchProvider::App(
           this, extension->id(), extension->short_name(),
-          prefs->GetLastLaunchTime(extension->id())));
+          prefs->GetLastLaunchTime(extension->id()),
+          prefs->GetInstallTime(extension->id())));
       apps->push_back(std::move(app));
     }
   }
 
   ScopedObserver<extensions::ExtensionRegistry,
                  extensions::ExtensionRegistryObserver>
       extension_registry_observer_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionDataSource);
 };
@@ skipping 22 matching lines @@
         continue;
 
       std::unique_ptr<ArcAppListPrefs::AppInfo> app_info =
           arc_prefs->GetApp(app_id);
       if (!app_info) {
         NOTREACHED();
         continue;
       }
 
       std::unique_ptr<AppSearchProvider::App> app(new AppSearchProvider::App(
-          this, app_id, app_info->name, app_info->last_launch_time));
+          this, app_id, app_info->name, app_info->last_launch_time,
+          app_info->install_time));
       apps->push_back(std::move(app));
     }
   }
 
   std::unique_ptr<AppResult> CreateResult(
       const std::string& app_id,
       AppListControllerDelegate* list_controller,
       AppListItemList* top_level_item_list,
       bool is_recommended) override {
     return std::unique_ptr<AppResult>(
@@ skipping 82 matching lines @@
     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_) {
       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()) {
+      // The apps that have been installed or launched recently should be
+      // more relevant than other apps.
+      const base::Time time = app->last_launch_time().is_null()
+                                  ? app->install_time()
+                                  : app->last_launch_time();
+      if (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());
+        result->UpdateFromLastLaunchedOrInstalledTime(clock_->Now(), time);
       }
       Add(std::move(result));
     }
   } else {
     for (auto& app : apps_) {
       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;
@@ skipping 14 matching lines @@
   } else {
     if (!update_results_factory_.HasWeakPtrs()) {
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE, base::Bind(&AppSearchProvider::UpdateResults,
                                 update_results_factory_.GetWeakPtr()));
     }
   }
 }
 
 }  // namespace app_list