kiosk: Network connectivity test during launch.

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/shell_window.h"
 #include "apps/shell_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"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
+#include "base/callback.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_browser_main.h"
 #include "chrome/browser/chrome_browser_main_extra_parts.h"
 #include "chrome/browser/chrome_content_browser_client.h"
 #include "chrome/browser/chrome_notification_types.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/login/app_launch_controller.h"
 #include "chrome/browser/chromeos/login/app_launch_signin_screen.h"
 #include "chrome/browser/chromeos/login/existing_user_controller.h"
 #include "chrome/browser/chromeos/login/fake_user_manager.h"
 #include "chrome/browser/chromeos/login/login_display_host_impl.h"
 #include "chrome/browser/chromeos/login/mock_user_manager.h"
 #include "chrome/browser/chromeos/login/test/oobe_screen_waiter.h"
 #include "chrome/browser/chromeos/login/webui_login_display.h"
 #include "chrome/browser/chromeos/login/wizard_controller.h"
+#include "chrome/browser/chromeos/net/network_portal_detector_test_impl.h"
 #include "chrome/browser/chromeos/policy/device_policy_cros_browser_test.h"
 #include "chrome/browser/chromeos/settings/cros_settings.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_system.h"
 #include "chrome/browser/extensions/extension_test_message_listener.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
 #include "chrome/browser/policy/cloud/policy_builder.h"
 #include "chrome/browser/policy/proto/chromeos/chrome_device_policy.pb.h"
@@ skipping 50 matching lines @@
 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 kTestAccessToken[] = "fake-access-token";
 
+// Note the path name must be the same as in shill stub.
+const char kStubEthernetServicePath[] = "eth1";
+
 // Helper function for GetConsumerKioskModeStatusCallback.
 void ConsumerKioskModeStatusCheck(
     KioskAppManager::ConsumerKioskModeStatus* out_status,
     const base::Closure& runner_quit_task,
     KioskAppManager::ConsumerKioskModeStatus in_status) {
   LOG(INFO) << "KioskAppManager::ConsumerKioskModeStatus = " << in_status;
   *out_status = in_status;
   runner_quit_task.Run();
 }
 
@@ skipping 14 matching lines @@
 
 // Helper function for DeviceOAuth2TokenServiceFactory::Get().
 void CopyTokenService(DeviceOAuth2TokenService** out_token_service,
                       DeviceOAuth2TokenService* in_token_service) {
   *out_token_service = in_token_service;
 }
 
 // Helper functions for CanConfigureNetwork mock.
 class ScopedCanConfigureNetwork {
  public:
-  explicit ScopedCanConfigureNetwork(bool can_configure)
+  ScopedCanConfigureNetwork(bool can_configure, bool needs_owner_auth)
       : can_configure_(can_configure),
-        callback_(base::Bind(&ScopedCanConfigureNetwork::CanConfigureNetwork,
-                             base::Unretained(this))) {
-    AppLaunchController::SetCanConfigureNetworkCallbackForTesting(&callback_);
+        needs_owner_auth_(needs_owner_auth),
+        can_configure_network_callback_(
+            base::Bind(&ScopedCanConfigureNetwork::CanConfigureNetwork,
+                       base::Unretained(this))),
+        needs_owner_auth_callback_(base::Bind(
+            &ScopedCanConfigureNetwork::NeedsOwnerAuthToConfigureNetwork,
+            base::Unretained(this))) {
+    AppLaunchController::SetCanConfigureNetworkCallbackForTesting(
+        &can_configure_network_callback_);
+    AppLaunchController::SetNeedOwnerAuthToConfigureNetworkCallbackForTesting(
+        &needs_owner_auth_callback_);
   }
   ~ScopedCanConfigureNetwork() {
     AppLaunchController::SetCanConfigureNetworkCallbackForTesting(NULL);
+    AppLaunchController::SetNeedOwnerAuthToConfigureNetworkCallbackForTesting(
+        NULL);
   }
 
   bool CanConfigureNetwork() {
     return can_configure_;
   }
 
+  bool NeedsOwnerAuthToConfigureNetwork() {
+    return needs_owner_auth_;
+  }
+
  private:
   bool can_configure_;
-  AppLaunchController::CanConfigureNetworkCallback callback_;
+  bool needs_owner_auth_;
+  AppLaunchController::ReturnBoolCallback can_configure_network_callback_;
+  AppLaunchController::ReturnBoolCallback needs_owner_auth_callback_;
   DISALLOW_COPY_AND_ASSIGN(ScopedCanConfigureNetwork);
 };
 
 }  // namespace
 
