Update cached kiosk app crx from usb stick.

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 "ash/desktop_background/desktop_background_controller.h"
 #include "ash/desktop_background/desktop_background_controller_observer.h"
 #include "ash/shell.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/app_mode/fake_cws.h"
 #include "chrome/browser/chromeos/app_mode/kiosk_app_launch_error.h"
 #include "chrome/browser/chromeos/app_mode/kiosk_app_manager.h"
+#include "chrome/browser/chromeos/file_manager/fake_disk_mount_manager.h"
 #include "chrome/browser/chromeos/login/app_launch_controller.h"
 #include "chrome/browser/chromeos/login/startup_utils.h"
 #include "chrome/browser/chromeos/login/test/app_window_waiter.h"
 #include "chrome/browser/chromeos/login/test/oobe_base_test.h"
 #include "chrome/browser/chromeos/login/test/oobe_screen_waiter.h"
 #include "chrome/browser/chromeos/login/users/fake_user_manager.h"
 #include "chrome/browser/chromeos/login/users/mock_user_manager.h"
 #include "chrome/browser/chromeos/login/users/scoped_user_manager_enabler.h"
 #include "chrome/browser/chromeos/login/wizard_controller.h"
 #include "chrome/browser/chromeos/policy/device_policy_cros_browser_test.h"
 #include "chrome/browser/chromeos/policy/proto/chrome_device_policy.pb.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/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_test_message_listener.h"
 #include "chrome/browser/profiles/profile_impl.h"
 #include "chrome/browser/profiles/profiles_state.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_switches.h"
 #include "chromeos/dbus/cryptohome_client.h"
+#include "chromeos/disks/disk_mount_manager.h"
 #include "components/signin/core/common/signin_pref_names.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/test/browser_test_utils.h"
 #include "extensions/browser/app_window/native_app_window.h"
 #include "extensions/browser/extension_system.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "google_apis/gaia/gaia_switches.h"
 #include "google_apis/gaia/gaia_urls.h"
@@ skipping 27 matching lines @@
 //   chrome/test/data/chromeos/app_mode/webstore/downloads/
 const char kTestOfflineEnabledKioskApp[] = "ajoggoflpgplnnjkjamcmbepjdjdnpdp";
 
 // An app to test local fs data persistence across app update. V1 app writes
 // data into local fs. V2 app reads and verifies the data.
 // Webstore data json is in
 //   chrome/test/data/chromeos/app_mode/webstore/inlineinstall/
 //       detail/bmbpicmpniaclbbpdkfglgipkkebnbjf
 const char kTestLocalFsKioskApp[] = "bmbpicmpniaclbbpdkfglgipkkebnbjf";
 
+const char kFakeUsbStickMountPath[] = "chromeos/app_mode/external_update/";
+
 // Timeout while waiting for network connectivity during tests.
 const int kTestNetworkTimeoutSeconds = 1;
 
 // Email of owner account for test.
 const char kTestOwnerEmail[] = "owner@example.com";
 
 const char kTestEnterpriseAccountId[] = "enterprise-kiosk-app@localhost";
 const char kTestEnterpriseServiceAccountId[] = "service_account@example.com";
 const char kTestRefreshToken[] = "fake-refresh-token";
 const char kTestUserinfoToken[] = "fake-userinfo-token";
@@ skipping 117 matching lines @@
       runner_->Quit();
   }
 
   content::WebContents* web_contents_;
   const std::string js_;
   scoped_refptr<content::MessageLoopRunner> runner_;
 
   DISALLOW_COPY_AND_ASSIGN(JsConditionWaiter);
 };
 
+class KioskFakeDiskMountManager : public file_manager::FakeDiskMountManager {
+ public:
+  explicit KioskFakeDiskMountManager(const std::string& usb_mount_path)
+      : usb_mount_path_(usb_mount_path) {}
+
+  virtual ~KioskFakeDiskMountManager() {}
+
+  void MountUsbStick() {
+    MountPath(usb_mount_path_, "", "", chromeos::MOUNT_TYPE_DEVICE);
+  }
+
+  void UnMountUsbStick() {
+    UnmountPath(usb_mount_path_,
+                UNMOUNT_OPTIONS_NONE,
+                disks::DiskMountManager::UnmountPathCallback());
+  }
+
+ private:
+  std::string usb_mount_path_;
+
+  DISALLOW_COPY_AND_ASSIGN(KioskFakeDiskMountManager);
+};
+
 }  // namespace
 
 class KioskTest : public OobeBaseTest {
  public:
   KioskTest() : fake_cws_(new FakeCWS) {
     set_exit_when_last_browser_closes(false);
   }
 
   virtual ~KioskTest() {}
 
@@ skipping 646 matching lines @@
       chrome::NOTIFICATION_KIOSK_ENABLE_WARNING_VISIBLE,
       content::NotificationService::AllSources()).Wait();
 }
 
 class KioskUpdateTest : public KioskTest {
  public:
   KioskUpdateTest() {}
   virtual ~KioskUpdateTest() {}
 
  protected:
+  virtual void SetUp() OVERRIDE {
+    base::FilePath test_data_dir;
+    PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir);
+    test_data_dir = test_data_dir.AppendASCII(kFakeUsbStickMountPath);
+    fake_disk_mount_manager_ =
+        new KioskFakeDiskMountManager(test_data_dir.value());
+    disks::DiskMountManager::InitializeForTesting(fake_disk_mount_manager_);
+
+    KioskTest::SetUp();
+  }
+
+  virtual void TearDown() OVERRIDE {
+    disks::DiskMountManager::Shutdown();
+
+    KioskTest::TearDown();
+  }
+
   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);
