Revert 275154 "ChromeOS login webui refactoring : Move GAIA-rela..."

trunk/src/chrome/browser/ui/webui/chromeos/login/signin_screen_handler.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 "chrome/browser/ui/webui/chromeos/login/signin_screen_handler.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 45 matching lines @@
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/power_manager_client.h"
 #include "chromeos/ime/ime_keyboard.h"
 #include "chromeos/ime/input_method_manager.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
 #include "google_apis/gaia/gaia_auth_util.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 #include "ui/base/webui/web_ui_util.h"
 
 #if defined(USE_AURA)
@@ skipping 12 matching lines @@
 // current network.
 const int kOfflineTimeoutSec = 5;
 
 // Timeout used to prevent infinite connecting to a flaky network.
 const int kConnectingTimeoutSec = 60;
 
 // Type of the login screen UI that is currently presented to user.
 const char kSourceGaiaSignin[] = "gaia-signin";
 const char kSourceAccountPicker[] = "account-picker";
 
+// The Task posted to PostTaskAndReply in StartClearingDnsCache on the IO
+// thread.
+void ClearDnsCache(IOThread* io_thread) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (browser_shutdown::IsTryingToQuit())
+    return;
+
+  io_thread->ClearHostCache();
+}
+
 static bool Contains(const std::vector<std::string>& container,
                      const std::string& value) {
   return std::find(container.begin(), container.end(), value) !=
          container.end();
 }
 
 }  // namespace
 
 namespace chromeos {
 
@@ skipping 90 matching lines @@
       DLOG(ERROR) << "SigninScreenHandler::SetUserInputMethod('" << username
                   << "'): user input method '" << input_method
                   << "' is not enabled and enabling failed (ignored!).";
     }
   }
   manager->ChangeInputMethod(input_method);
 
   return true;
 }
 
