src/chrome/browser/ui/app_list/recommended_apps.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/ui/app_list/recommended_apps.h"
   6
   7 #include <algorithm>
   8 #include <vector>
   9
  10 #include "base/bind.h"
  11 #include "chrome/browser/extensions/extension_service.h"
  12 #include "chrome/browser/extensions/install_tracker.h"
  13 #include "chrome/browser/extensions/install_tracker_factory.h"
  14 #include "chrome/browser/profiles/profile.h"
  15 #include "chrome/browser/ui/app_list/recommended_apps_observer.h"
  16 #include "chrome/common/pref_names.h"
  17 #include "extensions/browser/extension_prefs.h"
  18 #include "extensions/browser/extension_system.h"
  19 #include "extensions/browser/extension_system_provider.h"
  20 #include "extensions/browser/extensions_browser_client.h"
  21 #include "extensions/browser/pref_names.h"
  22 #include "extensions/common/extension.h"
  23 #include "extensions/common/extension_set.h"
  24
  25 namespace app_list {
  26
  27 namespace {
  28
  29 struct AppSortInfo {
  30   AppSortInfo() : app(NULL) {}
  31   AppSortInfo(const extensions::Extension* app,
  32               const base::Time& last_launch_time)
  33       : app(app), last_launch_time(last_launch_time) {}
  34
  35   const extensions::Extension* app;
  36   base::Time last_launch_time;
  37 };
  38
  39 bool AppLaunchedMoreRecent(const AppSortInfo& app1, const AppSortInfo& app2) {
  40   return app1.last_launch_time > app2.last_launch_time;
  41 }
  42
  43 }  // namespace
  44
  45 RecommendedApps::RecommendedApps(Profile* profile) : profile_(profile) {
  46   extensions::InstallTrackerFactory::GetForProfile(profile_)->AddObserver(this);
  47
  48   ExtensionService* service =
  49       extensions::ExtensionSystem::Get(profile_)->extension_service();
  50   extensions::ExtensionPrefs* prefs = service->extension_prefs();
  51   pref_change_registrar_.Init(prefs->pref_service());
  52   pref_change_registrar_.Add(extensions::pref_names::kExtensions,
  53                              base::Bind(&RecommendedApps::Update,
  54                                         base::Unretained(this)));
  55
  56   Update();
  57 }
  58
  59 RecommendedApps::~RecommendedApps() {
  60   extensions::InstallTrackerFactory::GetForProfile(profile_)
  61       ->RemoveObserver(this);
  62 }
  63
  64 void RecommendedApps::AddObserver(RecommendedAppsObserver* observer) {
  65   observers_.AddObserver(observer);
  66 }
  67
  68 void RecommendedApps::RemoveObserver(RecommendedAppsObserver* observer) {
  69   observers_.RemoveObserver(observer);
  70 }
  71
  72 void RecommendedApps::Update() {
  73   ExtensionService* service =
  74       extensions::ExtensionSystem::Get(profile_)->extension_service();
  75   extensions::ExtensionPrefs* prefs = service->extension_prefs();
  76
  77   std::vector<AppSortInfo> sorted_apps;
  78   const extensions::ExtensionSet* extensions = service->extensions();
  79   for (extensions::ExtensionSet::const_iterator app = extensions->begin();
  80        app != extensions->end(); ++app) {
  81     if (!(*app)->ShouldDisplayInAppLauncher())
  82       continue;
  83
  84     sorted_apps.push_back(
  85         AppSortInfo(app->get(), prefs->GetLastLaunchTime((*app)->id())));
  86   }
  87
  88   std::sort(sorted_apps.begin(), sorted_apps.end(), &AppLaunchedMoreRecent);
  89
  90   const size_t kMaxRecommendedApps = 4;
  91   sorted_apps.resize(std::min(kMaxRecommendedApps, sorted_apps.size()));
  92
  93   Apps new_recommends;
  94   for (size_t i = 0; i < sorted_apps.size(); ++i)
  95     new_recommends.push_back(sorted_apps[i].app);
  96
  97   const bool changed = apps_.size() != new_recommends.size() ||
  98       !std::equal(apps_.begin(), apps_.end(), new_recommends.begin());
  99   if (changed) {
 100     apps_.swap(new_recommends);
 101     FOR_EACH_OBSERVER(
 102         RecommendedAppsObserver, observers_, OnRecommendedAppsChanged());
 103   }
 104 }
 105
 106 void RecommendedApps::OnBeginExtensionInstall(
 107     const ExtensionInstallParams& params) {}
 108
 109 void RecommendedApps::OnDownloadProgress(const std::string& extension_id,
 110                                 int percent_downloaded) {}
 111
 112 void RecommendedApps::OnInstallFailure(const std::string& extension_id) {}
 113
 114 void RecommendedApps::OnExtensionInstalled(
 115     const extensions::Extension* extension) {
 116   Update();
 117 }
 118
 119 void RecommendedApps::OnExtensionLoaded(
 120     const extensions::Extension* extension) {
 121   Update();
 122 }
 123
 124 void RecommendedApps::OnExtensionUnloaded(
 125     const extensions::Extension* extension) {
 126   Update();
 127 }
 128
 129 void RecommendedApps::OnExtensionUninstalled(
 130     const extensions::Extension* extension) {
 131   Update();
 132 }
 133
 134 void RecommendedApps::OnAppsReordered() {}
 135
 136 void RecommendedApps::OnAppInstalledToAppList(
 137     const std::string& extension_id) {}
 138
 139 void RecommendedApps::OnShutdown() {}
 140
 141 }  // namespace app_list