Implement kiosk multiple apps feature.

chrome/browser/chromeos/login/kiosk_browsertest.cc

 // Copyright (c) 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 <vector>
 
 #include "ash/desktop_background/desktop_background_controller.h"
 #include "ash/desktop_background/desktop_background_controller_observer.h"
 #include "ash/shell.h"
 #include "base/bind.h"
@@ skipping 25 matching lines @@
 #include "chrome/browser/chromeos/login/users/scoped_user_manager_enabler.h"
 #include "chrome/browser/chromeos/login/wizard_controller.h"
 #include "chrome/browser/chromeos/ownership/fake_owner_settings_service.h"
 #include "chrome/browser/chromeos/policy/device_local_account.h"
 #include "chrome/browser/chromeos/policy/device_policy_cros_browser_test.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/chromeos/settings/device_oauth2_token_service.h"
 #include "chrome/browser/chromeos/settings/device_oauth2_token_service_factory.h"
 #include "chrome/browser/chromeos/settings/scoped_cros_settings_test_helper.h"
 #include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/extensions/updater/local_extension_cache.h"
 #include "chrome/browser/profiles/profile_impl.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/profiles/profiles_state.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/ui/webui/chromeos/login/kiosk_app_menu_handler.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/pref_names.h"
+#include "chromeos/chromeos_paths.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/dbus/cryptohome_client.h"
 #include "chromeos/disks/disk_mount_manager.h"
 #include "chromeos/settings/cros_settings_provider.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "components/signin/core/common/signin_pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
@@ skipping 47 matching lines @@
 //       detail/bmbpicmpniaclbbpdkfglgipkkebnbjf
 const char kTestLocalFsKioskApp[] = "bmbpicmpniaclbbpdkfglgipkkebnbjf";
 
 // An app to test local access to file systems via the
 // chrome.fileSystem.requestFileSystem API.
 // Webstore data json is in
 //   chrome/test/data/chromeos/app_mode/webstore/inlineinstall/
 //       detail/aaedpojejpghjkedenggihopfhfijcko
 const char kTestGetVolumeListKioskApp[] = "aaedpojejpghjkedenggihopfhfijcko";
 
+// Testing apps for testing kiosk multi-app feature.
+const char kTestPrimaryKioskApp[] = "ceobkcclegcliomogfoeoheahogoecgl";
+const char kTestSecondaryApp1[] = "ihplaomghjbeafnpnjkhppmfpnmdihgd";
+const char kTestSecondaryApp2[] = "fiehokkcgaojmbhfhlpiheggjhaedjoc";
+const char kTestSecondaryApp3[] = "aabnpdpieclcikafhdkkpldcaodmfoai";
+
 // Fake usb stick mount path.
 const char kFakeUsbMountPathUpdatePass[] =
     "chromeos/app_mode/external_update/update_pass";
 const char kFakeUsbMountPathNoManifest[] =
     "chromeos/app_mode/external_update/no_manifest";
 const char kFakeUsbMountPathBadManifest[] =
     "chromeos/app_mode/external_update/bad_manifest";
 const char kFakeUsbMountPathLowerAppVersion[] =
     "chromeos/app_mode/external_update/lower_app_version";
 const char kFakeUsbMountPathLowerCrxVersion[] =
@@ skipping 51 matching lines @@
 void OnNetworkWaitTimedOut(const base::Closure& runner_quit_task) {
   runner_quit_task.Run();
 }
 
 // Helper function for LockFileThread.
 void LockAndUnlock(scoped_ptr<base::Lock> lock) {
   lock->Acquire();
   lock->Release();
 }
 
