src/chrome/browser/chromeos/login/kiosk_browsertest.cc

   1 // Copyright (c) 2013 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 "apps/app_window.h"
   6 #include "apps/app_window_registry.h"
   7 #include "apps/ui/native_app_window.h"
   8 #include "ash/desktop_background/desktop_background_controller.h"
   9 #include "ash/desktop_background/desktop_background_controller_observer.h"
  10 #include "ash/shell.h"
  11 #include "base/file_util.h"
  12 #include "base/path_service.h"
  13 #include "base/prefs/pref_service.h"
  14 #include "base/strings/string_number_conversions.h"
  15 #include "base/strings/string_util.h"
  16 #include "chrome/browser/browser_process.h"
  17 #include "chrome/browser/chrome_notification_types.h"
  18 #include "chrome/browser/chromeos/app_mode/fake_cws.h"
  19 #include "chrome/browser/chromeos/app_mode/kiosk_app_launch_error.h"
  20 #include "chrome/browser/chromeos/app_mode/kiosk_app_manager.h"
  21 #include "chrome/browser/chromeos/login/app_launch_controller.h"
  22 #include "chrome/browser/chromeos/login/startup_utils.h"
  23 #include "chrome/browser/chromeos/login/test/app_window_waiter.h"
  24 #include "chrome/browser/chromeos/login/test/oobe_base_test.h"
  25 #include "chrome/browser/chromeos/login/test/oobe_screen_waiter.h"
  26 #include "chrome/browser/chromeos/login/users/fake_user_manager.h"
  27 #include "chrome/browser/chromeos/login/users/mock_user_manager.h"
  28 #include "chrome/browser/chromeos/login/users/scoped_user_manager_enabler.h"
  29 #include "chrome/browser/chromeos/login/wizard_controller.h"
  30 #include "chrome/browser/chromeos/policy/device_policy_cros_browser_test.h"
  31 #include "chrome/browser/chromeos/policy/proto/chrome_device_policy.pb.h"
  32 #include "chrome/browser/chromeos/profiles/profile_helper.h"
  33 #include "chrome/browser/chromeos/settings/device_oauth2_token_service.h"
  34 #include "chrome/browser/chromeos/settings/device_oauth2_token_service_factory.h"
  35 #include "chrome/browser/extensions/extension_service.h"
  36 #include "chrome/browser/extensions/extension_test_message_listener.h"
  37 #include "chrome/browser/profiles/profile_impl.h"
  38 #include "chrome/browser/profiles/profiles_state.h"
  39 #include "chrome/browser/ui/webui/chromeos/login/kiosk_app_menu_handler.h"
  40 #include "chrome/common/chrome_constants.h"
  41 #include "chrome/common/chrome_paths.h"
  42 #include "chrome/common/pref_names.h"
  43 #include "chromeos/chromeos_switches.h"
  44 #include "chromeos/dbus/cryptohome_client.h"
  45 #include "components/signin/core/common/signin_pref_names.h"
  46 #include "content/public/browser/notification_observer.h"
  47 #include "content/public/browser/notification_registrar.h"
  48 #include "content/public/browser/notification_service.h"
  49 #include "content/public/test/browser_test_utils.h"
  50 #include "extensions/browser/extension_system.h"
  51 #include "google_apis/gaia/gaia_constants.h"
  52 #include "google_apis/gaia/gaia_switches.h"
  53 #include "google_apis/gaia/gaia_urls.h"
  54 #include "net/test/embedded_test_server/embedded_test_server.h"
  55
  56 namespace em = enterprise_management;
  57
  58 namespace chromeos {
  59
  60 namespace {
  61
  62 // This is a simple test app that creates an app window and immediately closes
  63 // it again. Webstore data json is in
  64 //   chrome/test/data/chromeos/app_mode/webstore/inlineinstall/
  65 //       detail/ggbflgnkafappblpkiflbgpmkfdpnhhe
  66 const char kTestKioskApp[] = "ggbflgnkafappblpkiflbgpmkfdpnhhe";
  67
  68 // This app creates a window and declares usage of the identity API in its
  69 // manifest, so we can test device robot token minting via the identity API.
  70 // Webstore data json is in
  71 //   chrome/test/data/chromeos/app_mode/webstore/inlineinstall/
  72 //       detail/ibjkkfdnfcaoapcpheeijckmpcfkifob
  73 const char kTestEnterpriseKioskApp[] = "ibjkkfdnfcaoapcpheeijckmpcfkifob";
  74
  75 // An offline enable test app. Webstore data json is in
  76 //   chrome/test/data/chromeos/app_mode/webstore/inlineinstall/
  77 //       detail/ajoggoflpgplnnjkjamcmbepjdjdnpdp
  78 // An app profile with version 1.0.0 installed is in
  79 //   chrome/test/data/chromeos/app_mode/offline_enabled_app_profile
  80 // The version 2.0.0 crx is in
  81 //   chrome/test/data/chromeos/app_mode/webstore/downloads/
  82 const char kTestOfflineEnabledKioskApp[] = "ajoggoflpgplnnjkjamcmbepjdjdnpdp";
  83
  84 // An app to test local fs data persistence across app update. V1 app writes
  85 // data into local fs. V2 app reads and verifies the data.
  86 // Webstore data json is in
  87 //   chrome/test/data/chromeos/app_mode/webstore/inlineinstall/
  88 //       detail/bmbpicmpniaclbbpdkfglgipkkebnbjf
  89 const char kTestLocalFsKioskApp[] = "bmbpicmpniaclbbpdkfglgipkkebnbjf";
  90
  91 // Timeout while waiting for network connectivity during tests.
  92 const int kTestNetworkTimeoutSeconds = 1;
  93
  94 // Email of owner account for test.
  95 const char kTestOwnerEmail[] = "owner@example.com";
  96
  97 const char kTestEnterpriseAccountId[] = "enterprise-kiosk-app@localhost";
  98 const char kTestEnterpriseServiceAccountId[] = "service_account@example.com";
  99 const char kTestRefreshToken[] = "fake-refresh-token";
 100 const char kTestUserinfoToken[] = "fake-userinfo-token";
 101 const char kTestLoginToken[] = "fake-login-token";
 102 const char kTestAccessToken[] = "fake-access-token";
 103 const char kTestClientId[] = "fake-client-id";
 104 const char kTestAppScope[] =
 105     "https://www.googleapis.com/auth/userinfo.profile";
 106
 107 // Test JS API.
 108 const char kLaunchAppForTestNewAPI[] =
 109     "login.AccountPickerScreen.runAppForTesting";
 110 const char kLaunchAppForTestOldAPI[] =
 111     "login.AppsMenuButton.runAppForTesting";
 112 const char kCheckDiagnosticModeNewAPI[] =
 113     "$('oobe').confirmDiagnosticMode_";
 114 const char kCheckDiagnosticModeOldAPI[] =
 115     "$('show-apps-button').confirmDiagnosticMode_";
 116
 117 // Helper function for GetConsumerKioskAutoLaunchStatusCallback.
 118 void ConsumerKioskAutoLaunchStatusCheck(
 119     KioskAppManager::ConsumerKioskAutoLaunchStatus* out_status,
 120     const base::Closure& runner_quit_task,
 121     KioskAppManager::ConsumerKioskAutoLaunchStatus in_status) {
 122   LOG(INFO) << "KioskAppManager::ConsumerKioskModeStatus = " << in_status;
 123   *out_status = in_status;
 124   runner_quit_task.Run();
 125 }
 126
 127 // Helper KioskAppManager::EnableKioskModeCallback implementation.
 128 void ConsumerKioskModeAutoStartLockCheck(
 129     bool* out_locked,
 130     const base::Closure& runner_quit_task,
 131     bool in_locked) {
 132   LOG(INFO) << "kiosk locked  = " << in_locked;
 133   *out_locked = in_locked;
 134   runner_quit_task.Run();
 135 }
 136
 137 // Helper function for WaitForNetworkTimeOut.
 138 void OnNetworkWaitTimedOut(const base::Closure& runner_quit_task) {
 139   runner_quit_task.Run();
 140 }
 141
 142 // Helper functions for CanConfigureNetwork mock.
 143 class ScopedCanConfigureNetwork {
 144  public:
 145   ScopedCanConfigureNetwork(bool can_configure, bool needs_owner_auth)
 146       : can_configure_(can_configure),
 147         needs_owner_auth_(needs_owner_auth),
 148         can_configure_network_callback_(
 149             base::Bind(&ScopedCanConfigureNetwork::CanConfigureNetwork,
 150                        base::Unretained(this))),
 151         needs_owner_auth_callback_(base::Bind(
 152             &ScopedCanConfigureNetwork::NeedsOwnerAuthToConfigureNetwork,
 153             base::Unretained(this))) {
 154     AppLaunchController::SetCanConfigureNetworkCallbackForTesting(
 155         &can_configure_network_callback_);
 156     AppLaunchController::SetNeedOwnerAuthToConfigureNetworkCallbackForTesting(
 157         &needs_owner_auth_callback_);
 158   }
 159   ~ScopedCanConfigureNetwork() {
 160     AppLaunchController::SetCanConfigureNetworkCallbackForTesting(NULL);
 161     AppLaunchController::SetNeedOwnerAuthToConfigureNetworkCallbackForTesting(
 162         NULL);
 163   }
 164
 165   bool CanConfigureNetwork() {
 166     return can_configure_;
 167   }
 168
 169   bool NeedsOwnerAuthToConfigureNetwork() {
 170     return needs_owner_auth_;
 171   }
 172
 173  private:
 174   bool can_configure_;
 175   bool needs_owner_auth_;
 176   AppLaunchController::ReturnBoolCallback can_configure_network_callback_;
 177   AppLaunchController::ReturnBoolCallback needs_owner_auth_callback_;
 178   DISALLOW_COPY_AND_ASSIGN(ScopedCanConfigureNetwork);
 179 };
 180
 181 // Helper class to wait until a js condition becomes true.
 182 class JsConditionWaiter {
 183  public:
 184   JsConditionWaiter(content::WebContents* web_contents,
 185                     const std::string& js)
 186       : web_contents_(web_contents),
 187         js_(js) {
 188   }
 189
 190   void Wait() {
 191     if (CheckJs())
 192       return;
 193
 194     base::RepeatingTimer<JsConditionWaiter> check_timer;
 195     check_timer.Start(
 196         FROM_HERE,
 197         base::TimeDelta::FromMilliseconds(10),
 198         this,
 199         &JsConditionWaiter::OnTimer);
 200
 201     runner_ = new content::MessageLoopRunner;
 202     runner_->Run();
 203   }
 204
 205  private:
 206   bool CheckJs() {
 207     bool result;
 208     CHECK(content::ExecuteScriptAndExtractBool(
 209         web_contents_,
 210         "window.domAutomationController.send(!!(" + js_ + "));",
 211         &result));
 212     return result;
 213   }
 214
 215   void OnTimer() {
 216     DCHECK(runner_);
 217     if (CheckJs())
 218       runner_->Quit();
 219   }
 220
 221   content::WebContents* web_contents_;
 222   const std::string js_;
 223   scoped_refptr<content::MessageLoopRunner> runner_;
 224
 225   DISALLOW_COPY_AND_ASSIGN(JsConditionWaiter);
 226 };
 227
 228 }  // namespace
 229
 230 class KioskTest : public OobeBaseTest {
 231  public:
 232   KioskTest() : fake_cws_(new FakeCWS) {
 233     set_exit_when_last_browser_closes(false);
 234   }
 235
 236   virtual ~KioskTest() {}
 237
 238  protected:
 239   virtual void SetUp() OVERRIDE {
 240     test_app_id_ = kTestKioskApp;
 241     set_test_app_version("1.0.0");
 242     set_test_crx_file(test_app_id() + ".crx");
 243     needs_background_networking_ = true;
 244     mock_user_manager_.reset(new MockUserManager);
 245     ProfileHelper::SetAlwaysReturnPrimaryUserForTesting(true);
 246     AppLaunchController::SkipSplashWaitForTesting();
 247     AppLaunchController::SetNetworkWaitForTesting(kTestNetworkTimeoutSeconds);
 248
 249     OobeBaseTest::SetUp();
 250   }
 251
 252   virtual void TearDown() OVERRIDE {
 253     ProfileHelper::SetAlwaysReturnPrimaryUserForTesting(false);
 254     OobeBaseTest::TearDown();
 255   }
 256
 257   virtual void SetUpOnMainThread() OVERRIDE {
 258     OobeBaseTest::SetUpOnMainThread();
 259     // Needed to avoid showing Gaia screen instead of owner signin for
 260     // consumer network down test cases.
 261     StartupUtils::MarkDeviceRegistered(base::Closure());
 262   }
 263
 264   virtual void TearDownOnMainThread() OVERRIDE {
 265     AppLaunchController::SetNetworkTimeoutCallbackForTesting(NULL);
 266     AppLaunchSigninScreen::SetUserManagerForTesting(NULL);
 267
 268     OobeBaseTest::TearDownOnMainThread();
 269
 270     // Clean up while main thread still runs.
 271     // See http://crbug.com/176659.
 272     KioskAppManager::Get()->CleanUp();
 273   }
 274
 275   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
 276     OobeBaseTest::SetUpCommandLine(command_line);
 277     fake_cws_->Init(embedded_test_server());
 278   }
 279
 280   void LaunchApp(const std::string& app_id, bool diagnostic_mode) {
 281     bool new_kiosk_ui = KioskAppMenuHandler::EnableNewKioskUI();
 282     GetLoginUI()->CallJavascriptFunction(new_kiosk_ui ?
 283         kLaunchAppForTestNewAPI : kLaunchAppForTestOldAPI,
 284         base::StringValue(app_id),
 285         base::FundamentalValue(diagnostic_mode));
 286   }
 287
 288   void ReloadKioskApps() {
 289     SetupTestAppUpdateCheck();
 290
 291     // Remove then add to ensure NOTIFICATION_KIOSK_APPS_LOADED fires.
 292     KioskAppManager::Get()->RemoveApp(test_app_id_);
 293     KioskAppManager::Get()->AddApp(test_app_id_);
 294   }
 295
 296   void FireKioskAppSettingsChanged() {
 297     KioskAppManager::Get()->UpdateAppData();
 298   }
 299
 300   void SetupTestAppUpdateCheck() {
 301     if (!test_app_version().empty()) {
 302       fake_cws_->SetUpdateCrx(
 303           test_app_id(), test_crx_file(), test_app_version());
 304     }
 305   }
 306
 307   void ReloadAutolaunchKioskApps() {
 308     SetupTestAppUpdateCheck();
 309
 310     KioskAppManager::Get()->AddApp(test_app_id_);
 311     KioskAppManager::Get()->SetAutoLaunchApp(test_app_id_);
 312   }
 313
 314   void StartUIForAppLaunch() {
 315     EnableConsumerKioskMode();
 316
 317     // Start UI
 318     chromeos::WizardController::SkipPostLoginScreensForTesting();
 319     chromeos::WizardController* wizard_controller =
 320         chromeos::WizardController::default_controller();
 321     if (wizard_controller) {
 322       wizard_controller->SkipToLoginForTesting(LoginScreenContext());
 323       OobeScreenWaiter(OobeDisplay::SCREEN_GAIA_SIGNIN).Wait();
 324     } else {
 325       // No wizard and running with an existing profile and it should land
 326       // on account picker when new kiosk UI is enabled. Otherwise, just
 327       // wait for the login signal from Gaia.
 328       if (KioskAppMenuHandler::EnableNewKioskUI())
 329         OobeScreenWaiter(OobeDisplay::SCREEN_ACCOUNT_PICKER).Wait();
 330       else
 331         OobeScreenWaiter(OobeDisplay::SCREEN_GAIA_SIGNIN).Wait();
 332     }
 333   }
 334
 335   void PrepareAppLaunch() {
 336     // Start UI
 337     StartUIForAppLaunch();
 338
 339     // Wait for the Kiosk App configuration to reload.
 340     content::WindowedNotificationObserver apps_loaded_signal(
 341         chrome::NOTIFICATION_KIOSK_APPS_LOADED,
 342         content::NotificationService::AllSources());
 343     ReloadKioskApps();
 344     apps_loaded_signal.Wait();
 345   }
 346
 347   void StartAppLaunchFromLoginScreen(const base::Closure& network_setup_cb) {
 348     PrepareAppLaunch();
 349
 350     if (!network_setup_cb.is_null())
 351       network_setup_cb.Run();
 352
 353     LaunchApp(test_app_id(), false);
 354   }
 355
 356   const extensions::Extension* GetInstalledApp() {
 357     Profile* app_profile = ProfileManager::GetPrimaryUserProfile();
 358     return extensions::ExtensionSystem::Get(app_profile)->
 359         extension_service()->GetInstalledExtension(test_app_id_);
 360   }
 361
 362   const Version& GetInstalledAppVersion() {
 363     return *GetInstalledApp()->version();
 364   }
 365
 366   void WaitForAppLaunchSuccess() {
 367     ExtensionTestMessageListener
 368         launch_data_check_listener("launchData.isKioskSession = true", false);
 369
 370     // Wait for the Kiosk App to launch.
 371     content::WindowedNotificationObserver(
 372         chrome::NOTIFICATION_KIOSK_APP_LAUNCHED,
 373         content::NotificationService::AllSources()).Wait();
 374
 375     // Default profile switches to app profile after app is launched.
 376     Profile* app_profile = ProfileManager::GetPrimaryUserProfile();
 377     ASSERT_TRUE(app_profile);
 378
 379     // Check ChromeOS preference is initialized.
 380     EXPECT_TRUE(
 381         static_cast<ProfileImpl*>(app_profile)->chromeos_preferences_);
 382
 383     // Check installer status.
 384     EXPECT_EQ(chromeos::KioskAppLaunchError::NONE,
 385               chromeos::KioskAppLaunchError::Get());
 386
 387     // Check if the kiosk webapp is really installed for the default profile.
 388     const extensions::Extension* app =
 389         extensions::ExtensionSystem::Get(app_profile)->
 390         extension_service()->GetInstalledExtension(test_app_id_);
 391     EXPECT_TRUE(app);
 392
 393     // App should appear with its window.
 394     apps::AppWindowRegistry* app_window_registry =
 395         apps::AppWindowRegistry::Get(app_profile);
 396     apps::AppWindow* window =
 397         AppWindowWaiter(app_window_registry, test_app_id_).Wait();
 398     EXPECT_TRUE(window);
 399
 400     // Login screen should be gone or fading out.
 401     chromeos::LoginDisplayHost* login_display_host =
 402         chromeos::LoginDisplayHostImpl::default_host();
 403     EXPECT_TRUE(
 404         login_display_host == NULL ||
 405         login_display_host->GetNativeWindow()->layer()->GetTargetOpacity() ==
 406             0.0f);
 407
 408     // Wait until the app terminates if it is still running.
 409     if (!app_window_registry->GetAppWindowsForApp(test_app_id_).empty())
 410       content::RunMessageLoop();
 411
 412     // Check that the app had been informed that it is running in a kiosk
 413     // session.
 414     EXPECT_TRUE(launch_data_check_listener.was_satisfied());
 415   }
 416
 417   void WaitForAppLaunchNetworkTimeout() {
 418     if (GetAppLaunchController()->network_wait_timedout())
 419       return;
 420
 421     scoped_refptr<content::MessageLoopRunner> runner =
 422         new content::MessageLoopRunner;
 423
 424     base::Closure callback = base::Bind(
 425         &OnNetworkWaitTimedOut, runner->QuitClosure());
 426     AppLaunchController::SetNetworkTimeoutCallbackForTesting(&callback);
 427
 428     runner->Run();
 429
 430     CHECK(GetAppLaunchController()->network_wait_timedout());
 431     AppLaunchController::SetNetworkTimeoutCallbackForTesting(NULL);
 432   }
 433
 434   void EnableConsumerKioskMode() {
 435     scoped_ptr<bool> locked(new bool(false));
 436     scoped_refptr<content::MessageLoopRunner> runner =
 437         new content::MessageLoopRunner;
 438     KioskAppManager::Get()->EnableConsumerKioskAutoLaunch(
 439         base::Bind(&ConsumerKioskModeAutoStartLockCheck,
 440                    locked.get(),
 441                    runner->QuitClosure()));
 442     runner->Run();
 443     EXPECT_TRUE(*locked.get());
 444   }
 445
 446   KioskAppManager::ConsumerKioskAutoLaunchStatus
 447   GetConsumerKioskModeStatus() {
 448     KioskAppManager::ConsumerKioskAutoLaunchStatus status =
 449         static_cast<KioskAppManager::ConsumerKioskAutoLaunchStatus>(-1);
 450     scoped_refptr<content::MessageLoopRunner> runner =
 451         new content::MessageLoopRunner;
 452     KioskAppManager::Get()->GetConsumerKioskAutoLaunchStatus(
 453         base::Bind(&ConsumerKioskAutoLaunchStatusCheck,
 454                    &status,
 455                    runner->QuitClosure()));
 456     runner->Run();
 457     CHECK_NE(status,
 458              static_cast<KioskAppManager::ConsumerKioskAutoLaunchStatus>(-1));
 459     return status;
 460   }
 461
 462   void RunAppLaunchNetworkDownTest() {
 463     mock_user_manager()->SetActiveUser(kTestOwnerEmail);
 464     AppLaunchSigninScreen::SetUserManagerForTesting(mock_user_manager());
 465
 466     // Mock network could be configured with owner's password.
 467     ScopedCanConfigureNetwork can_configure_network(true, true);
 468
 469     // Start app launch and wait for network connectivity timeout.
 470     StartAppLaunchFromLoginScreen(SimulateNetworkOfflineClosure());
 471     OobeScreenWaiter splash_waiter(OobeDisplay::SCREEN_APP_LAUNCH_SPLASH);
 472     splash_waiter.Wait();
 473     WaitForAppLaunchNetworkTimeout();
 474
 475     // Configure network link should be visible.
 476     JsExpect("$('splash-config-network').hidden == false");
 477
 478     // Set up fake user manager with an owner for the test.
 479     static_cast<LoginDisplayHostImpl*>(LoginDisplayHostImpl::default_host())
 480         ->GetOobeUI()->ShowOobeUI(false);
 481
 482     // Configure network should bring up lock screen for owner.
 483     OobeScreenWaiter lock_screen_waiter(OobeDisplay::SCREEN_ACCOUNT_PICKER);
 484     static_cast<AppLaunchSplashScreenActor::Delegate*>(GetAppLaunchController())
 485         ->OnConfigureNetwork();
 486     lock_screen_waiter.Wait();
 487
 488     // There should be only one owner pod on this screen.
 489     JsExpect("$('pod-row').alwaysFocusSinglePod");
 490
 491     // A network error screen should be shown after authenticating.
 492     OobeScreenWaiter error_screen_waiter(OobeDisplay::SCREEN_ERROR_MESSAGE);
 493     static_cast<AppLaunchSigninScreen::Delegate*>(GetAppLaunchController())
 494         ->OnOwnerSigninSuccess();
 495     error_screen_waiter.Wait();
 496
 497     ASSERT_TRUE(GetAppLaunchController()->showing_network_dialog());
 498
 499     SimulateNetworkOnline();
 500     WaitForAppLaunchSuccess();
 501   }
 502
 503   AppLaunchController* GetAppLaunchController() {
 504     return chromeos::LoginDisplayHostImpl::default_host()
 505         ->GetAppLaunchController();
 506   }
 507
 508   MockUserManager* mock_user_manager() { return mock_user_manager_.get(); }
 509
 510   void set_test_app_id(const std::string& test_app_id) {
 511     test_app_id_ = test_app_id;
 512   }
 513   const std::string& test_app_id() const { return test_app_id_; }
 514   void set_test_app_version(const std::string& version) {
 515     test_app_version_ = version;
 516   }
 517   const std::string& test_app_version() const { return test_app_version_; }
 518   void set_test_crx_file(const std::string& filename) {
 519     test_crx_file_ = filename;
 520   }
 521   const std::string& test_crx_file() const { return test_crx_file_; }
 522   FakeCWS* fake_cws() { return fake_cws_.get(); }
 523
 524  private:
 525   std::string test_app_id_;
 526   std::string test_app_version_;
 527   std::string test_crx_file_;
 528   scoped_ptr<FakeCWS> fake_cws_;
 529   scoped_ptr<MockUserManager> mock_user_manager_;
 530
 531   DISALLOW_COPY_AND_ASSIGN(KioskTest);
 532 };
 533
 534 IN_PROC_BROWSER_TEST_F(KioskTest, InstallAndLaunchApp) {
 535   StartAppLaunchFromLoginScreen(SimulateNetworkOnlineClosure());
 536   WaitForAppLaunchSuccess();
 537 }
 538
 539 IN_PROC_BROWSER_TEST_F(KioskTest, NotSignedInWithGAIAAccount) {
 540   // Tests that the kiosk session is not considered to be logged in with a GAIA
 541   // account.
 542   StartAppLaunchFromLoginScreen(SimulateNetworkOnlineClosure());
 543   WaitForAppLaunchSuccess();
 544
 545   Profile* app_profile = ProfileManager::GetPrimaryUserProfile();
 546   ASSERT_TRUE(app_profile);
 547   EXPECT_FALSE(app_profile->GetPrefs()->HasPrefPath(
 548       prefs::kGoogleServicesUsername));
 549 }
 550
 551 IN_PROC_BROWSER_TEST_F(KioskTest, PRE_LaunchAppNetworkDown) {
 552   // Tests the network down case for the initial app download and launch.
 553   RunAppLaunchNetworkDownTest();
 554 }
 555
 556 IN_PROC_BROWSER_TEST_F(KioskTest, LaunchAppNetworkDown) {
 557   // Tests the network down case for launching an existing app that is
 558   // installed in PRE_LaunchAppNetworkDown.
 559   RunAppLaunchNetworkDownTest();
 560 }
 561
 562 // TODO(zelidrag): Figure out why this test is flaky on bbots.
 563 IN_PROC_BROWSER_TEST_F(KioskTest,
 564                        DISABLED_LaunchAppWithNetworkConfigAccelerator) {
 565   ScopedCanConfigureNetwork can_configure_network(true, false);
 566
 567   // Start app launch and wait for network connectivity timeout.
 568   StartAppLaunchFromLoginScreen(SimulateNetworkOnlineClosure());
 569   OobeScreenWaiter splash_waiter(OobeDisplay::SCREEN_APP_LAUNCH_SPLASH);
 570   splash_waiter.Wait();
 571
 572   // A network error screen should be shown after authenticating.
 573   OobeScreenWaiter error_screen_waiter(OobeDisplay::SCREEN_ERROR_MESSAGE);
 574   // Simulate Ctrl+Alt+N accelerator.
 575   GetLoginUI()->CallJavascriptFunction(
 576       "cr.ui.Oobe.handleAccelerator",
 577       base::StringValue("app_launch_network_config"));
 578   error_screen_waiter.Wait();
 579   ASSERT_TRUE(GetAppLaunchController()->showing_network_dialog());
 580
 581   // Continue button should be visible since we are online.
 582   JsExpect("$('continue-network-config-btn').hidden == false");
 583
 584   // Click on [Continue] button.
 585   ASSERT_TRUE(content::ExecuteScript(
 586       GetLoginUI()->GetWebContents(),
 587       "(function() {"
 588       "var e = new Event('click');"
 589       "$('continue-network-config-btn').dispatchEvent(e);"
 590       "})();"));
 591
 592   WaitForAppLaunchSuccess();
 593 }
 594
 595 IN_PROC_BROWSER_TEST_F(KioskTest, LaunchAppNetworkDownConfigureNotAllowed) {
 596   // Mock network could not be configured.
 597   ScopedCanConfigureNetwork can_configure_network(false, true);
 598
 599   // Start app launch and wait for network connectivity timeout.
 600   StartAppLaunchFromLoginScreen(SimulateNetworkOfflineClosure());
 601   OobeScreenWaiter splash_waiter(OobeDisplay::SCREEN_APP_LAUNCH_SPLASH);
 602   splash_waiter.Wait();
 603   WaitForAppLaunchNetworkTimeout();
 604
 605   // Configure network link should not be visible.
 606   JsExpect("$('splash-config-network').hidden == true");
 607
 608   // Network becomes online and app launch is resumed.
 609   SimulateNetworkOnline();
 610   WaitForAppLaunchSuccess();
 611 }
 612
 613 IN_PROC_BROWSER_TEST_F(KioskTest, LaunchAppNetworkPortal) {
 614   // Mock network could be configured without the owner password.
 615   ScopedCanConfigureNetwork can_configure_network(true, false);
 616
 617   // Start app launch with network portal state.
 618   StartAppLaunchFromLoginScreen(SimulateNetworkPortalClosure());
 619   OobeScreenWaiter(OobeDisplay::SCREEN_APP_LAUNCH_SPLASH)
 620       .WaitNoAssertCurrentScreen();
 621   WaitForAppLaunchNetworkTimeout();
 622
 623   // Network error should show up automatically since this test does not
 624   // require owner auth to configure network.
 625   OobeScreenWaiter(OobeDisplay::SCREEN_ERROR_MESSAGE).Wait();
 626
 627   ASSERT_TRUE(GetAppLaunchController()->showing_network_dialog());
 628   SimulateNetworkOnline();
 629   WaitForAppLaunchSuccess();
 630 }
 631
 632 IN_PROC_BROWSER_TEST_F(KioskTest, LaunchAppUserCancel) {
 633   // Make fake_cws_ return empty update response.
 634   set_test_app_version("");
 635   StartAppLaunchFromLoginScreen(SimulateNetworkOfflineClosure());
 636   OobeScreenWaiter splash_waiter(OobeDisplay::SCREEN_APP_LAUNCH_SPLASH);
 637   splash_waiter.Wait();
 638
 639   CrosSettings::Get()->SetBoolean(
 640       kAccountsPrefDeviceLocalAccountAutoLoginBailoutEnabled, true);
 641   content::WindowedNotificationObserver signal(
 642       chrome::NOTIFICATION_APP_TERMINATING,
 643       content::NotificationService::AllSources());
 644   GetLoginUI()->CallJavascriptFunction("cr.ui.Oobe.handleAccelerator",
 645                                        base::StringValue("app_launch_bailout"));
 646   signal.Wait();
 647   EXPECT_EQ(chromeos::KioskAppLaunchError::USER_CANCEL,
 648             chromeos::KioskAppLaunchError::Get());
 649 }
 650
 651 IN_PROC_BROWSER_TEST_F(KioskTest, LaunchInDiagnosticMode) {
 652   PrepareAppLaunch();
 653   SimulateNetworkOnline();
 654
 655   LaunchApp(kTestKioskApp, true);
 656
 657   content::WebContents* login_contents = GetLoginUI()->GetWebContents();
 658
 659   bool new_kiosk_ui = KioskAppMenuHandler::EnableNewKioskUI();
 660   JsConditionWaiter(login_contents, new_kiosk_ui ?
 661       kCheckDiagnosticModeNewAPI : kCheckDiagnosticModeOldAPI).Wait();
 662
 663   std::string diagnosticMode(new_kiosk_ui ?
 664       kCheckDiagnosticModeNewAPI : kCheckDiagnosticModeOldAPI);
 665   ASSERT_TRUE(content::ExecuteScript(
 666       login_contents,
 667       "(function() {"
 668          "var e = new Event('click');" +
 669          diagnosticMode + "."
 670              "okButton_.dispatchEvent(e);"
 671       "})();"));
 672
 673   WaitForAppLaunchSuccess();
 674 }
 675
 676 IN_PROC_BROWSER_TEST_F(KioskTest, AutolaunchWarningCancel) {
 677   EnableConsumerKioskMode();
 678
 679   chromeos::WizardController::SkipPostLoginScreensForTesting();
 680   chromeos::WizardController* wizard_controller =
 681       chromeos::WizardController::default_controller();
 682   CHECK(wizard_controller);
 683
 684   // Start login screen after configuring auto launch app since the warning
 685   // is triggered when switching to login screen.
 686   wizard_controller->AdvanceToScreen(WizardController::kNetworkScreenName);
 687   ReloadAutolaunchKioskApps();
 688   EXPECT_FALSE(KioskAppManager::Get()->GetAutoLaunchApp().empty());
 689   EXPECT_FALSE(KioskAppManager::Get()->IsAutoLaunchEnabled());
 690   wizard_controller->SkipToLoginForTesting(LoginScreenContext());
 691
 692   // Wait for the auto launch warning come up.
 693   content::WindowedNotificationObserver(
 694       chrome::NOTIFICATION_KIOSK_AUTOLAUNCH_WARNING_VISIBLE,
 695       content::NotificationService::AllSources()).Wait();
 696   GetLoginUI()->CallJavascriptFunction(
 697       "login.AutolaunchScreen.confirmAutoLaunchForTesting",
 698       base::FundamentalValue(false));
 699
 700   // Wait for the auto launch warning to go away.
 701   content::WindowedNotificationObserver(
 702       chrome::NOTIFICATION_KIOSK_AUTOLAUNCH_WARNING_COMPLETED,
 703       content::NotificationService::AllSources()).Wait();
 704
 705   EXPECT_FALSE(KioskAppManager::Get()->IsAutoLaunchEnabled());
 706 }
 707
 708 IN_PROC_BROWSER_TEST_F(KioskTest, AutolaunchWarningConfirm) {
 709   EnableConsumerKioskMode();
 710
 711   chromeos::WizardController::SkipPostLoginScreensForTesting();
 712   chromeos::WizardController* wizard_controller =
 713       chromeos::WizardController::default_controller();
 714   CHECK(wizard_controller);
 715
 716   // Start login screen after configuring auto launch app since the warning
 717   // is triggered when switching to login screen.
 718   wizard_controller->AdvanceToScreen(WizardController::kNetworkScreenName);
 719   ReloadAutolaunchKioskApps();
 720   EXPECT_FALSE(KioskAppManager::Get()->GetAutoLaunchApp().empty());
 721   EXPECT_FALSE(KioskAppManager::Get()->IsAutoLaunchEnabled());
 722   wizard_controller->SkipToLoginForTesting(LoginScreenContext());
 723
 724   // Wait for the auto launch warning come up.
 725   content::WindowedNotificationObserver(
 726       chrome::NOTIFICATION_KIOSK_AUTOLAUNCH_WARNING_VISIBLE,
 727       content::NotificationService::AllSources()).Wait();
 728   GetLoginUI()->CallJavascriptFunction(
 729       "login.AutolaunchScreen.confirmAutoLaunchForTesting",
 730       base::FundamentalValue(true));
 731
 732   // Wait for the auto launch warning to go away.
 733   content::WindowedNotificationObserver(
 734       chrome::NOTIFICATION_KIOSK_AUTOLAUNCH_WARNING_COMPLETED,
 735       content::NotificationService::AllSources()).Wait();
 736
 737   EXPECT_FALSE(KioskAppManager::Get()->GetAutoLaunchApp().empty());
 738   EXPECT_TRUE(KioskAppManager::Get()->IsAutoLaunchEnabled());
 739
 740   WaitForAppLaunchSuccess();
 741 }
 742
 743 IN_PROC_BROWSER_TEST_F(KioskTest, KioskEnableCancel) {
 744   chromeos::WizardController::SkipPostLoginScreensForTesting();
 745   chromeos::WizardController* wizard_controller =
 746       chromeos::WizardController::default_controller();
 747   CHECK(wizard_controller);
 748
 749   // Check Kiosk mode status.
 750   EXPECT_EQ(KioskAppManager::CONSUMER_KIOSK_AUTO_LAUNCH_CONFIGURABLE,
 751             GetConsumerKioskModeStatus());
 752
 753   // Wait for the login UI to come up and switch to the kiosk_enable screen.
 754   wizard_controller->SkipToLoginForTesting(LoginScreenContext());
 755   OobeScreenWaiter(OobeDisplay::SCREEN_GAIA_SIGNIN).Wait();
 756   GetLoginUI()->CallJavascriptFunction("cr.ui.Oobe.handleAccelerator",
 757                                        base::StringValue("kiosk_enable"));
 758
 759   // Wait for the kiosk_enable screen to show and cancel the screen.
 760   content::WindowedNotificationObserver(
 761       chrome::NOTIFICATION_KIOSK_ENABLE_WARNING_VISIBLE,
 762       content::NotificationService::AllSources()).Wait();
 763   GetLoginUI()->CallJavascriptFunction(
 764       "login.KioskEnableScreen.enableKioskForTesting",
 765       base::FundamentalValue(false));
 766
 767   // Wait for the kiosk_enable screen to disappear.
 768   content::WindowedNotificationObserver(
 769       chrome::NOTIFICATION_KIOSK_ENABLE_WARNING_COMPLETED,
 770       content::NotificationService::AllSources()).Wait();
 771
 772   // Check that the status still says configurable.
 773   EXPECT_EQ(KioskAppManager::CONSUMER_KIOSK_AUTO_LAUNCH_CONFIGURABLE,
 774             GetConsumerKioskModeStatus());
 775 }
 776
 777 IN_PROC_BROWSER_TEST_F(KioskTest, KioskEnableConfirmed) {
 778   // Start UI, find menu entry for this app and launch it.
 779   chromeos::WizardController::SkipPostLoginScreensForTesting();
 780   chromeos::WizardController* wizard_controller =
 781       chromeos::WizardController::default_controller();
 782   CHECK(wizard_controller);
 783
 784   // Check Kiosk mode status.
 785   EXPECT_EQ(KioskAppManager::CONSUMER_KIOSK_AUTO_LAUNCH_CONFIGURABLE,
 786             GetConsumerKioskModeStatus());
 787
 788   // Wait for the login UI to come up and switch to the kiosk_enable screen.
 789   wizard_controller->SkipToLoginForTesting(LoginScreenContext());
 790   OobeScreenWaiter(OobeDisplay::SCREEN_GAIA_SIGNIN).Wait();
 791   GetLoginUI()->CallJavascriptFunction("cr.ui.Oobe.handleAccelerator",
 792                                        base::StringValue("kiosk_enable"));
 793
 794   // Wait for the kiosk_enable screen to show and cancel the screen.
 795   content::WindowedNotificationObserver(
 796       chrome::NOTIFICATION_KIOSK_ENABLE_WARNING_VISIBLE,
 797       content::NotificationService::AllSources()).Wait();
 798   GetLoginUI()->CallJavascriptFunction(
 799       "login.KioskEnableScreen.enableKioskForTesting",
 800       base::FundamentalValue(true));
 801
 802   // Wait for the signal that indicates Kiosk Mode is enabled.
 803   content::WindowedNotificationObserver(
 804       chrome::NOTIFICATION_KIOSK_ENABLED,
 805       content::NotificationService::AllSources()).Wait();
 806   EXPECT_EQ(KioskAppManager::CONSUMER_KIOSK_AUTO_LAUNCH_ENABLED,
 807             GetConsumerKioskModeStatus());
 808 }
 809
 810 IN_PROC_BROWSER_TEST_F(KioskTest, KioskEnableAbortedWithAutoEnrollment) {
 811   // Fake an auto enrollment is going to be enforced.
 812   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
 813       switches::kEnterpriseEnrollmentInitialModulus, "1");
 814   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
 815       switches::kEnterpriseEnrollmentModulusLimit, "2");
 816   g_browser_process->local_state()->SetBoolean(prefs::kShouldAutoEnroll, true);
 817   g_browser_process->local_state()->SetInteger(
 818       prefs::kAutoEnrollmentPowerLimit, 3);
 819
 820   // Start UI, find menu entry for this app and launch it.
 821   chromeos::WizardController::SkipPostLoginScreensForTesting();
 822   chromeos::WizardController* wizard_controller =
 823       chromeos::WizardController::default_controller();
 824   CHECK(wizard_controller);
 825
 826   // Check Kiosk mode status.
 827   EXPECT_EQ(KioskAppManager::CONSUMER_KIOSK_AUTO_LAUNCH_CONFIGURABLE,
 828             GetConsumerKioskModeStatus());
 829
 830   // Wait for the login UI to come up and switch to the kiosk_enable screen.
 831   wizard_controller->SkipToLoginForTesting(LoginScreenContext());
 832   OobeScreenWaiter(OobeDisplay::SCREEN_GAIA_SIGNIN).Wait();
 833   GetLoginUI()->CallJavascriptFunction("cr.ui.Oobe.handleAccelerator",
 834                                        base::StringValue("kiosk_enable"));
 835
 836   // The flow should be aborted due to auto enrollment enforcement.
 837   scoped_refptr<content::MessageLoopRunner> runner =
 838       new content::MessageLoopRunner;
 839   GetSigninScreenHandler()->set_kiosk_enable_flow_aborted_callback_for_test(
 840       runner->QuitClosure());
 841   runner->Run();
 842 }
 843
 844 IN_PROC_BROWSER_TEST_F(KioskTest, KioskEnableAfter2ndSigninScreen) {
 845   chromeos::WizardController::SkipPostLoginScreensForTesting();
 846   chromeos::WizardController* wizard_controller =
 847       chromeos::WizardController::default_controller();
 848   CHECK(wizard_controller);
 849
 850   // Check Kiosk mode status.
 851   EXPECT_EQ(KioskAppManager::CONSUMER_KIOSK_AUTO_LAUNCH_CONFIGURABLE,
 852             GetConsumerKioskModeStatus());
 853
 854   // Wait for the login UI to come up and switch to the kiosk_enable screen.
 855   wizard_controller->SkipToLoginForTesting(LoginScreenContext());
 856   OobeScreenWaiter(OobeDisplay::SCREEN_GAIA_SIGNIN).Wait();
 857   GetLoginUI()->CallJavascriptFunction("cr.ui.Oobe.handleAccelerator",
 858                                        base::StringValue("kiosk_enable"));
 859
 860   // Wait for the kiosk_enable screen to show and cancel the screen.
 861   content::WindowedNotificationObserver(
 862       chrome::NOTIFICATION_KIOSK_ENABLE_WARNING_VISIBLE,
 863       content::NotificationService::AllSources()).Wait();
 864   GetLoginUI()->CallJavascriptFunction(
 865       "login.KioskEnableScreen.enableKioskForTesting",
 866       base::FundamentalValue(false));
 867
 868   // Wait for the kiosk_enable screen to disappear.
 869   content::WindowedNotificationObserver(
 870       chrome::NOTIFICATION_KIOSK_ENABLE_WARNING_COMPLETED,
 871       content::NotificationService::AllSources()).Wait();
 872
 873   // Show signin screen again.
 874   chromeos::LoginDisplayHostImpl::default_host()->StartSignInScreen(
 875       LoginScreenContext());
 876   OobeScreenWaiter(OobeDisplay::SCREEN_GAIA_SIGNIN).Wait();
 877
 878   // Show kiosk enable screen again.
 879   GetLoginUI()->CallJavascriptFunction("cr.ui.Oobe.handleAccelerator",
 880                                        base::StringValue("kiosk_enable"));
 881
 882   // And it should show up.
 883   content::WindowedNotificationObserver(
 884       chrome::NOTIFICATION_KIOSK_ENABLE_WARNING_VISIBLE,
 885       content::NotificationService::AllSources()).Wait();
 886 }
 887
 888 class KioskUpdateTest : public KioskTest {
 889  public:
 890   KioskUpdateTest() {}
 891   virtual ~KioskUpdateTest() {}
 892
 893  protected:
 894   virtual void SetUpOnMainThread() OVERRIDE {
 895     KioskTest::SetUpOnMainThread();
 896   }
 897
 898   void PreCacheApp(const std::string& app_id,
 899                    const std::string& version,
 900                    const std::string& crx_file) {
 901     set_test_app_id(app_id);
 902     set_test_app_version(version);
 903     set_test_crx_file(crx_file);
 904
 905     KioskAppManager* manager = KioskAppManager::Get();
 906     AppDataLoadWaiter waiter(manager, app_id, version);
 907     ReloadKioskApps();
 908     waiter.Wait();
 909     EXPECT_TRUE(waiter.loaded());
 910     std::string cached_version;
 911     base::FilePath file_path;
 912     EXPECT_TRUE(manager->GetCachedCrx(app_id, &file_path, &cached_version));
 913     EXPECT_EQ(version, cached_version);
 914   }
 915
 916   void UpdateExternalCache(const std::string& version,
 917                            const std::string& crx_file) {
 918     set_test_app_version(version);
 919     set_test_crx_file(crx_file);
 920     SetupTestAppUpdateCheck();
 921
 922     KioskAppManager* manager = KioskAppManager::Get();
 923     AppDataLoadWaiter waiter(manager, test_app_id(), version);
 924     KioskAppManager::Get()->UpdateExternalCache();
 925     waiter.Wait();
 926     EXPECT_TRUE(waiter.loaded());
 927     std::string cached_version;
 928     base::FilePath file_path;
 929     EXPECT_TRUE(
 930         manager->GetCachedCrx(test_app_id(), &file_path, &cached_version));
 931     EXPECT_EQ(version, cached_version);
 932   }
 933
 934   void PreCacheAndLaunchApp(const std::string& app_id,
 935                             const std::string& version,
 936                             const std::string& crx_file) {
 937     set_test_app_id(app_id);
 938     set_test_app_version(version);
 939     set_test_crx_file(crx_file);
 940     PrepareAppLaunch();
 941     SimulateNetworkOnline();
 942     LaunchApp(test_app_id(), false);
 943     WaitForAppLaunchSuccess();
 944     EXPECT_EQ(version, GetInstalledAppVersion().GetString());
 945   }
 946
 947  private:
 948   class AppDataLoadWaiter : public KioskAppManagerObserver {
 949    public:
 950     AppDataLoadWaiter(KioskAppManager* manager,
 951                       const std::string& app_id,
 952                       const std::string& version)
 953         : runner_(NULL),
 954           manager_(manager),
 955           loaded_(false),
 956           quit_(false),
 957           app_id_(app_id),
 958           version_(version) {
 959       manager_->AddObserver(this);
 960     }
 961
 962     virtual ~AppDataLoadWaiter() { manager_->RemoveObserver(this); }
 963
 964     void Wait() {
 965       if (quit_)
 966         return;
 967       runner_ = new content::MessageLoopRunner;
 968       runner_->Run();
 969     }
 970
 971     bool loaded() const { return loaded_; }
 972
 973    private:
 974     // KioskAppManagerObserver overrides:
 975     virtual void OnKioskExtensionLoadedInCache(
 976         const std::string& app_id) OVERRIDE {
 977       std::string cached_version;
 978       base::FilePath file_path;
 979       if (!manager_->GetCachedCrx(app_id_, &file_path, &cached_version))
 980         return;
 981       if (version_ != cached_version)
 982         return;
 983       loaded_ = true;
 984       quit_ = true;
 985       if (runner_)
 986         runner_->Quit();
 987     }
 988
 989     virtual void OnKioskExtensionDownloadFailed(
 990         const std::string& app_id) OVERRIDE {
 991       loaded_ = false;
 992       quit_ = true;
 993       if (runner_)
 994         runner_->Quit();
 995     }
 996
 997     scoped_refptr<content::MessageLoopRunner> runner_;
 998     KioskAppManager* manager_;
 999     bool loaded_;
1000     bool quit_;
1001     std::string app_id_;
1002     std::string version_;
1003
1004     DISALLOW_COPY_AND_ASSIGN(AppDataLoadWaiter);
1005   };
1006
1007   DISALLOW_COPY_AND_ASSIGN(KioskUpdateTest);
1008 };
1009
1010 IN_PROC_BROWSER_TEST_F(KioskUpdateTest, PRE_LaunchOfflineEnabledAppNoNetwork) {
1011   PreCacheAndLaunchApp(kTestOfflineEnabledKioskApp,
1012                        "1.0.0",
1013                        std::string(kTestOfflineEnabledKioskApp) + "_v1.crx");
1014 }
1015
1016 IN_PROC_BROWSER_TEST_F(KioskUpdateTest, LaunchOfflineEnabledAppNoNetwork) {
1017   set_test_app_id(kTestOfflineEnabledKioskApp);
1018   StartUIForAppLaunch();
1019   SimulateNetworkOffline();
1020   LaunchApp(test_app_id(), false);
1021   WaitForAppLaunchSuccess();
1022
1023   EXPECT_EQ("1.0.0", GetInstalledAppVersion().GetString());
1024 }
1025
1026 IN_PROC_BROWSER_TEST_F(KioskUpdateTest,
1027                        PRE_LaunchCachedOfflineEnabledAppNoNetwork) {
1028   PreCacheApp(kTestOfflineEnabledKioskApp,
1029               "1.0.0",
1030               std::string(kTestOfflineEnabledKioskApp) + "_v1.crx");
1031 }
1032
1033 IN_PROC_BROWSER_TEST_F(KioskUpdateTest,
1034                        LaunchCachedOfflineEnabledAppNoNetwork) {
1035   set_test_app_id(kTestOfflineEnabledKioskApp);
1036   EXPECT_TRUE(
1037       KioskAppManager::Get()->HasCachedCrx(kTestOfflineEnabledKioskApp));
1038   StartUIForAppLaunch();
1039   SimulateNetworkOffline();
1040   LaunchApp(test_app_id(), false);
1041   WaitForAppLaunchSuccess();
1042
1043   EXPECT_EQ("1.0.0", GetInstalledAppVersion().GetString());
1044 }
1045
1046 // Network offline, app v1.0 has run before, has cached v2.0 crx and v2.0 should
1047 // be installed and launched during next launch.
1048 IN_PROC_BROWSER_TEST_F(KioskUpdateTest,
1049                        PRE_LaunchCachedNewVersionOfflineEnabledAppNoNetwork) {
1050   // Install and launch v1 app.
1051   PreCacheAndLaunchApp(kTestOfflineEnabledKioskApp,
1052                        "1.0.0",
1053                        std::string(kTestOfflineEnabledKioskApp) + "_v1.crx");
1054   // Update cache for v2 app.
1055   UpdateExternalCache("2.0.0",
1056                       std::string(kTestOfflineEnabledKioskApp) + ".crx");
1057   // The installed app is still in v1.
1058   EXPECT_EQ("1.0.0", GetInstalledAppVersion().GetString());
1059 }
1060
1061 IN_PROC_BROWSER_TEST_F(KioskUpdateTest,
1062                        LaunchCachedNewVersionOfflineEnabledAppNoNetwork) {
1063   set_test_app_id(kTestOfflineEnabledKioskApp);
1064   EXPECT_TRUE(KioskAppManager::Get()->HasCachedCrx(test_app_id()));
1065
1066   StartUIForAppLaunch();
1067   SimulateNetworkOffline();
1068   LaunchApp(test_app_id(), false);
1069   WaitForAppLaunchSuccess();
1070
1071   // v2 app should have been installed.
1072   EXPECT_EQ("2.0.0", GetInstalledAppVersion().GetString());
1073 }
1074
1075 IN_PROC_BROWSER_TEST_F(KioskUpdateTest, PRE_LaunchOfflineEnabledAppNoUpdate) {
1076   PreCacheAndLaunchApp(kTestOfflineEnabledKioskApp,
1077                        "1.0.0",
1078                        std::string(kTestOfflineEnabledKioskApp) + "_v1.crx");
1079 }
1080
1081 IN_PROC_BROWSER_TEST_F(KioskUpdateTest, LaunchOfflineEnabledAppNoUpdate) {
1082   set_test_app_id(kTestOfflineEnabledKioskApp);
1083   fake_cws()->SetNoUpdate(test_app_id());
1084
1085   StartUIForAppLaunch();
1086   SimulateNetworkOnline();
1087   LaunchApp(test_app_id(), false);
1088   WaitForAppLaunchSuccess();
1089
1090   EXPECT_EQ("1.0.0", GetInstalledAppVersion().GetString());
1091 }
1092
1093 IN_PROC_BROWSER_TEST_F(KioskUpdateTest, PRE_LaunchOfflineEnabledAppHasUpdate) {
1094   PreCacheAndLaunchApp(kTestOfflineEnabledKioskApp,
1095                        "1.0.0",
1096                        std::string(kTestOfflineEnabledKioskApp) + "_v1.crx");
1097 }
1098
1099 IN_PROC_BROWSER_TEST_F(KioskUpdateTest, LaunchOfflineEnabledAppHasUpdate) {
1100   set_test_app_id(kTestOfflineEnabledKioskApp);
1101   fake_cws()->SetUpdateCrx(
1102       test_app_id(), "ajoggoflpgplnnjkjamcmbepjdjdnpdp.crx", "2.0.0");
1103
1104   StartUIForAppLaunch();
1105   SimulateNetworkOnline();
1106   LaunchApp(test_app_id(), false);
1107   WaitForAppLaunchSuccess();
1108
1109   EXPECT_EQ("2.0.0", GetInstalledAppVersion().GetString());
1110 }
1111
1112 IN_PROC_BROWSER_TEST_F(KioskUpdateTest, PRE_PermissionChange) {
1113   PreCacheAndLaunchApp(kTestOfflineEnabledKioskApp,
1114                        "2.0.0",
1115                        std::string(kTestOfflineEnabledKioskApp) + ".crx");
1116 }
1117
1118 IN_PROC_BROWSER_TEST_F(KioskUpdateTest, PermissionChange) {
1119   set_test_app_id(kTestOfflineEnabledKioskApp);
1120   set_test_app_version("2.0.0");
1121   set_test_crx_file(test_app_id() + "_v2_permission_change.crx");
1122
1123   StartUIForAppLaunch();
1124   SimulateNetworkOnline();
1125   LaunchApp(test_app_id(), false);
1126   WaitForAppLaunchSuccess();
1127
1128   EXPECT_EQ("2.0.0", GetInstalledAppVersion().GetString());
1129 }
1130
1131 IN_PROC_BROWSER_TEST_F(KioskUpdateTest, PRE_PreserveLocalData) {
1132   // Installs v1 app and writes some local data.
1133   set_test_app_id(kTestLocalFsKioskApp);
1134   set_test_app_version("1.0.0");
1135   set_test_crx_file(test_app_id() + ".crx");
1136
1137   ResultCatcher catcher;
1138   StartAppLaunchFromLoginScreen(SimulateNetworkOnlineClosure());
1139   WaitForAppLaunchSuccess();
1140   ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
1141 }
1142
1143 IN_PROC_BROWSER_TEST_F(KioskUpdateTest, PreserveLocalData) {
1144   // Update existing v1 app installed in PRE_PreserveLocalData to v2
1145   // that reads and verifies the local data.
1146   set_test_app_id(kTestLocalFsKioskApp);
1147   set_test_app_version("2.0.0");
1148   set_test_crx_file(test_app_id() + "_v2_read_and_verify_data.crx");
1149   ResultCatcher catcher;
1150   StartAppLaunchFromLoginScreen(SimulateNetworkOnlineClosure());
1151   WaitForAppLaunchSuccess();
1152
1153   EXPECT_EQ("2.0.0", GetInstalledAppVersion().GetString());
1154   ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
1155 }
1156
1157 class KioskEnterpriseTest : public KioskTest {
1158  protected:
1159   KioskEnterpriseTest() {}
1160
1161   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
1162     device_policy_test_helper_.MarkAsEnterpriseOwned();
1163     device_policy_test_helper_.InstallOwnerKey();
1164
1165     KioskTest::SetUpInProcessBrowserTestFixture();
1166   }
1167
1168   virtual void SetUpOnMainThread() OVERRIDE {
1169     set_test_app_id(kTestEnterpriseKioskApp);
1170     set_test_app_version("1.0.0");
1171     set_test_crx_file(test_app_id() + ".crx");
1172     SetupTestAppUpdateCheck();
1173
1174     KioskTest::SetUpOnMainThread();
1175     // Configure kTestEnterpriseKioskApp in device policy.
1176     em::DeviceLocalAccountsProto* accounts =
1177         device_policy_test_helper_.device_policy()->payload()
1178             .mutable_device_local_accounts();
1179     em::DeviceLocalAccountInfoProto* account = accounts->add_account();
1180     account->set_account_id(kTestEnterpriseAccountId);
1181     account->set_type(
1182         em::DeviceLocalAccountInfoProto::ACCOUNT_TYPE_KIOSK_APP);
1183     account->mutable_kiosk_app()->set_app_id(kTestEnterpriseKioskApp);
1184     accounts->set_auto_login_id(kTestEnterpriseAccountId);
1185     em::PolicyData& policy_data =
1186         device_policy_test_helper_.device_policy()->policy_data();
1187     policy_data.set_service_account_identity(kTestEnterpriseServiceAccountId);
1188     device_policy_test_helper_.device_policy()->Build();
1189
1190     base::RunLoop run_loop;
1191     DBusThreadManager::Get()->GetSessionManagerClient()->StoreDevicePolicy(
1192         device_policy_test_helper_.device_policy()->GetBlob(),
1193         base::Bind(&KioskEnterpriseTest::StorePolicyCallback,
1194                    run_loop.QuitClosure()));
1195     run_loop.Run();
1196
1197     DeviceSettingsService::Get()->Load();
1198
1199     // Configure OAuth authentication.
1200     GaiaUrls* gaia_urls = GaiaUrls::GetInstance();
1201
1202     // This token satisfies the userinfo.email request from
1203     // DeviceOAuth2TokenService used in token validation.
1204     FakeGaia::AccessTokenInfo userinfo_token_info;
1205     userinfo_token_info.token = kTestUserinfoToken;
1206     userinfo_token_info.scopes.insert(
1207         "https://www.googleapis.com/auth/userinfo.email");
1208     userinfo_token_info.audience = gaia_urls->oauth2_chrome_client_id();
1209     userinfo_token_info.email = kTestEnterpriseServiceAccountId;
1210     fake_gaia_->IssueOAuthToken(kTestRefreshToken, userinfo_token_info);
1211
1212     // The any-api access token for accessing the token minting endpoint.
1213     FakeGaia::AccessTokenInfo login_token_info;
1214     login_token_info.token = kTestLoginToken;
1215     login_token_info.scopes.insert(GaiaConstants::kAnyApiOAuth2Scope);
1216     login_token_info.audience = gaia_urls->oauth2_chrome_client_id();
1217     fake_gaia_->IssueOAuthToken(kTestRefreshToken, login_token_info);
1218
1219     // This is the access token requested by the app via the identity API.
1220     FakeGaia::AccessTokenInfo access_token_info;
1221     access_token_info.token = kTestAccessToken;
1222     access_token_info.scopes.insert(kTestAppScope);
1223     access_token_info.audience = kTestClientId;
1224     access_token_info.email = kTestEnterpriseServiceAccountId;
1225     fake_gaia_->IssueOAuthToken(kTestLoginToken, access_token_info);
1226
1227     DeviceOAuth2TokenService* token_service =
1228         DeviceOAuth2TokenServiceFactory::Get();
1229     token_service->SetAndSaveRefreshToken(
1230         kTestRefreshToken, DeviceOAuth2TokenService::StatusCallback());
1231     base::RunLoop().RunUntilIdle();
1232   }
1233
1234   static void StorePolicyCallback(const base::Closure& callback, bool result) {
1235     ASSERT_TRUE(result);
1236     callback.Run();
1237   }
1238
1239   policy::DevicePolicyCrosTestHelper device_policy_test_helper_;
1240
1241  private:
1242   DISALLOW_COPY_AND_ASSIGN(KioskEnterpriseTest);
1243 };
1244
1245 IN_PROC_BROWSER_TEST_F(KioskEnterpriseTest, EnterpriseKioskApp) {
1246   chromeos::WizardController::SkipPostLoginScreensForTesting();
1247   chromeos::WizardController* wizard_controller =
1248       chromeos::WizardController::default_controller();
1249   wizard_controller->SkipToLoginForTesting(LoginScreenContext());
1250
1251   // Wait for the Kiosk App configuration to reload, then launch the app.
1252   KioskAppManager::App app;
1253   content::WindowedNotificationObserver app_config_waiter(
1254       chrome::NOTIFICATION_KIOSK_APPS_LOADED,
1255       base::Bind(&KioskAppManager::GetApp,
1256                  base::Unretained(KioskAppManager::Get()),
1257                  kTestEnterpriseKioskApp, &app));
1258   FireKioskAppSettingsChanged();
1259   app_config_waiter.Wait();
1260
1261   LaunchApp(kTestEnterpriseKioskApp, false);
1262
1263   // Wait for the Kiosk App to launch.
1264   content::WindowedNotificationObserver(
1265       chrome::NOTIFICATION_KIOSK_APP_LAUNCHED,
1266       content::NotificationService::AllSources()).Wait();
1267
1268   // Check installer status.
1269   EXPECT_EQ(chromeos::KioskAppLaunchError::NONE,
1270             chromeos::KioskAppLaunchError::Get());
1271
1272   // Wait for the window to appear.
1273   apps::AppWindow* window =
1274       AppWindowWaiter(
1275           apps::AppWindowRegistry::Get(ProfileManager::GetPrimaryUserProfile()),
1276           kTestEnterpriseKioskApp).Wait();
1277   ASSERT_TRUE(window);
1278
1279   // Check whether the app can retrieve an OAuth2 access token.
1280   std::string result;
1281   EXPECT_TRUE(content::ExecuteScriptAndExtractString(
1282       window->web_contents(),
1283       "chrome.identity.getAuthToken({ 'interactive': false }, function(token) {"
1284       "    window.domAutomationController.setAutomationId(0);"
1285       "    window.domAutomationController.send(token);"
1286       "});",
1287       &result));
1288   EXPECT_EQ(kTestAccessToken, result);
1289
1290   // Verify that the session is not considered to be logged in with a GAIA
1291   // account.
1292   Profile* app_profile = ProfileManager::GetPrimaryUserProfile();
1293   ASSERT_TRUE(app_profile);
1294   EXPECT_FALSE(app_profile->GetPrefs()->HasPrefPath(
1295       prefs::kGoogleServicesUsername));
1296
1297   // Terminate the app.
1298   window->GetBaseWindow()->Close();
1299   content::RunAllPendingInMessageLoop();
1300 }
1301
1302 // Specialized test fixture for testing kiosk mode on the
1303 // hidden WebUI initialization flow for slow hardware.
1304 class KioskHiddenWebUITest : public KioskTest,
1305                              public ash::DesktopBackgroundControllerObserver {
1306  public:
1307   KioskHiddenWebUITest() : wallpaper_loaded_(false) {}
1308
1309   // KioskTest overrides:
1310   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
1311     KioskTest::SetUpCommandLine(command_line);
1312     command_line->AppendSwitch(switches::kDisableBootAnimation);
1313   }
1314
1315   virtual void SetUpOnMainThread() OVERRIDE {
1316     KioskTest::SetUpOnMainThread();
1317     ash::Shell::GetInstance()->desktop_background_controller()
1318         ->AddObserver(this);
1319   }
1320
1321   virtual void TearDownOnMainThread() OVERRIDE {
1322     ash::Shell::GetInstance()->desktop_background_controller()
1323         ->RemoveObserver(this);
1324     KioskTest::TearDownOnMainThread();
1325   }
1326
1327   void WaitForWallpaper() {
1328     if (!wallpaper_loaded_) {
1329       runner_ = new content::MessageLoopRunner;
1330       runner_->Run();
1331     }
1332   }
1333
1334   bool wallpaper_loaded() const { return wallpaper_loaded_; }
1335
1336   // ash::DesktopBackgroundControllerObserver overrides:
1337   virtual void OnWallpaperDataChanged() OVERRIDE {
1338     wallpaper_loaded_ = true;
1339     if (runner_.get())
1340       runner_->Quit();
1341   }
1342
1343   bool wallpaper_loaded_;
1344   scoped_refptr<content::MessageLoopRunner> runner_;
1345
1346   DISALLOW_COPY_AND_ASSIGN(KioskHiddenWebUITest);
1347 };
1348
1349 IN_PROC_BROWSER_TEST_F(KioskHiddenWebUITest, AutolaunchWarning) {
1350   // Add a device owner.
1351   FakeUserManager* user_manager = new FakeUserManager();
1352   user_manager->AddUser(kTestOwnerEmail);
1353   ScopedUserManagerEnabler enabler(user_manager);
1354
1355   // Set kiosk app to autolaunch.
1356   EnableConsumerKioskMode();
1357   chromeos::WizardController::SkipPostLoginScreensForTesting();
1358   chromeos::WizardController* wizard_controller =
1359       chromeos::WizardController::default_controller();
1360   CHECK(wizard_controller);
1361
1362   // Start login screen after configuring auto launch app since the warning
1363   // is triggered when switching to login screen.
1364   wizard_controller->AdvanceToScreen(WizardController::kNetworkScreenName);
1365   ReloadAutolaunchKioskApps();
1366   wizard_controller->SkipToLoginForTesting(LoginScreenContext());
1367
1368   EXPECT_FALSE(KioskAppManager::Get()->GetAutoLaunchApp().empty());
1369   EXPECT_FALSE(KioskAppManager::Get()->IsAutoLaunchEnabled());
1370
1371   // Wait for the auto launch warning come up.
1372   content::WindowedNotificationObserver(
1373       chrome::NOTIFICATION_KIOSK_AUTOLAUNCH_WARNING_VISIBLE,
1374       content::NotificationService::AllSources()).Wait();
1375
1376   // Wait for the wallpaper to load.
1377   WaitForWallpaper();
1378   EXPECT_TRUE(wallpaper_loaded());
1379 }
1380
1381 }  // namespace chromeos