Install and launch kiosk app from cached crx file at start up.

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 "apps/app_window.h"
 #include "apps/app_window_registry.h"
 #include "apps/ui/native_app_window.h"
 #include "ash/desktop_background/desktop_background_controller.h"
 #include "ash/desktop_background/desktop_background_controller_observer.h"
 #include "ash/shell.h"
@@ skipping 219 matching lines @@
  public:
   KioskTest() : fake_cws_(new FakeCWS) {
     set_exit_when_last_browser_closes(false);
   }
 
   virtual ~KioskTest() {}
 
  protected:
   virtual void SetUp() OVERRIDE {
     test_app_id_ = kTestKioskApp;
+    set_test_app_version("1.0.0");
+    set_test_crx_file(test_app_id() + ".crx");
+    needs_background_networking_ = true;
     mock_user_manager_.reset(new MockUserManager);
     ProfileHelper::SetAlwaysReturnPrimaryUserForTesting(true);
     AppLaunchController::SkipSplashWaitForTesting();
     AppLaunchController::SetNetworkWaitForTesting(kTestNetworkTimeoutSeconds);
 
     OobeBaseTest::SetUp();
   }
 
   virtual void TearDown() OVERRIDE {
     ProfileHelper::SetAlwaysReturnPrimaryUserForTesting(false);
@@ skipping 18 matching lines @@
 
   void LaunchApp(const std::string& app_id, bool diagnostic_mode) {
     bool new_kiosk_ui = KioskAppMenuHandler::EnableNewKioskUI();
     GetLoginUI()->CallJavascriptFunction(new_kiosk_ui ?
         kLaunchAppForTestNewAPI : kLaunchAppForTestOldAPI,
         base::StringValue(app_id),
         base::FundamentalValue(diagnostic_mode));
   }
 
   void ReloadKioskApps() {
+    SetupTestAppUpdateCheck();
+
     // Remove then add to ensure NOTIFICATION_KIOSK_APPS_LOADED fires.
     KioskAppManager::Get()->RemoveApp(test_app_id_);
     KioskAppManager::Get()->AddApp(test_app_id_);
   }
 
+  void SetupTestAppUpdateCheck() {
+    if (!test_app_version().empty()) {
+      fake_cws_->SetUpdateCrx(
+          test_app_id(), test_crx_file(), test_app_version());
+    }
+  }
+
   void ReloadAutolaunchKioskApps() {
+    SetupTestAppUpdateCheck();
+
     KioskAppManager::Get()->AddApp(test_app_id_);
     KioskAppManager::Get()->SetAutoLaunchApp(test_app_id_);
   }
 
-  void PrepareAppLaunch() {
+  void StartUIForAppLaunch() {
     EnableConsumerKioskMode();
 
     // Start UI
     content::WindowedNotificationObserver login_signal(
         chrome::NOTIFICATION_LOGIN_OR_LOCK_WEBUI_VISIBLE,
         content::NotificationService::AllSources());
     chromeos::WizardController::SkipPostLoginScreensForTesting();
     chromeos::WizardController* wizard_controller =
         chromeos::WizardController::default_controller();
     if (wizard_controller) {
       wizard_controller->SkipToLoginForTesting(LoginScreenContext());
       login_signal.Wait();
     } else {
       // No wizard and running with an existing profile and it should land
       // on account picker when new kiosk UI is enabled. Otherwise, just
       // wait for the login signal from Gaia.
       if (KioskAppMenuHandler::EnableNewKioskUI())
         OobeScreenWaiter(OobeDisplay::SCREEN_ACCOUNT_PICKER).Wait();
       else
         login_signal.Wait();
     }
+  }
+
+  void PrepareAppLaunch() {
+    // Start UI
+    StartUIForAppLaunch();
 
     // Wait for the Kiosk App configuration to reload.
     content::WindowedNotificationObserver apps_loaded_signal(
         chrome::NOTIFICATION_KIOSK_APPS_LOADED,
         content::NotificationService::AllSources());
     ReloadKioskApps();
     apps_loaded_signal.Wait();
   }
 
   void StartAppLaunchFromLoginScreen(const base::Closure& network_setup_cb) {
@@ skipping 104 matching lines @@
     KioskAppManager::Get()->GetConsumerKioskAutoLaunchStatus(
         base::Bind(&ConsumerKioskAutoLaunchStatusCheck,
                    &status,
                    runner->QuitClosure()));
     runner->Run();
     CHECK_NE(status,
              static_cast<KioskAppManager::ConsumerKioskAutoLaunchStatus>(-1));
     return status;
   }
 
-  // Copies the app profile from |relative_app_profile_dir| from test directory
-  // to the app profile directory (assuming "user") under testing profile. This
-  // is for that needs to have a kiosk app already installed from a previous
-  // run. Note this must be called before app profile is loaded.
-  void SetupAppProfile(const std::string& relative_app_profile_dir) {
-    base::FilePath app_profile_dir;
-    KioskAppManager::App app_data;
-    CHECK(KioskAppManager::Get()->GetApp(test_app_id(), &app_data));
-    std::string app_user_id_hash =
-        CryptohomeClient::GetStubSanitizedUsername(app_data.user_id);
-    app_profile_dir =
-        ProfileHelper::GetProfilePathByUserIdHash(app_user_id_hash);
-    ASSERT_TRUE(base::CreateDirectory(app_profile_dir));
-
-    base::FilePath test_data_dir;
-    ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir));
-    test_data_dir = test_data_dir.AppendASCII(relative_app_profile_dir);
-    ASSERT_TRUE(
-        base::CopyFile(test_data_dir.Append(chrome::kPreferencesFilename),
-                       app_profile_dir.Append(chrome::kPreferencesFilename)));
-    ASSERT_TRUE(
-        base::CopyDirectory(test_data_dir.AppendASCII("Extensions"),
-                            app_profile_dir,
-                            true));
-  }
-
   void RunAppLaunchNetworkDownTest() {
     mock_user_manager()->SetActiveUser(kTestOwnerEmail);
     AppLaunchSigninScreen::SetUserManagerForTesting(mock_user_manager());
 
     // Mock network could be configured with owner's password.
     ScopedCanConfigureNetwork can_configure_network(true, true);
 
     // Start app launch and wait for network connectivity timeout.
     StartAppLaunchFromLoginScreen(SimulateNetworkOfflineClosure());
     OobeScreenWaiter splash_waiter(OobeDisplay::SCREEN_APP_LAUNCH_SPLASH);
@@ skipping 32 matching lines @@
     return chromeos::LoginDisplayHostImpl::default_host()
         ->GetAppLaunchController();
   }
 
   MockUserManager* mock_user_manager() { return mock_user_manager_.get(); }
 
   void set_test_app_id(const std::string& test_app_id) {
     test_app_id_ = test_app_id;
   }
   const std::string& test_app_id() const { return test_app_id_; }