+bool IsAppInstalled(const std::string app_id) {
+  Profile* app_profile = ProfileManager::GetPrimaryUserProfile();
+  DCHECK(app_profile);
+  const extensions::Extension* app =
+      extensions::ExtensionSystem::Get(app_profile)
+          ->extension_service()
+          ->GetInstalledExtension(app_id);
+  return app != nullptr;
+}
+
 // Helper functions for CanConfigureNetwork mock.
 class ScopedCanConfigureNetwork {
  public:
   ScopedCanConfigureNetwork(bool can_configure, bool needs_owner_auth)
       : can_configure_(can_configure),
         needs_owner_auth_(needs_owner_auth),
         can_configure_network_callback_(
             base::Bind(&ScopedCanConfigureNetwork::CanConfigureNetwork,
                        base::Unretained(this))),
         needs_owner_auth_callback_(base::Bind(
@@ skipping 1038 matching lines @@
 
   // Check that no launch has started.
   EXPECT_FALSE(login_display_host->GetAppLaunchController());
 }
 
 class KioskUpdateTest : public KioskTest {
  public:
   KioskUpdateTest() {}
   ~KioskUpdateTest() override {}
 
+  struct TestAppInfo {
+    std::string id;
+    std::string version;
+    std::string crx_filename;
+    TestAppInfo() {}
+    TestAppInfo(const std::string& id,
+                const std::string& version,
+                const std::string& crx_filename)
+        : id(id), version(version), crx_filename(crx_filename) {}
+    ~TestAppInfo() {}
+  };
+
  protected:
   void SetUp() override {
     fake_disk_mount_manager_ = new KioskFakeDiskMountManager();
     disks::DiskMountManager::InitializeForTesting(fake_disk_mount_manager_);
 
     KioskTest::SetUp();
   }
 
   void TearDown() override {
     disks::DiskMountManager::Shutdown();
 
     KioskTest::TearDown();
   }
 
   void SetUpOnMainThread() override {
     // For update tests, we cache the app in the PRE part, and then we load it
     // in the test, so we need to both store the apps list on teardown (so that
     // the app manager would accept existing files in its extension cache on the
     // next startup) and copy the list to our stub settings provider as well.
     settings_helper_.CopyStoredValue(kAccountsPrefDeviceLocalAccounts);
+
+    CreateAndInitializeLocalCache();
+
     KioskTest::SetUpOnMainThread();
   }
 
   void TearDownOnMainThread() override {
     settings_helper_.StoreCachedDeviceSetting(kAccountsPrefDeviceLocalAccounts);
     KioskTest::TearDownOnMainThread();
   }
 
   void PreCacheApp(const std::string& app_id,
                    const std::string& version,
@@ skipping 56 matching lines @@
     set_test_app_id(app_id);
     set_test_app_version(version);
     set_test_crx_file(crx_file);
     PrepareAppLaunch();
     SimulateNetworkOnline();
     LaunchApp(test_app_id(), false);
     WaitForAppLaunchSuccess();
     EXPECT_EQ(version, GetInstalledAppVersion().GetString());
   }
 
+  void LaunchKioskWithSecondaryApps(
+      const TestAppInfo& primary_app,
+      const std::vector<TestAppInfo>& secondary_apps) {
+    // Pre-cache the primary app.
+    PreCacheApp(primary_app.id, primary_app.version, primary_app.crx_filename);
+
+    set_test_app_id(primary_app.id);
+    fake_cws()->SetNoUpdate(primary_app.id);
+    for (size_t i = 0; i < secondary_apps.size(); ++i) {
+      fake_cws()->SetUpdateCrx(secondary_apps[i].id,
+                               secondary_apps[i].crx_filename,
+                               secondary_apps[i].version);
+    }
+
+    // Launch the primary app.
+    StartUIForAppLaunch();
+    SimulateNetworkOnline();
+    LaunchApp(test_app_id(), false);
+    WaitForAppLaunchWithOptions(false, true);
+
+    // Verify the primary app and the secondary apps are all installed.
+    EXPECT_EQ(primary_app.version, GetInstalledAppVersion().GetString());
+    for (size_t i = 0; i < secondary_apps.size(); ++i)
+      EXPECT_TRUE(IsAppInstalled(secondary_apps[i].id));
+  }
+
+  void LaunchTestKioskAppWithTwoSecondaryApps() {
+    TestAppInfo primary_app(kTestPrimaryKioskApp, "1.0.0",
+                            std::string(kTestPrimaryKioskApp) + "-1.0.0.crx");
+
+    std::vector<TestAppInfo> secondary_apps;
+    TestAppInfo secondary_app_1(kTestSecondaryApp1, "1.0.0",
+                                std::string(kTestSecondaryApp1) + "-1.0.0.crx");
+    secondary_apps.push_back(secondary_app_1);
+    TestAppInfo secondary_app_2(kTestSecondaryApp2, "1.0.0",
+                                std::string(kTestSecondaryApp2) + "-1.0.0.crx");
+    secondary_apps.push_back(secondary_app_2);
+
+    LaunchKioskWithSecondaryApps(primary_app, secondary_apps);
+  }
+
  private:
   class KioskAppExternalUpdateWaiter : public KioskAppManagerObserver {
    public:
     KioskAppExternalUpdateWaiter(KioskAppManager* manager,
                                  const std::string& app_id)
         : runner_(NULL),
           manager_(manager),
           app_id_(app_id),
           quit_(false),
           update_success_(false),
@@ skipping 32 matching lines @@
     scoped_refptr<content::MessageLoopRunner> runner_;
     KioskAppManager* manager_;
     const std::string app_id_;
     bool quit_;
     bool update_success_;
     bool app_update_notified_;
 
     DISALLOW_COPY_AND_ASSIGN(KioskAppExternalUpdateWaiter);
   };
 
+  // The local cache is supposed to be initialized on chromeos device, and a
+  // ready flag file will be pre-created to mark the ready state, before chrome
+  // starts. In order for the tests to run without being on real chromeos
+  // device, we need to manually create this file.
+  void CreateAndInitializeLocalCache() {
+    base::FilePath extension_cache_dir;
+    CHECK(PathService::Get(chromeos::DIR_DEVICE_EXTENSION_LOCAL_CACHE,
+                           &extension_cache_dir));
+    base::FilePath cache_init_file = extension_cache_dir.Append(
+        extensions::LocalExtensionCache::kCacheReadyFlagFileName);
+    EXPECT_EQ(base::WriteFile(cache_init_file, "", 0), 0);
+  }
+
   // Owned by DiskMountManager.
   KioskFakeDiskMountManager* fake_disk_mount_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(KioskUpdateTest);
 };
 
 IN_PROC_BROWSER_TEST_F(KioskUpdateTest, PRE_LaunchOfflineEnabledAppNoNetwork) {
   PreCacheAndLaunchApp(kTestOfflineEnabledKioskApp,
                        "1.0.0",
                        std::string(kTestOfflineEnabledKioskApp) + "_v1.crx");
@@ skipping 293 matching lines @@
   set_test_crx_file(test_app_id() + "_v2_read_and_verify_data.crx");
   extensions::ResultCatcher catcher;
   StartAppLaunchFromLoginScreen(SimulateNetworkOnlineClosure());
   WaitForAppLaunchWithOptions(true /* check_launch_data */,
                               false /* terminate_app */);
 
   EXPECT_EQ("2.0.0", GetInstalledAppVersion().GetString());
   ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
 }
 
+/* ***** Test Kiosk multi-app feature ***** */
+
+// Launch a primary kiosk app which has two secondary apps.
+IN_PROC_BROWSER_TEST_F(KioskUpdateTest,
+                       LaunchTestKioskAppWithTwoSecondaryApps) {
+  LaunchTestKioskAppWithTwoSecondaryApps();
+}
+
+IN_PROC_BROWSER_TEST_F(KioskUpdateTest, PRE_UpdateMultiAppKioskRemoveOneApp) {
+  LaunchTestKioskAppWithTwoSecondaryApps();
+}
+
+// Update the primary app to version 2 which removes one of the secondary app
+// from its manifest.
+IN_PROC_BROWSER_TEST_F(KioskUpdateTest, UpdateMultiAppKioskRemoveOneApp) {
+  set_test_app_id(kTestPrimaryKioskApp);
+  fake_cws()->SetUpdateCrx(
+      kTestPrimaryKioskApp,
+      std::string(kTestPrimaryKioskApp) + "-2.0.0-1app.crx", "2.0.0");
+  fake_cws()->SetNoUpdate(kTestSecondaryApp1);
+  fake_cws()->SetNoUpdate(kTestSecondaryApp2);
+
+  StartUIForAppLaunch();
+  SimulateNetworkOnline();
+  LaunchApp(test_app_id(), false);
+  WaitForAppLaunchWithOptions(false, true);
+
+  // Verify the secondary app kTestSecondaryApp1 is removed.
+  EXPECT_EQ("2.0.0", GetInstalledAppVersion().GetString());
+  EXPECT_FALSE(IsAppInstalled(kTestSecondaryApp1));
+  EXPECT_TRUE(IsAppInstalled(kTestSecondaryApp2));
+}
+
+IN_PROC_BROWSER_TEST_F(KioskUpdateTest, PRE_UpdateMultiAppKioskAddOneApp) {
+  LaunchTestKioskAppWithTwoSecondaryApps();
+}
+
+// Update the primary app to version 3 which adds a new secondary app in its
+// manifest.
+IN_PROC_BROWSER_TEST_F(KioskUpdateTest, UpdateMultiAppKioskAddOneApp) {
+  set_test_app_id(kTestPrimaryKioskApp);
+  fake_cws()->SetUpdateCrx(
+      kTestPrimaryKioskApp,
+      std::string(kTestPrimaryKioskApp) + "-3.0.0-3app.crx", "3.0.0");
+  fake_cws()->SetNoUpdate(kTestSecondaryApp1);
+  fake_cws()->SetNoUpdate(kTestSecondaryApp2);
+  fake_cws()->SetUpdateCrx(kTestSecondaryApp3,
+                           std::string(kTestSecondaryApp3) + "-1.0.0.crx",
+                           "1.0.0");
+
+  StartUIForAppLaunch();
+  SimulateNetworkOnline();
+  LaunchApp(test_app_id(), false);
+  WaitForAppLaunchWithOptions(false, true);
+
+  // Verify the secondary app kTestSecondaryApp3 is installed.
+  EXPECT_EQ("3.0.0", GetInstalledAppVersion().GetString());
+  EXPECT_TRUE(IsAppInstalled(kTestSecondaryApp1));
+  EXPECT_TRUE(IsAppInstalled(kTestSecondaryApp2));
+  EXPECT_TRUE(IsAppInstalled(kTestSecondaryApp3));
+}
+
 class KioskEnterpriseTest : public KioskTest {
  protected:
   KioskEnterpriseTest() {
     set_use_consumer_kiosk_mode(false);
   }
 
   void SetUpInProcessBrowserTestFixture() override {
     policy::DevicePolicyCrosTestHelper::MarkAsEnterpriseOwnedBy(
         kTestOwnerEmail);
     settings_helper_.SetCurrentUserIsOwner(false);
@@ skipping 224 matching lines @@
   content::WindowedNotificationObserver(
       chrome::NOTIFICATION_KIOSK_AUTOLAUNCH_WARNING_VISIBLE,
       content::NotificationService::AllSources()).Wait();
 
   // Wait for the wallpaper to load.
   WaitForWallpaper();
   EXPECT_TRUE(wallpaper_loaded());
 }
 
 }  // namespace chromeos