OLD | NEW |
(Empty) | |
| 1 // Copyright 2017 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/chromeos/lock_screen_apps/app_manager_impl.h" |
| 6 |
| 7 #include <memory> |
| 8 #include <string> |
| 9 #include <utility> |
| 10 #include <vector> |
| 11 |
| 12 #include "base/files/file_path.h" |
| 13 #include "base/memory/ptr_util.h" |
| 14 #include "base/test/scoped_command_line.h" |
| 15 #include "base/values.h" |
| 16 #include "chrome/browser/chromeos/arc/arc_session_manager.h" |
| 17 #include "chrome/browser/chromeos/login/users/scoped_test_user_manager.h" |
| 18 #include "chrome/browser/chromeos/note_taking_helper.h" |
| 19 #include "chrome/browser/chromeos/settings/cros_settings.h" |
| 20 #include "chrome/browser/chromeos/settings/device_settings_service.h" |
| 21 #include "chrome/browser/extensions/extension_service.h" |
| 22 #include "chrome/browser/extensions/test_extension_system.h" |
| 23 #include "chrome/common/chrome_constants.h" |
| 24 #include "chrome/common/pref_names.h" |
| 25 #include "chrome/test/base/testing_browser_process.h" |
| 26 #include "chrome/test/base/testing_profile.h" |
| 27 #include "chrome/test/base/testing_profile_manager.h" |
| 28 #include "components/arc/arc_service_manager.h" |
| 29 #include "components/arc/arc_session.h" |
| 30 #include "content/public/test/test_browser_thread_bundle.h" |
| 31 #include "extensions/browser/event_router.h" |
| 32 #include "extensions/browser/event_router_factory.h" |
| 33 #include "extensions/browser/extension_prefs.h" |
| 34 #include "extensions/browser/extension_registry.h" |
| 35 #include "extensions/common/api/app_runtime.h" |
| 36 #include "extensions/common/extension.h" |
| 37 #include "extensions/common/extension_builder.h" |
| 38 #include "extensions/common/value_builder.h" |
| 39 #include "testing/gtest/include/gtest/gtest.h" |
| 40 |
| 41 using extensions::DictionaryBuilder; |
| 42 using extensions::ListBuilder; |
| 43 |
| 44 namespace lock_screen_apps { |
| 45 namespace { |
| 46 |
| 47 std::unique_ptr<arc::ArcSession> ArcSessionFactory() { |
| 48 ADD_FAILURE() << "Attempt to create arc session."; |
| 49 return nullptr; |
| 50 } |
| 51 |
| 52 class TestEventRouter : public extensions::EventRouter { |
| 53 public: |
| 54 explicit TestEventRouter(content::BrowserContext* context) |
| 55 : extensions::EventRouter(context, |
| 56 extensions::ExtensionPrefs::Get(context)), |
| 57 context_(context) {} |
| 58 ~TestEventRouter() override = default; |
| 59 |
| 60 bool ExtensionHasEventListener(const std::string& extension_id, |
| 61 const std::string& event_name) const override { |
| 62 return event_name == extensions::api::app_runtime::OnLaunched::kEventName; |
| 63 } |
| 64 |
| 65 void BroadcastEvent(std::unique_ptr<extensions::Event> event) override {} |
| 66 |
| 67 void DispatchEventToExtension( |
| 68 const std::string& extension_id, |
| 69 std::unique_ptr<extensions::Event> event) override { |
| 70 if (event->event_name != |
| 71 extensions::api::app_runtime::OnLaunched::kEventName) { |
| 72 return; |
| 73 } |
| 74 ASSERT_TRUE(event->event_args); |
| 75 const base::Value* arg_value = nullptr; |
| 76 ASSERT_TRUE(event->event_args->Get(0, &arg_value)); |
| 77 ASSERT_TRUE(arg_value); |
| 78 if (event->restrict_to_browser_context) |
| 79 EXPECT_EQ(context_, event->restrict_to_browser_context); |
| 80 |
| 81 std::unique_ptr<extensions::api::app_runtime::LaunchData> launch_data = |
| 82 extensions::api::app_runtime::LaunchData::FromValue(*arg_value); |
| 83 ASSERT_TRUE(launch_data); |
| 84 ASSERT_TRUE(launch_data->action_data); |
| 85 EXPECT_EQ(extensions::api::app_runtime::ACTION_TYPE_NEW_NOTE, |
| 86 launch_data->action_data->action_type); |
| 87 |
| 88 launched_apps_.push_back(extension_id); |
| 89 } |
| 90 |
| 91 const std::vector<std::string>& launched_apps() const { |
| 92 return launched_apps_; |
| 93 } |
| 94 |
| 95 void ClearLaunchedApps() { launched_apps_.clear(); } |
| 96 |
| 97 private: |
| 98 std::vector<std::string> launched_apps_; |
| 99 content::BrowserContext* context_; |
| 100 |
| 101 DISALLOW_COPY_AND_ASSIGN(TestEventRouter); |
| 102 }; |
| 103 |
| 104 std::unique_ptr<KeyedService> TestEventRouterFactoryFunction( |
| 105 content::BrowserContext* profile) { |
| 106 return base::MakeUnique<TestEventRouter>(profile); |
| 107 } |
| 108 |
| 109 class TestAppManagerObserver : public AppManager::Observer { |
| 110 public: |
| 111 TestAppManagerObserver() = default; |
| 112 ~TestAppManagerObserver() override = default; |
| 113 |
| 114 void OnNoteTakingAvailabilityChanged() override { |
| 115 ++availability_changed_count_; |
| 116 } |
| 117 |
| 118 int availability_changed_count() const { return availability_changed_count_; } |
| 119 |
| 120 void ResetAvailabilityChangedCount() { availability_changed_count_ = 0; } |
| 121 |
| 122 private: |
| 123 int availability_changed_count_ = 0; |
| 124 |
| 125 DISALLOW_COPY_AND_ASSIGN(TestAppManagerObserver); |
| 126 }; |
| 127 |
| 128 class LockScreenAppManagerImplTest : public testing::Test { |
| 129 public: |
| 130 LockScreenAppManagerImplTest() |
| 131 : profile_manager_(TestingBrowserProcess::GetGlobal()) {} |
| 132 |
| 133 ~LockScreenAppManagerImplTest() override = default; |
| 134 |
| 135 void SetUp() override { |
| 136 // Initialize command line so chromeos::NoteTakingHelper thinks note taking |
| 137 // on lock screen is enabled. |
| 138 command_line_ = base::MakeUnique<base::test::ScopedCommandLine>(); |
| 139 command_line_->GetProcessCommandLine()->InitFromArgv( |
| 140 {"", "--enable-lock-screen-apps", "--force-enable-stylus-tools"}); |
| 141 |
| 142 ASSERT_TRUE(profile_manager_.SetUp()); |
| 143 |
| 144 TestingProfile::Builder builder; |
| 145 builder.SetPath( |
| 146 profile_manager_.profiles_dir().AppendASCII(chrome::kInitialProfile)); |
| 147 signin_profile_ = builder.BuildIncognito( |
| 148 profile_manager_.CreateTestingProfile(chrome::kInitialProfile)); |
| 149 |
| 150 InitExtensionSystem(profile()); |
| 151 InitExtensionSystem(signin_profile()); |
| 152 |
| 153 // Initialize arc session manager, since NoteTakingHelper expects it to be |
| 154 // set. |
| 155 arc_session_manager_ = base::MakeUnique<arc::ArcSessionManager>( |
| 156 base::MakeUnique<arc::ArcSessionRunner>( |
| 157 base::Bind(&ArcSessionFactory))); |
| 158 |
| 159 chromeos::NoteTakingHelper::Initialize(); |
| 160 |
| 161 ResetAppManager(); |
| 162 } |
| 163 |
| 164 void TearDown() override { |
| 165 extensions::ExtensionSystem::Get(profile())->Shutdown(); |
| 166 extensions::ExtensionSystem::Get(signin_profile())->Shutdown(); |
| 167 chromeos::NoteTakingHelper::Shutdown(); |
| 168 } |
| 169 |
| 170 void InitExtensionSystem(Profile* profile) { |
| 171 extensions::TestExtensionSystem* extension_system = |
| 172 static_cast<extensions::TestExtensionSystem*>( |
| 173 extensions::ExtensionSystem::Get(profile)); |
| 174 extension_system->CreateExtensionService( |
| 175 base::CommandLine::ForCurrentProcess(), |
| 176 base::FilePath() /* install_directory */, |
| 177 false /* autoupdate_enabled */); |
| 178 } |
| 179 |
| 180 scoped_refptr<const extensions::Extension> CreateTestApp( |
| 181 const std::string& id, |
| 182 const std::string& version, |
| 183 bool supports_lock_screen) { |
| 184 DictionaryBuilder manifest_builder; |
| 185 manifest_builder.Set("name", "Note taking app") |
| 186 .Set("version", version) |
| 187 .Set("manifest_version", 2) |
| 188 .Set("app", |
| 189 DictionaryBuilder() |
| 190 .Set("background", |
| 191 DictionaryBuilder() |
| 192 .Set("scripts", |
| 193 ListBuilder().Append("background.js").Build()) |
| 194 .Build()) |
| 195 .Build()) |
| 196 .Set("action_handlers", |
| 197 ListBuilder() |
| 198 .Append(DictionaryBuilder() |
| 199 .Set("action", "new_note") |
| 200 .SetBoolean("enabled_on_lock_screen", |
| 201 supports_lock_screen) |
| 202 .Build()) |
| 203 .Build()); |
| 204 return extensions::ExtensionBuilder() |
| 205 .SetManifest(manifest_builder.Build()) |
| 206 .SetID(id) |
| 207 .Build(); |
| 208 } |
| 209 |
| 210 TestingProfile* CreateSecondaryProfile() { |
| 211 TestingProfile* profile = |
| 212 profile_manager_.CreateTestingProfile("secondary_profile"); |
| 213 InitExtensionSystem(profile); |
| 214 return profile; |
| 215 } |
| 216 |
| 217 TestingProfile* profile() { return &profile_; } |
| 218 TestingProfile* signin_profile() { return signin_profile_; } |
| 219 |
| 220 AppManager* app_manager() { return app_manager_.get(); } |
| 221 |
| 222 void ResetAppManager() { app_manager_ = base::MakeUnique<AppManagerImpl>(); } |
| 223 |
| 224 private: |
| 225 std::unique_ptr<base::test::ScopedCommandLine> command_line_; |
| 226 content::TestBrowserThreadBundle threads_; |
| 227 |
| 228 chromeos::ScopedTestDeviceSettingsService test_device_settings_service_; |
| 229 chromeos::ScopedTestCrosSettings test_cros_settings_; |
| 230 chromeos::ScopedTestUserManager user_manager_; |
| 231 |
| 232 TestingProfileManager profile_manager_; |
| 233 TestingProfile profile_; |
| 234 TestingProfile* signin_profile_ = nullptr; |
| 235 |
| 236 std::unique_ptr<arc::ArcServiceManager> arc_service_manager_; |
| 237 std::unique_ptr<arc::ArcSessionManager> arc_session_manager_; |
| 238 |
| 239 std::unique_ptr<AppManager> app_manager_; |
| 240 |
| 241 DISALLOW_COPY_AND_ASSIGN(LockScreenAppManagerImplTest); |
| 242 }; |
| 243 |
| 244 } // namespace |
| 245 |
| 246 TEST_F(LockScreenAppManagerImplTest, StartAddsAppToTarget) { |
| 247 app_manager()->Initialize(profile(), signin_profile()); |
| 248 scoped_refptr<const extensions::Extension> note_taking_app = CreateTestApp( |
| 249 chromeos::NoteTakingHelper::kProdKeepExtensionId, "1.0", true); |
| 250 extensions::ExtensionSystem::Get(profile()) |
| 251 ->extension_service() |
| 252 ->AddExtension(note_taking_app.get()); |
| 253 |
| 254 chromeos::NoteTakingHelper::Get()->SetPreferredApp( |
| 255 profile(), chromeos::NoteTakingHelper::kProdKeepExtensionId); |
| 256 profile()->GetPrefs()->SetBoolean(prefs::kNoteTakingAppEnabledOnLockScreen, |
| 257 true); |
| 258 |
| 259 TestAppManagerObserver observer; |
| 260 app_manager()->Start(&observer); |
| 261 |
| 262 EXPECT_EQ(0, observer.availability_changed_count()); |
| 263 EXPECT_TRUE(app_manager()->IsNoteTakingAppAvailable()); |
| 264 EXPECT_EQ(chromeos::NoteTakingHelper::kProdKeepExtensionId, |
| 265 app_manager()->GetNoteTakingAppId()); |
| 266 |
| 267 const extensions::Extension* lock_app = |
| 268 extensions::ExtensionRegistry::Get(signin_profile()) |
| 269 ->GetExtensionById(chromeos::NoteTakingHelper::kProdKeepExtensionId, |
| 270 extensions::ExtensionRegistry::ENABLED); |
| 271 ASSERT_TRUE(lock_app); |
| 272 EXPECT_TRUE(lock_app->runs_on_lock_screen()); |
| 273 |
| 274 app_manager()->Stop(); |
| 275 EXPECT_EQ(0, observer.availability_changed_count()); |
| 276 EXPECT_FALSE(app_manager()->IsNoteTakingAppAvailable()); |
| 277 EXPECT_TRUE(app_manager()->GetNoteTakingAppId().empty()); |
| 278 |
| 279 lock_app = |
| 280 extensions::ExtensionRegistry::Get(signin_profile()) |
| 281 ->GetExtensionById(chromeos::NoteTakingHelper::kProdKeepExtensionId, |
| 282 extensions::ExtensionRegistry::EVERYTHING); |
| 283 EXPECT_FALSE(lock_app); |
| 284 } |
| 285 |
| 286 TEST_F(LockScreenAppManagerImplTest, StartWhenLockScreenNotesNotEnabled) { |
| 287 app_manager()->Initialize(profile(), signin_profile()); |
| 288 scoped_refptr<const extensions::Extension> note_taking_app = CreateTestApp( |
| 289 chromeos::NoteTakingHelper::kProdKeepExtensionId, "1.0", true); |
| 290 extensions::ExtensionSystem::Get(profile()) |
| 291 ->extension_service() |
| 292 ->AddExtension(note_taking_app.get()); |
| 293 |
| 294 chromeos::NoteTakingHelper::Get()->SetPreferredApp( |
| 295 profile(), chromeos::NoteTakingHelper::kProdKeepExtensionId); |
| 296 |
| 297 TestAppManagerObserver observer; |
| 298 app_manager()->Start(&observer); |
| 299 |
| 300 EXPECT_EQ(0, observer.availability_changed_count()); |
| 301 EXPECT_FALSE(app_manager()->IsNoteTakingAppAvailable()); |
| 302 EXPECT_TRUE(app_manager()->GetNoteTakingAppId().empty()); |
| 303 |
| 304 const extensions::Extension* lock_app = |
| 305 extensions::ExtensionRegistry::Get(signin_profile()) |
| 306 ->GetExtensionById(chromeos::NoteTakingHelper::kProdKeepExtensionId, |
| 307 extensions::ExtensionRegistry::ENABLED); |
| 308 EXPECT_FALSE(lock_app); |
| 309 |
| 310 app_manager()->Stop(); |
| 311 EXPECT_EQ(0, observer.availability_changed_count()); |
| 312 EXPECT_FALSE(app_manager()->IsNoteTakingAppAvailable()); |
| 313 EXPECT_TRUE(app_manager()->GetNoteTakingAppId().empty()); |
| 314 |
| 315 lock_app = |
| 316 extensions::ExtensionRegistry::Get(signin_profile()) |
| 317 ->GetExtensionById(chromeos::NoteTakingHelper::kProdKeepExtensionId, |
| 318 extensions::ExtensionRegistry::EVERYTHING); |
| 319 EXPECT_FALSE(lock_app); |
| 320 } |
| 321 |
| 322 TEST_F(LockScreenAppManagerImplTest, LockScreenNoteTakingDisabledWhileStarted) { |
| 323 app_manager()->Initialize(profile(), signin_profile()); |
| 324 scoped_refptr<const extensions::Extension> note_taking_app = CreateTestApp( |
| 325 chromeos::NoteTakingHelper::kProdKeepExtensionId, "1.0", true); |
| 326 extensions::ExtensionSystem::Get(profile()) |
| 327 ->extension_service() |
| 328 ->AddExtension(note_taking_app.get()); |
| 329 |
| 330 chromeos::NoteTakingHelper::Get()->SetPreferredApp( |
| 331 profile(), chromeos::NoteTakingHelper::kProdKeepExtensionId); |
| 332 profile()->GetPrefs()->SetBoolean(prefs::kNoteTakingAppEnabledOnLockScreen, |
| 333 true); |
| 334 |
| 335 TestAppManagerObserver observer; |
| 336 app_manager()->Start(&observer); |
| 337 |
| 338 EXPECT_EQ(0, observer.availability_changed_count()); |
| 339 EXPECT_TRUE(app_manager()->IsNoteTakingAppAvailable()); |
| 340 EXPECT_EQ(chromeos::NoteTakingHelper::kProdKeepExtensionId, |
| 341 app_manager()->GetNoteTakingAppId()); |
| 342 |
| 343 const extensions::Extension* lock_app = |
| 344 extensions::ExtensionRegistry::Get(signin_profile()) |
| 345 ->GetExtensionById(chromeos::NoteTakingHelper::kProdKeepExtensionId, |
| 346 extensions::ExtensionRegistry::ENABLED); |
| 347 ASSERT_TRUE(lock_app); |
| 348 EXPECT_TRUE(lock_app->runs_on_lock_screen()); |
| 349 |
| 350 profile()->GetPrefs()->SetBoolean(prefs::kNoteTakingAppEnabledOnLockScreen, |
| 351 false); |
| 352 |
| 353 EXPECT_EQ(1, observer.availability_changed_count()); |
| 354 observer.ResetAvailabilityChangedCount(); |
| 355 EXPECT_FALSE(app_manager()->IsNoteTakingAppAvailable()); |
| 356 EXPECT_TRUE(app_manager()->GetNoteTakingAppId().empty()); |
| 357 lock_app = |
| 358 extensions::ExtensionRegistry::Get(signin_profile()) |
| 359 ->GetExtensionById(chromeos::NoteTakingHelper::kProdKeepExtensionId, |
| 360 extensions::ExtensionRegistry::EVERYTHING); |
| 361 EXPECT_FALSE(lock_app); |
| 362 |
| 363 app_manager()->Stop(); |
| 364 EXPECT_EQ(0, observer.availability_changed_count()); |
| 365 EXPECT_FALSE(app_manager()->IsNoteTakingAppAvailable()); |
| 366 EXPECT_TRUE(app_manager()->GetNoteTakingAppId().empty()); |
| 367 } |
| 368 |
| 369 TEST_F(LockScreenAppManagerImplTest, LockScreenNoteTakingEnabledWhileStarted) { |
| 370 app_manager()->Initialize(profile(), signin_profile()); |
| 371 scoped_refptr<const extensions::Extension> note_taking_app = CreateTestApp( |
| 372 chromeos::NoteTakingHelper::kProdKeepExtensionId, "1.0", true); |
| 373 extensions::ExtensionSystem::Get(profile()) |
| 374 ->extension_service() |
| 375 ->AddExtension(note_taking_app.get()); |
| 376 |
| 377 chromeos::NoteTakingHelper::Get()->SetPreferredApp( |
| 378 profile(), chromeos::NoteTakingHelper::kProdKeepExtensionId); |
| 379 profile()->GetPrefs()->SetBoolean(prefs::kNoteTakingAppEnabledOnLockScreen, |
| 380 false); |
| 381 |
| 382 TestAppManagerObserver observer; |
| 383 app_manager()->Start(&observer); |
| 384 |
| 385 EXPECT_EQ(0, observer.availability_changed_count()); |
| 386 EXPECT_FALSE(app_manager()->IsNoteTakingAppAvailable()); |
| 387 EXPECT_TRUE(app_manager()->GetNoteTakingAppId().empty()); |
| 388 const extensions::Extension* lock_app = |
| 389 extensions::ExtensionRegistry::Get(signin_profile()) |
| 390 ->GetExtensionById(chromeos::NoteTakingHelper::kProdKeepExtensionId, |
| 391 extensions::ExtensionRegistry::EVERYTHING); |
| 392 EXPECT_FALSE(lock_app); |
| 393 |
| 394 profile()->GetPrefs()->SetBoolean(prefs::kNoteTakingAppEnabledOnLockScreen, |
| 395 true); |
| 396 |
| 397 EXPECT_EQ(1, observer.availability_changed_count()); |
| 398 observer.ResetAvailabilityChangedCount(); |
| 399 EXPECT_TRUE(app_manager()->IsNoteTakingAppAvailable()); |
| 400 EXPECT_EQ(chromeos::NoteTakingHelper::kProdKeepExtensionId, |
| 401 app_manager()->GetNoteTakingAppId()); |
| 402 |
| 403 lock_app = |
| 404 extensions::ExtensionRegistry::Get(signin_profile()) |
| 405 ->GetExtensionById(chromeos::NoteTakingHelper::kProdKeepExtensionId, |
| 406 extensions::ExtensionRegistry::ENABLED); |
| 407 ASSERT_TRUE(lock_app); |
| 408 EXPECT_TRUE(lock_app->runs_on_lock_screen()); |
| 409 |
| 410 app_manager()->Stop(); |
| 411 EXPECT_EQ(0, observer.availability_changed_count()); |
| 412 EXPECT_FALSE(app_manager()->IsNoteTakingAppAvailable()); |
| 413 EXPECT_TRUE(app_manager()->GetNoteTakingAppId().empty()); |
| 414 } |
| 415 |
| 416 TEST_F(LockScreenAppManagerImplTest, LockScreenNoteTakingChangedWhileStarted) { |
| 417 app_manager()->Initialize(profile(), signin_profile()); |
| 418 scoped_refptr<const extensions::Extension> prod_note_taking_app = |
| 419 CreateTestApp(chromeos::NoteTakingHelper::kProdKeepExtensionId, "1.0", |
| 420 true); |
| 421 extensions::ExtensionSystem::Get(profile()) |
| 422 ->extension_service() |
| 423 ->AddExtension(prod_note_taking_app.get()); |
| 424 |
| 425 scoped_refptr<const extensions::Extension> dev_note_taking_app = |
| 426 CreateTestApp(chromeos::NoteTakingHelper::kDevKeepExtensionId, "1.0", |
| 427 true); |
| 428 extensions::ExtensionSystem::Get(profile()) |
| 429 ->extension_service() |
| 430 ->AddExtension(dev_note_taking_app.get()); |
| 431 |
| 432 chromeos::NoteTakingHelper::Get()->SetPreferredApp( |
| 433 profile(), chromeos::NoteTakingHelper::kProdKeepExtensionId); |
| 434 profile()->GetPrefs()->SetBoolean(prefs::kNoteTakingAppEnabledOnLockScreen, |
| 435 true); |
| 436 |
| 437 TestAppManagerObserver observer; |
| 438 app_manager()->Start(&observer); |
| 439 |
| 440 EXPECT_EQ(0, observer.availability_changed_count()); |
| 441 EXPECT_TRUE(app_manager()->IsNoteTakingAppAvailable()); |
| 442 EXPECT_EQ(chromeos::NoteTakingHelper::kProdKeepExtensionId, |
| 443 app_manager()->GetNoteTakingAppId()); |
| 444 |
| 445 const extensions::Extension* lock_app = |
| 446 extensions::ExtensionRegistry::Get(signin_profile()) |
| 447 ->GetExtensionById(chromeos::NoteTakingHelper::kProdKeepExtensionId, |
| 448 extensions::ExtensionRegistry::ENABLED); |
| 449 ASSERT_TRUE(lock_app); |
| 450 EXPECT_TRUE(lock_app->runs_on_lock_screen()); |
| 451 |
| 452 chromeos::NoteTakingHelper::Get()->SetPreferredApp( |
| 453 profile(), chromeos::NoteTakingHelper::kDevKeepExtensionId); |
| 454 |
| 455 EXPECT_EQ(1, observer.availability_changed_count()); |
| 456 observer.ResetAvailabilityChangedCount(); |
| 457 |
| 458 EXPECT_TRUE(app_manager()->IsNoteTakingAppAvailable()); |
| 459 EXPECT_EQ(chromeos::NoteTakingHelper::kDevKeepExtensionId, |
| 460 app_manager()->GetNoteTakingAppId()); |
| 461 |
| 462 // Verify prod app was unloaded from signin profile. |
| 463 lock_app = |
| 464 extensions::ExtensionRegistry::Get(signin_profile()) |
| 465 ->GetExtensionById(chromeos::NoteTakingHelper::kProdKeepExtensionId, |
| 466 extensions::ExtensionRegistry::EVERYTHING); |
| 467 EXPECT_FALSE(lock_app); |
| 468 |
| 469 lock_app = |
| 470 extensions::ExtensionRegistry::Get(signin_profile()) |
| 471 ->GetExtensionById(chromeos::NoteTakingHelper::kDevKeepExtensionId, |
| 472 extensions::ExtensionRegistry::ENABLED); |
| 473 |
| 474 ASSERT_TRUE(lock_app); |
| 475 EXPECT_TRUE(lock_app->runs_on_lock_screen()); |
| 476 |
| 477 app_manager()->Stop(); |
| 478 EXPECT_EQ(0, observer.availability_changed_count()); |
| 479 EXPECT_FALSE(app_manager()->IsNoteTakingAppAvailable()); |
| 480 EXPECT_TRUE(app_manager()->GetNoteTakingAppId().empty()); |
| 481 } |
| 482 |
| 483 TEST_F(LockScreenAppManagerImplTest, LockScreenNoteTakingReloadedWhileStarted) { |
| 484 app_manager()->Initialize(profile(), signin_profile()); |
| 485 scoped_refptr<const extensions::Extension> prod_note_taking_app = |
| 486 CreateTestApp(chromeos::NoteTakingHelper::kProdKeepExtensionId, "1.0", |
| 487 true); |
| 488 extensions::ExtensionSystem::Get(profile()) |
| 489 ->extension_service() |
| 490 ->AddExtension(prod_note_taking_app.get()); |
| 491 |
| 492 chromeos::NoteTakingHelper::Get()->SetPreferredApp( |
| 493 profile(), chromeos::NoteTakingHelper::kProdKeepExtensionId); |
| 494 profile()->GetPrefs()->SetBoolean(prefs::kNoteTakingAppEnabledOnLockScreen, |
| 495 true); |
| 496 |
| 497 TestAppManagerObserver observer; |
| 498 app_manager()->Start(&observer); |
| 499 |
| 500 EXPECT_EQ(0, observer.availability_changed_count()); |
| 501 EXPECT_TRUE(app_manager()->IsNoteTakingAppAvailable()); |
| 502 EXPECT_EQ(chromeos::NoteTakingHelper::kProdKeepExtensionId, |
| 503 app_manager()->GetNoteTakingAppId()); |
| 504 |
| 505 const extensions::Extension* lock_app = |
| 506 extensions::ExtensionRegistry::Get(signin_profile()) |
| 507 ->GetExtensionById(chromeos::NoteTakingHelper::kProdKeepExtensionId, |
| 508 extensions::ExtensionRegistry::ENABLED); |
| 509 ASSERT_TRUE(lock_app); |
| 510 EXPECT_TRUE(lock_app->runs_on_lock_screen()); |
| 511 EXPECT_EQ("1.0", lock_app->VersionString()); |
| 512 |
| 513 extensions::ExtensionSystem::Get(profile()) |
| 514 ->extension_service() |
| 515 ->UnloadExtension(chromeos::NoteTakingHelper::kProdKeepExtensionId, |
| 516 extensions::UnloadedExtensionReason::UPDATE); |
| 517 |
| 518 EXPECT_EQ(1, observer.availability_changed_count()); |
| 519 observer.ResetAvailabilityChangedCount(); |
| 520 |
| 521 EXPECT_FALSE(app_manager()->IsNoteTakingAppAvailable()); |
| 522 EXPECT_TRUE(app_manager()->GetNoteTakingAppId().empty()); |
| 523 |
| 524 // Verify prod app was unloaded from signin profile. |
| 525 lock_app = |
| 526 extensions::ExtensionRegistry::Get(signin_profile()) |
| 527 ->GetExtensionById(chromeos::NoteTakingHelper::kProdKeepExtensionId, |
| 528 extensions::ExtensionRegistry::EVERYTHING); |
| 529 EXPECT_FALSE(lock_app); |
| 530 |
| 531 // Add the app again. |
| 532 prod_note_taking_app = CreateTestApp( |
| 533 chromeos::NoteTakingHelper::kProdKeepExtensionId, "1.1", true); |
| 534 extensions::ExtensionSystem::Get(profile()) |
| 535 ->extension_service() |
| 536 ->AddExtension(prod_note_taking_app.get()); |
| 537 |
| 538 EXPECT_EQ(1, observer.availability_changed_count()); |
| 539 observer.ResetAvailabilityChangedCount(); |
| 540 EXPECT_TRUE(app_manager()->IsNoteTakingAppAvailable()); |
| 541 EXPECT_EQ(chromeos::NoteTakingHelper::kProdKeepExtensionId, |
| 542 app_manager()->GetNoteTakingAppId()); |
| 543 |
| 544 lock_app = |
| 545 extensions::ExtensionRegistry::Get(signin_profile()) |
| 546 ->GetExtensionById(chromeos::NoteTakingHelper::kProdKeepExtensionId, |
| 547 extensions::ExtensionRegistry::ENABLED); |
| 548 |
| 549 ASSERT_TRUE(lock_app); |
| 550 EXPECT_TRUE(lock_app->runs_on_lock_screen()); |
| 551 EXPECT_EQ("1.1", lock_app->VersionString()); |
| 552 |
| 553 app_manager()->Stop(); |
| 554 EXPECT_EQ(0, observer.availability_changed_count()); |
| 555 EXPECT_FALSE(app_manager()->IsNoteTakingAppAvailable()); |
| 556 EXPECT_TRUE(app_manager()->GetNoteTakingAppId().empty()); |
| 557 } |
| 558 |
| 559 TEST_F(LockScreenAppManagerImplTest, ReloadOldLockScreenApps) { |
| 560 app_manager()->Initialize(profile(), signin_profile()); |
| 561 scoped_refptr<const extensions::Extension> prod_note_taking_app = |
| 562 CreateTestApp(chromeos::NoteTakingHelper::kProdKeepExtensionId, "1.1", |
| 563 true); |
| 564 extensions::ExtensionSystem::Get(profile()) |
| 565 ->extension_service() |
| 566 ->AddExtension(prod_note_taking_app.get()); |
| 567 |
| 568 chromeos::NoteTakingHelper::Get()->SetPreferredApp( |
| 569 profile(), chromeos::NoteTakingHelper::kProdKeepExtensionId); |
| 570 profile()->GetPrefs()->SetBoolean(prefs::kNoteTakingAppEnabledOnLockScreen, |
| 571 true); |
| 572 |
| 573 TestAppManagerObserver observer; |
| 574 app_manager()->Start(&observer); |
| 575 EXPECT_TRUE(app_manager()->IsNoteTakingAppAvailable()); |
| 576 EXPECT_EQ(chromeos::NoteTakingHelper::kProdKeepExtensionId, |
| 577 app_manager()->GetNoteTakingAppId()); |
| 578 |
| 579 const extensions::Extension* lock_app = |
| 580 extensions::ExtensionRegistry::Get(signin_profile()) |
| 581 ->GetExtensionById(chromeos::NoteTakingHelper::kProdKeepExtensionId, |
| 582 extensions::ExtensionRegistry::ENABLED); |
| 583 ASSERT_TRUE(lock_app); |
| 584 EXPECT_TRUE(lock_app->runs_on_lock_screen()); |
| 585 EXPECT_EQ("1.1", lock_app->VersionString()); |
| 586 |
| 587 ResetAppManager(); |
| 588 TestingProfile* secondary_profile = CreateSecondaryProfile(); |
| 589 app_manager()->Initialize(secondary_profile, signin_profile()); |
| 590 |
| 591 scoped_refptr<const extensions::Extension> secondary_note_taking_app = |
| 592 CreateTestApp(chromeos::NoteTakingHelper::kProdKeepExtensionId, "1.0", |
| 593 true); |
| 594 extensions::ExtensionSystem::Get(secondary_profile) |
| 595 ->extension_service() |
| 596 ->AddExtension(secondary_note_taking_app.get()); |
| 597 |
| 598 chromeos::NoteTakingHelper::Get()->SetPreferredApp( |
| 599 secondary_profile, chromeos::NoteTakingHelper::kProdKeepExtensionId); |
| 600 secondary_profile->GetPrefs()->SetBoolean( |
| 601 prefs::kNoteTakingAppEnabledOnLockScreen, true); |
| 602 |
| 603 app_manager()->Start(&observer); |
| 604 EXPECT_TRUE(app_manager()->IsNoteTakingAppAvailable()); |
| 605 EXPECT_EQ(chromeos::NoteTakingHelper::kProdKeepExtensionId, |
| 606 app_manager()->GetNoteTakingAppId()); |
| 607 lock_app = |
| 608 extensions::ExtensionRegistry::Get(signin_profile()) |
| 609 ->GetExtensionById(chromeos::NoteTakingHelper::kProdKeepExtensionId, |
| 610 extensions::ExtensionRegistry::ENABLED); |
| 611 ASSERT_TRUE(lock_app); |
| 612 EXPECT_TRUE(lock_app->runs_on_lock_screen()); |
| 613 EXPECT_EQ("1.0", lock_app->VersionString()); |
| 614 |
| 615 app_manager()->Stop(); |
| 616 } |
| 617 |
| 618 TEST_F(LockScreenAppManagerImplTest, |
| 619 DontOverrideDisabledNonLockScreenSigninProfileApps) { |
| 620 app_manager()->Initialize(profile(), signin_profile()); |
| 621 |
| 622 scoped_refptr<const extensions::Extension> prod_note_taking_app = |
| 623 CreateTestApp(chromeos::NoteTakingHelper::kProdKeepExtensionId, "1.1", |
| 624 true); |
| 625 extensions::ExtensionSystem::Get(profile()) |
| 626 ->extension_service() |
| 627 ->AddExtension(prod_note_taking_app.get()); |
| 628 |
| 629 scoped_refptr<const extensions::Extension> signin_profile_note_taking_app = |
| 630 CreateTestApp(chromeos::NoteTakingHelper::kProdKeepExtensionId, "1.0", |
| 631 true); |
| 632 extensions::ExtensionSystem::Get(signin_profile()) |
| 633 ->extension_service() |
| 634 ->AddExtension(signin_profile_note_taking_app.get()); |
| 635 |
| 636 chromeos::NoteTakingHelper::Get()->SetPreferredApp( |
| 637 profile(), chromeos::NoteTakingHelper::kProdKeepExtensionId); |
| 638 profile()->GetPrefs()->SetBoolean(prefs::kNoteTakingAppEnabledOnLockScreen, |
| 639 true); |
| 640 |
| 641 TestAppManagerObserver observer; |
| 642 app_manager()->Start(&observer); |
| 643 |
| 644 EXPECT_FALSE(app_manager()->IsNoteTakingAppAvailable()); |
| 645 EXPECT_TRUE(app_manager()->GetNoteTakingAppId().empty()); |
| 646 |
| 647 const extensions::Extension* lock_app = |
| 648 extensions::ExtensionRegistry::Get(signin_profile()) |
| 649 ->GetExtensionById(chromeos::NoteTakingHelper::kProdKeepExtensionId, |
| 650 extensions::ExtensionRegistry::ENABLED); |
| 651 ASSERT_TRUE(lock_app); |
| 652 EXPECT_FALSE(lock_app->runs_on_lock_screen()); |
| 653 EXPECT_EQ("1.0", lock_app->VersionString()); |
| 654 |
| 655 app_manager()->Stop(); |
| 656 } |
| 657 |
| 658 TEST_F(LockScreenAppManagerImplTest, DontOverrideDisabledSigninProfileApps) { |
| 659 app_manager()->Initialize(profile(), signin_profile()); |
| 660 |
| 661 scoped_refptr<const extensions::Extension> prod_note_taking_app = |
| 662 CreateTestApp(chromeos::NoteTakingHelper::kProdKeepExtensionId, "1.1", |
| 663 true); |
| 664 extensions::ExtensionSystem::Get(profile()) |
| 665 ->extension_service() |
| 666 ->AddExtension(prod_note_taking_app.get()); |
| 667 |
| 668 scoped_refptr<const extensions::Extension> signin_profile_note_taking_app = |
| 669 CreateTestApp(chromeos::NoteTakingHelper::kProdKeepExtensionId, "1.0", |
| 670 true); |
| 671 extensions::ExtensionSystem::Get(signin_profile()) |
| 672 ->extension_service() |
| 673 ->AddExtension(signin_profile_note_taking_app.get()); |
| 674 extensions::ExtensionSystem::Get(signin_profile()) |
| 675 ->extension_service() |
| 676 ->DisableExtension(signin_profile_note_taking_app->id(), |
| 677 extensions::Extension::DISABLE_USER_ACTION); |
| 678 |
| 679 chromeos::NoteTakingHelper::Get()->SetPreferredApp( |
| 680 profile(), chromeos::NoteTakingHelper::kProdKeepExtensionId); |
| 681 profile()->GetPrefs()->SetBoolean(prefs::kNoteTakingAppEnabledOnLockScreen, |
| 682 true); |
| 683 |
| 684 TestAppManagerObserver observer; |
| 685 app_manager()->Start(&observer); |
| 686 |
| 687 EXPECT_FALSE(app_manager()->IsNoteTakingAppAvailable()); |
| 688 EXPECT_TRUE(app_manager()->GetNoteTakingAppId().empty()); |
| 689 |
| 690 const extensions::Extension* lock_app = |
| 691 extensions::ExtensionRegistry::Get(signin_profile()) |
| 692 ->GetExtensionById(chromeos::NoteTakingHelper::kProdKeepExtensionId, |
| 693 extensions::ExtensionRegistry::DISABLED); |
| 694 ASSERT_TRUE(lock_app); |
| 695 EXPECT_FALSE(lock_app->runs_on_lock_screen()); |
| 696 EXPECT_EQ("1.0", lock_app->VersionString()); |
| 697 |
| 698 app_manager()->Stop(); |
| 699 } |
| 700 |
| 701 TEST_F(LockScreenAppManagerImplTest, ShutdownWhenStarted) { |
| 702 app_manager()->Initialize(profile(), signin_profile()); |
| 703 scoped_refptr<const extensions::Extension> prod_note_taking_app = |
| 704 CreateTestApp(chromeos::NoteTakingHelper::kProdKeepExtensionId, "1.1", |
| 705 true); |
| 706 extensions::ExtensionSystem::Get(profile()) |
| 707 ->extension_service() |
| 708 ->AddExtension(prod_note_taking_app.get()); |
| 709 chromeos::NoteTakingHelper::Get()->SetPreferredApp( |
| 710 profile(), chromeos::NoteTakingHelper::kProdKeepExtensionId); |
| 711 profile()->GetPrefs()->SetBoolean(prefs::kNoteTakingAppEnabledOnLockScreen, |
| 712 true); |
| 713 TestAppManagerObserver observer; |
| 714 app_manager()->Start(&observer); |
| 715 |
| 716 const extensions::Extension* lock_app = |
| 717 extensions::ExtensionRegistry::Get(signin_profile()) |
| 718 ->GetExtensionById(chromeos::NoteTakingHelper::kProdKeepExtensionId, |
| 719 extensions::ExtensionRegistry::ENABLED); |
| 720 EXPECT_TRUE(lock_app); |
| 721 } |
| 722 |
| 723 TEST_F(LockScreenAppManagerImplTest, LaunchAppWhenEnabled) { |
| 724 TestEventRouter* event_router = static_cast<TestEventRouter*>( |
| 725 extensions::EventRouterFactory::GetInstance()->SetTestingFactoryAndUse( |
| 726 signin_profile()->GetOriginalProfile(), |
| 727 &TestEventRouterFactoryFunction)); |
| 728 ASSERT_TRUE(event_router); |
| 729 |
| 730 app_manager()->Initialize(profile(), signin_profile()); |
| 731 scoped_refptr<const extensions::Extension> note_taking_app = CreateTestApp( |
| 732 chromeos::NoteTakingHelper::kProdKeepExtensionId, "1.0", true); |
| 733 extensions::ExtensionSystem::Get(profile()) |
| 734 ->extension_service() |
| 735 ->AddExtension(note_taking_app.get()); |
| 736 |
| 737 chromeos::NoteTakingHelper::Get()->SetPreferredApp( |
| 738 profile(), chromeos::NoteTakingHelper::kProdKeepExtensionId); |
| 739 profile()->GetPrefs()->SetBoolean(prefs::kNoteTakingAppEnabledOnLockScreen, |
| 740 true); |
| 741 |
| 742 TestAppManagerObserver observer; |
| 743 app_manager()->Start(&observer); |
| 744 |
| 745 ASSERT_EQ(chromeos::NoteTakingHelper::kProdKeepExtensionId, |
| 746 app_manager()->GetNoteTakingAppId()); |
| 747 |
| 748 EXPECT_TRUE(app_manager()->LaunchNoteTaking()); |
| 749 |
| 750 ASSERT_EQ(1u, event_router->launched_apps().size()); |
| 751 EXPECT_EQ(chromeos::NoteTakingHelper::kProdKeepExtensionId, |
| 752 event_router->launched_apps()[0]); |
| 753 event_router->ClearLaunchedApps(); |
| 754 |
| 755 app_manager()->Stop(); |
| 756 |
| 757 EXPECT_FALSE(app_manager()->LaunchNoteTaking()); |
| 758 EXPECT_TRUE(event_router->launched_apps().empty()); |
| 759 } |
| 760 |
| 761 TEST_F(LockScreenAppManagerImplTest, LaunchAppWhenNoLockScreenApp) { |
| 762 TestEventRouter* event_router = static_cast<TestEventRouter*>( |
| 763 extensions::EventRouterFactory::GetInstance()->SetTestingFactoryAndUse( |
| 764 signin_profile()->GetOriginalProfile(), |
| 765 &TestEventRouterFactoryFunction)); |
| 766 ASSERT_TRUE(event_router); |
| 767 |
| 768 app_manager()->Initialize(profile(), signin_profile()); |
| 769 scoped_refptr<const extensions::Extension> note_taking_app = CreateTestApp( |
| 770 chromeos::NoteTakingHelper::kProdKeepExtensionId, "1.0", true); |
| 771 extensions::ExtensionSystem::Get(profile()) |
| 772 ->extension_service() |
| 773 ->AddExtension(note_taking_app.get()); |
| 774 |
| 775 chromeos::NoteTakingHelper::Get()->SetPreferredApp( |
| 776 profile(), chromeos::NoteTakingHelper::kProdKeepExtensionId); |
| 777 |
| 778 TestAppManagerObserver observer; |
| 779 app_manager()->Start(&observer); |
| 780 |
| 781 EXPECT_FALSE(app_manager()->LaunchNoteTaking()); |
| 782 EXPECT_TRUE(event_router->launched_apps().empty()); |
| 783 |
| 784 app_manager()->Stop(); |
| 785 EXPECT_FALSE(app_manager()->LaunchNoteTaking()); |
| 786 EXPECT_TRUE(event_router->launched_apps().empty()); |
| 787 } |
| 788 |
| 789 } // namespace lock_screen_apps |
OLD | NEW |