+  void set_test_app_version(const std::string& version) {
+    test_app_version_ = version;
+  }
+  const std::string& test_app_version() const { return test_app_version_; }
+  void set_test_crx_file(const std::string& filename) {
+    test_crx_file_ = filename;
+  }
+  const std::string& test_crx_file() const { return test_crx_file_; }
   FakeCWS* fake_cws() { return fake_cws_.get(); }
 
  private:
   std::string test_app_id_;
+  std::string test_app_version_;
+  std::string test_crx_file_;
   scoped_ptr<FakeCWS> fake_cws_;
   scoped_ptr<MockUserManager> mock_user_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(KioskTest);
 };
 
 IN_PROC_BROWSER_TEST_F(KioskTest, InstallAndLaunchApp) {
   StartAppLaunchFromLoginScreen(SimulateNetworkOnlineClosure());
   WaitForAppLaunchSuccess();
 }
@@ skipping 86 matching lines @@
   // Network error should show up automatically since this test does not
   // require owner auth to configure network.
   OobeScreenWaiter(OobeDisplay::SCREEN_ERROR_MESSAGE).Wait();
 
   ASSERT_TRUE(GetAppLaunchController()->showing_network_dialog());
   SimulateNetworkOnline();
   WaitForAppLaunchSuccess();
 }
 
 IN_PROC_BROWSER_TEST_F(KioskTest, LaunchAppUserCancel) {
+  // Make fake_cws_ return empty update response.
+  set_test_app_version("");
   StartAppLaunchFromLoginScreen(SimulateNetworkOfflineClosure());
   OobeScreenWaiter splash_waiter(OobeDisplay::SCREEN_APP_LAUNCH_SPLASH);
   splash_waiter.Wait();
 
   CrosSettings::Get()->SetBoolean(
       kAccountsPrefDeviceLocalAccountAutoLoginBailoutEnabled, true);
   content::WindowedNotificationObserver signal(
       chrome::NOTIFICATION_APP_TERMINATING,
       content::NotificationService::AllSources());
   GetLoginUI()->CallJavascriptFunction("cr.ui.Oobe.handleAccelerator",
@@ skipping 243 matching lines @@
       chrome::NOTIFICATION_KIOSK_ENABLE_WARNING_VISIBLE,
       content::NotificationService::AllSources()).Wait();
 }
 
 class KioskUpdateTest : public KioskTest {
  public:
   KioskUpdateTest() {}
   virtual ~KioskUpdateTest() {}
 
  protected:
-  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
-    // Needs background networking so that ExtensionDownloader works.
-    needs_background_networking_ = true;
-    KioskTest::SetUpCommandLine(command_line);
-  }
-
   virtual void SetUpOnMainThread() OVERRIDE {
     KioskTest::SetUpOnMainThread();
   }
 