@@ skipping 20 matching lines @@
     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 SimulateUpdateAppFromUsbStick() {
+    KioskAppExternalUpdateWaiter waiter(KioskAppManager::Get(), test_app_id());
+    fake_disk_mount_manager_->MountUsbStick();
+    waiter.Wait();
+    fake_disk_mount_manager_->UnMountUsbStick();
+  }
+
   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 KioskAppExternalUpdateWaiter : KioskAppManagerObserver {
+   public:
+    KioskAppExternalUpdateWaiter(KioskAppManager* manager,
+                                 const std::string& app_id)
+        : runner_(NULL), manager_(manager), app_id_(app_id), quit_(false) {
+      manager_->AddObserver(this);
+    }
+
+    virtual ~KioskAppExternalUpdateWaiter() { manager_->RemoveObserver(this); }
+
+    void Wait() {
+      if (quit_)
+        return;
+      runner_ = new content::MessageLoopRunner;
+      runner_->Run();
+    }
+
+   private:
+    // KioskAppManagerObserver overrides:
+    virtual void OnKioskAppCacheUpdated(const std::string& app_id) OVERRIDE {
+      if (app_id_ != app_id)
+        return;
+      quit_ = true;
+      if (runner_)
+        runner_->Quit();
+    }
+
+    scoped_refptr<content::MessageLoopRunner> runner_;
+    KioskAppManager* manager_;
+    const std::string app_id_;
+    bool quit_;
+
+    DISALLOW_COPY_AND_ASSIGN(KioskAppExternalUpdateWaiter);
+  };
+
   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),
@@ skipping 39 matching lines @@
     scoped_refptr<content::MessageLoopRunner> runner_;
     KioskAppManager* manager_;
     bool loaded_;
     bool quit_;
     std::string app_id_;
     std::string version_;
 
     DISALLOW_COPY_AND_ASSIGN(AppDataLoadWaiter);
   };
 
+  // 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");
 }
 
 IN_PROC_BROWSER_TEST_F(KioskUpdateTest, LaunchOfflineEnabledAppNoNetwork) {
@@ skipping 85 matching lines @@
       test_app_id(), "ajoggoflpgplnnjkjamcmbepjdjdnpdp.crx", "2.0.0");
 
   StartUIForAppLaunch();
   SimulateNetworkOnline();
   LaunchApp(test_app_id(), false);
   WaitForAppLaunchSuccess();
 
   EXPECT_EQ("2.0.0", GetInstalledAppVersion().GetString());
 }
 
+// Pre-cache v1 kiosk app.
+IN_PROC_BROWSER_TEST_F(KioskUpdateTest, PRE_PRE_UsbStickUpdateAppNoNetwork) {
+  PreCacheApp(kTestOfflineEnabledKioskApp,
+              "1.0.0",
+              std::string(kTestOfflineEnabledKioskApp) + "_v1.crx");
+}
+
+// Take off network, plug in usb stick with a v2 app.
+IN_PROC_BROWSER_TEST_F(KioskUpdateTest, PRE_UsbStickUpdateAppNoNetwork) {
+  set_test_app_id(kTestOfflineEnabledKioskApp);
+  StartUIForAppLaunch();
+  SimulateNetworkOffline();
+  LaunchApp(test_app_id(), false);
+  WaitForAppLaunchSuccess();
+  EXPECT_EQ("1.0.0", GetInstalledAppVersion().GetString());
+
+  // Simulate mounting of usb stick with v2 app on the stick.
+  SimulateUpdateAppFromUsbStick();
+
+  // The v2 kiosk app is copied into external cache, but won't be loaded
+  // until next time the device is started.
+  EXPECT_EQ("1.0.0", GetInstalledAppVersion().GetString());
+}
+
+// Restart the device, verify the app has been updated to v2.
+IN_PROC_BROWSER_TEST_F(KioskUpdateTest, UsbStickUpdateAppNoNetwork) {
+  // Verify the kiosk app has been updated to v2.
+  set_test_app_id(kTestOfflineEnabledKioskApp);
+  StartUIForAppLaunch();
+  SimulateNetworkOffline();
+  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);
   set_test_app_version("2.0.0");
   set_test_crx_file(test_app_id() + "_v2_permission_change.crx");
@@ skipping 250 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