cros: Cleanup lock screen and OOBE C++ backing code.

chrome/browser/chromeos/login/lock/screen_locker.cc

 // Copyright 2014 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/chromeos/login/lock/screen_locker.h"
 
 #include <string>
 #include <vector>
 
 #include "ash/common/wallpaper/wallpaper_controller.h"
@@ skipping 145 matching lines @@
 }
 
 void ScreenLocker::Init() {
   input_method::InputMethodManager* imm =
       input_method::InputMethodManager::Get();
   saved_ime_state_ = imm->GetActiveIMEState();
   imm->SetState(saved_ime_state_->Clone());
 
   authenticator_ = UserSessionManager::GetInstance()->CreateAuthenticator(this);
   extended_authenticator_ = ExtendedAuthenticator::Create(this);
-  delegate_.reset(new WebUIScreenLocker(this));
-  delegate_->LockScreen();
+  web_ui_.reset(new WebUIScreenLocker(this));
+  web_ui()->LockScreen();
 
   // Ownership of |icon_image_source| is passed.
   screenlock_icon_provider_.reset(new ScreenlockIconProvider);
   ScreenlockIconSource* screenlock_icon_source =
       new ScreenlockIconSource(screenlock_icon_provider_->AsWeakPtr());
-  content::URLDataSource::Add(
-      GetAssociatedWebUI()->GetWebContents()->GetBrowserContext(),
-      screenlock_icon_source);
+  content::URLDataSource::Add(web_ui()->GetWebContents()->GetBrowserContext(),
+                              screenlock_icon_source);
 }
 
 void ScreenLocker::OnAuthFailure(const AuthFailure& error) {
   content::RecordAction(UserMetricsAction("ScreenLocker_OnLoginFailure"));
   if (authentication_start_time_.is_null()) {
     LOG(ERROR) << "Start time is not set at authentication failure";
   } else {
     base::TimeDelta delta = base::Time::Now() - authentication_start_time_;
     VLOG(1) << "Authentication failure: " << delta.InSecondsF() << " second(s)";
     UMA_HISTOGRAM_TIMES("ScreenLocker.AuthenticationFailureTime", delta);
   }
 
   UMA_HISTOGRAM_ENUMERATION(
       "ScreenLocker.AuthenticationFailure",
       is_pin_attempt_ ? UnlockType::AUTH_PIN : UnlockType::AUTH_PASSWORD,
       UnlockType::AUTH_COUNT);
 
   EnableInput();
   // Don't enable signout button here as we're showing
   // MessageBubble.
 
-  delegate_->ShowErrorMessage(incorrect_passwords_count_++ ?
-                                  IDS_LOGIN_ERROR_AUTHENTICATING_2ND_TIME :
-                                  IDS_LOGIN_ERROR_AUTHENTICATING,
-                              HelpAppLauncher::HELP_CANT_ACCESS_ACCOUNT);
+  web_ui()->ShowErrorMessage(incorrect_passwords_count_++
+                                 ? IDS_LOGIN_ERROR_AUTHENTICATING_2ND_TIME
+                                 : IDS_LOGIN_ERROR_AUTHENTICATING,
+                             HelpAppLauncher::HELP_CANT_ACCESS_ACCOUNT);
 
   if (auth_status_consumer_)
     auth_status_consumer_->OnAuthFailure(error);
 }
 
 void ScreenLocker::OnAuthSuccess(const UserContext& user_context) {
   incorrect_passwords_count_ = 0;
   if (authentication_start_time_.is_null()) {
     if (user_context.GetAccountId().is_valid())
       LOG(ERROR) << "Start time is not set at authentication success";
@@ skipping 35 matching lines @@
 
   authentication_capture_.reset(new AuthenticationParametersCapture());
   authentication_capture_->user_context = user_context;
 
   // Add guard for case when something get broken in call chain to unlock
   // for sure.
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(&ScreenLocker::UnlockOnLoginSuccess,
                             weak_factory_.GetWeakPtr()),
       base::TimeDelta::FromMilliseconds(kUnlockGuardTimeoutMs));
-  delegate_->AnimateAuthenticationSuccess();
+  web_ui()->AnimateAuthenticationSuccess();
 }
 
 void ScreenLocker::OnPasswordAuthSuccess(const UserContext& user_context) {
   // The user has signed in using their password, so reset the PIN timeout.
   PinStorage* pin_storage =
       PinStorageFactory::GetForAccountId(user_context.GetAccountId());
   if (pin_storage)
     pin_storage->MarkStrongAuth();
 }
 