+  void PreCacheApp(const std::string& app_id,
+                   const std::string& version,
+                   const std::string& crx_file) {
+    set_test_app_id(app_id);
+    set_test_app_version(version);
+    set_test_crx_file(crx_file);
+
+    KioskAppManager* manager = KioskAppManager::Get();
+    AppDataLoadWaiter waiter(manager, app_id, version);
+    ReloadKioskApps();
+    waiter.Wait();
+    EXPECT_TRUE(waiter.loaded());
+    std::string cached_version;
+    base::FilePath file_path;
+    EXPECT_TRUE(manager->GetCachedCrx(app_id, &file_path, &cached_version));
+    EXPECT_EQ(version, cached_version);
+  }
+
+  void UpdateExternalCache(const std::string& version,
+                           const std::string& crx_file) {
+    set_test_app_version(version);
+    set_test_crx_file(crx_file);
+    SetupTestAppUpdateCheck();
+
+    KioskAppManager* manager = KioskAppManager::Get();
+    AppDataLoadWaiter waiter(manager, test_app_id(), version);
+    KioskAppManager::Get()->UpdateExternalCache();
+    waiter.Wait();
+    EXPECT_TRUE(waiter.loaded());
+    std::string cached_version;
+    base::FilePath file_path;
+    EXPECT_TRUE(
+        manager->GetCachedCrx(test_app_id(), &file_path, &cached_version));
+    EXPECT_EQ(version, cached_version);
+  }
+
+  void PreCacheAndLaunchApp(const std::string& app_id,
+                            const std::string& version,
+                            const std::string& crx_file) {
+    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());
+  }
+
  private:
+  class AppDataLoadWaiter : public KioskAppManagerObserver {
+   public:
+    AppDataLoadWaiter(KioskAppManager* manager,
+                      const std::string& app_id,
+                      const std::string& version)
+        : runner_(NULL),
+          manager_(manager),
+          loaded_(false),
+          quit_(false),
+          app_id_(app_id),
+          version_(version) {
+      manager_->AddObserver(this);
+    }
+
+    virtual ~AppDataLoadWaiter() { manager_->RemoveObserver(this); }
+
+    void Wait() {
+      if (quit_)
+        return;
+      runner_ = new content::MessageLoopRunner;
+      runner_->Run();
+    }
+
+    bool loaded() const { return loaded_; }
+
+   private:
+    // KioskAppManagerObserver overrides:
+    virtual void OnKioskExtensionLoadedInCache(
+        const std::string& app_id) OVERRIDE {
+      std::string cached_version;
+      base::FilePath file_path;
+      if (!manager_->GetCachedCrx(app_id_, &file_path, &cached_version))
+        return;
+      if (version_ != cached_version)
+        return;
+      loaded_ = true;
+      quit_ = true;
+      if (runner_)
+        runner_->Quit();
+    }
+
+    virtual void OnKioskExtensionDownloadFailed(
+        const std::string& app_id) OVERRIDE {
+      loaded_ = false;
+      quit_ = true;
+      if (runner_)
+        runner_->Quit();
+    }
+
+    scoped_refptr<content::MessageLoopRunner> runner_;
+    KioskAppManager* manager_;
+    bool loaded_;
+    bool quit_;
+    std::string app_id_;
+    std::string version_;
+
+    DISALLOW_COPY_AND_ASSIGN(AppDataLoadWaiter);
+  };
 
   DISALLOW_COPY_AND_ASSIGN(KioskUpdateTest);
 };
 