+void RecordSAMLScrapingVerificationResultInHistogram(bool success) {
+  UMA_HISTOGRAM_BOOLEAN("ChromeOS.SAML.Scraping.VerificationResult", success);
+}
+
 }  // namespace
 
 // LoginScreenContext implementation ------------------------------------------
 
 LoginScreenContext::LoginScreenContext() {
   Init();
 }
 
 LoginScreenContext::LoginScreenContext(const base::ListValue* args) {
   Init();
@@ skipping 14 matching lines @@
 SigninScreenHandler::SigninScreenHandler(
     const scoped_refptr<NetworkStateInformer>& network_state_informer,
     ErrorScreenActor* error_screen_actor,
     CoreOobeActor* core_oobe_actor,
     GaiaScreenHandler* gaia_screen_handler)
     : ui_state_(UI_STATE_UNKNOWN),
       delegate_(NULL),
       native_window_delegate_(NULL),
       show_on_init_(false),
       oobe_ui_(false),
+      focus_stolen_(false),
+      gaia_silent_load_(false),
       is_account_picker_showing_first_time_(false),
+      dns_cleared_(false),
+      dns_clear_task_running_(false),
+      cookies_cleared_(false),
       network_state_informer_(network_state_informer),
+      using_saml_api_(false),
+      test_expects_complete_login_(false),
+      weak_factory_(this),
       webui_visible_(false),
       preferences_changed_delayed_(false),
       error_screen_actor_(error_screen_actor),
       core_oobe_actor_(core_oobe_actor),
       is_first_update_state_call_(true),
       offline_login_active_(false),
       last_network_state_(NetworkStateInformer::UNKNOWN),
       has_pending_auth_ui_(false),
       caps_lock_enabled_(chromeos::input_method::InputMethodManager::Get()
                              ->GetImeKeyboard()
                              ->CapsLockIsEnabled()),
-      gaia_screen_handler_(gaia_screen_handler),
-      weak_factory_(this) {
+      gaia_screen_handler_(gaia_screen_handler) {
   DCHECK(network_state_informer_.get());
   DCHECK(error_screen_actor_);
   DCHECK(core_oobe_actor_);
   DCHECK(gaia_screen_handler_);
   gaia_screen_handler_->SetSigninScreenHandler(this);
   network_state_informer_->AddObserver(this);
 
   registrar_.Add(this,
                  chrome::NOTIFICATION_AUTH_NEEDED,
                  content::NotificationService::AllSources());
@@ skipping 130 matching lines @@
   builder->Add("runType", CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kFirstExecAfterBoot) ?  "firstExecAfterBoot" :
                                         "notFirstExecAfterBoot");
 }
 
 void SigninScreenHandler::Show(const LoginScreenContext& context) {
   CHECK(delegate_);
 
   // Just initialize internal fields from context and call ShowImpl().
   oobe_ui_ = context.oobe_ui();
-  gaia_screen_handler_->PopulateEmail(context.email());
+  if (!context.email().empty())
+    email_ = context.email();
+  else
+    email_.clear();
   ShowImpl();
 }
 
 void SigninScreenHandler::ShowRetailModeLoginSpinner() {
   CallJS("showLoginSpinner");
 }
 
 void SigninScreenHandler::SetDelegate(SigninScreenHandlerDelegate* delegate) {
   delegate_ = delegate;
   if (delegate_)
     delegate_->SetWebUIHandler(this);
   else
     auto_enrollment_progress_subscription_.reset();
 }
 
 void SigninScreenHandler::SetNativeWindowDelegate(
     NativeWindowDelegate* native_window_delegate) {
   native_window_delegate_ = native_window_delegate;
 }
 
 void SigninScreenHandler::OnNetworkReady() {
   LOG(WARNING) << "OnNetworkReady() call.";
-  DCHECK(gaia_screen_handler_);
-  gaia_screen_handler_->MaybePreloadAuthExtension();
+  MaybePreloadAuthExtension();
 }
 
 void SigninScreenHandler::UpdateState(ErrorScreenActor::ErrorReason reason) {
   UpdateStateInternal(reason, false);
 }
 
 // SigninScreenHandler, private: -----------------------------------------------
 
 void SigninScreenHandler::ShowImpl() {
   if (!page_is_ready()) {
     show_on_init_ = true;
     return;
   }
 
   if (oobe_ui_) {
     // Shows new user sign-in for OOBE.
-    OnShowAddUser();
+    OnShowAddUser(email_);
   } else {
     // Populates account picker. Animation is turned off for now until we
     // figure out how to make it fast enough.
     delegate_->HandleGetUsers();
 
     // Reset Caps Lock state when login screen is shown.
     input_method::InputMethodManager::Get()
         ->GetImeKeyboard()
         ->SetCapsLockEnabled(false);
 
@@ skipping 222 matching lines @@
   }
 }
 
 gfx::NativeWindow SigninScreenHandler::GetNativeWindow() {
   if (native_window_delegate_)
     return native_window_delegate_->GetNativeWindow();
   return NULL;
 }
 
 void SigninScreenHandler::RegisterMessages() {
+  AddCallback("usingSAMLAPI", &SigninScreenHandler::HandleUsingSAMLAPI);
+  AddCallback("scrapedPasswordCount",
+              &SigninScreenHandler::HandleScrapedPasswordCount);
+  AddCallback("scrapedPasswordVerificationFailed",
+              &SigninScreenHandler::HandleScrapedPasswordVerificationFailed);
   AddCallback("authenticateUser", &SigninScreenHandler::HandleAuthenticateUser);
   AddCallback("attemptUnlock", &SigninScreenHandler::HandleAttemptUnlock);
+  AddCallback("completeLogin", &SigninScreenHandler::HandleCompleteLogin);
+  AddCallback("completeAuthentication",
+              &SigninScreenHandler::HandleCompleteAuthentication);
   AddCallback("getUsers", &SigninScreenHandler::HandleGetUsers);
   AddCallback("launchDemoUser", &SigninScreenHandler::HandleLaunchDemoUser);
   AddCallback("launchIncognito", &SigninScreenHandler::HandleLaunchIncognito);
   AddCallback("showLocallyManagedUserCreationScreen",
               &SigninScreenHandler::HandleShowLocallyManagedUserCreationScreen);
   AddCallback("launchPublicAccount",
               &SigninScreenHandler::HandleLaunchPublicAccount);
   AddRawCallback("offlineLogin", &SigninScreenHandler::HandleOfflineLogin);
   AddCallback("rebootSystem", &SigninScreenHandler::HandleRebootSystem);
   AddRawCallback("showAddUser", &SigninScreenHandler::HandleShowAddUser);
   AddCallback("shutdownSystem", &SigninScreenHandler::HandleShutdownSystem);
   AddCallback("loadWallpaper", &SigninScreenHandler::HandleLoadWallpaper);
   AddCallback("removeUser", &SigninScreenHandler::HandleRemoveUser);
   AddCallback("toggleEnrollmentScreen",
               &SigninScreenHandler::HandleToggleEnrollmentScreen);
   AddCallback("toggleKioskEnableScreen",
               &SigninScreenHandler::HandleToggleKioskEnableScreen);
   AddCallback("createAccount", &SigninScreenHandler::HandleCreateAccount);
   AddCallback("accountPickerReady",
               &SigninScreenHandler::HandleAccountPickerReady);
   AddCallback("wallpaperReady", &SigninScreenHandler::HandleWallpaperReady);
+  AddCallback("loginWebuiReady", &SigninScreenHandler::HandleLoginWebuiReady);
   AddCallback("signOutUser", &SigninScreenHandler::HandleSignOutUser);
   AddCallback("openProxySettings",
               &SigninScreenHandler::HandleOpenProxySettings);
   AddCallback("loginVisible", &SigninScreenHandler::HandleLoginVisible);
   AddCallback("cancelPasswordChangedFlow",
               &SigninScreenHandler::HandleCancelPasswordChangedFlow);
   AddCallback("cancelUserAdding",
               &SigninScreenHandler::HandleCancelUserAdding);
   AddCallback("migrateUserData", &SigninScreenHandler::HandleMigrateUserData);
   AddCallback("resyncUserData", &SigninScreenHandler::HandleResyncUserData);
@@ skipping 31 matching lines @@
   core_oobe_actor_->ClearUserPodPassword();
 }
 
 void SigninScreenHandler::RefocusCurrentPod() {
   core_oobe_actor_->RefocusCurrentPod();
 }
 
 void SigninScreenHandler::OnUserRemoved(const std::string& username) {
   CallJS("login.AccountPickerScreen.removeUser", username);
   if (delegate_->GetUsers().empty())
-    OnShowAddUser();
+    OnShowAddUser("");
 }
 
 void SigninScreenHandler::OnUserImageChanged(const User& user) {
   if (page_is_ready())
     CallJS("login.AccountPickerScreen.updateUserImage", user.email());
 }
 
 void SigninScreenHandler::OnPreferencesChanged() {
   // Make sure that one of the login UI is fully functional now, otherwise
   // preferences update would be picked up next time it will be shown.
@@ skipping 34 matching lines @@
       NOTREACHED() << "Unknown sign in error";
       break;
   }
 }
 
 void SigninScreenHandler::ShowSigninUI(const std::string& email) {
   core_oobe_actor_->ShowSignInUI(email);
 }
 
 void SigninScreenHandler::ShowGaiaPasswordChanged(const std::string& username) {
-  gaia_screen_handler_->PasswordChangedFor(username);
-  gaia_screen_handler_->PopulateEmail(username);
-  core_oobe_actor_->ShowSignInUI(username);
+  email_ = username;
+  password_changed_for_.insert(email_);
+  core_oobe_actor_->ShowSignInUI(email_);
   CallJS("login.setAuthType",
          username,
          static_cast<int>(ONLINE_SIGN_IN),
          base::StringValue(""));
 }
 
 void SigninScreenHandler::ShowPasswordChangedDialog(bool show_password_error) {
   core_oobe_actor_->ShowPasswordChangedScreen(show_password_error);
 }
 
 void SigninScreenHandler::ShowSigninScreenForCreds(
     const std::string& username,
     const std::string& password) {
-  DCHECK(gaia_screen_handler_);
-  gaia_screen_handler_->ShowSigninScreenForCreds(username, password);
+  VLOG(2) << "ShowSigninScreenForCreds  for user " << username
+          << ", frame_state=" << FrameState();
+
+  test_user_ = username;
+  test_pass_ = password;
+  test_expects_complete_login_ = true;
+
+  // Submit login form for test if gaia is ready. If gaia is loading, login
+  // will be attempted in HandleLoginWebuiReady after gaia is ready. Otherwise,
+  // reload gaia then follow the loading case.
+  if (FrameState() == GaiaScreenHandler::FRAME_STATE_LOADED)
+    SubmitLoginFormForTest();
+  else if (FrameState() != GaiaScreenHandler::FRAME_STATE_LOADING)
+    HandleShowAddUser(NULL);
+}
+
+void SigninScreenHandler::OnCookiesCleared(base::Closure on_clear_callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  cookies_cleared_ = true;
+  on_clear_callback.Run();
 }
 
 void SigninScreenHandler::OnKeyEvent(ui::KeyEvent* key) {
   if (key->type() == ui::ET_KEY_PRESSED && key->key_code() == ui::VKEY_CAPITAL)
     OnCapsLockChanged(!caps_lock_enabled_);
 }
 
 void SigninScreenHandler::Observe(int type,
                                   const content::NotificationSource& source,
                                   const content::NotificationDetails& details) {
@@ skipping 70 matching lines @@
 ScreenlockBridge::LockHandler::AuthType SigninScreenHandler::GetAuthType(
     const std::string& username) const {
   return delegate_->GetAuthType(username);
 }
 
 void SigninScreenHandler::Unlock(const std::string& user_email) {
   DCHECK(ScreenLocker::default_screen_locker());
   ScreenLocker::Hide();
 }
 
-bool SigninScreenHandler::ShouldLoadGaia() const {
-  // Fetching of the extension is not started before account picker page is
-  // loaded because it can affect the loading speed.
-  // Do not load the extension for the screen locker, see crosbug.com/25018.
-  return !ScreenLocker::default_screen_locker() &&
-         is_account_picker_showing_first_time_;
+void SigninScreenHandler::OnDnsCleared() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  dns_clear_task_running_ = false;
+  dns_cleared_ = true;
+  ShowSigninScreenIfReady();
 }
 
 // Update keyboard layout to least recently used by the user.
 void SigninScreenHandler::SetUserInputMethod(const std::string& username) {
   UserManager* user_manager = UserManager::Get();
   if (user_manager->IsUserLoggedIn()) {
     // We are on sign-in screen inside user session (adding new user to
     // the session or on lock screen), don't switch input methods in this case.
     // TODO(dpolukhin): adding user and sign-in should be consistent
     // crbug.com/292774
     return;
   }
 
   chromeos::input_method::InputMethodManager* const manager =
       chromeos::input_method::InputMethodManager::Get();
 
   const bool succeed = SetUserInputMethodImpl(username, manager);
 
   // This is also a case when LRU layout is set only for a few local users,
   // thus others need to be switched to default locale.
   // Otherwise they will end up using another user's locale to log in.
   if (!succeed) {
     DVLOG(0) << "SetUserInputMethod('" << username
                << "'): failed to set user layout. Switching to default.";
 
     manager->SetInputMethodLoginDefault();
   }
 }
 
+void SigninScreenHandler::ShowSigninScreenIfReady() {
+  LOG(WARNING) << "ShowSigninScreenIfReady() call.";
+
+  if (!dns_cleared_ || !cookies_cleared_ || !delegate_)
+    return;
+
+  std::string active_network_path = network_state_informer_->network_path();
+  if (gaia_silent_load_ &&
+      (network_state_informer_->state() != NetworkStateInformer::ONLINE ||
+       gaia_silent_load_network_ != active_network_path)) {
+    // Network has changed. Force Gaia reload.
+    gaia_silent_load_ = false;
+    // Gaia page will be realoded, so focus isn't stolen anymore.
+    focus_stolen_ = false;
+  }
+
+  // Note that LoadAuthExtension clears |email_|.
+  if (email_.empty())
+    delegate_->LoadSigninWallpaper();
+  else
+    delegate_->LoadWallpaper(email_);
+
+  // Set Least Recently Used input method for the user.
+  if (!email_.empty())
+    SetUserInputMethod(email_);
+
+  LoadAuthExtension(!gaia_silent_load_, false, false);
+  UpdateUIState(UI_STATE_GAIA_SIGNIN, NULL);
+
+  if (gaia_silent_load_) {
+    // The variable is assigned to false because silently loaded Gaia page was
+    // used.
+    gaia_silent_load_ = false;
+    if (focus_stolen_)
+      HandleLoginWebuiReady();
+  }
+
+  UpdateState(ErrorScreenActor::ERROR_REASON_UPDATE);
+}
+
+void SigninScreenHandler::LoadAuthExtension(
+    bool force, bool silent_load, bool offline) {
+  GaiaContext context;
+  context.force_reload = force;
+  context.is_local = offline;
+  context.password_changed =
+      !email_.empty() && password_changed_for_.count(email_);
+  if (delegate_)
+    context.show_users = delegate_->IsShowUsers();
+  context.use_offline = offline;
+  if (delegate_)
+    context.has_users = !delegate_->GetUsers().empty();
+  context.email = email_;
+
+  email_.clear();
+
+  DCHECK(gaia_screen_handler_);
+  gaia_screen_handler_->LoadGaia(context);
+}
 
 void SigninScreenHandler::UserSettingsChanged() {
   DCHECK(gaia_screen_handler_);
   GaiaContext context;
   if (delegate_)
     context.has_users = !delegate_->GetUsers().empty();
   gaia_screen_handler_->UpdateGaia(context);
   UpdateAddButtonStatus();
 }
 
 void SigninScreenHandler::UpdateAddButtonStatus() {
   CallJS("cr.ui.login.DisplayManager.updateAddUserButtonStatus",
          AllWhitelistedUsersPresent());
 }
 
+void SigninScreenHandler::HandleUsingSAMLAPI() {
+  SetSAMLPrincipalsAPIUsed(true);
+}
+
+void SigninScreenHandler::HandleScrapedPasswordCount(int password_count) {
+  SetSAMLPrincipalsAPIUsed(false);
+  // Use a histogram that has 11 buckets, one for each of the values in [0, 9]
+  // and an overflow bucket at the end.
+  UMA_HISTOGRAM_ENUMERATION(
+      "ChromeOS.SAML.Scraping.PasswordCount", std::min(password_count, 10), 11);
+  if (password_count == 0)
+    HandleScrapedPasswordVerificationFailed();
+}
+
+void SigninScreenHandler::HandleScrapedPasswordVerificationFailed() {
+  RecordSAMLScrapingVerificationResultInHistogram(false);
+}
+
+void SigninScreenHandler::HandleCompleteLogin(const std::string& typed_email,
+                                              const std::string& password,
+                                              bool using_saml) {
+  if (!delegate_)
+    return;
+
+  if (using_saml && !using_saml_api_)
+    RecordSAMLScrapingVerificationResultInHistogram(true);
+
+  const std::string sanitized_email = gaia::SanitizeEmail(typed_email);
+  delegate_->SetDisplayEmail(sanitized_email);
+  UserContext user_context(sanitized_email);
+  user_context.SetKey(Key(password));
+  user_context.SetAuthFlow(using_saml ?
+      UserContext::AUTH_FLOW_GAIA_WITH_SAML :
+      UserContext::AUTH_FLOW_GAIA_WITHOUT_SAML);
+  delegate_->CompleteLogin(user_context);
+
+  if (test_expects_complete_login_) {
+    VLOG(2) << "Complete test login for " << typed_email
+            << ", requested=" << test_user_;
+
+    test_expects_complete_login_ = false;
+    test_user_.clear();
+    test_pass_.clear();
+  }
+}
+
+void SigninScreenHandler::HandleCompleteAuthentication(
+    const std::string& email,
+    const std::string& password,
+    const std::string& auth_code) {
+  if (!delegate_)
+    return;
+  delegate_->SetDisplayEmail(gaia::SanitizeEmail(email));
+  UserContext user_context(email);
+  user_context.SetKey(Key(password));
+  user_context.SetAuthCode(auth_code);
+  delegate_->CompleteLogin(user_context);
+}
+
 void SigninScreenHandler::HandleAuthenticateUser(const std::string& username,
                                                  const std::string& password) {
   if (!delegate_)
     return;
   UserContext user_context(username);
   user_context.SetKey(Key(password));
   delegate_->Login(user_context);
 }
 
 void SigninScreenHandler::HandleAttemptUnlock(const std::string& username) {
@@ skipping 42 matching lines @@
     const std::string& username) {
   if (delegate_)
     delegate_->LoginAsPublicAccount(username);
 }
 
 void SigninScreenHandler::HandleOfflineLogin(const base::ListValue* args) {
   if (!delegate_ || delegate_->IsShowUsers()) {
     NOTREACHED();
     return;
   }
-  std::string email;
-  args->GetString(0, &email);
-
-  gaia_screen_handler_->PopulateEmail(email);
+  if (!args->GetString(0, &email_))
+    email_.clear();
   // Load auth extension. Parameters are: force reload, do not load extension in
   // background, use offline version.
-  gaia_screen_handler_->LoadAuthExtension(true, false, true);
+  LoadAuthExtension(true, false, true);
   UpdateUIState(UI_STATE_GAIA_SIGNIN, NULL);
 }
 
 void SigninScreenHandler::HandleShutdownSystem() {
   ash::Shell::GetInstance()->lock_state_controller()->RequestShutdown();
 }
 
 void SigninScreenHandler::HandleLoadWallpaper(const std::string& email) {
   if (delegate_)
     delegate_->LoadWallpaper(email);
@@ skipping 12 matching lines @@
 
 void SigninScreenHandler::HandleShowAddUser(const base::ListValue* args) {
   TRACE_EVENT_ASYNC_STEP_INTO0("ui",
                                "ShowLoginWebUI",
                                LoginDisplayHostImpl::kShowLoginWebUIid,
                                "ShowAddUser");
   std::string email;
   // |args| can be null if it's OOBE.
   if (args)
     args->GetString(0, &email);
-  gaia_screen_handler_->PopulateEmail(email);
-  OnShowAddUser();
+  OnShowAddUser(email);
 }
 
 void SigninScreenHandler::HandleToggleEnrollmentScreen() {
   if (delegate_)
     delegate_->ShowEnterpriseEnrollmentScreen();
 }
 
 void SigninScreenHandler::HandleToggleKioskEnableScreen() {
   policy::BrowserPolicyConnectorChromeOS* connector =
       g_browser_process->platform_part()->browser_policy_connector_chromeos();
@@ skipping 38 matching lines @@
   }
 
   PrefService* prefs = g_browser_process->local_state();
   if (prefs->GetBoolean(prefs::kFactoryResetRequested)) {
     if (core_oobe_actor_)
       core_oobe_actor_->ShowDeviceResetScreen();
     return;
   }
 
   is_account_picker_showing_first_time_ = true;
-  gaia_screen_handler_->MaybePreloadAuthExtension();
+  MaybePreloadAuthExtension();
 
   if (ScreenLocker::default_screen_locker()) {
     ScreenLocker::default_screen_locker()->delegate()->OnLockWebUIReady();
     ScreenlockBridge::Get()->SetLockHandler(this);
   }
 
   if (delegate_)
     delegate_->OnSigninScreenReady();
 }
 
 void SigninScreenHandler::HandleWallpaperReady() {
   if (ScreenLocker::default_screen_locker()) {
     ScreenLocker::default_screen_locker()->delegate()->
         OnLockBackgroundDisplayed();
   }
 }
 
+void SigninScreenHandler::HandleLoginWebuiReady() {
+  if (focus_stolen_) {
+    // Set focus to the Gaia page.
+    // TODO(altimofeev): temporary solution, until focus parameters are
+    // implemented on the Gaia side.
+    // Do this only once. Any subsequent call would relod GAIA frame.
+    focus_stolen_ = false;
+    const char code[] =
+        "if (typeof gWindowOnLoad != 'undefined') gWindowOnLoad();";
+    content::RenderFrameHost* frame =
+        LoginDisplayHostImpl::GetGaiaAuthIframe(web_ui()->GetWebContents());
+    frame->ExecuteJavaScript(base::ASCIIToUTF16(code));
+  }
+  if (gaia_silent_load_) {
+    focus_stolen_ = true;
+    // Prevent focus stealing by the Gaia page.
+    // TODO(altimofeev): temporary solution, until focus parameters are
+    // implemented on the Gaia side.
+    const char code[] = "var gWindowOnLoad = window.onload; "
+                        "window.onload=function() {};";
+    content::RenderFrameHost* frame =
+        LoginDisplayHostImpl::GetGaiaAuthIframe(web_ui()->GetWebContents());
+    frame->ExecuteJavaScript(base::ASCIIToUTF16(code));
+    // As we could miss and window.onload could already be called, restore
+    // focus to current pod (see crbug/175243).
+    RefocusCurrentPod();
+  }
+  DCHECK(gaia_screen_handler_);
+  gaia_screen_handler_->HandleFrameLoadingCompleted(0);
+
+  if (test_expects_complete_login_)
+    SubmitLoginFormForTest();
+}
+
 void SigninScreenHandler::HandleSignOutUser() {
   if (delegate_)
     delegate_->Signout();
 }
 
 void SigninScreenHandler::HandleCreateAccount() {
   if (delegate_)
     delegate_->CreateAccount();
 }
 
@@ skipping 13 matching lines @@
         content::NotificationService::NoDetails());
     TRACE_EVENT_ASYNC_END0(
         "ui", "ShowLoginWebUI", LoginDisplayHostImpl::kShowLoginWebUIid);
   }
   webui_visible_ = true;
   if (preferences_changed_delayed_)
     OnPreferencesChanged();
 }
 
 void SigninScreenHandler::HandleCancelPasswordChangedFlow() {
-  gaia_screen_handler_->StartClearingCookies(
-      base::Bind(&SigninScreenHandler::CancelPasswordChangedFlowInternal,
-                 weak_factory_.GetWeakPtr()));
+  StartClearingCookies(base::Bind(
+      &SigninScreenHandler::CancelPasswordChangedFlowInternal,
+      weak_factory_.GetWeakPtr()));
 }
 
 void SigninScreenHandler::HandleCancelUserAdding() {
   if (delegate_)
     delegate_->CancelUserAdding();
 }
 
 void SigninScreenHandler::HandleMigrateUserData(
     const std::string& old_password) {
   if (delegate_)
@@ skipping 58 matching lines @@
                  "login.GaiaSigninScreen.setAuthenticatedUserEmail",
                  attempt_token),
       Profile::FromWebUI(web_ui())->GetRequestContext()));
 }
 
 void SigninScreenHandler::HandleLaunchKioskApp(const std::string& app_id,
                                                bool diagnostic_mode) {
   delegate_->LoginAsKioskApp(app_id, diagnostic_mode);
 }
 