@@ skipping 13 matching lines @@
 
   VLOG(1) << "Hiding the lock screen.";
   chromeos::ScreenLocker::Hide();
 }
 
 void ScreenLocker::Authenticate(const UserContext& user_context) {
   LOG_ASSERT(IsUserLoggedIn(user_context.GetAccountId()))
       << "Invalid user trying to unlock.";
 
   authentication_start_time_ = base::Time::Now();
-  delegate_->SetInputEnabled(false);
-  delegate_->OnAuthenticate();
+  web_ui()->SetInputEnabled(false);
   is_pin_attempt_ = user_context.IsUsingPin();
 
   const user_manager::User* user = FindUnlockUser(user_context.GetAccountId());
   if (user) {
     // Check to see if the user submitted a PIN and it is valid.
     const std::string pin = user_context.GetKey()->GetSecret();
 
     // We only want to try authenticating the pin if it is a number,
     // otherwise we will timeout PIN if the user enters their account password
     // incorrectly more than a few times.
@@ skipping 34 matching lines @@
 const user_manager::User* ScreenLocker::FindUnlockUser(
     const AccountId& account_id) {
   for (const user_manager::User* user : users_) {
     if (user->GetAccountId() == account_id)
       return user;
   }
   return nullptr;
 }
 
 void ScreenLocker::ClearErrors() {
-  delegate_->ClearErrors();
+  web_ui()->ClearErrors();
 }
 
 void ScreenLocker::Signout() {
-  delegate_->ClearErrors();
+  web_ui()->ClearErrors();
   content::RecordAction(UserMetricsAction("ScreenLocker_Signout"));
   // We expect that this call will not wait for any user input.
   // If it changes at some point, we will need to force exit.
   chrome::AttemptUserExit();
 
   // Don't hide yet the locker because the chrome screen may become visible
   // briefly.
 }
 
 void ScreenLocker::EnableInput() {
-  delegate_->SetInputEnabled(true);
+  web_ui()->SetInputEnabled(true);
 }
 
 void ScreenLocker::ShowErrorMessage(int error_msg_id,
                                     HelpAppLauncher::HelpTopic help_topic_id,
                                     bool sign_out_only) {
-  delegate_->SetInputEnabled(!sign_out_only);
-  delegate_->ShowErrorMessage(error_msg_id, help_topic_id);
+  web_ui()->SetInputEnabled(!sign_out_only);
+  web_ui()->ShowErrorMessage(error_msg_id, help_topic_id);
 }
 
 void ScreenLocker::SetLoginStatusConsumer(
     chromeos::AuthStatusConsumer* consumer) {
   auth_status_consumer_ = consumer;
 }
 
 // static
 void ScreenLocker::InitClass() {
   DCHECK(!g_screen_lock_observer);
@@ skipping 151 matching lines @@
       content::Source<ScreenLocker>(this),
       content::Details<bool>(&state));
   VLOG(1) << "Calling session manager's HandleLockScreenShown D-Bus method";
   DBusThreadManager::Get()->GetSessionManagerClient()->NotifyLockScreenShown();
 
   input_method::InputMethodManager::Get()
       ->GetActiveIMEState()
       ->EnableLockScreenLayouts();
 }
 
-content::WebUI* ScreenLocker::GetAssociatedWebUI() {
-  return delegate_->GetAssociatedWebUI();
-}
-
 bool ScreenLocker::IsUserLoggedIn(const AccountId& account_id) const {
   for (user_manager::User* user : users_) {
     if (user->GetAccountId() == account_id)
       return true;
   }
   return false;
 }
 
 }  // namespace chromeos