Introduce lock screen app manager

chrome/browser/chromeos/lock_screen_apps/app_manager_impl_unittest.cc

+// Copyright 2017 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/chromeos/lock_screen_apps/app_manager_impl.h"
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "base/files/file_path.h"
+#include "base/memory/ptr_util.h"
+#include "base/test/scoped_command_line.h"
+#include "base/values.h"
+#include "chrome/browser/chromeos/arc/arc_session_manager.h"
+#include "chrome/browser/chromeos/login/users/scoped_test_user_manager.h"
+#include "chrome/browser/chromeos/note_taking_helper.h"
+#include "chrome/browser/chromeos/settings/cros_settings.h"
+#include "chrome/browser/chromeos/settings/device_settings_service.h"
+#include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/extensions/test_extension_system.h"
+#include "chrome/common/chrome_constants.h"
+#include "chrome/common/pref_names.h"
+#include "chrome/test/base/testing_browser_process.h"
+#include "chrome/test/base/testing_profile.h"
+#include "chrome/test/base/testing_profile_manager.h"
+#include "components/arc/arc_service_manager.h"
+#include "components/arc/arc_session.h"
+#include "content/public/test/test_browser_thread_bundle.h"
+#include "extensions/browser/event_router.h"
+#include "extensions/browser/event_router_factory.h"
+#include "extensions/browser/extension_prefs.h"
+#include "extensions/browser/extension_registry.h"
+#include "extensions/common/api/app_runtime.h"
+#include "extensions/common/extension.h"
+#include "extensions/common/extension_builder.h"
+#include "extensions/common/value_builder.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using extensions::DictionaryBuilder;
+using extensions::ListBuilder;
+
+namespace lock_screen_apps {
+namespace {
+
+std::unique_ptr<arc::ArcSession> ArcSessionFactory() {
+  ADD_FAILURE() << "Attempt to create arc session.";
+  return nullptr;
+}
+
+class TestEventRouter : public extensions::EventRouter {
+ public:
+  explicit TestEventRouter(content::BrowserContext* context)
+      : extensions::EventRouter(context,
+                                extensions::ExtensionPrefs::Get(context)),
+        context_(context) {}
+  ~TestEventRouter() override = default;
+
+  bool ExtensionHasEventListener(const std::string& extension_id,
+                                 const std::string& event_name) const override {
+    return event_name == extensions::api::app_runtime::OnLaunched::kEventName;
+  }
+
+  void BroadcastEvent(std::unique_ptr<extensions::Event> event) override {}
+
+  void DispatchEventToExtension(
+      const std::string& extension_id,
+      std::unique_ptr<extensions::Event> event) override {
+    if (event->event_name !=
+        extensions::api::app_runtime::OnLaunched::kEventName) {
+      return;
+    }
+    ASSERT_TRUE(event->event_args);
+    const base::Value* arg_value = nullptr;
+    ASSERT_TRUE(event->event_args->Get(0, &arg_value));
+    ASSERT_TRUE(arg_value);
+    if (event->restrict_to_browser_context)
+      EXPECT_EQ(context_, event->restrict_to_browser_context);
+
+    std::unique_ptr<extensions::api::app_runtime::LaunchData> launch_data =
+        extensions::api::app_runtime::LaunchData::FromValue(*arg_value);
+    ASSERT_TRUE(launch_data);
+    ASSERT_TRUE(launch_data->action_data);
+    EXPECT_EQ(extensions::api::app_runtime::ACTION_TYPE_NEW_NOTE,
+              launch_data->action_data->action_type);
+
+    launched_apps_.push_back(extension_id);
+  }
+
+  const std::vector<std::string>& launched_apps() const {
+    return launched_apps_;
+  }
+
+  void ClearLaunchedApps() { launched_apps_.clear(); }
+
+ private:
+  std::vector<std::string> launched_apps_;
+  content::BrowserContext* context_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestEventRouter);
+};
+
+std::unique_ptr<KeyedService> TestEventRouterFactoryFunction(
+    content::BrowserContext* profile) {
+  return base::MakeUnique<TestEventRouter>(profile);
+}
+
+class TestAppManagerObserver : public AppManager::Observer {
+ public:
+  TestAppManagerObserver() = default;
+  ~TestAppManagerObserver() override = default;
+
+  void OnNoteTakingAvailabilityChanged() override {
+    ++availability_changed_count_;
+  }
+
+  int availability_changed_count() const { return availability_changed_count_; }
+
+  void ResetAvailabilityChangedCount() { availability_changed_count_ = 0; }
+
+ private:
+  int availability_changed_count_ = 0;
+
+  DISALLOW_COPY_AND_ASSIGN(TestAppManagerObserver);
+};
+
+class LockScreenAppManagerImplTest : public testing::Test {
+ public:
+  LockScreenAppManagerImplTest()
+      : profile_manager_(TestingBrowserProcess::GetGlobal()) {}
+
+  ~LockScreenAppManagerImplTest() override = default;
+
+  void SetUp() override {
+    // Initialize command line so chromeos::NoteTakingHelper thinks note taking
+    // on lock screen is enabled.
+    command_line_ = base::MakeUnique<base::test::ScopedCommandLine>();
+    command_line_->GetProcessCommandLine()->InitFromArgv(
+        {"", "--enable-lock-screen-apps", "--force-enable-stylus-tools"});
+
+    ASSERT_TRUE(profile_manager_.SetUp());
+
+    TestingProfile::Builder builder;
+    builder.SetPath(
+        profile_manager_.profiles_dir().AppendASCII(chrome::kInitialProfile));
+    signin_profile_ = builder.BuildIncognito(
+        profile_manager_.CreateTestingProfile(chrome::kInitialProfile));
+
+    InitExtensionSystem(profile());
+    InitExtensionSystem(signin_profile());
+
+    // Initialize arc session manager, since NoteTakingHelper expects it to be
+    // set.
+    arc_session_manager_ = base::MakeUnique<arc::ArcSessionManager>(
+        base::MakeUnique<arc::ArcSessionRunner>(
+            base::Bind(&ArcSessionFactory)));
+
+    chromeos::NoteTakingHelper::Initialize();
+
+    ResetAppManager();
+  }
+
+  void TearDown() override {
+    extensions::ExtensionSystem::Get(profile())->Shutdown();
+    extensions::ExtensionSystem::Get(signin_profile())->Shutdown();
+    chromeos::NoteTakingHelper::Shutdown();
+  }
+
+  void InitExtensionSystem(Profile* profile) {
+    extensions::TestExtensionSystem* extension_system =
+        static_cast<extensions::TestExtensionSystem*>(
+            extensions::ExtensionSystem::Get(profile));
+    extension_system->CreateExtensionService(
+        base::CommandLine::ForCurrentProcess(),
+        base::FilePath() /* install_directory */,
+        false /* autoupdate_enabled */);
+  }
+
+  scoped_refptr<const extensions::Extension> CreateTestApp(
+      const std::string& id,
+      const std::string& version,
+      bool supports_lock_screen) {
+    DictionaryBuilder manifest_builder;
+    manifest_builder.Set("name", "Note taking app")
+        .Set("version", version)
+        .Set("manifest_version", 2)
+        .Set("app",
+             DictionaryBuilder()
+                 .Set("background",
+                      DictionaryBuilder()
+                          .Set("scripts",
+                               ListBuilder().Append("background.js").Build())
+                          .Build())
+                 .Build())
+        .Set("action_handlers",
+             ListBuilder()
+                 .Append(DictionaryBuilder()
+                             .Set("action", "new_note")
+                             .SetBoolean("enabled_on_lock_screen",
+                                         supports_lock_screen)
+                             .Build())
+                 .Build());
+    return extensions::ExtensionBuilder()
+        .SetManifest(manifest_builder.Build())
+        .SetID(id)
+        .Build();
+  }
+
+  TestingProfile* CreateSecondaryProfile() {
+    TestingProfile* profile =
+        profile_manager_.CreateTestingProfile("secondary_profile");
+    InitExtensionSystem(profile);
+    return profile;
+  }
+
+  TestingProfile* profile() { return &profile_; }
+  TestingProfile* signin_profile() { return signin_profile_; }
+
+  AppManager* app_manager() { return app_manager_.get(); }
+
+  void ResetAppManager() { app_manager_ = base::MakeUnique<AppManagerImpl>(); }
+
+ private:
+  std::unique_ptr<base::test::ScopedCommandLine> command_line_;
+  content::TestBrowserThreadBundle threads_;
+
+  chromeos::ScopedTestDeviceSettingsService test_device_settings_service_;
+  chromeos::ScopedTestCrosSettings test_cros_settings_;
+  chromeos::ScopedTestUserManager user_manager_;
+
+  TestingProfileManager profile_manager_;
+  TestingProfile profile_;
+  TestingProfile* signin_profile_ = nullptr;
+
+  std::unique_ptr<arc::ArcServiceManager> arc_service_manager_;
+  std::unique_ptr<arc::ArcSessionManager> arc_session_manager_;
+
+  std::unique_ptr<AppManager> app_manager_;
+
+  DISALLOW_COPY_AND_ASSIGN(LockScreenAppManagerImplTest);
+};
+
+}  // namespace
+
+TEST_F(LockScreenAppManagerImplTest, StartAddsAppToTarget) {
+  app_manager()->Initialize(profile(), signin_profile());
+  scoped_refptr<const extensions::Extension> note_taking_app = CreateTestApp(
+      chromeos::NoteTakingHelper::kProdKeepExtensionId, "1.0", true);
+  extensions::ExtensionSystem::Get(profile())
+      ->extension_service()
+      ->AddExtension(note_taking_app.get());
+
+  chromeos::NoteTakingHelper::Get()->SetPreferredApp(
+      profile(), chromeos::NoteTakingHelper::kProdKeepExtensionId);
+  profile()->GetPrefs()->SetBoolean(prefs::kNoteTakingAppEnabledOnLockScreen,
+                                    true);

[xiyuan, 2017/05/26 22:44:52]

nit: The above lines are quite similar in the test cases before this one. Create
a helper to reduce dup code?

[tbarzic, 2017/05/27 00:48:35]

Done.

+
+  TestAppManagerObserver observer;
+  app_manager()->Start(&observer);
+
+  EXPECT_EQ(0, observer.availability_changed_count());
+  EXPECT_TRUE(app_manager()->IsNoteTakingAppAvailable());
+  EXPECT_EQ(chromeos::NoteTakingHelper::kProdKeepExtensionId,
+            app_manager()->GetNoteTakingAppId());
+
+  const extensions::Extension* lock_app =
+      extensions::ExtensionRegistry::Get(signin_profile())
+          ->GetExtensionById(chromeos::NoteTakingHelper::kProdKeepExtensionId,
+                             extensions::ExtensionRegistry::ENABLED);
+  ASSERT_TRUE(lock_app);
+  EXPECT_TRUE(lock_app->runs_on_lock_screen());
+
+  app_manager()->Stop();
+  EXPECT_EQ(0, observer.availability_changed_count());
+  EXPECT_FALSE(app_manager()->IsNoteTakingAppAvailable());
+  EXPECT_TRUE(app_manager()->GetNoteTakingAppId().empty());
+
+  lock_app =
+      extensions::ExtensionRegistry::Get(signin_profile())
+          ->GetExtensionById(chromeos::NoteTakingHelper::kProdKeepExtensionId,
+                             extensions::ExtensionRegistry::EVERYTHING);
+  EXPECT_FALSE(lock_app);
+}
+
+TEST_F(LockScreenAppManagerImplTest, StartWhenLockScreenNotesNotEnabled) {
+  app_manager()->Initialize(profile(), signin_profile());
+  scoped_refptr<const extensions::Extension> note_taking_app = CreateTestApp(
+      chromeos::NoteTakingHelper::kProdKeepExtensionId, "1.0", true);
+  extensions::ExtensionSystem::Get(profile())
+      ->extension_service()
+      ->AddExtension(note_taking_app.get());
+
+  chromeos::NoteTakingHelper::Get()->SetPreferredApp(
+      profile(), chromeos::NoteTakingHelper::kProdKeepExtensionId);
+
+  TestAppManagerObserver observer;
+  app_manager()->Start(&observer);
+
+  EXPECT_EQ(0, observer.availability_changed_count());
+  EXPECT_FALSE(app_manager()->IsNoteTakingAppAvailable());
+  EXPECT_TRUE(app_manager()->GetNoteTakingAppId().empty());
+
+  const extensions::Extension* lock_app =
+      extensions::ExtensionRegistry::Get(signin_profile())
+          ->GetExtensionById(chromeos::NoteTakingHelper::kProdKeepExtensionId,
+                             extensions::ExtensionRegistry::ENABLED);
+  EXPECT_FALSE(lock_app);
+
+  app_manager()->Stop();
+  EXPECT_EQ(0, observer.availability_changed_count());
+  EXPECT_FALSE(app_manager()->IsNoteTakingAppAvailable());
+  EXPECT_TRUE(app_manager()->GetNoteTakingAppId().empty());
+
+  lock_app =
+      extensions::ExtensionRegistry::Get(signin_profile())
+          ->GetExtensionById(chromeos::NoteTakingHelper::kProdKeepExtensionId,
+                             extensions::ExtensionRegistry::EVERYTHING);
+  EXPECT_FALSE(lock_app);
+}
+
+TEST_F(LockScreenAppManagerImplTest, LockScreenNoteTakingDisabledWhileStarted) {
+  app_manager()->Initialize(profile(), signin_profile());
+  scoped_refptr<const extensions::Extension> note_taking_app = CreateTestApp(
+      chromeos::NoteTakingHelper::kProdKeepExtensionId, "1.0", true);
+  extensions::ExtensionSystem::Get(profile())
+      ->extension_service()
+      ->AddExtension(note_taking_app.get());
+
+  chromeos::NoteTakingHelper::Get()->SetPreferredApp(
+      profile(), chromeos::NoteTakingHelper::kProdKeepExtensionId);
+  profile()->GetPrefs()->SetBoolean(prefs::kNoteTakingAppEnabledOnLockScreen,
+                                    true);
+
+  TestAppManagerObserver observer;
+  app_manager()->Start(&observer);
+
+  EXPECT_EQ(0, observer.availability_changed_count());
+  EXPECT_TRUE(app_manager()->IsNoteTakingAppAvailable());
+  EXPECT_EQ(chromeos::NoteTakingHelper::kProdKeepExtensionId,
+            app_manager()->GetNoteTakingAppId());
+
+  const extensions::Extension* lock_app =
+      extensions::ExtensionRegistry::Get(signin_profile())
+          ->GetExtensionById(chromeos::NoteTakingHelper::kProdKeepExtensionId,
+                             extensions::ExtensionRegistry::ENABLED);
+  ASSERT_TRUE(lock_app);
+  EXPECT_TRUE(lock_app->runs_on_lock_screen());
+
+  profile()->GetPrefs()->SetBoolean(prefs::kNoteTakingAppEnabledOnLockScreen,
+                                    false);
+
+  EXPECT_EQ(1, observer.availability_changed_count());
+  observer.ResetAvailabilityChangedCount();
+  EXPECT_FALSE(app_manager()->IsNoteTakingAppAvailable());
+  EXPECT_TRUE(app_manager()->GetNoteTakingAppId().empty());
+  lock_app =
+      extensions::ExtensionRegistry::Get(signin_profile())
+          ->GetExtensionById(chromeos::NoteTakingHelper::kProdKeepExtensionId,
+                             extensions::ExtensionRegistry::EVERYTHING);
+  EXPECT_FALSE(lock_app);
+
+  app_manager()->Stop();
+  EXPECT_EQ(0, observer.availability_changed_count());
+  EXPECT_FALSE(app_manager()->IsNoteTakingAppAvailable());
+  EXPECT_TRUE(app_manager()->GetNoteTakingAppId().empty());
+}
+
+TEST_F(LockScreenAppManagerImplTest, LockScreenNoteTakingEnabledWhileStarted) {
+  app_manager()->Initialize(profile(), signin_profile());
+  scoped_refptr<const extensions::Extension> note_taking_app = CreateTestApp(
+      chromeos::NoteTakingHelper::kProdKeepExtensionId, "1.0", true);
+  extensions::ExtensionSystem::Get(profile())
+      ->extension_service()
+      ->AddExtension(note_taking_app.get());
+
+  chromeos::NoteTakingHelper::Get()->SetPreferredApp(
+      profile(), chromeos::NoteTakingHelper::kProdKeepExtensionId);
+  profile()->GetPrefs()->SetBoolean(prefs::kNoteTakingAppEnabledOnLockScreen,
+                                    false);
+
+  TestAppManagerObserver observer;
+  app_manager()->Start(&observer);
+
+  EXPECT_EQ(0, observer.availability_changed_count());
+  EXPECT_FALSE(app_manager()->IsNoteTakingAppAvailable());
+  EXPECT_TRUE(app_manager()->GetNoteTakingAppId().empty());
+  const extensions::Extension* lock_app =
+      extensions::ExtensionRegistry::Get(signin_profile())
+          ->GetExtensionById(chromeos::NoteTakingHelper::kProdKeepExtensionId,
+                             extensions::ExtensionRegistry::EVERYTHING);
+  EXPECT_FALSE(lock_app);
+
+  profile()->GetPrefs()->SetBoolean(prefs::kNoteTakingAppEnabledOnLockScreen,
+                                    true);
+
+  EXPECT_EQ(1, observer.availability_changed_count());
+  observer.ResetAvailabilityChangedCount();
+  EXPECT_TRUE(app_manager()->IsNoteTakingAppAvailable());
+  EXPECT_EQ(chromeos::NoteTakingHelper::kProdKeepExtensionId,
+            app_manager()->GetNoteTakingAppId());
+
+  lock_app =
+      extensions::ExtensionRegistry::Get(signin_profile())
+          ->GetExtensionById(chromeos::NoteTakingHelper::kProdKeepExtensionId,
+                             extensions::ExtensionRegistry::ENABLED);
+  ASSERT_TRUE(lock_app);
+  EXPECT_TRUE(lock_app->runs_on_lock_screen());
+
+  app_manager()->Stop();
+  EXPECT_EQ(0, observer.availability_changed_count());
+  EXPECT_FALSE(app_manager()->IsNoteTakingAppAvailable());
+  EXPECT_TRUE(app_manager()->GetNoteTakingAppId().empty());
+}
+
+TEST_F(LockScreenAppManagerImplTest, LockScreenNoteTakingChangedWhileStarted) {
+  app_manager()->Initialize(profile(), signin_profile());
+  scoped_refptr<const extensions::Extension> prod_note_taking_app =
+      CreateTestApp(chromeos::NoteTakingHelper::kProdKeepExtensionId, "1.0",
+                    true);
+  extensions::ExtensionSystem::Get(profile())
+      ->extension_service()
+      ->AddExtension(prod_note_taking_app.get());
+
+  scoped_refptr<const extensions::Extension> dev_note_taking_app =
+      CreateTestApp(chromeos::NoteTakingHelper::kDevKeepExtensionId, "1.0",
+                    true);
+  extensions::ExtensionSystem::Get(profile())
+      ->extension_service()
+      ->AddExtension(dev_note_taking_app.get());
+
+  chromeos::NoteTakingHelper::Get()->SetPreferredApp(
+      profile(), chromeos::NoteTakingHelper::kProdKeepExtensionId);
+  profile()->GetPrefs()->SetBoolean(prefs::kNoteTakingAppEnabledOnLockScreen,
+                                    true);
+
+  TestAppManagerObserver observer;
+  app_manager()->Start(&observer);
+
+  EXPECT_EQ(0, observer.availability_changed_count());
+  EXPECT_TRUE(app_manager()->IsNoteTakingAppAvailable());
+  EXPECT_EQ(chromeos::NoteTakingHelper::kProdKeepExtensionId,
+            app_manager()->GetNoteTakingAppId());
+
+  const extensions::Extension* lock_app =
+      extensions::ExtensionRegistry::Get(signin_profile())
+          ->GetExtensionById(chromeos::NoteTakingHelper::kProdKeepExtensionId,
+                             extensions::ExtensionRegistry::ENABLED);
+  ASSERT_TRUE(lock_app);
+  EXPECT_TRUE(lock_app->runs_on_lock_screen());
+
+  chromeos::NoteTakingHelper::Get()->SetPreferredApp(
+      profile(), chromeos::NoteTakingHelper::kDevKeepExtensionId);
+
+  EXPECT_EQ(1, observer.availability_changed_count());
+  observer.ResetAvailabilityChangedCount();
+
+  EXPECT_TRUE(app_manager()->IsNoteTakingAppAvailable());
+  EXPECT_EQ(chromeos::NoteTakingHelper::kDevKeepExtensionId,
+            app_manager()->GetNoteTakingAppId());
+
+  // Verify prod app was unloaded from signin profile.
+  lock_app =
+      extensions::ExtensionRegistry::Get(signin_profile())
+          ->GetExtensionById(chromeos::NoteTakingHelper::kProdKeepExtensionId,
+                             extensions::ExtensionRegistry::EVERYTHING);
+  EXPECT_FALSE(lock_app);
+
+  lock_app =
+      extensions::ExtensionRegistry::Get(signin_profile())
+          ->GetExtensionById(chromeos::NoteTakingHelper::kDevKeepExtensionId,
+                             extensions::ExtensionRegistry::ENABLED);
+
+  ASSERT_TRUE(lock_app);
+  EXPECT_TRUE(lock_app->runs_on_lock_screen());
+
+  app_manager()->Stop();
+  EXPECT_EQ(0, observer.availability_changed_count());
+  EXPECT_FALSE(app_manager()->IsNoteTakingAppAvailable());
+  EXPECT_TRUE(app_manager()->GetNoteTakingAppId().empty());
+}
+
+TEST_F(LockScreenAppManagerImplTest, LockScreenNoteTakingReloadedWhileStarted) {
+  app_manager()->Initialize(profile(), signin_profile());
+  scoped_refptr<const extensions::Extension> prod_note_taking_app =
+      CreateTestApp(chromeos::NoteTakingHelper::kProdKeepExtensionId, "1.0",
+                    true);
+  extensions::ExtensionSystem::Get(profile())
+      ->extension_service()
+      ->AddExtension(prod_note_taking_app.get());
+
+  chromeos::NoteTakingHelper::Get()->SetPreferredApp(
+      profile(), chromeos::NoteTakingHelper::kProdKeepExtensionId);
+  profile()->GetPrefs()->SetBoolean(prefs::kNoteTakingAppEnabledOnLockScreen,
+                                    true);
+
+  TestAppManagerObserver observer;
+  app_manager()->Start(&observer);
+
+  EXPECT_EQ(0, observer.availability_changed_count());
+  EXPECT_TRUE(app_manager()->IsNoteTakingAppAvailable());
+  EXPECT_EQ(chromeos::NoteTakingHelper::kProdKeepExtensionId,
+            app_manager()->GetNoteTakingAppId());
+
+  const extensions::Extension* lock_app =
+      extensions::ExtensionRegistry::Get(signin_profile())
+          ->GetExtensionById(chromeos::NoteTakingHelper::kProdKeepExtensionId,
+                             extensions::ExtensionRegistry::ENABLED);
+  ASSERT_TRUE(lock_app);
+  EXPECT_TRUE(lock_app->runs_on_lock_screen());
+  EXPECT_EQ("1.0", lock_app->VersionString());
+
+  extensions::ExtensionSystem::Get(profile())
+      ->extension_service()
+      ->UnloadExtension(chromeos::NoteTakingHelper::kProdKeepExtensionId,
+                        extensions::UnloadedExtensionReason::UPDATE);
+
+  EXPECT_EQ(1, observer.availability_changed_count());
+  observer.ResetAvailabilityChangedCount();
+
+  EXPECT_FALSE(app_manager()->IsNoteTakingAppAvailable());
+  EXPECT_TRUE(app_manager()->GetNoteTakingAppId().empty());
+
+  // Verify prod app was unloaded from signin profile.
+  lock_app =
+      extensions::ExtensionRegistry::Get(signin_profile())
+          ->GetExtensionById(chromeos::NoteTakingHelper::kProdKeepExtensionId,
+                             extensions::ExtensionRegistry::EVERYTHING);
+  EXPECT_FALSE(lock_app);
+
+  // Add the app again.
+  prod_note_taking_app = CreateTestApp(
+      chromeos::NoteTakingHelper::kProdKeepExtensionId, "1.1", true);
+  extensions::ExtensionSystem::Get(profile())
+      ->extension_service()
+      ->AddExtension(prod_note_taking_app.get());
+
+  EXPECT_EQ(1, observer.availability_changed_count());
+  observer.ResetAvailabilityChangedCount();
+  EXPECT_TRUE(app_manager()->IsNoteTakingAppAvailable());
+  EXPECT_EQ(chromeos::NoteTakingHelper::kProdKeepExtensionId,
+            app_manager()->GetNoteTakingAppId());
+
+  lock_app =
+      extensions::ExtensionRegistry::Get(signin_profile())
+          ->GetExtensionById(chromeos::NoteTakingHelper::kProdKeepExtensionId,
+                             extensions::ExtensionRegistry::ENABLED);
+
+  ASSERT_TRUE(lock_app);
+  EXPECT_TRUE(lock_app->runs_on_lock_screen());
+  EXPECT_EQ("1.1", lock_app->VersionString());
+
+  app_manager()->Stop();
+  EXPECT_EQ(0, observer.availability_changed_count());
+  EXPECT_FALSE(app_manager()->IsNoteTakingAppAvailable());
+  EXPECT_TRUE(app_manager()->GetNoteTakingAppId().empty());
+}
+
+TEST_F(LockScreenAppManagerImplTest, ReloadOldLockScreenApps) {
+  app_manager()->Initialize(profile(), signin_profile());
+  scoped_refptr<const extensions::Extension> prod_note_taking_app =
+      CreateTestApp(chromeos::NoteTakingHelper::kProdKeepExtensionId, "1.1",
+                    true);
+  extensions::ExtensionSystem::Get(profile())
+      ->extension_service()
+      ->AddExtension(prod_note_taking_app.get());
+
+  chromeos::NoteTakingHelper::Get()->SetPreferredApp(
+      profile(), chromeos::NoteTakingHelper::kProdKeepExtensionId);
+  profile()->GetPrefs()->SetBoolean(prefs::kNoteTakingAppEnabledOnLockScreen,
+                                    true);
+
+  TestAppManagerObserver observer;
+  app_manager()->Start(&observer);
+  EXPECT_TRUE(app_manager()->IsNoteTakingAppAvailable());
+  EXPECT_EQ(chromeos::NoteTakingHelper::kProdKeepExtensionId,
+            app_manager()->GetNoteTakingAppId());
+
+  const extensions::Extension* lock_app =
+      extensions::ExtensionRegistry::Get(signin_profile())
+          ->GetExtensionById(chromeos::NoteTakingHelper::kProdKeepExtensionId,
+                             extensions::ExtensionRegistry::ENABLED);
+  ASSERT_TRUE(lock_app);
+  EXPECT_TRUE(lock_app->runs_on_lock_screen());
+  EXPECT_EQ("1.1", lock_app->VersionString());
+
+  ResetAppManager();
+  TestingProfile* secondary_profile = CreateSecondaryProfile();
+  app_manager()->Initialize(secondary_profile, signin_profile());
+
+  scoped_refptr<const extensions::Extension> secondary_note_taking_app =
+      CreateTestApp(chromeos::NoteTakingHelper::kProdKeepExtensionId, "1.0",
+                    true);
+  extensions::ExtensionSystem::Get(secondary_profile)
+      ->extension_service()
+      ->AddExtension(secondary_note_taking_app.get());
+
+  chromeos::NoteTakingHelper::Get()->SetPreferredApp(
+      secondary_profile, chromeos::NoteTakingHelper::kProdKeepExtensionId);
+  secondary_profile->GetPrefs()->SetBoolean(
+      prefs::kNoteTakingAppEnabledOnLockScreen, true);
+
+  app_manager()->Start(&observer);
+  EXPECT_TRUE(app_manager()->IsNoteTakingAppAvailable());
+  EXPECT_EQ(chromeos::NoteTakingHelper::kProdKeepExtensionId,
+            app_manager()->GetNoteTakingAppId());
+  lock_app =
+      extensions::ExtensionRegistry::Get(signin_profile())
+          ->GetExtensionById(chromeos::NoteTakingHelper::kProdKeepExtensionId,
+                             extensions::ExtensionRegistry::ENABLED);
+  ASSERT_TRUE(lock_app);
+  EXPECT_TRUE(lock_app->runs_on_lock_screen());
+  EXPECT_EQ("1.0", lock_app->VersionString());
+
+  app_manager()->Stop();
+}
+
+TEST_F(LockScreenAppManagerImplTest,
+       DontOverrideDisabledNonLockScreenSigninProfileApps) {
+  app_manager()->Initialize(profile(), signin_profile());
+
+  scoped_refptr<const extensions::Extension> prod_note_taking_app =
+      CreateTestApp(chromeos::NoteTakingHelper::kProdKeepExtensionId, "1.1",
+                    true);
+  extensions::ExtensionSystem::Get(profile())
+      ->extension_service()
+      ->AddExtension(prod_note_taking_app.get());
+
+  scoped_refptr<const extensions::Extension> signin_profile_note_taking_app =
+      CreateTestApp(chromeos::NoteTakingHelper::kProdKeepExtensionId, "1.0",
+                    true);
+  extensions::ExtensionSystem::Get(signin_profile())
+      ->extension_service()
+      ->AddExtension(signin_profile_note_taking_app.get());
+
+  chromeos::NoteTakingHelper::Get()->SetPreferredApp(
+      profile(), chromeos::NoteTakingHelper::kProdKeepExtensionId);
+  profile()->GetPrefs()->SetBoolean(prefs::kNoteTakingAppEnabledOnLockScreen,
+                                    true);
+
+  TestAppManagerObserver observer;
+  app_manager()->Start(&observer);
+
+  EXPECT_FALSE(app_manager()->IsNoteTakingAppAvailable());
+  EXPECT_TRUE(app_manager()->GetNoteTakingAppId().empty());
+
+  const extensions::Extension* lock_app =
+      extensions::ExtensionRegistry::Get(signin_profile())
+          ->GetExtensionById(chromeos::NoteTakingHelper::kProdKeepExtensionId,
+                             extensions::ExtensionRegistry::ENABLED);
+  ASSERT_TRUE(lock_app);
+  EXPECT_FALSE(lock_app->runs_on_lock_screen());
+  EXPECT_EQ("1.0", lock_app->VersionString());
+
+  app_manager()->Stop();
+}
+
+TEST_F(LockScreenAppManagerImplTest, DontOverrideDisabledSigninProfileApps) {
+  app_manager()->Initialize(profile(), signin_profile());
+
+  scoped_refptr<const extensions::Extension> prod_note_taking_app =
+      CreateTestApp(chromeos::NoteTakingHelper::kProdKeepExtensionId, "1.1",
+                    true);
+  extensions::ExtensionSystem::Get(profile())
+      ->extension_service()
+      ->AddExtension(prod_note_taking_app.get());
+
+  scoped_refptr<const extensions::Extension> signin_profile_note_taking_app =
+      CreateTestApp(chromeos::NoteTakingHelper::kProdKeepExtensionId, "1.0",
+                    true);
+  extensions::ExtensionSystem::Get(signin_profile())
+      ->extension_service()
+      ->AddExtension(signin_profile_note_taking_app.get());
+  extensions::ExtensionSystem::Get(signin_profile())
+      ->extension_service()
+      ->DisableExtension(signin_profile_note_taking_app->id(),
+                         extensions::Extension::DISABLE_USER_ACTION);
+
+  chromeos::NoteTakingHelper::Get()->SetPreferredApp(
+      profile(), chromeos::NoteTakingHelper::kProdKeepExtensionId);
+  profile()->GetPrefs()->SetBoolean(prefs::kNoteTakingAppEnabledOnLockScreen,
+                                    true);
+
+  TestAppManagerObserver observer;
+  app_manager()->Start(&observer);
+
+  EXPECT_FALSE(app_manager()->IsNoteTakingAppAvailable());
+  EXPECT_TRUE(app_manager()->GetNoteTakingAppId().empty());
+
+  const extensions::Extension* lock_app =
+      extensions::ExtensionRegistry::Get(signin_profile())
+          ->GetExtensionById(chromeos::NoteTakingHelper::kProdKeepExtensionId,
+                             extensions::ExtensionRegistry::DISABLED);
+  ASSERT_TRUE(lock_app);
+  EXPECT_FALSE(lock_app->runs_on_lock_screen());
+  EXPECT_EQ("1.0", lock_app->VersionString());
+
+  app_manager()->Stop();
+}
+
+TEST_F(LockScreenAppManagerImplTest, ShutdownWhenStarted) {
+  app_manager()->Initialize(profile(), signin_profile());
+  scoped_refptr<const extensions::Extension> prod_note_taking_app =
+      CreateTestApp(chromeos::NoteTakingHelper::kProdKeepExtensionId, "1.1",
+                    true);
+  extensions::ExtensionSystem::Get(profile())
+      ->extension_service()
+      ->AddExtension(prod_note_taking_app.get());
+  chromeos::NoteTakingHelper::Get()->SetPreferredApp(
+      profile(), chromeos::NoteTakingHelper::kProdKeepExtensionId);
+  profile()->GetPrefs()->SetBoolean(prefs::kNoteTakingAppEnabledOnLockScreen,
+                                    true);
+  TestAppManagerObserver observer;
+  app_manager()->Start(&observer);
+
+  const extensions::Extension* lock_app =
+      extensions::ExtensionRegistry::Get(signin_profile())
+          ->GetExtensionById(chromeos::NoteTakingHelper::kProdKeepExtensionId,
+                             extensions::ExtensionRegistry::ENABLED);
+  EXPECT_TRUE(lock_app);
+}
+
+TEST_F(LockScreenAppManagerImplTest, LaunchAppWhenEnabled) {
+  TestEventRouter* event_router = static_cast<TestEventRouter*>(
+      extensions::EventRouterFactory::GetInstance()->SetTestingFactoryAndUse(
+          signin_profile()->GetOriginalProfile(),
+          &TestEventRouterFactoryFunction));
+  ASSERT_TRUE(event_router);
+
+  app_manager()->Initialize(profile(), signin_profile());
+  scoped_refptr<const extensions::Extension> note_taking_app = CreateTestApp(
+      chromeos::NoteTakingHelper::kProdKeepExtensionId, "1.0", true);
+  extensions::ExtensionSystem::Get(profile())
+      ->extension_service()
+      ->AddExtension(note_taking_app.get());
+
+  chromeos::NoteTakingHelper::Get()->SetPreferredApp(
+      profile(), chromeos::NoteTakingHelper::kProdKeepExtensionId);
+  profile()->GetPrefs()->SetBoolean(prefs::kNoteTakingAppEnabledOnLockScreen,
+                                    true);
+
+  TestAppManagerObserver observer;
+  app_manager()->Start(&observer);
+
+  ASSERT_EQ(chromeos::NoteTakingHelper::kProdKeepExtensionId,
+            app_manager()->GetNoteTakingAppId());
+
+  EXPECT_TRUE(app_manager()->LaunchNoteTaking());
+
+  ASSERT_EQ(1u, event_router->launched_apps().size());
+  EXPECT_EQ(chromeos::NoteTakingHelper::kProdKeepExtensionId,
+            event_router->launched_apps()[0]);
+  event_router->ClearLaunchedApps();
+
+  app_manager()->Stop();
+
+  EXPECT_FALSE(app_manager()->LaunchNoteTaking());
+  EXPECT_TRUE(event_router->launched_apps().empty());
+}
+
+TEST_F(LockScreenAppManagerImplTest, LaunchAppWhenNoLockScreenApp) {
+  TestEventRouter* event_router = static_cast<TestEventRouter*>(
+      extensions::EventRouterFactory::GetInstance()->SetTestingFactoryAndUse(
+          signin_profile()->GetOriginalProfile(),
+          &TestEventRouterFactoryFunction));
+  ASSERT_TRUE(event_router);
+
+  app_manager()->Initialize(profile(), signin_profile());
+  scoped_refptr<const extensions::Extension> note_taking_app = CreateTestApp(
+      chromeos::NoteTakingHelper::kProdKeepExtensionId, "1.0", true);
+  extensions::ExtensionSystem::Get(profile())
+      ->extension_service()
+      ->AddExtension(note_taking_app.get());
+
+  chromeos::NoteTakingHelper::Get()->SetPreferredApp(
+      profile(), chromeos::NoteTakingHelper::kProdKeepExtensionId);
+
+  TestAppManagerObserver observer;
+  app_manager()->Start(&observer);
+
+  EXPECT_FALSE(app_manager()->LaunchNoteTaking());
+  EXPECT_TRUE(event_router->launched_apps().empty());
+
+  app_manager()->Stop();
+  EXPECT_FALSE(app_manager()->LaunchNoteTaking());
+  EXPECT_TRUE(event_router->launched_apps().empty());
+}
+
+}  // namespace lock_screen_apps