chrome/browser/ui/webui/chromeos/login/gaia_screen_handler.cc

   1 // Copyright 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 "chrome/browser/ui/webui/chromeos/login/gaia_screen_handler.h"
   6
   7 #include "base/bind.h"
   8 #include "base/logging.h"
   9 #include "base/metrics/histogram.h"
  10 #include "base/prefs/pref_service.h"
  11 #include "base/strings/utf_string_conversions.h"
  12 #include "base/values.h"
  13 #include "chrome/browser/browser_process.h"
  14 #include "chrome/browser/browser_shutdown.h"
  15 #include "chrome/browser/chromeos/input_method/input_method_util.h"
  16 #include "chrome/browser/chromeos/language_preferences.h"
  17 #include "chrome/browser/chromeos/login/screens/network_error.h"
  18 #include "chrome/browser/chromeos/login/startup_utils.h"
  19 #include "chrome/browser/chromeos/login/ui/user_adding_screen.h"
  20 #include "chrome/browser/chromeos/login/users/chrome_user_manager.h"
  21 #include "chrome/browser/chromeos/policy/consumer_management_service.h"
  22 #include "chrome/browser/chromeos/policy/consumer_management_stage.h"
  23 #include "chrome/browser/chromeos/profiles/profile_helper.h"
  24 #include "chrome/browser/chromeos/settings/cros_settings.h"
  25 #include "chrome/browser/io_thread.h"
  26 #include "chrome/browser/lifetime/application_lifetime.h"
  27 #include "chrome/browser/ui/webui/chromeos/login/signin_screen_handler.h"
  28 #include "chrome/browser/ui/webui/signin/inline_login_ui.h"
  29 #include "chrome/common/chrome_version_info.h"
  30 #include "chrome/common/pref_names.h"
  31 #include "chrome/grit/generated_resources.h"
  32 #include "chromeos/chromeos_switches.h"
  33 #include "chromeos/login/auth/user_context.h"
  34 #include "chromeos/settings/cros_settings_names.h"
  35 #include "components/login/localized_values_builder.h"
  36 #include "components/user_manager/user_manager.h"
  37 #include "content/public/browser/browser_thread.h"
  38 #include "content/public/browser/render_frame_host.h"
  39 #include "google_apis/gaia/gaia_auth_util.h"
  40 #include "google_apis/gaia/gaia_switches.h"
  41 #include "google_apis/gaia/gaia_urls.h"
  42 #include "ui/base/ime/chromeos/input_method_manager.h"
  43 #include "ui/base/l10n/l10n_util.h"
  44
  45 using content::BrowserThread;
  46
  47 namespace chromeos {
  48
  49 namespace {
  50
  51 const char kJsScreenPath[] = "login.GaiaSigninScreen";
  52 const char kAuthIframeParentName[] = "signin-frame";
  53 const char kAuthIframeParentOrigin[] =
  54     "chrome-extension://mfffpogegjflfpflabcdkioaeobkgjik/";
  55
  56 void UpdateAuthParams(base::DictionaryValue* params,
  57                       bool has_users,
  58                       bool is_enrolling_consumer_management) {
  59   CrosSettings* cros_settings = CrosSettings::Get();
  60   bool allow_new_user = true;
  61   cros_settings->GetBoolean(kAccountsPrefAllowNewUser, &allow_new_user);
  62   bool allow_guest = true;
  63   cros_settings->GetBoolean(kAccountsPrefAllowGuest, &allow_guest);
  64   // Account creation depends on Guest sign-in (http://crosbug.com/24570).
  65   params->SetBoolean("createAccount", allow_new_user && allow_guest);
  66   params->SetBoolean("guestSignin", allow_guest);
  67
  68   // Allow supervised user creation only if:
  69   // 1. Enterprise managed device > is allowed by policy.
  70   // 2. Consumer device > owner exists.
  71   // 3. New users are allowed by owner.
  72   // 4. Supervised users are allowed by owner.
  73   bool supervised_users_allowed =
  74       user_manager::UserManager::Get()->AreSupervisedUsersAllowed();
  75   bool supervised_users_can_create = true;
  76   int message_id = -1;
  77   if (!has_users) {
  78     supervised_users_can_create = false;
  79     message_id = IDS_CREATE_SUPERVISED_USER_NO_MANAGER_TEXT;
  80   }
  81   if (!allow_new_user || !supervised_users_allowed) {
  82     supervised_users_can_create = false;
  83     message_id = IDS_CREATE_SUPERVISED_USER_CREATION_RESTRICTED_TEXT;
  84   }
  85   if (supervised_users_can_create &&
  86       ChromeUserManager::Get()
  87           ->GetUsersAllowedForSupervisedUsersCreation()
  88           .empty()) {
  89     supervised_users_can_create = false;
  90     message_id = IDS_CREATE_SUPERVISED_USER_NO_MANAGER_EXCEPT_KIDS_TEXT;
  91   }
  92
  93   params->SetBoolean("supervisedUsersEnabled", supervised_users_allowed);
  94   params->SetBoolean("supervisedUsersCanCreate", supervised_users_can_create);
  95   if (!supervised_users_can_create) {
  96     params->SetString("supervisedUsersRestrictionReason",
  97                       l10n_util::GetStringUTF16(message_id));
  98   }
  99
 100   // Now check whether we're in multi-profiles user adding scenario and
 101   // disable GAIA right panel features if that's the case.
 102   // For consumer management enrollment, we also hide all right panel components
 103   // and show only an enrollment message.
 104   if (UserAddingScreen::Get()->IsRunning() ||
 105       is_enrolling_consumer_management) {
 106     params->SetBoolean("createAccount", false);
 107     params->SetBoolean("guestSignin", false);
 108     params->SetBoolean("supervisedUsersEnabled", false);
 109   }
 110 }
 111
 112 void RecordSAMLScrapingVerificationResultInHistogram(bool success) {
 113   UMA_HISTOGRAM_BOOLEAN("ChromeOS.SAML.Scraping.VerificationResult", success);
 114 }
 115
 116 // The Task posted to PostTaskAndReply in StartClearingDnsCache on the IO
 117 // thread.
 118 void ClearDnsCache(IOThread* io_thread) {
 119   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 120   if (browser_shutdown::IsTryingToQuit())
 121     return;
 122
 123   io_thread->ClearHostCache();
 124 }
 125
 126 void PushFrontIMIfNotExists(const std::string& input_method,
 127                             std::vector<std::string>* input_methods) {
 128   if (input_method.empty())
 129     return;
 130
 131   if (std::find(input_methods->begin(), input_methods->end(), input_method) ==
 132       input_methods->end())
 133     input_methods->insert(input_methods->begin(), input_method);
 134 }
 135
 136 }  // namespace
 137
 138 GaiaContext::GaiaContext()
 139     : force_reload(false),
 140       is_local(false),
 141       password_changed(false),
 142       show_users(false),
 143       use_offline(false),
 144       has_users(false) {}
 145
 146 GaiaScreenHandler::GaiaScreenHandler(
 147     CoreOobeActor* core_oobe_actor,
 148     const scoped_refptr<NetworkStateInformer>& network_state_informer,
 149     policy::ConsumerManagementService* consumer_management)
 150     : BaseScreenHandler(kJsScreenPath),
 151       frame_state_(FRAME_STATE_UNKNOWN),
 152       frame_error_(net::OK),
 153       network_state_informer_(network_state_informer),
 154       consumer_management_(consumer_management),
 155       core_oobe_actor_(core_oobe_actor),
 156       dns_cleared_(false),
 157       dns_clear_task_running_(false),
 158       cookies_cleared_(false),
 159       show_when_dns_and_cookies_cleared_(false),
 160       focus_stolen_(false),
 161       gaia_silent_load_(false),
 162       using_saml_api_(false),
 163       is_enrolling_consumer_management_(false),
 164       test_expects_complete_login_(false),
 165       embedded_signin_enabled_by_shortcut_(false),
 166       signin_screen_handler_(NULL),
 167       weak_factory_(this) {
 168   DCHECK(network_state_informer_.get());
 169 }
 170
 171 GaiaScreenHandler::~GaiaScreenHandler() {
 172 }
 173
 174 void GaiaScreenHandler::LoadGaia(const GaiaContext& context) {
 175   if (!auth_extension_) {
 176     Profile* signin_profile = ProfileHelper::GetSigninProfile();
 177     auth_extension_.reset(new ScopedGaiaAuthExtension(signin_profile));
 178   }
 179
 180   base::DictionaryValue params;
 181   const bool is_enrolling_consumer_management =
 182       context.is_enrolling_consumer_management;
 183
 184   params.SetBoolean("forceReload", context.force_reload);
 185   params.SetBoolean("isLocal", context.is_local);
 186   params.SetBoolean("passwordChanged", context.password_changed);
 187   params.SetBoolean("isShowUsers", context.show_users);
 188   params.SetBoolean("useOffline", context.use_offline);
 189   params.SetString("email", context.email);
 190   params.SetBoolean("isEnrollingConsumerManagement",
 191                     is_enrolling_consumer_management);
 192
 193   UpdateAuthParams(&params,
 194                    context.has_users,
 195                    is_enrolling_consumer_management);
 196
 197   if (!context.use_offline) {
 198     const std::string app_locale = g_browser_process->GetApplicationLocale();
 199     if (!app_locale.empty())
 200       params.SetString("hl", app_locale);
 201   } else {
 202     base::DictionaryValue* localized_strings = new base::DictionaryValue();
 203     localized_strings->SetString(
 204         "stringEmail", l10n_util::GetStringUTF16(IDS_LOGIN_OFFLINE_EMAIL));
 205     localized_strings->SetString(
 206         "stringPassword",
 207         l10n_util::GetStringUTF16(IDS_LOGIN_OFFLINE_PASSWORD));
 208     localized_strings->SetString(
 209         "stringSignIn", l10n_util::GetStringUTF16(IDS_LOGIN_OFFLINE_SIGNIN));
 210     localized_strings->SetString(
 211         "stringEmptyEmail",
 212         l10n_util::GetStringUTF16(IDS_LOGIN_OFFLINE_EMPTY_EMAIL));
 213     localized_strings->SetString(
 214         "stringEmptyPassword",
 215         l10n_util::GetStringUTF16(IDS_LOGIN_OFFLINE_EMPTY_PASSWORD));
 216     localized_strings->SetString(
 217         "stringError", l10n_util::GetStringUTF16(IDS_LOGIN_OFFLINE_ERROR));
 218     params.Set("localizedStrings", localized_strings);
 219   }
 220
 221   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
 222
 223   const GURL gaia_url =
 224       command_line->HasSwitch(::switches::kGaiaUrl)
 225           ? GURL(command_line->GetSwitchValueASCII(::switches::kGaiaUrl))
 226           : GaiaUrls::GetInstance()->gaia_url();
 227   params.SetString("gaiaUrl", gaia_url.spec());
 228
 229   if (command_line->HasSwitch(switches::kGaiaEndpointChromeOS)) {
 230     params.SetString("gaiaEndpoint", command_line->GetSwitchValueASCII(
 231                                          switches::kGaiaEndpointChromeOS));
 232   }
 233   if (context.embedded_signin_enabled) {
 234     params.SetBoolean("useEmbedded", true);
 235     // We set 'constrained' here to switch troubleshooting page on embedded
 236     // signin to full tab.
 237     params.SetInteger("constrained", 1);
 238   }
 239
 240   frame_state_ = FRAME_STATE_LOADING;
 241   CallJS("loadAuthExtension", params);
 242 }
 243
 244 void GaiaScreenHandler::UpdateGaia(const GaiaContext& context) {
 245   base::DictionaryValue params;
 246   UpdateAuthParams(&params, context.has_users,
 247                    context.is_enrolling_consumer_management);
 248   CallJS("updateAuthExtension", params);
 249 }
 250
 251 void GaiaScreenHandler::ReloadGaia(bool force_reload) {
 252   if (frame_state_ == FRAME_STATE_LOADING && !force_reload) {
 253     VLOG(1) << "Skipping reloading of Gaia since gaia is loading.";
 254     return;
 255   }
 256   NetworkStateInformer::State state = network_state_informer_->state();
 257   if (state != NetworkStateInformer::ONLINE) {
 258     VLOG(1) << "Skipping reloading of Gaia since network state="
 259             << NetworkStateInformer::StatusString(state);
 260     return;
 261   }
 262   VLOG(1) << "Reloading Gaia.";
 263   frame_state_ = FRAME_STATE_LOADING;
 264   CallJS("doReload");
 265 }
 266
 267 void GaiaScreenHandler::SwitchToEmbeddedSignin() {
 268   // This feature should not be working on Stable,Beta images.
 269   chrome::VersionInfo::Channel channel = chrome::VersionInfo::GetChannel();
 270   if (channel == chrome::VersionInfo::CHANNEL_STABLE ||
 271       channel == chrome::VersionInfo::CHANNEL_BETA) {
 272     return;
 273   }
 274   embedded_signin_enabled_by_shortcut_ = true;
 275   LoadAuthExtension(
 276       true /* force */, true /* silent_load */, false /* offline */);
 277 }
 278
 279 void GaiaScreenHandler::CancelEmbeddedSignin() {
 280   embedded_signin_enabled_by_shortcut_ = false;
 281 }
 282
 283 void GaiaScreenHandler::DeclareLocalizedValues(
 284     ::login::LocalizedValuesBuilder* builder) {
 285   builder->Add("signinScreenTitle", IDS_SIGNIN_SCREEN_TITLE);
 286   builder->Add("signinScreenPasswordChanged",
 287                IDS_SIGNIN_SCREEN_PASSWORD_CHANGED);
 288   builder->Add("createAccount", IDS_CREATE_ACCOUNT_HTML);
 289   builder->Add("guestSignin", IDS_BROWSE_WITHOUT_SIGNING_IN_HTML);
 290   builder->Add("createSupervisedUser",
 291                IDS_CREATE_SUPERVISED_USER_HTML);
 292   builder->Add("createSupervisedUserFeatureName",
 293                IDS_CREATE_SUPERVISED_USER_FEATURE_NAME);
 294   builder->Add("consumerManagementEnrollmentSigninMessage",
 295                IDS_LOGIN_CONSUMER_MANAGEMENT_ENROLLMENT);
 296
 297   // Strings used by the SAML fatal error dialog.
 298   builder->Add("fatalErrorMessageNoAccountDetails",
 299                IDS_LOGIN_FATAL_ERROR_NO_ACCOUNT_DETAILS);
 300   builder->Add("fatalErrorMessageNoPassword",
 301                IDS_LOGIN_FATAL_ERROR_NO_PASSWORD);
 302   builder->Add("fatalErrorMessageVerificationFailed",
 303                IDS_LOGIN_FATAL_ERROR_PASSWORD_VERIFICATION);
 304   builder->Add("fatalErrorMessageInsecureURL",
 305                IDS_LOGIN_FATAL_ERROR_TEXT_INSECURE_URL);
 306   builder->Add("fatalErrorInstructions", IDS_LOGIN_FATAL_ERROR_INSTRUCTIONS);
 307   builder->Add("fatalErrorDismissButton", IDS_OK);
 308 }
 309
 310 void GaiaScreenHandler::GetAdditionalParameters(base::DictionaryValue* dict) {
 311   dict->SetBoolean("isWebviewSignin", StartupUtils::IsWebviewSigninEnabled());
 312 }
 313
 314 void GaiaScreenHandler::Initialize() {
 315 }
 316
 317 void GaiaScreenHandler::RegisterMessages() {
 318   AddCallback("frameLoadingCompleted",
 319               &GaiaScreenHandler::HandleFrameLoadingCompleted);
 320   AddCallback("completeLogin", &GaiaScreenHandler::HandleCompleteLogin);
 321   AddCallback("completeAuthentication",
 322               &GaiaScreenHandler::HandleCompleteAuthentication);
 323   AddCallback("usingSAMLAPI", &GaiaScreenHandler::HandleUsingSAMLAPI);
 324   AddCallback("scrapedPasswordCount",
 325               &GaiaScreenHandler::HandleScrapedPasswordCount);
 326   AddCallback("scrapedPasswordVerificationFailed",
 327               &GaiaScreenHandler::HandleScrapedPasswordVerificationFailed);
 328   AddCallback("loginWebuiReady", &GaiaScreenHandler::HandleGaiaUIReady);
 329   AddCallback("switchToFullTab", &GaiaScreenHandler::HandleSwitchToFullTab);
 330   AddCallback("toggleWebviewSignin",
 331               &GaiaScreenHandler::HandleToggleWebviewSignin);
 332 }
 333
 334 void GaiaScreenHandler::HandleFrameLoadingCompleted(int status) {
 335   const net::Error frame_error = static_cast<net::Error>(-status);
 336   if (frame_error == net::ERR_ABORTED) {
 337     LOG(WARNING) << "Ignoring Gaia frame error: " << frame_error;
 338     return;
 339   }
 340   frame_error_ = frame_error;
 341   if (frame_error == net::OK) {
 342     VLOG(1) << "Gaia is loaded";
 343     frame_state_ = FRAME_STATE_LOADED;
 344   } else {
 345     LOG(WARNING) << "Gaia frame error: " << frame_error_;
 346     frame_state_ = FRAME_STATE_ERROR;
 347   }
 348
 349   if (network_state_informer_->state() != NetworkStateInformer::ONLINE)
 350     return;
 351   if (frame_state_ == FRAME_STATE_LOADED)
 352     UpdateState(NetworkError::ERROR_REASON_UPDATE);
 353   else if (frame_state_ == FRAME_STATE_ERROR)
 354     UpdateState(NetworkError::ERROR_REASON_FRAME_ERROR);
 355 }
 356
 357 void GaiaScreenHandler::HandleCompleteAuthentication(
 358     const std::string& gaia_id,
 359     const std::string& email,
 360     const std::string& password,
 361     const std::string& auth_code) {
 362   if (!Delegate())
 363     return;
 364
 365   DCHECK(!email.empty());
 366   DCHECK(!gaia_id.empty());
 367   Delegate()->SetDisplayEmail(gaia::SanitizeEmail(email));
 368   UserContext user_context(email);
 369   user_context.SetGaiaID(gaia_id);
 370   user_context.SetKey(Key(password));
 371   user_context.SetAuthCode(auth_code);
 372   Delegate()->CompleteLogin(user_context);
 373 }
 374
 375 void GaiaScreenHandler::HandleCompleteLogin(const std::string& gaia_id,
 376                                             const std::string& typed_email,
 377                                             const std::string& password,
 378                                             bool using_saml) {
 379   if (!is_enrolling_consumer_management_) {
 380     DoCompleteLogin(gaia_id, typed_email, password, using_saml);
 381     return;
 382   }
 383
 384   // Consumer management enrollment is in progress.
 385   const std::string owner_email =
 386       user_manager::UserManager::Get()->GetOwnerEmail();
 387   if (typed_email != owner_email) {
 388     // Show Gaia sign-in screen again, since we only allow the owner to sign
 389     // in.
 390     populated_email_ = owner_email;
 391     ShowGaiaAsync(is_enrolling_consumer_management_);
 392     return;
 393   }
 394
 395   CHECK(consumer_management_);
 396   consumer_management_->SetOwner(owner_email,
 397                                  base::Bind(&GaiaScreenHandler::OnSetOwnerDone,
 398                                             weak_factory_.GetWeakPtr(),
 399                                             gaia_id,
 400                                             typed_email,
 401                                             password,
 402                                             using_saml));
 403 }
 404
 405 void GaiaScreenHandler::HandleUsingSAMLAPI() {
 406   SetSAMLPrincipalsAPIUsed(true);
 407 }
 408
 409 void GaiaScreenHandler::HandleScrapedPasswordCount(int password_count) {
 410   SetSAMLPrincipalsAPIUsed(false);
 411   // Use a histogram that has 11 buckets, one for each of the values in [0, 9]
 412   // and an overflow bucket at the end.
 413   UMA_HISTOGRAM_ENUMERATION(
 414       "ChromeOS.SAML.Scraping.PasswordCount", std::min(password_count, 10), 11);
 415   if (password_count == 0)
 416     HandleScrapedPasswordVerificationFailed();
 417 }
 418
 419 void GaiaScreenHandler::HandleScrapedPasswordVerificationFailed() {
 420   RecordSAMLScrapingVerificationResultInHistogram(false);
 421 }
 422
 423 void GaiaScreenHandler::HandleSwitchToFullTab() {
 424   CallJS("switchToFullTab");
 425 }
 426
 427 void GaiaScreenHandler::HandleToggleWebviewSignin() {
 428   if (StartupUtils::EnableWebviewSignin(
 429         !StartupUtils::IsWebviewSigninEnabled())) {
 430     chrome::AttemptRestart();
 431   }
 432 }
 433
 434 void GaiaScreenHandler::HandleGaiaUIReady() {
 435   if (focus_stolen_) {
 436     // Set focus to the Gaia page.
 437     // TODO(altimofeev): temporary solution, until focus parameters are
 438     // implemented on the Gaia side.
 439     // Do this only once. Any subsequent call would relod GAIA frame.
 440     focus_stolen_ = false;
 441     const char code[] =
 442         "if (typeof gWindowOnLoad != 'undefined') gWindowOnLoad();";
 443     content::RenderFrameHost* frame = InlineLoginUI::GetAuthIframe(
 444         web_ui()->GetWebContents(),
 445         GURL(kAuthIframeParentOrigin),
 446         kAuthIframeParentName);
 447     frame->ExecuteJavaScript(base::ASCIIToUTF16(code));
 448   }
 449   if (gaia_silent_load_) {
 450     focus_stolen_ = true;
 451     // Prevent focus stealing by the Gaia page.
 452     // TODO(altimofeev): temporary solution, until focus parameters are
 453     // implemented on the Gaia side.
 454     const char code[] =
 455         "var gWindowOnLoad = window.onload; "
 456         "window.onload=function() {};";
 457     content::RenderFrameHost* frame = InlineLoginUI::GetAuthIframe(
 458         web_ui()->GetWebContents(),
 459         GURL(kAuthIframeParentOrigin),
 460         kAuthIframeParentName);
 461     frame->ExecuteJavaScript(base::ASCIIToUTF16(code));
 462
 463     // As we could miss and window.onload could already be called, restore
 464     // focus to current pod (see crbug/175243).
 465     DCHECK(signin_screen_handler_);
 466     signin_screen_handler_->RefocusCurrentPod();
 467   }
 468   HandleFrameLoadingCompleted(0);
 469
 470   if (test_expects_complete_login_)
 471     SubmitLoginFormForTest();
 472 }
 473
 474 void GaiaScreenHandler::OnSetOwnerDone(const std::string& gaia_id,
 475                                        const std::string& typed_email,
 476                                        const std::string& password,
 477                                        bool using_saml,
 478                                        bool success) {
 479   CHECK(consumer_management_);
 480   if (success) {
 481     consumer_management_->SetStage(
 482         policy::ConsumerManagementStage::EnrollmentOwnerStored());
 483   } else {
 484     LOG(ERROR) << "Failed to write owner e-mail to boot lockbox.";
 485     consumer_management_->SetStage(
 486         policy::ConsumerManagementStage::EnrollmentBootLockboxFailed());
 487     // We should continue logging in the user, as there's not much we can do
 488     // here.
 489   }
 490   DoCompleteLogin(gaia_id, typed_email, password, using_saml);
 491 }
 492
 493 void GaiaScreenHandler::DoCompleteLogin(const std::string& gaia_id,
 494                                         const std::string& typed_email,
 495                                         const std::string& password,
 496                                         bool using_saml) {
 497   if (!Delegate())
 498     return;
 499
 500   if (using_saml && !using_saml_api_)
 501     RecordSAMLScrapingVerificationResultInHistogram(true);
 502
 503   DCHECK(!typed_email.empty());
 504   DCHECK(!gaia_id.empty());
 505   const std::string sanitized_email = gaia::SanitizeEmail(typed_email);
 506   Delegate()->SetDisplayEmail(sanitized_email);
 507   UserContext user_context(sanitized_email);
 508   user_context.SetGaiaID(gaia_id);
 509   user_context.SetKey(Key(password));
 510   user_context.SetAuthFlow(using_saml
 511                                ? UserContext::AUTH_FLOW_GAIA_WITH_SAML
 512                                : UserContext::AUTH_FLOW_GAIA_WITHOUT_SAML);
 513   Delegate()->CompleteLogin(user_context);
 514
 515   if (test_expects_complete_login_) {
 516     VLOG(2) << "Complete test login for " << typed_email
 517             << ", requested=" << test_user_;
 518
 519     test_expects_complete_login_ = false;
 520     test_user_.clear();
 521     test_pass_.clear();
 522   }
 523 }
 524
 525 void GaiaScreenHandler::PopulateEmail(const std::string& user_id) {
 526   populated_email_ = user_id;
 527 }
 528
 529 void GaiaScreenHandler::PasswordChangedFor(const std::string& user_id) {
 530   password_changed_for_.insert(user_id);
 531 }
 532
 533 void GaiaScreenHandler::StartClearingDnsCache() {
 534   if (dns_clear_task_running_ || !g_browser_process->io_thread())
 535     return;
 536
 537   dns_cleared_ = false;
 538   BrowserThread::PostTaskAndReply(
 539       BrowserThread::IO,
 540       FROM_HERE,
 541       base::Bind(&ClearDnsCache, g_browser_process->io_thread()),
 542       base::Bind(&GaiaScreenHandler::OnDnsCleared, weak_factory_.GetWeakPtr()));
 543   dns_clear_task_running_ = true;
 544 }
 545
 546 void GaiaScreenHandler::OnDnsCleared() {
 547   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 548   dns_clear_task_running_ = false;
 549   dns_cleared_ = true;
 550   ShowGaiaScreenIfReady();
 551 }
 552
 553 void GaiaScreenHandler::StartClearingCookies(
 554     const base::Closure& on_clear_callback) {
 555   cookies_cleared_ = false;
 556   ProfileHelper* profile_helper = ProfileHelper::Get();
 557   LOG_ASSERT(Profile::FromWebUI(web_ui()) ==
 558              profile_helper->GetSigninProfile());
 559   profile_helper->ClearSigninProfile(
 560       base::Bind(&GaiaScreenHandler::OnCookiesCleared,
 561                  weak_factory_.GetWeakPtr(),
 562                  on_clear_callback));
 563 }
 564
 565 void GaiaScreenHandler::OnCookiesCleared(
 566     const base::Closure& on_clear_callback) {
 567   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 568   cookies_cleared_ = true;
 569   on_clear_callback.Run();
 570 }
 571
 572 void GaiaScreenHandler::ShowSigninScreenForCreds(const std::string& username,
 573                                                  const std::string& password) {
 574   VLOG(2) << "ShowSigninScreenForCreds  for user " << username
 575           << ", frame_state=" << frame_state();
 576
 577   test_user_ = username;
 578   test_pass_ = password;
 579   test_expects_complete_login_ = true;
 580
 581   // Submit login form for test if gaia is ready. If gaia is loading, login
 582   // will be attempted in HandleLoginWebuiReady after gaia is ready. Otherwise,
 583   // reload gaia then follow the loading case.
 584   if (frame_state() == GaiaScreenHandler::FRAME_STATE_LOADED) {
 585     SubmitLoginFormForTest();
 586   } else if (frame_state() != GaiaScreenHandler::FRAME_STATE_LOADING) {
 587     DCHECK(signin_screen_handler_);
 588     signin_screen_handler_->OnShowAddUser();
 589   }
 590 }
 591
 592 void GaiaScreenHandler::SubmitLoginFormForTest() {
 593   VLOG(2) << "Submit login form for test, user=" << test_user_;
 594
 595   std::string code;
 596   code += "document.getElementById('Email').value = '" + test_user_ + "';";
 597   code += "document.getElementById('Passwd').value = '" + test_pass_ + "';";
 598   code += "document.getElementById('signIn').click();";
 599
 600   content::RenderFrameHost* frame = InlineLoginUI::GetAuthIframe(
 601       web_ui()->GetWebContents(),
 602       GURL(kAuthIframeParentOrigin),
 603       kAuthIframeParentName);
 604   frame->ExecuteJavaScript(base::ASCIIToUTF16(code));
 605
 606   // Test properties are cleared in HandleCompleteLogin because the form
 607   // submission might fail and login will not be attempted after reloading
 608   // if they are cleared here.
 609 }
 610
 611 void GaiaScreenHandler::SetSAMLPrincipalsAPIUsed(bool api_used) {
 612   using_saml_api_ = api_used;
 613   UMA_HISTOGRAM_BOOLEAN("ChromeOS.SAML.APIUsed", api_used);
 614 }
 615
 616 void GaiaScreenHandler::ShowGaiaAsync(bool is_enrolling_consumer_management) {
 617   is_enrolling_consumer_management_ = is_enrolling_consumer_management;
 618   show_when_dns_and_cookies_cleared_ = true;
 619   if (gaia_silent_load_ && populated_email_.empty()) {
 620     dns_cleared_ = true;
 621     cookies_cleared_ = true;
 622     ShowGaiaScreenIfReady();
 623   } else {
 624     StartClearingDnsCache();
 625     StartClearingCookies(base::Bind(&GaiaScreenHandler::ShowGaiaScreenIfReady,
 626                                     weak_factory_.GetWeakPtr()));
 627   }
 628 }
 629
 630 void GaiaScreenHandler::CancelShowGaiaAsync() {
 631   show_when_dns_and_cookies_cleared_ = false;
 632 }
 633
 634 void GaiaScreenHandler::ShowGaiaScreenIfReady() {
 635   if (!dns_cleared_ ||
 636       !cookies_cleared_ ||
 637       !show_when_dns_and_cookies_cleared_ ||
 638       !Delegate()) {
 639     return;
 640   }
 641
 642   std::string active_network_path = network_state_informer_->network_path();
 643   if (gaia_silent_load_ &&
 644       (network_state_informer_->state() != NetworkStateInformer::ONLINE ||
 645        gaia_silent_load_network_ != active_network_path)) {
 646     // Network has changed. Force Gaia reload.
 647     gaia_silent_load_ = false;
 648     // Gaia page will be realoded, so focus isn't stolen anymore.
 649     focus_stolen_ = false;
 650   }
 651
 652   // Note that LoadAuthExtension clears |populated_email_|.
 653   if (populated_email_.empty())
 654     Delegate()->LoadSigninWallpaper();
 655   else
 656     Delegate()->LoadWallpaper(populated_email_);
 657
 658   input_method::InputMethodManager* imm =
 659       input_method::InputMethodManager::Get();
 660
 661   scoped_refptr<input_method::InputMethodManager::State> gaia_ime_state =
 662       imm->GetActiveIMEState()->Clone();
 663   imm->SetState(gaia_ime_state);
 664
 665   // Set Least Recently Used input method for the user.
 666   if (!populated_email_.empty()) {
 667     SigninScreenHandler::SetUserInputMethod(populated_email_,
 668                                             gaia_ime_state.get());
 669   } else {
 670     std::vector<std::string> input_methods =
 671         imm->GetInputMethodUtil()->GetHardwareLoginInputMethodIds();
 672     const std::string owner_im = SigninScreenHandler::GetUserLRUInputMethod(
 673         user_manager::UserManager::Get()->GetOwnerEmail());
 674     const std::string system_im = g_browser_process->local_state()->GetString(
 675         language_prefs::kPreferredKeyboardLayout);
 676
 677     PushFrontIMIfNotExists(owner_im, &input_methods);
 678     PushFrontIMIfNotExists(system_im, &input_methods);
 679
 680     gaia_ime_state->EnableLoginLayouts(
 681         g_browser_process->GetApplicationLocale(), input_methods);
 682
 683     if (!system_im.empty()) {
 684       gaia_ime_state->ChangeInputMethod(system_im, false /* show_message */);
 685     } else if (!owner_im.empty()) {
 686       gaia_ime_state->ChangeInputMethod(owner_im, false /* show_message */);
 687     }
 688   }
 689
 690   LoadAuthExtension(!gaia_silent_load_, false, false);
 691   signin_screen_handler_->UpdateUIState(
 692       SigninScreenHandler::UI_STATE_GAIA_SIGNIN, NULL);
 693
 694   if (gaia_silent_load_) {
 695     // The variable is assigned to false because silently loaded Gaia page was
 696     // used.
 697     gaia_silent_load_ = false;
 698     if (focus_stolen_)
 699       HandleGaiaUIReady();
 700   }
 701   signin_screen_handler_->UpdateState(NetworkError::ERROR_REASON_UPDATE);
 702
 703   if (core_oobe_actor_) {
 704     PrefService* prefs = g_browser_process->local_state();
 705     if (prefs->GetBoolean(prefs::kFactoryResetRequested)) {
 706       core_oobe_actor_->ShowDeviceResetScreen();
 707     } else if (prefs->GetBoolean(prefs::kDebuggingFeaturesRequested)) {
 708       core_oobe_actor_->ShowEnableDebuggingScreen();
 709     }
 710   }
 711 }
 712
 713 void GaiaScreenHandler::MaybePreloadAuthExtension() {
 714   VLOG(1) << "MaybePreloadAuthExtension() call.";
 715
 716   // If cookies clearing was initiated or |dns_clear_task_running_| then auth
 717   // extension showing has already been initiated and preloading is senseless.
 718   if (signin_screen_handler_->ShouldLoadGaia() &&
 719       !gaia_silent_load_ &&
 720       !cookies_cleared_ &&
 721       !dns_clear_task_running_ &&
 722       network_state_informer_->state() == NetworkStateInformer::ONLINE) {
 723     gaia_silent_load_ = true;
 724     gaia_silent_load_network_ = network_state_informer_->network_path();
 725     LoadAuthExtension(true, true, false);
 726   }
 727 }
 728
 729 void GaiaScreenHandler::LoadAuthExtension(bool force,
 730                                           bool silent_load,
 731                                           bool offline) {
 732   GaiaContext context;
 733   context.force_reload = force;
 734   context.is_local = offline;
 735   context.password_changed = !populated_email_.empty() &&
 736                              password_changed_for_.count(populated_email_);
 737   context.use_offline = offline;
 738   context.email = populated_email_;
 739   context.is_enrolling_consumer_management = is_enrolling_consumer_management_;
 740   if (Delegate()) {
 741     context.show_users = Delegate()->IsShowUsers();
 742     context.has_users = !Delegate()->GetUsers().empty();
 743   }
 744
 745   context.embedded_signin_enabled =
 746       base::CommandLine::ForCurrentProcess()->HasSwitch(
 747           chromeos::switches::kEnableEmbeddedSignin) ||
 748       embedded_signin_enabled_by_shortcut_;
 749
 750   populated_email_.clear();
 751
 752   LoadGaia(context);
 753 }
 754
 755 void GaiaScreenHandler::UpdateState(NetworkError::ErrorReason reason) {
 756   if (signin_screen_handler_)
 757     signin_screen_handler_->UpdateState(reason);
 758 }
 759
 760 SigninScreenHandlerDelegate* GaiaScreenHandler::Delegate() {
 761   DCHECK(signin_screen_handler_);
 762   return signin_screen_handler_->delegate_;
 763 }
 764
 765 void GaiaScreenHandler::SetSigninScreenHandler(SigninScreenHandler* handler) {
 766   signin_screen_handler_ = handler;
 767 }
 768 }  // namespace chromeos