-// Fake NetworkChangeNotifier used to simulate network connectivity.
-class FakeNetworkChangeNotifier : public net::NetworkChangeNotifier {
- public:
-  FakeNetworkChangeNotifier() : connection_type_(CONNECTION_NONE) {}
-
-  virtual ConnectionType GetCurrentConnectionType() const OVERRIDE {
-    return connection_type_;
-  }
-
-  void GoOnline() {
-    SetConnectionType(net::NetworkChangeNotifier::CONNECTION_ETHERNET);
-  }
-
-  void GoOffline() {
-    SetConnectionType(net::NetworkChangeNotifier::CONNECTION_NONE);
-  }
-
-  void SetConnectionType(ConnectionType type) {
-    connection_type_ = type;
-    NotifyObserversOfNetworkChange(type);
-    base::RunLoop().RunUntilIdle();
-  }
-
-  virtual ~FakeNetworkChangeNotifier() {}
-
- private:
-  ConnectionType connection_type_;
-  DISALLOW_COPY_AND_ASSIGN(FakeNetworkChangeNotifier);
-};
-
 // Helper class that monitors app windows to wait for a window to appear.
 class ShellWindowObserver : public apps::ShellWindowRegistry::Observer {
  public:
   ShellWindowObserver(apps::ShellWindowRegistry* registry,
                       const std::string& app_id)
       : registry_(registry), app_id_(app_id), window_(NULL), running_(false) {
     registry_->AddObserver(this);
   }
   virtual ~ShellWindowObserver() {
     registry_->RemoveObserver(this);
@@ skipping 54 matching lines @@
 
     mock_user_manager_.reset(new MockUserManager);
     AppLaunchController::SkipSplashWaitForTesting();
     AppLaunchController::SetNetworkWaitForTesting(kTestNetworkTimeoutSeconds);
 
     InProcessBrowserTest::SetUp();
   }
 
   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
     host_resolver()->AddRule("*", "127.0.0.1");
+
+    network_portal_detector_ = new NetworkPortalDetectorTestImpl();
+    NetworkPortalDetector::InitializeForTesting(network_portal_detector_);
+    network_portal_detector_->SetDefaultNetworkPathForTesting(
+        kStubEthernetServicePath);
   }
 
   virtual void SetUpOnMainThread() OVERRIDE {
     // Restart the thread as the sandbox host process has already been spawned.
     embedded_test_server()->RestartThreadAndListen();
   }
 
   virtual void CleanUpOnMainThread() OVERRIDE {
-    // We need to clean up these objects in this specific order.
-    fake_network_notifier_.reset(NULL);
-    disable_network_notifier_.reset(NULL);
-
     AppLaunchController::SetNetworkTimeoutCallbackForTesting(NULL);
     AppLaunchSigninScreen::SetUserManagerForTesting(NULL);
 
     // If the login display is still showing, exit gracefully.
     if (LoginDisplayHostImpl::default_host()) {
       base::MessageLoop::current()->PostTask(FROM_HERE,
                                              base::Bind(&chrome::AttemptExit));
       content::RunMessageLoop();
     }
 
@@ skipping 37 matching lines @@
 
   void ReloadKioskApps() {
     KioskAppManager::Get()->AddApp(kTestKioskApp);
   }
 
   void ReloadAutolaunchKioskApps() {
     KioskAppManager::Get()->AddApp(kTestKioskApp);
     KioskAppManager::Get()->SetAutoLaunchApp(kTestKioskApp);
   }
 
-  void StartAppLaunchFromLoginScreen(bool has_connectivity) {
+  void StartAppLaunchFromLoginScreen(const base::Closure& network_setup_cb) {
     EnableConsumerKioskMode();
 
     // Start UI, find menu entry for this app and launch it.
     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();
     CHECK(wizard_controller);
     wizard_controller->SkipToLoginForTesting(LoginScreenContext());
     login_signal.Wait();
 
     // Wait for the Kiosk App configuration to reload, then launch the app.
     content::WindowedNotificationObserver apps_loaded_signal(
         chrome::NOTIFICATION_KIOSK_APPS_LOADED,
         content::NotificationService::AllSources());
     ReloadKioskApps();
     apps_loaded_signal.Wait();
 
-    if (!has_connectivity)
-      SimulateNetworkOffline();
+    if (!network_setup_cb.is_null())
+      network_setup_cb.Run();
 
     GetLoginUI()->CallJavascriptFunction(
         "login.AppsMenuButton.runAppForTesting",
         base::StringValue(kTestKioskApp));
   }
 
   void WaitForAppLaunchSuccess() {
     SimulateNetworkOnline();
 
     ExtensionTestMessageListener
@@ skipping 36 matching lines @@
     // Wait until the app terminates if it is still running.
     if (!shell_window_registry->GetShellWindowsForApp(kTestKioskApp).empty())
       content::RunMessageLoop();
 
     // Check that the app had been informed that it is running in a kiosk
     // session.
     EXPECT_TRUE(launch_data_check_listener.was_satisfied());
   }
 
   void SimulateNetworkOffline() {
-    disable_network_notifier_.reset(
-        new net::NetworkChangeNotifier::DisableForTest);
+    NetworkPortalDetector::CaptivePortalState offline_state;
+    offline_state.status = NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_OFFLINE;
+    network_portal_detector_->SetDetectionResultsForTesting(
+        kStubEthernetServicePath, offline_state);
+    network_portal_detector_->NotifyObserversForTesting();
+  }
 
-    fake_network_notifier_.reset(new FakeNetworkChangeNotifier);
+  base::Closure SimulateNetworkOfflineClosure() {
+    return base::Bind(&KioskTest::SimulateNetworkOffline,
+                      base::Unretained(this));
   }
 
   void SimulateNetworkOnline() {
-    if (fake_network_notifier_.get())
-      fake_network_notifier_->GoOnline();
+    NetworkPortalDetector::CaptivePortalState online_state;
+    online_state.status = NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE;
+    online_state.response_code = 204;
+    network_portal_detector_->SetDetectionResultsForTesting(
+        kStubEthernetServicePath, online_state);
+    network_portal_detector_->NotifyObserversForTesting();
+  }
+
+  base::Closure SimulateNetworkOnlineClosure() {
+    return base::Bind(&KioskTest::SimulateNetworkOnline,
+                      base::Unretained(this));
+  }
+
+  void SimulateNetworkPortal() {
+    NetworkPortalDetector::CaptivePortalState portal_state;
+    portal_state.status = NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL;
+    network_portal_detector_->SetDetectionResultsForTesting(
+        kStubEthernetServicePath, portal_state);
+    network_portal_detector_->NotifyObserversForTesting();
+  }
+
+  base::Closure SimulateNetworkPortalClosure() {
+    return base::Bind(&KioskTest::SimulateNetworkPortal,
+                      base::Unretained(this));
   }
 
   void WaitForAppLaunchNetworkTimeout() {
     if (GetAppLaunchController()->network_wait_timedout())
       return;
 
     scoped_refptr<content::MessageLoopRunner> runner =
         new content::MessageLoopRunner;
 
     base::Closure callback = base::Bind(
@@ skipping 52 matching lines @@
         ->GetOobeUI()
         ->signin_screen_handler_for_test();
   }
 
   AppLaunchController* GetAppLaunchController() {
     return chromeos::LoginDisplayHostImpl::default_host()
         ->GetAppLaunchController();
   }
 
   FakeGaia fake_gaia_;
-  scoped_ptr<net::NetworkChangeNotifier::DisableForTest>
-      disable_network_notifier_;
-  scoped_ptr<FakeNetworkChangeNotifier> fake_network_notifier_;
   scoped_ptr<MockUserManager> mock_user_manager_;
+  NetworkPortalDetectorTestImpl* network_portal_detector_;
 };
 
 IN_PROC_BROWSER_TEST_F(KioskTest, InstallAndLaunchApp) {
-  StartAppLaunchFromLoginScreen(true);
+  StartAppLaunchFromLoginScreen(SimulateNetworkOnlineClosure());
   WaitForAppLaunchSuccess();
 }
 
 IN_PROC_BROWSER_TEST_F(KioskTest, LaunchAppNetworkDown) {
-  // Mock network could be configured.
-  ScopedCanConfigureNetwork can_configure_network(true);
+  // 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(false);
+  StartAppLaunchFromLoginScreen(SimulateNetworkOfflineClosure());
   OobeScreenWaiter splash_waiter(OobeDisplay::SCREEN_APP_LAUNCH_SPLASH);
   splash_waiter.Wait();
   WaitForAppLaunchNetworkTimeout();
 
   // Configure network link should be visible.
   JsExpect("$('splash-config-network').hidden == false");
 
   // Set up fake user manager with an owner for the test.
   mock_user_manager_->SetActiveUser(kTestOwnerEmail);
   AppLaunchSigninScreen::SetUserManagerForTesting(mock_user_manager_.get());
@@ skipping 12 matching lines @@
       ->OnOwnerSigninSuccess();
   error_screen_waiter.Wait();
 
   ASSERT_TRUE(GetAppLaunchController()->showing_network_dialog());
 
   WaitForAppLaunchSuccess();
 }
 
 IN_PROC_BROWSER_TEST_F(KioskTest, LaunchAppNetworkDownConfigureNotAllowed) {
   // Mock network could not be configured.
-  ScopedCanConfigureNetwork can_configure_network(false);
+  ScopedCanConfigureNetwork can_configure_network(false, true);
 
   // Start app launch and wait for network connectivity timeout.
-  StartAppLaunchFromLoginScreen(false);
+  StartAppLaunchFromLoginScreen(SimulateNetworkOfflineClosure());
   OobeScreenWaiter splash_waiter(OobeDisplay::SCREEN_APP_LAUNCH_SPLASH);
   splash_waiter.Wait();
   WaitForAppLaunchNetworkTimeout();
 
   // Configure network link should not be visible.
   JsExpect("$('splash-config-network').hidden == true");
 
   // Network becomes online and app launch is resumed.
   WaitForAppLaunchSuccess();
 }
 
+IN_PROC_BROWSER_TEST_F(KioskTest, LaunchAppNetworkPortal) {
+  // Mock network could be configured without the owner password.
+  ScopedCanConfigureNetwork can_configure_network(true, false);
+
+  // Start app launch with network portal state.
+  StartAppLaunchFromLoginScreen(SimulateNetworkPortalClosure());
+  OobeScreenWaiter(OobeDisplay::SCREEN_APP_LAUNCH_SPLASH)
+      .WaitNoAssertCurrentScreen();
+  WaitForAppLaunchNetworkTimeout();
+
+  // 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());
+  WaitForAppLaunchSuccess();
+}
+
 IN_PROC_BROWSER_TEST_F(KioskTest, LaunchAppUserCancel) {
-  StartAppLaunchFromLoginScreen(false);
+  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",
                                        base::StringValue("app_launch_bailout"));
@@ skipping 403 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