+IN_PROC_BROWSER_TEST_F(KioskUpdateTest, PRE_LaunchOfflineEnabledAppNoNetwork) {
+  PreCacheAndLaunchApp(kTestOfflineEnabledKioskApp,
+                       "1.0.0",
+                       std::string(kTestOfflineEnabledKioskApp) + "_v1.crx");
+}
+
 IN_PROC_BROWSER_TEST_F(KioskUpdateTest, LaunchOfflineEnabledAppNoNetwork) {
   set_test_app_id(kTestOfflineEnabledKioskApp);
-
-  PrepareAppLaunch();
+  StartUIForAppLaunch();
   SimulateNetworkOffline();
-  SetupAppProfile("chromeos/app_mode/offline_enabled_app_profile");
-
-  LaunchApp(test_app_id(), false);
-  WaitForAppLaunchSuccess();
+  LaunchApp(test_app_id(), false);
+  WaitForAppLaunchSuccess();
+
+  EXPECT_EQ("1.0.0", GetInstalledAppVersion().GetString());
+}
+
+IN_PROC_BROWSER_TEST_F(KioskUpdateTest,
+                       PRE_LaunchCachedOfflineEnabledAppNoNetwork) {
+  PreCacheApp(kTestOfflineEnabledKioskApp,
+              "1.0.0",
+              std::string(kTestOfflineEnabledKioskApp) + "_v1.crx");
+}
+
+IN_PROC_BROWSER_TEST_F(KioskUpdateTest,
+                       LaunchCachedOfflineEnabledAppNoNetwork) {
+  set_test_app_id(kTestOfflineEnabledKioskApp);
+  EXPECT_TRUE(
+      KioskAppManager::Get()->HasCachedCrx(kTestOfflineEnabledKioskApp));
+  StartUIForAppLaunch();
+  SimulateNetworkOffline();
+  LaunchApp(test_app_id(), false);
+  WaitForAppLaunchSuccess();
+
+  EXPECT_EQ("1.0.0", GetInstalledAppVersion().GetString());
+}
+
+// Network offline, app v1.0 has run before, has cached v2.0 crx and v2.0 should
+// be installed and launched during next launch.
+IN_PROC_BROWSER_TEST_F(KioskUpdateTest,
+                       PRE_LaunchCachedNewVersionOfflineEnabledAppNoNetwork) {
+  // Install and launch v1 app.
+  PreCacheAndLaunchApp(kTestOfflineEnabledKioskApp,
+                       "1.0.0",
+                       std::string(kTestOfflineEnabledKioskApp) + "_v1.crx");
+  // Update cache for v2 app.
+  UpdateExternalCache("2.0.0",
+                      std::string(kTestOfflineEnabledKioskApp) + ".crx");
+  // The installed app is still in v1.
+  EXPECT_EQ("1.0.0", GetInstalledAppVersion().GetString());
+}
+
+IN_PROC_BROWSER_TEST_F(KioskUpdateTest,
+                       LaunchCachedNewVersionOfflineEnabledAppNoNetwork) {
+  set_test_app_id(kTestOfflineEnabledKioskApp);
+  EXPECT_TRUE(KioskAppManager::Get()->HasCachedCrx(test_app_id()));
+
+  StartUIForAppLaunch();
+  SimulateNetworkOffline();
+  LaunchApp(test_app_id(), false);
+  WaitForAppLaunchSuccess();
+
+  // v2 app should have been installed.
+  EXPECT_EQ("2.0.0", GetInstalledAppVersion().GetString());
+}
+
+IN_PROC_BROWSER_TEST_F(KioskUpdateTest, PRE_LaunchOfflineEnabledAppNoUpdate) {
+  PreCacheAndLaunchApp(kTestOfflineEnabledKioskApp,
+                       "1.0.0",
+                       std::string(kTestOfflineEnabledKioskApp) + "_v1.crx");
 }
 
 IN_PROC_BROWSER_TEST_F(KioskUpdateTest, LaunchOfflineEnabledAppNoUpdate) {
   set_test_app_id(kTestOfflineEnabledKioskApp);
-
   fake_cws()->SetNoUpdate(test_app_id());
 
-  PrepareAppLaunch();
+  StartUIForAppLaunch();
   SimulateNetworkOnline();
-  SetupAppProfile("chromeos/app_mode/offline_enabled_app_profile");
-
-  LaunchApp(test_app_id(), false);
-  WaitForAppLaunchSuccess();
-
-  EXPECT_EQ("1.0.0", GetInstalledAppVersion().GetString());
+  LaunchApp(test_app_id(), false);
+  WaitForAppLaunchSuccess();
+
+  EXPECT_EQ("1.0.0", GetInstalledAppVersion().GetString());
+}
+
+IN_PROC_BROWSER_TEST_F(KioskUpdateTest, PRE_LaunchOfflineEnabledAppHasUpdate) {
+  PreCacheAndLaunchApp(kTestOfflineEnabledKioskApp,
+                       "1.0.0",
+                       std::string(kTestOfflineEnabledKioskApp) + "_v1.crx");
 }
 
 IN_PROC_BROWSER_TEST_F(KioskUpdateTest, LaunchOfflineEnabledAppHasUpdate) {
   set_test_app_id(kTestOfflineEnabledKioskApp);
-
   fake_cws()->SetUpdateCrx(
       test_app_id(), "ajoggoflpgplnnjkjamcmbepjdjdnpdp.crx", "2.0.0");
 
-  PrepareAppLaunch();
+  StartUIForAppLaunch();
   SimulateNetworkOnline();
-  SetupAppProfile("chromeos/app_mode/offline_enabled_app_profile");
-
   LaunchApp(test_app_id(), false);
   WaitForAppLaunchSuccess();
 
   EXPECT_EQ("2.0.0", GetInstalledAppVersion().GetString());
 }
 