+void SigninScreenHandler::StartClearingDnsCache() {
+  if (dns_clear_task_running_ || !g_browser_process->io_thread())
+    return;
+
+  dns_cleared_ = false;
+  BrowserThread::PostTaskAndReply(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&ClearDnsCache, g_browser_process->io_thread()),
+      base::Bind(&SigninScreenHandler::OnDnsCleared,
+                 weak_factory_.GetWeakPtr()));
+  dns_clear_task_running_ = true;
+}
+
+void SigninScreenHandler::StartClearingCookies(
+    const base::Closure& on_clear_callback) {
+  cookies_cleared_ = false;
+  ProfileHelper* profile_helper =
+      g_browser_process->platform_part()->profile_helper();
+  LOG_ASSERT(
+      Profile::FromWebUI(web_ui()) == profile_helper->GetSigninProfile());
+  profile_helper->ClearSigninProfile(base::Bind(
+      &SigninScreenHandler::OnCookiesCleared,
+      weak_factory_.GetWeakPtr(), on_clear_callback));
+}
+
+void SigninScreenHandler::MaybePreloadAuthExtension() {
+  LOG(WARNING) << "MaybePreloadAuthExtension() call.";
+
+  // Fetching of the extension is not started before account picker page is
+  // loaded because it can affect the loading speed. Also if cookies clearing
+  // was initiated or |dns_clear_task_running_| then auth extension showing has
+  // already been initiated and preloading is senseless.
+  // Do not load the extension for the screen locker, see crosbug.com/25018.
+  if (is_account_picker_showing_first_time_ &&
+      !gaia_silent_load_ &&
+      !ScreenLocker::default_screen_locker() &&
+      !cookies_cleared_ &&
+      !dns_clear_task_running_ &&
+      network_state_informer_->state() == NetworkStateInformer::ONLINE) {
+    gaia_silent_load_ = true;
+    gaia_silent_load_network_ = network_state_informer_->network_path();
+    LoadAuthExtension(true, true, false);
+  }
+}
+
 bool SigninScreenHandler::AllWhitelistedUsersPresent() {
   CrosSettings* cros_settings = CrosSettings::Get();
   bool allow_new_user = false;
   cros_settings->GetBoolean(kAccountsPrefAllowNewUser, &allow_new_user);
   if (allow_new_user)
     return false;
   UserManager* user_manager = UserManager::Get();
   const UserList& users = user_manager->GetUsers();
   if (!delegate_ || users.size() > kMaxUsers) {
     return false;
@@ skipping 55 matching lines @@
   CrosSettings* cros_settings = CrosSettings::Get();
   if (!cros_settings)
     return false;
 
   // Offline login is allowed only when user pods are hidden.
   bool show_pods;
   cros_settings->GetBoolean(kAccountsPrefShowUserNamesOnSignIn, &show_pods);
   return !show_pods;
 }
 
+void SigninScreenHandler::SubmitLoginFormForTest() {
+  VLOG(2) << "Submit login form for test, user=" << test_user_;
+
+  std::string code;
+  code += "document.getElementById('Email').value = '" + test_user_ + "';";
+  code += "document.getElementById('Passwd').value = '" + test_pass_ + "';";
+  code += "document.getElementById('signIn').click();";
+
+  content::RenderFrameHost* frame =
+      LoginDisplayHostImpl::GetGaiaAuthIframe(web_ui()->GetWebContents());
+  frame->ExecuteJavaScript(base::ASCIIToUTF16(code));
+
+  // Test properties are cleared in HandleCompleteLogin because the form
+  // submission might fail and login will not be attempted after reloading
+  // if they are cleared here.
+}
+
 void SigninScreenHandler::ContinueKioskEnableFlow(
     policy::AutoEnrollmentState state) {
   // Do not proceed with kiosk enable when auto enroll will be enforced.
   // TODO(xiyuan): Add an error UI feedkback so user knows what happens.
   switch (state) {
     case policy::AUTO_ENROLLMENT_STATE_IDLE:
     case policy::AUTO_ENROLLMENT_STATE_PENDING:
     case policy::AUTO_ENROLLMENT_STATE_CONNECTION_ERROR:
       // Wait for the next callback.
       return;
     case policy::AUTO_ENROLLMENT_STATE_TRIGGER_ENROLLMENT:
       // Auto-enrollment is on.
       LOG(WARNING) << "Kiosk enable flow aborted because auto enrollment is "
                       "going to be enforced.";
       if (!kiosk_enable_flow_aborted_callback_for_test_.is_null())
         kiosk_enable_flow_aborted_callback_for_test_.Run();
       break;
     case policy::AUTO_ENROLLMENT_STATE_SERVER_ERROR:
     case policy::AUTO_ENROLLMENT_STATE_NO_ENROLLMENT:
       // Auto-enrollment not applicable.
       if (delegate_)
         delegate_->ShowKioskEnableScreen();
       break;
   }
   auto_enrollment_progress_subscription_.reset();
 }
 
-void SigninScreenHandler::OnShowAddUser() {
+void SigninScreenHandler::OnShowAddUser(const std::string& email) {
+  email_ = email;
   is_account_picker_showing_first_time_ = false;
-  DCHECK(gaia_screen_handler_);
-  gaia_screen_handler_->ShowGaia();
+
+  if (gaia_silent_load_ && email_.empty()) {
+    dns_cleared_ = true;
+    cookies_cleared_ = true;
+    ShowSigninScreenIfReady();
+  } else {
+    StartClearingDnsCache();
+    StartClearingCookies(base::Bind(
+        &SigninScreenHandler::ShowSigninScreenIfReady,
+        weak_factory_.GetWeakPtr()));
+  }
+}
+
+void SigninScreenHandler::SetSAMLPrincipalsAPIUsed(bool api_used) {
+  using_saml_api_ = api_used;
+  UMA_HISTOGRAM_BOOLEAN("ChromeOS.SAML.APIUsed", api_used);
 }
 
 GaiaScreenHandler::FrameState SigninScreenHandler::FrameState() const {
   DCHECK(gaia_screen_handler_);
   return gaia_screen_handler_->frame_state();
 }
 
 net::Error SigninScreenHandler::FrameError() const {
   DCHECK(gaia_screen_handler_);
   return gaia_screen_handler_->frame_error();
 }
 
 void SigninScreenHandler::OnCapsLockChanged(bool enabled) {
   caps_lock_enabled_ = enabled;
   if (page_is_ready())
     CallJS("login.AccountPickerScreen.setCapsLockState", caps_lock_enabled_);
 }
 
 }  // namespace chromeos