src/chrome/browser/ui/app_list/app_list_service_unittest.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 "base/command_line.h"
   6 #include "base/files/file_path.h"
   7 #include "base/memory/scoped_ptr.h"
   8 #include "base/prefs/pref_registry_simple.h"
   9 #include "base/prefs/pref_service.h"
  10 #include "base/prefs/pref_service_factory.h"
  11 #include "base/prefs/testing_pref_store.h"
  12 #include "chrome/browser/profiles/profile.h"
  13 #include "chrome/browser/profiles/profiles_state.h"
  14 #include "chrome/browser/ui/app_list/app_list_service.h"
  15 #include "chrome/browser/ui/app_list/app_list_service_impl.h"
  16 #include "chrome/browser/ui/app_list/test/fake_profile.h"
  17 #include "chrome/browser/ui/app_list/test/fake_profile_store.h"
  18 #include "chrome/common/chrome_constants.h"
  19 #include "chrome/common/chrome_switches.h"
  20 #include "chrome/common/pref_names.h"
  21 #include "testing/gtest/include/gtest/gtest.h"
  22
  23 class TestingAppListServiceImpl : public AppListServiceImpl {
  24  public:
  25   TestingAppListServiceImpl(const CommandLine& command_line,
  26                             PrefService* local_state,
  27                             scoped_ptr<ProfileStore> profile_store)
  28       : AppListServiceImpl(command_line, local_state, profile_store.Pass()),
  29         showing_for_profile_(NULL),
  30         destroy_app_list_call_count_(0) {}
  31
  32   Profile* showing_for_profile() const {
  33     return showing_for_profile_;
  34   }
  35
  36   int destroy_app_list_call_count() const {
  37     return destroy_app_list_call_count_;
  38   }
  39
  40   void PerformStartupChecks(Profile* profile) {
  41     AppListServiceImpl::PerformStartupChecks(profile);
  42   }
  43
  44   // AppListService overrides:
  45   virtual Profile* GetCurrentAppListProfile() OVERRIDE {
  46     // We don't return showing_for_profile_ here because that is only defined if
  47     // the app list is visible.
  48     return NULL;
  49   }
  50
  51   virtual void CreateForProfile(Profile* requested_profile) OVERRIDE {
  52   }
  53
  54   virtual void ShowForProfile(Profile* requested_profile) OVERRIDE {
  55     showing_for_profile_ = requested_profile;
  56     RecordAppListLaunch();
  57   }
  58
  59   virtual void DismissAppList() OVERRIDE {
  60     showing_for_profile_ = NULL;
  61   }
  62
  63   virtual bool IsAppListVisible() const OVERRIDE {
  64     return !!showing_for_profile_;
  65   }
  66
  67   virtual gfx::NativeWindow GetAppListWindow() OVERRIDE {
  68     return NULL;
  69   }
  70
  71   virtual AppListControllerDelegate* GetControllerDelegate() OVERRIDE {
  72     return NULL;
  73   }
  74
  75   // AppListServiceImpl overrides:
  76   virtual void DestroyAppList() OVERRIDE { ++destroy_app_list_call_count_; }
  77
  78  private:
  79   Profile* showing_for_profile_;
  80   int destroy_app_list_call_count_;
  81
  82   DISALLOW_COPY_AND_ASSIGN(TestingAppListServiceImpl);
  83 };
  84
  85 class AppListServiceUnitTest : public testing::Test {
  86  public:
  87   AppListServiceUnitTest() {}
  88
  89   virtual void SetUp() OVERRIDE {
  90     SetupWithCommandLine(CommandLine(CommandLine::NO_PROGRAM));
  91   }
  92
  93  protected:
  94   void SetupWithCommandLine(const CommandLine& command_line) {
  95     user_data_dir_ = base::FilePath(FILE_PATH_LITERAL("udd"));
  96     profile1_.reset(
  97         new FakeProfile("p1", user_data_dir_.AppendASCII("profile1")));
  98     profile2_.reset(
  99         new FakeProfile("p2", user_data_dir_.AppendASCII("profile2")));
 100     PrefRegistrySimple* pref_registry = new PrefRegistrySimple;
 101
 102     AppListService::RegisterPrefs(pref_registry);
 103     profiles::RegisterPrefs(pref_registry);
 104
 105     base::PrefServiceFactory factory;
 106     factory.set_user_prefs(make_scoped_refptr(new TestingPrefStore));
 107     local_state_ = factory.Create(pref_registry).Pass();
 108
 109     profile_store_ = new FakeProfileStore(user_data_dir_);
 110     service_.reset(new TestingAppListServiceImpl(
 111         command_line,
 112         local_state_.get(),
 113         scoped_ptr<ProfileStore>(profile_store_)));
 114   }
 115
 116   void EnableAppList() {
 117     service_->EnableAppList(profile1_.get(),
 118                             AppListService::ENABLE_VIA_COMMAND_LINE);
 119   }
 120
 121   base::FilePath user_data_dir_;
 122   scoped_ptr<PrefService> local_state_;
 123   FakeProfileStore* profile_store_;
 124   scoped_ptr<TestingAppListServiceImpl> service_;
 125   scoped_ptr<FakeProfile> profile1_;
 126   scoped_ptr<FakeProfile> profile2_;
 127
 128   DISALLOW_COPY_AND_ASSIGN(AppListServiceUnitTest);
 129 };
 130
 131 TEST_F(AppListServiceUnitTest, EnablingStateIsPersisted) {
 132   EXPECT_FALSE(local_state_->GetBoolean(prefs::kAppLauncherHasBeenEnabled));
 133   EnableAppList();
 134   EXPECT_TRUE(local_state_->GetBoolean(prefs::kAppLauncherHasBeenEnabled));
 135   EXPECT_EQ(profile1_->GetPath(), user_data_dir_.Append(
 136       local_state_->GetFilePath(prefs::kAppListProfile)));
 137 }
 138
 139 TEST_F(AppListServiceUnitTest, ShowingForProfileLoadsAProfile) {
 140   profile_store_->LoadProfile(profile1_.get());
 141   EnableAppList();
 142   service_->Show();
 143   EXPECT_EQ(profile1_.get(), service_->showing_for_profile());
 144   EXPECT_TRUE(service_->IsAppListVisible());
 145 }
 146
 147 TEST_F(AppListServiceUnitTest, RemovedProfileResetsToInitialProfile) {
 148   EnableAppList();
 149   profile_store_->RemoveProfile(profile1_.get());
 150   base::FilePath initial_profile_path =
 151       user_data_dir_.AppendASCII(chrome::kInitialProfile);
 152   EXPECT_EQ(initial_profile_path,
 153             service_->GetProfilePath(profile_store_->GetUserDataDir()));
 154 }
 155
 156 TEST_F(AppListServiceUnitTest,
 157        RemovedProfileResetsToLastUsedProfileIfExists) {
 158   local_state_->SetString(prefs::kProfileLastUsed, "last-used");
 159   EnableAppList();
 160   profile_store_->RemoveProfile(profile1_.get());
 161
 162   base::FilePath last_used_profile_path =
 163       user_data_dir_.AppendASCII("last-used");
 164   EXPECT_EQ(last_used_profile_path,
 165             service_->GetProfilePath(profile_store_->GetUserDataDir()));
 166
 167   // For this test, the AppListViewDelegate is not created because the
 168   // app list is never shown, so there is nothing to destroy.
 169   EXPECT_EQ(0, service_->destroy_app_list_call_count());
 170 }
 171
 172 TEST_F(AppListServiceUnitTest, SwitchingProfilesPersists) {
 173   profile_store_->LoadProfile(profile1_.get());
 174   profile_store_->LoadProfile(profile2_.get());
 175   EnableAppList();
 176   service_->SetProfilePath(profile2_->GetPath());
 177   service_->Show();
 178   EXPECT_EQ(profile2_.get(), service_->showing_for_profile());
 179   EXPECT_EQ(profile2_->GetPath(),
 180             service_->GetProfilePath(profile_store_->GetUserDataDir()));
 181   service_->SetProfilePath(profile1_->GetPath());
 182   EXPECT_EQ(profile1_->GetPath(),
 183             service_->GetProfilePath(profile_store_->GetUserDataDir()));
 184 }
 185
 186 TEST_F(AppListServiceUnitTest, EnableViaCommandLineFlag) {
 187   CommandLine command_line(CommandLine::NO_PROGRAM);
 188   command_line.AppendSwitch(switches::kEnableAppList);
 189   SetupWithCommandLine(command_line);
 190   service_->PerformStartupChecks(profile1_.get());
 191   EXPECT_TRUE(local_state_->GetBoolean(prefs::kAppLauncherHasBeenEnabled));
 192 }
 193
 194 TEST_F(AppListServiceUnitTest, DisableViaCommandLineFlag) {
 195   CommandLine command_line(CommandLine::NO_PROGRAM);
 196   command_line.AppendSwitch(switches::kResetAppListInstallState);
 197   SetupWithCommandLine(command_line);
 198   service_->PerformStartupChecks(profile1_.get());
 199   EXPECT_FALSE(local_state_->GetBoolean(prefs::kAppLauncherHasBeenEnabled));
 200 }
 201
 202 TEST_F(AppListServiceUnitTest, UMAPrefStates) {
 203   EXPECT_FALSE(local_state_->GetBoolean(prefs::kAppLauncherHasBeenEnabled));
 204   EXPECT_EQ(AppListService::ENABLE_NOT_RECORDED,
 205             local_state_->GetInteger(prefs::kAppListEnableMethod));
 206   EXPECT_EQ(0, local_state_->GetInt64(prefs::kAppListEnableTime));
 207
 208   service_->EnableAppList(profile1_.get(),
 209                           AppListService::ENABLE_FOR_APP_INSTALL);
 210
 211   // After enable, method and time should be recorded.
 212   EXPECT_TRUE(local_state_->GetBoolean(prefs::kAppLauncherHasBeenEnabled));
 213   EXPECT_EQ(AppListService::ENABLE_FOR_APP_INSTALL,
 214             local_state_->GetInteger(prefs::kAppListEnableMethod));
 215   EXPECT_NE(0, local_state_->GetInt64(prefs::kAppListEnableTime));
 216
 217   service_->ShowForProfile(profile1_.get());
 218
 219   // After a regular "show", time should be cleared, so UMA is not re-recorded.
 220   EXPECT_EQ(AppListService::ENABLE_FOR_APP_INSTALL,
 221             local_state_->GetInteger(prefs::kAppListEnableMethod));
 222   EXPECT_EQ(0, local_state_->GetInt64(prefs::kAppListEnableTime));
 223
 224   // A second enable should be a no-op.
 225   service_->EnableAppList(profile1_.get(),
 226                           AppListService::ENABLE_FOR_APP_INSTALL);
 227   EXPECT_EQ(AppListService::ENABLE_FOR_APP_INSTALL,
 228             local_state_->GetInteger(prefs::kAppListEnableMethod));
 229   EXPECT_EQ(0, local_state_->GetInt64(prefs::kAppListEnableTime));
 230
 231   // An auto-show here should keep the recorded enable method.
 232   service_->AutoShowForProfile(profile1_.get());
 233   EXPECT_EQ(AppListService::ENABLE_FOR_APP_INSTALL,
 234             local_state_->GetInteger(prefs::kAppListEnableMethod));
 235
 236   // Clear the enable state, so we can enable again.
 237   local_state_->SetBoolean(prefs::kAppLauncherHasBeenEnabled, false);
 238   service_->EnableAppList(profile1_.get(),
 239                           AppListService::ENABLE_FOR_APP_INSTALL);
 240
 241   EXPECT_EQ(AppListService::ENABLE_FOR_APP_INSTALL,
 242             local_state_->GetInteger(prefs::kAppListEnableMethod));
 243   EXPECT_NE(0, local_state_->GetInt64(prefs::kAppListEnableTime));
 244
 245   // An auto-show here should update the enable method to prevent recording it
 246   // as ENABLE_FOR_APP_INSTALL.
 247   service_->AutoShowForProfile(profile1_.get());
 248   EXPECT_EQ(AppListService::ENABLE_SHOWN_UNDISCOVERED,
 249             local_state_->GetInteger(prefs::kAppListEnableMethod));
 250 }