cros: Make sure views-based lock screen is destroyed after it is dismissed.

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/login/ui/lock_screen.h"
@@ skipping 226 matching lines @@
   imm->SetState(saved_ime_state_->Clone());
 
   authenticator_ = UserSessionManager::GetInstance()->CreateAuthenticator(this);
   extended_authenticator_ = ExtendedAuthenticator::Create(this);
   if (IsUsingMdLogin()) {
     // Create delegate that calls into the views-based lock screen via mojo.
     delegate_ = new MojoDelegate();
     owns_delegate_ = true;
 
     // Create and display lock screen.
-    // TODO(jdufault): Calling ash::ShowLockScreenInWidget should be a mojo
-    // call. We should only set the session state to locked after the mojo call
-    // has completed.
-    if (ash::ShowLockScreen()) {
+    LockScreenClient::Get()->ShowLockScreen(base::BindOnce([](bool did_show) {
+      CHECK(did_show);
       session_manager::SessionManager::Get()->SetSessionState(
           session_manager::SessionState::LOCKED);
-    }
+    }));
   } else {
     web_ui_.reset(new WebUIScreenLocker(this));
     delegate_ = web_ui_.get();
     owns_delegate_ = false;
     web_ui_->LockScreen();
 
     // Ownership of |icon_image_source| is passed.
     screenlock_icon_provider_ = base::MakeUnique<ScreenlockIconProvider>();
     ScreenlockIconSource* screenlock_icon_source =
         new ScreenlockIconSource(screenlock_icon_provider_->AsWeakPtr());
@@ skipping 23 matching lines @@
   // 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);
 
   if (auth_status_consumer_)
     auth_status_consumer_->OnAuthFailure(error);
+
+  if (on_auth_complete_)
+    std::move(on_auth_complete_).Run(false);
 }
 
 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";
   } else {
     base::TimeDelta delta = base::Time::Now() - authentication_start_time_;
     VLOG(1) << "Authentication success: " << delta.InSecondsF() << " second(s)";
@@ skipping 34 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();
+
+  if (on_auth_complete_)
+    std::move(on_auth_complete_).Run(true);
 }
 
 void ScreenLocker::OnPasswordAuthSuccess(const UserContext& user_context) {
   // The user has signed in using their password, so reset the PIN timeout.
   quick_unlock::QuickUnlockStorage* quick_unlock_storage =
       quick_unlock::QuickUnlockFactory::GetForAccountId(
           user_context.GetAccountId());
   if (quick_unlock_storage)
     quick_unlock_storage->MarkStrongAuth();
 }
 
 void ScreenLocker::UnlockOnLoginSuccess() {
   DCHECK(base::MessageLoopForUI::IsCurrent());
   if (!authentication_capture_.get()) {
     LOG(WARNING) << "Call to UnlockOnLoginSuccess without previous " <<
       "authentication success.";
     return;
   }
 
   if (auth_status_consumer_) {
     auth_status_consumer_->OnAuthSuccess(authentication_capture_->user_context);
   }
   authentication_capture_.reset();
   weak_factory_.InvalidateWeakPtrs();
 
   VLOG(1) << "Hiding the lock screen.";
   chromeos::ScreenLocker::Hide();
 }
 
-void ScreenLocker::Authenticate(const UserContext& user_context) {
+void ScreenLocker::Authenticate(const UserContext& user_context,
+                                AuthenticateCallback callback) {
   LOG_ASSERT(IsUserLoggedIn(user_context.GetAccountId()))
       << "Invalid user trying to unlock.";
 
+  DCHECK(!on_auth_complete_);
+  on_auth_complete_ = std::move(callback);
+
   authentication_start_time_ = base::Time::Now();
   delegate_->SetPasswordInputEnabled(false);
   if (user_context.IsUsingPin())
     unlock_attempt_type_ = AUTH_PIN;
 
   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();
 
@@ skipping 324 matching lines @@
     }
   }
 
   if (auth_status_consumer_) {
     AuthFailure failure(AuthFailure::UNLOCK_FAILED);
     auth_status_consumer_->OnAuthFailure(failure);
   }
 }
 
 }  // namespace chromeos