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