Adding mojo calls for several lock screen related operations.

chrome/browser/ui/ash/lock_screen_client.cc

 // Copyright 2017 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/ash/lock_screen_client.h"
 
+#include <utility>
+
 #include "ash/public/interfaces/constants.mojom.h"
 #include "chrome/browser/chromeos/login/lock/screen_locker.h"
+#include "chrome/browser/chromeos/login/reauth_stats.h"
+#include "chrome/browser/chromeos/login/users/wallpaper/wallpaper_manager.h"
 #include "content/public/common/service_manager_connection.h"
 #include "services/service_manager/public/cpp/connector.h"
 
 namespace {
 LockScreenClient* g_instance = nullptr;
 }  // namespace
 
 LockScreenClient::Delegate::Delegate() = default;
 LockScreenClient::Delegate::~Delegate() = default;
 
@@ skipping 17 matching lines @@
 
 // static
 LockScreenClient* LockScreenClient::Get() {
   return g_instance;
 }
 
 void LockScreenClient::AuthenticateUser(const AccountId& account_id,
                                         const std::string& hashed_password,
                                         bool authenticated_by_pin,
                                         AuthenticateUserCallback callback) {
-  // TODO(xiaoyinh): Complete the implementation below.
-  // It should be similar as SigninScreenHandler::HandleAuthenticateUser.
-  chromeos::UserContext user_context(account_id);
-  chromeos::Key key(chromeos::Key::KEY_TYPE_SALTED_SHA256_TOP_HALF,
-                    std::string(), hashed_password);
-  user_context.SetKey(key);
-  user_context.SetIsUsingPin(authenticated_by_pin);
-  chromeos::ScreenLocker::default_screen_locker()->Authenticate(
-      user_context, std::move(callback));
+  if (!delegate_)
+    return;
+  delegate_->HandleAuthenticateUser(account_id, hashed_password,
+                                    authenticated_by_pin, std::move(callback));
 }
 
 void LockScreenClient::ShowLockScreen(
     ash::mojom::LockScreen::ShowLockScreenCallback on_shown) {
   lock_screen_->ShowLockScreen(std::move(on_shown));
 }
 
 void LockScreenClient::AttemptUnlock(const AccountId& account_id) {
   if (!delegate_)
     return;
   delegate_->HandleAttemptUnlock(account_id);
 }
 
 void LockScreenClient::HardlockPod(const AccountId& account_id) {
   if (!delegate_)
     return;
   delegate_->HandleHardlockPod(account_id);
 }
 
 void LockScreenClient::RecordClickOnLockIcon(const AccountId& account_id) {
   if (!delegate_)
     return;
   delegate_->HandleRecordClickOnLockIcon(account_id);
 }
 
+void LockScreenClient::OnFocusPod(const AccountId& account_id) {
+  if (!delegate_)

[James Cook, 2017/06/13 00:58:04]

optional: If all these methods do is forward things to the delegate then

if (delegate_)
  delegate_->DoFoo();

is one line shorter. :-)

[xiaoyinh(OOO Sep 11-29), 2017/06/13 18:36:56]

Done.

+    return;
+  delegate_->HandleOnFocusPod(account_id);
+}
+
+void LockScreenClient::OnNoPodFocused() {
+  if (!delegate_)
+    return;
+  delegate_->HandleOnNoPodFocused();
+}

[James Cook, 2017/06/13 00:58:04]

It's a little odd that every mojo method here just calls a method with the same
name on the delegate. For a future CL, consider making the delegate
(ViewsScreenLocker?) directly implement the mojo interface.

[xiaoyinh(OOO Sep 11-29), 2017/06/13 18:36:56]

Thanks for the suggestion. Do you mean to have 2 separate code paths for calls
ash->chrome(LockScreenController->ViewsScreenLocker) and
chrome->ash(LockScreenClient->LockScreenController)?

Right now LockScreenClient will handle mojo method directly(like LoadWallpaper,
SignOutUser etc.) if they don't need to store some internal state.
ViewsScreenLocker in the other hand will store/update data like
focused_pod_account_id_ for mojo method OnFocusPod and OnNoPodFocused.

[James Cook, 2017/06/13 20:38:34]

It's just something to think about. I established this
FooController/FooControllerClient pattern for mojo in ash, but it's not
necessary to use it everywhere. It's most useful when both sides (Controller and
ControllerClient) both need to cache state.

+
+void LockScreenClient::LoadWallpaper(const AccountId& account_id) {
+  chromeos::WallpaperManager::Get()->SetUserWallpaperDelayed(account_id);
+}
+
+void LockScreenClient::SignOutUser() {
+  chromeos::ScreenLocker::default_screen_locker()->Signout();
+}
+
+void LockScreenClient::OnMaxIncorrectPasswordAttempted(
+    const AccountId& account_id) {
+  RecordReauthReason(account_id,
+                     chromeos::ReauthReason::INCORRECT_PASSWORD_ENTERED);
+}
+
 void LockScreenClient::ShowErrorMessage(int32_t login_attempts,
                                         const std::string& error_text,
                                         const std::string& help_link_text,
                                         int32_t help_topic_id) {
   lock_screen_->ShowErrorMessage(login_attempts, error_text, help_link_text,
                                  help_topic_id);
 }
 
 void LockScreenClient::ClearErrors() {
   lock_screen_->ClearErrors();
@@ skipping 13 matching lines @@
                                    ash::mojom::AuthType auth_type,
                                    const base::string16& initial_value) {
   lock_screen_->SetAuthType(account_id, auth_type, initial_value);
 }
 
 void LockScreenClient::LoadUsers(std::unique_ptr<base::ListValue> users_list,
                                  bool show_guest) {
   lock_screen_->LoadUsers(std::move(users_list), show_guest);
 }
 
+void LockScreenClient::SetPinEnabledForUser(const AccountId& account_id,
+                                            bool is_enabled) {
+  lock_screen_->SetPinEnabledForUser(account_id, is_enabled);
+}
+
 void LockScreenClient::SetDelegate(Delegate* delegate) {
   delegate_ = delegate;
 }