Add unit tests for AppListServiceImpl.

chrome/browser/ui/app_list/app_list_service_impl.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/app_list_service_impl.h"
 
+#include <string>
+
 #include "apps/pref_names.h"
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
+#include "base/strings/string16.h"
 #include "base/time/time.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profiles/profile_manager.h"
+#include "chrome/browser/ui/app_list/keep_alive_service.h"
+#include "chrome/browser/ui/app_list/keep_alive_service_impl.h"
+#include "chrome/browser/ui/app_list/profile_loader.h"
+#include "chrome/browser/ui/app_list/profile_store.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace {
 
 void SendAppListAppLaunch(int count) {
   UMA_HISTOGRAM_CUSTOM_COUNTS(
       "Apps.AppListDailyAppLaunches", count, 1, 1000, 50);
@@ skipping 35 matching lines @@
     void (*send_callback)(int count)) {
   PrefService* local_state = g_browser_process->local_state();
 
   int count = local_state->GetInteger(count_pref);
   local_state->SetInteger(count_pref, count + 1);
   if (SendDailyEventFrequency(last_ping_pref, count_pref, send_callback)) {
     local_state->SetInteger(count_pref, 1);
   }
 }
 
-bool HasAppListEnabledPreference() {
-  PrefService* local_state = g_browser_process->local_state();
-  return local_state->GetBoolean(apps::prefs::kAppLauncherHasBeenEnabled);
-}
+class ProfileStoreImpl : public ProfileStore {
+ public:
+  explicit ProfileStoreImpl(ProfileManager* profile_manager)
+      : profile_manager_(profile_manager),
+        weak_factory_(this) {
+  }
 
-void SetAppListEnabledPreference(bool enabled) {
-  PrefService* local_state = g_browser_process->local_state();
-  local_state->SetBoolean(apps::prefs::kAppLauncherHasBeenEnabled, enabled);
-}
+  virtual void AddProfileObserver(ProfileInfoCacheObserver* observer) OVERRIDE {
+    profile_manager_->GetProfileInfoCache().AddObserver(observer);
+  }
+
+  virtual void LoadProfileAsync(
+      const base::FilePath& path,
+      base::Callback<void(Profile*)> callback) OVERRIDE {
+    profile_manager_->CreateProfileAsync(
+        path,
+        base::Bind(&ProfileStoreImpl::OnProfileCreated,
+                   weak_factory_.GetWeakPtr(),
+                   callback),
+        base::string16(),
+        base::string16(),
+        std::string());
+  }
+
+  void OnProfileCreated(base::Callback<void(Profile*)> callback,
+                        Profile* profile,
+                        Profile::CreateStatus status) {
+    switch (status) {
+      case Profile::CREATE_STATUS_CREATED:
+        break;
+      case Profile::CREATE_STATUS_INITIALIZED:
+        callback.Run(profile);
+        break;
+      case Profile::CREATE_STATUS_LOCAL_FAIL:
+      case Profile::CREATE_STATUS_REMOTE_FAIL:
+      case Profile::CREATE_STATUS_CANCELED:

[benwells, 2013/09/26 06:55:29]

This previously decremented the pending profile load count (in the loader), but
now it doesn't. Is this a deliberate change?

[koz (OOO until 15th September), 2013/09/26 22:12:47]

Yes. All we need from the profile system is the ability to load profiles
asynchronously. We can keep track of whether or not there are pending loads
ourselves (which is what ProfileLoader does, currently).

+        break;
+      case Profile::MAX_CREATE_STATUS:
+        NOTREACHED();
+        break;
+    }
+  }
+
+  virtual Profile* GetProfileByPath(const base::FilePath& path) OVERRIDE {
+    return profile_manager_->GetProfileByPath(path);
+  }
+
+  virtual base::FilePath GetUserDataDir() OVERRIDE {
+    return profile_manager_->user_data_dir();
+  }
+
+  virtual bool IsProfileManaged(const base::FilePath& profile_path) {
+    ProfileInfoCache& profile_info =
+        g_browser_process->profile_manager()->GetProfileInfoCache();
+    size_t profile_index = profile_info.GetIndexOfProfileWithPath(profile_path);
+    return profile_info.ProfileIsManagedAtIndex(profile_index);
+  }
+
+ private:
+  ProfileManager* profile_manager_;
+  base::WeakPtrFactory<ProfileStoreImpl> weak_factory_;
+};
 
 }  // namespace
 
 // static
 void AppListServiceImpl::RecordAppListLaunch() {
   RecordDailyEventFrequency(prefs::kLastAppListLaunchPing,
                             prefs::kAppListLaunchCount,
                             &SendAppListLaunch);
 }
 
@@ skipping 12 matching lines @@
   SendDailyEventFrequency(prefs::kLastAppListLaunchPing,
                           prefs::kAppListLaunchCount,
                           &SendAppListLaunch);
   SendDailyEventFrequency(prefs::kLastAppListAppLaunchPing,
                           prefs::kAppListAppLaunchCount,
                           &SendAppListAppLaunch);
 }
 
 AppListServiceImpl::AppListServiceImpl()
     : profile_(NULL),
-      profile_load_sequence_id_(0),
-      pending_profile_loads_(0),
       weak_factory_(this),