+IN_PROC_BROWSER_TEST_F(KioskUpdateTest, PRE_PermissionChange) {
+  PreCacheAndLaunchApp(kTestOfflineEnabledKioskApp,
+                       "2.0.0",
+                       std::string(kTestOfflineEnabledKioskApp) + ".crx");
+}
+
 IN_PROC_BROWSER_TEST_F(KioskUpdateTest, PermissionChange) {
   set_test_app_id(kTestOfflineEnabledKioskApp);
-
-  fake_cws()->SetUpdateCrx(
-      test_app_id(),
-      "ajoggoflpgplnnjkjamcmbepjdjdnpdp_v2_permission_change.crx",
-      "2.0.0");
-
-  PrepareAppLaunch();
+  set_test_app_version("2.0.0");
+  set_test_crx_file(test_app_id() + "_v2_permission_change.crx");
+
+  StartUIForAppLaunch();
   SimulateNetworkOnline();
-  SetupAppProfile("chromeos/app_mode/offline_enabled_app_profile");
-
-  LaunchApp(test_app_id(), false);
-  WaitForAppLaunchSuccess();
-
+  LaunchApp(test_app_id(), false);
+  WaitForAppLaunchSuccess();
+
   EXPECT_EQ("2.0.0", GetInstalledAppVersion().GetString());
 }
 
 IN_PROC_BROWSER_TEST_F(KioskUpdateTest, PRE_PreserveLocalData) {
   // Installs v1 app and writes some local data.
   set_test_app_id(kTestLocalFsKioskApp);
+  set_test_app_version("1.0.0");
+  set_test_crx_file(test_app_id() + ".crx");
 
   ResultCatcher catcher;
   StartAppLaunchFromLoginScreen(SimulateNetworkOnlineClosure());
   WaitForAppLaunchSuccess();
   ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
 }
 
 IN_PROC_BROWSER_TEST_F(KioskUpdateTest, PreserveLocalData) {
   // Update existing v1 app installed in PRE_PreserveLocalData to v2
   // that reads and verifies the local data.
   set_test_app_id(kTestLocalFsKioskApp);
-
-  fake_cws()->SetUpdateCrx(
-      test_app_id(),
-      "bmbpicmpniaclbbpdkfglgipkkebnbjf_v2_read_and_verify_data.crx",
-      "2.0.0");
-
+  set_test_app_version("2.0.0");
+  set_test_crx_file(test_app_id() + "_v2_read_and_verify_data.crx");
   ResultCatcher catcher;
   StartAppLaunchFromLoginScreen(SimulateNetworkOnlineClosure());
   WaitForAppLaunchSuccess();
 
   EXPECT_EQ("2.0.0", GetInstalledAppVersion().GetString());
   ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
 }
 
 class KioskEnterpriseTest : public KioskTest {
  protected:
   KioskEnterpriseTest() {}
 
   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
     device_policy_test_helper_.MarkAsEnterpriseOwned();
     device_policy_test_helper_.InstallOwnerKey();
 
     KioskTest::SetUpInProcessBrowserTestFixture();
   }
 
   virtual void SetUpOnMainThread() OVERRIDE {
+    set_test_app_id(kTestEnterpriseKioskApp);
+    set_test_app_version("1.0.0");
+    set_test_crx_file(test_app_id() + ".crx");
+    SetupTestAppUpdateCheck();
+
     KioskTest::SetUpOnMainThread();
     // Configure kTestEnterpriseKioskApp in device policy.
     em::DeviceLocalAccountsProto* accounts =
         device_policy_test_helper_.device_policy()->payload()
             .mutable_device_local_accounts();
     em::DeviceLocalAccountInfoProto* account = accounts->add_account();
     account->set_account_id(kTestEnterpriseAccountId);
     account->set_type(
         em::DeviceLocalAccountInfoProto::ACCOUNT_TYPE_KIOSK_APP);
     account->mutable_kiosk_app()->set_app_id(kTestEnterpriseKioskApp);
@@ skipping 183 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