-      profile_loader_(g_browser_process->profile_manager()) {
-  ProfileManager* profile_manager = g_browser_process->profile_manager();
-  profile_manager->GetProfileInfoCache().AddObserver(this);
+      local_state_(g_browser_process->local_state()),
+      profile_store_(new ProfileStoreImpl(
+          g_browser_process->profile_manager())),
+      profile_loader_(new ProfileLoader(
+          profile_store_.get(), make_scoped_ptr(new KeepAliveServiceImpl))) {
+  profile_store_->AddProfileObserver(this);
+}
+
+AppListServiceImpl::AppListServiceImpl(
+    PrefService* local_state,
+    scoped_ptr<ProfileStore> profile_store,
+    scoped_ptr<KeepAliveService> keep_alive_service)
+    : profile_(NULL),
+      weak_factory_(this),
+      local_state_(local_state),
+      profile_store_(profile_store.Pass()),
+      profile_loader_(new ProfileLoader(
+          profile_store_.get(), keep_alive_service.Pass())) {
+  profile_store_->AddProfileObserver(this);
 }
 
 AppListServiceImpl::~AppListServiceImpl() {}
 
 void AppListServiceImpl::SetAppListNextPaintCallback(
     const base::Closure& callback) {}
 
 void AppListServiceImpl::HandleFirstRun() {}
 
 void AppListServiceImpl::Init(Profile* initial_profile) {}
 
 base::FilePath AppListServiceImpl::GetProfilePath(
     const base::FilePath& user_data_dir) {
-  PrefService* local_state = g_browser_process->local_state();
-  DCHECK(local_state);
-
   std::string app_list_profile;
-  if (local_state->HasPrefPath(prefs::kAppListProfile))
-    app_list_profile = local_state->GetString(prefs::kAppListProfile);
+  if (local_state_->HasPrefPath(prefs::kAppListProfile))
+    app_list_profile = local_state_->GetString(prefs::kAppListProfile);
 
   // If the user has no profile preference for the app launcher, default to the
   // last browser profile used.
   if (app_list_profile.empty() &&
-      local_state->HasPrefPath(prefs::kProfileLastUsed)) {
-    app_list_profile = local_state->GetString(prefs::kProfileLastUsed);
+      local_state_->HasPrefPath(prefs::kProfileLastUsed)) {
+    app_list_profile = local_state_->GetString(prefs::kProfileLastUsed);
   }
 
   // If there is no last used profile recorded, use the initial profile.
   if (app_list_profile.empty())
     app_list_profile = chrome::kInitialProfile;
 
   return user_data_dir.AppendASCII(app_list_profile);
 }
 
 void AppListServiceImpl::SetProfilePath(const base::FilePath& profile_path) {
   // Ensure we don't set the pref to a managed user's profile path.
-  ProfileInfoCache& profile_info =
-      g_browser_process->profile_manager()->GetProfileInfoCache();
-  size_t profile_index = profile_info.GetIndexOfProfileWithPath(profile_path);
-  if (profile_info.ProfileIsManagedAtIndex(profile_index))
+  // TODO(calamity): Filter out managed profiles from the settings app so this
+  // can't get hit, so we can remove it.
+  if (profile_store_->IsProfileManaged(profile_path))
     return;
 
-  g_browser_process->local_state()->SetString(
+  local_state_->SetString(
       prefs::kAppListProfile,
       profile_path.BaseName().MaybeAsASCII());
 }
 
 void AppListServiceImpl::CreateShortcut() {}
 
 // We need to watch for profile removal to keep kAppListProfile updated.
 void AppListServiceImpl::OnProfileWillBeRemoved(
     const base::FilePath& profile_path) {
   // If the profile the app list uses just got deleted, reset it to the last
   // used profile.
-  PrefService* local_state = g_browser_process->local_state();
-  std::string app_list_last_profile = local_state->GetString(
+  std::string app_list_last_profile = local_state_->GetString(
       prefs::kAppListProfile);
   if (profile_path.BaseName().MaybeAsASCII() == app_list_last_profile) {
-    local_state->SetString(prefs::kAppListProfile,
-        local_state->GetString(prefs::kProfileLastUsed));
+    local_state_->SetString(prefs::kAppListProfile,
+        local_state_->GetString(prefs::kProfileLastUsed));
   }
 }
 
 void AppListServiceImpl::Show() {
-  profile_loader_.LoadProfileInvalidatingOtherLoads(
-      GetProfilePath(g_browser_process->profile_manager()->user_data_dir()),
+  profile_loader_->LoadProfileInvalidatingOtherLoads(
+      GetProfilePath(profile_store_->GetUserDataDir()),
       base::Bind(&AppListServiceImpl::ShowForProfile,
                  weak_factory_.GetWeakPtr()));
 }
 
 void AppListServiceImpl::EnableAppList(Profile* initial_profile) {
   SetProfilePath(initial_profile->GetPath());
-  if (HasAppListEnabledPreference())
+  if (local_state_->GetBoolean(apps::prefs::kAppLauncherHasBeenEnabled))
     return;
 
-  SetAppListEnabledPreference(true);
+  local_state_->SetBoolean(apps::prefs::kAppLauncherHasBeenEnabled, true);
   CreateShortcut();
 }
 
 Profile* AppListServiceImpl::GetCurrentAppListProfile() {
   return profile();
 }
 
 void AppListServiceImpl::SetProfile(Profile* new_profile) {
   profile_ = new_profile;
 }
 
 void AppListServiceImpl::InvalidatePendingProfileLoads() {
-  profile_loader_.InvalidatePendingProfileLoads();
+  profile_loader_->InvalidatePendingProfileLoads();
 }
 
 void AppListServiceImpl::HandleCommandLineFlags(Profile* initial_profile) {
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnableAppList))
     EnableAppList(initial_profile);
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kDisableAppList))
-    SetAppListEnabledPreference(false);
+    local_state_->SetBoolean(apps::prefs::kAppLauncherHasBeenEnabled, false);
 
   // Send app list usage stats after a delay.
   const int kSendUsageStatsDelay = 5;
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&AppListServiceImpl::SendAppListStats),
       base::TimeDelta::FromSeconds(kSendUsageStatsDelay));
 }