Create Mojo Struct for user information used in login/lock screen.

components/proximity_auth/unlock_manager_impl_unittest.cc

 // Copyright 2015 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 "components/proximity_auth/unlock_manager_impl.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/macros.h"
@@ skipping 622 matching lines @@
 }
 
 TEST_F(ProximityAuthUnlockManagerImplTest,
        OnAuthAttempted_NoRemoteDeviceLifeCycle) {
   CreateUnlockManager(ProximityAuthSystem::SESSION_LOCK);
   SimulateUserPresentState();
 
   unlock_manager_->SetRemoteDeviceLifeCycle(nullptr);
 
   EXPECT_CALL(proximity_auth_client_, FinalizeUnlock(false));
-  unlock_manager_->OnAuthAttempted(ScreenlockBridge::LockHandler::USER_CLICK);
+  unlock_manager_->OnAuthAttempted(mojom::AuthType::USER_CLICK);
 }
 
 TEST_F(ProximityAuthUnlockManagerImplTest, OnAuthAttempted_UnlockNotAllowed) {
   CreateUnlockManager(ProximityAuthSystem::SESSION_LOCK);
   SimulateUserPresentState();
 
   ON_CALL(*proximity_monitor(), IsUnlockAllowed()).WillByDefault(Return(false));
 
   EXPECT_CALL(proximity_auth_client_, FinalizeUnlock(false));
-  unlock_manager_->OnAuthAttempted(ScreenlockBridge::LockHandler::USER_CLICK);
+  unlock_manager_->OnAuthAttempted(mojom::AuthType::USER_CLICK);
 }
 
 TEST_F(ProximityAuthUnlockManagerImplTest, OnAuthAttempted_NotUserClick) {
   CreateUnlockManager(ProximityAuthSystem::SESSION_LOCK);
   SimulateUserPresentState();
 
   EXPECT_CALL(proximity_auth_client_, FinalizeUnlock(_)).Times(0);
-  unlock_manager_->OnAuthAttempted(
-      ScreenlockBridge::LockHandler::EXPAND_THEN_USER_CLICK);
+  unlock_manager_->OnAuthAttempted(mojom::AuthType::EXPAND_THEN_USER_CLICK);
 }
 
 TEST_F(ProximityAuthUnlockManagerImplTest, OnAuthAttempted_DuplicateCall) {
   CreateUnlockManager(ProximityAuthSystem::SESSION_LOCK);
   SimulateUserPresentState();
 
   EXPECT_CALL(messenger_, RequestUnlock());
-  unlock_manager_->OnAuthAttempted(ScreenlockBridge::LockHandler::USER_CLICK);
+  unlock_manager_->OnAuthAttempted(mojom::AuthType::USER_CLICK);
 
   EXPECT_CALL(messenger_, RequestUnlock()).Times(0);
-  unlock_manager_->OnAuthAttempted(ScreenlockBridge::LockHandler::USER_CLICK);
+  unlock_manager_->OnAuthAttempted(mojom::AuthType::USER_CLICK);
 }
 
 TEST_F(ProximityAuthUnlockManagerImplTest, OnAuthAttempted_TimesOut) {
   CreateUnlockManager(ProximityAuthSystem::SESSION_LOCK);
   SimulateUserPresentState();
 
-  unlock_manager_->OnAuthAttempted(ScreenlockBridge::LockHandler::USER_CLICK);
+  unlock_manager_->OnAuthAttempted(mojom::AuthType::USER_CLICK);
 
   // Simulate the timeout period elapsing.
   EXPECT_CALL(proximity_auth_client_, FinalizeUnlock(false));
   RunPendingTasks();
 }
 
 TEST_F(ProximityAuthUnlockManagerImplTest,
        OnAuthAttempted_DoesntTimeOutFollowingResponse) {
   CreateUnlockManager(ProximityAuthSystem::SESSION_LOCK);
   SimulateUserPresentState();
 
-  unlock_manager_->OnAuthAttempted(ScreenlockBridge::LockHandler::USER_CLICK);
+  unlock_manager_->OnAuthAttempted(mojom::AuthType::USER_CLICK);
 
   EXPECT_CALL(proximity_auth_client_, FinalizeUnlock(_));
   unlock_manager_->OnUnlockResponse(false);
 
   // Simulate the timeout period elapsing.
   EXPECT_CALL(proximity_auth_client_, FinalizeUnlock(_)).Times(0);
   RunPendingTasks();
 }
 
 TEST_F(ProximityAuthUnlockManagerImplTest,
        OnAuthAttempted_Unlock_SupportsSignIn_UnlockRequestFails) {
   ON_CALL(messenger_, SupportsSignIn()).WillByDefault(Return(true));
   CreateUnlockManager(ProximityAuthSystem::SESSION_LOCK);
   SimulateUserPresentState();
 
   EXPECT_CALL(messenger_, RequestUnlock());
-  unlock_manager_->OnAuthAttempted(ScreenlockBridge::LockHandler::USER_CLICK);
+  unlock_manager_->OnAuthAttempted(mojom::AuthType::USER_CLICK);
 
   EXPECT_CALL(proximity_auth_client_, FinalizeUnlock(false));
   unlock_manager_->OnUnlockResponse(false);
 }
 
 TEST_F(ProximityAuthUnlockManagerImplTest,
        OnAuthAttempted_Unlock_WithSignIn_RequestSucceeds_EventSendFails) {
   ON_CALL(messenger_, SupportsSignIn()).WillByDefault(Return(true));
   CreateUnlockManager(ProximityAuthSystem::SESSION_LOCK);
   SimulateUserPresentState();
 
   EXPECT_CALL(messenger_, RequestUnlock());
-  unlock_manager_->OnAuthAttempted(ScreenlockBridge::LockHandler::USER_CLICK);
+  unlock_manager_->OnAuthAttempted(mojom::AuthType::USER_CLICK);
 
   EXPECT_CALL(messenger_, DispatchUnlockEvent());
   unlock_manager_->OnUnlockResponse(true);
 
   EXPECT_CALL(proximity_auth_client_, FinalizeUnlock(false));
   unlock_manager_->OnUnlockEventSent(false);
 }
 
 TEST_F(ProximityAuthUnlockManagerImplTest,
        OnAuthAttempted_Unlock_WithSignIn_RequestSucceeds_EventSendSucceeds) {
   ON_CALL(messenger_, SupportsSignIn()).WillByDefault(Return(true));
   CreateUnlockManager(ProximityAuthSystem::SESSION_LOCK);
   SimulateUserPresentState();
 
   EXPECT_CALL(messenger_, RequestUnlock());
-  unlock_manager_->OnAuthAttempted(ScreenlockBridge::LockHandler::USER_CLICK);
+  unlock_manager_->OnAuthAttempted(mojom::AuthType::USER_CLICK);
 
   EXPECT_CALL(messenger_, DispatchUnlockEvent());
   unlock_manager_->OnUnlockResponse(true);
 
   EXPECT_CALL(proximity_auth_client_, FinalizeUnlock(true));
   unlock_manager_->OnUnlockEventSent(true);
 }
 
 TEST_F(ProximityAuthUnlockManagerImplTest,
        OnAuthAttempted_Unlock_DoesntSupportSignIn_UnlockEventSendFails) {
   ON_CALL(messenger_, SupportsSignIn()).WillByDefault(Return(false));
   CreateUnlockManager(ProximityAuthSystem::SESSION_LOCK);
   SimulateUserPresentState();
 
   EXPECT_CALL(messenger_, DispatchUnlockEvent());
-  unlock_manager_->OnAuthAttempted(ScreenlockBridge::LockHandler::USER_CLICK);
+  unlock_manager_->OnAuthAttempted(mojom::AuthType::USER_CLICK);
 
   EXPECT_CALL(proximity_auth_client_, FinalizeUnlock(false));
   unlock_manager_->OnUnlockEventSent(false);
 }
 
 TEST_F(ProximityAuthUnlockManagerImplTest,
        OnAuthAttempted_Unlock_SupportsSignIn_UnlockEventSendSucceeds) {
   ON_CALL(messenger_, SupportsSignIn()).WillByDefault(Return(false));
   CreateUnlockManager(ProximityAuthSystem::SESSION_LOCK);
   SimulateUserPresentState();
 
   EXPECT_CALL(messenger_, DispatchUnlockEvent());
-  unlock_manager_->OnAuthAttempted(ScreenlockBridge::LockHandler::USER_CLICK);
+  unlock_manager_->OnAuthAttempted(mojom::AuthType::USER_CLICK);
 
   EXPECT_CALL(proximity_auth_client_, FinalizeUnlock(true));
   unlock_manager_->OnUnlockEventSent(true);
 }
 
 TEST_F(ProximityAuthUnlockManagerImplTest, OnAuthAttempted_SignIn_Success) {
   ON_CALL(messenger_, SupportsSignIn()).WillByDefault(Return(true));
   CreateUnlockManager(ProximityAuthSystem::SIGN_IN);
   SimulateUserPresentState();
 
   std::string channel_binding_data = secure_context_.GetChannelBindingData();
   EXPECT_CALL(proximity_auth_client_,
               GetChallengeForUserAndDevice(remote_device_.user_id,
                                            remote_device_.public_key,
                                            channel_binding_data, _))
       .WillOnce(Invoke(
           [](const std::string& user_id, const std::string& public_key,
              const std::string& channel_binding_data,
              base::Callback<void(const std::string& challenge)> callback) {
             callback.Run(kChallenge);
           }));
 
   EXPECT_CALL(messenger_, RequestDecryption(kChallenge));
-  unlock_manager_->OnAuthAttempted(ScreenlockBridge::LockHandler::USER_CLICK);
+  unlock_manager_->OnAuthAttempted(mojom::AuthType::USER_CLICK);
 
   EXPECT_CALL(messenger_, DispatchUnlockEvent());
   unlock_manager_->OnDecryptResponse(kSignInSecret);
 
   EXPECT_CALL(proximity_auth_client_, FinalizeSignin(kSignInSecret));
   unlock_manager_->OnUnlockEventSent(true);
 }
 
 TEST_F(ProximityAuthUnlockManagerImplTest,
        OnAuthAttempted_SignIn_UnlockEventSendFails) {
   ON_CALL(messenger_, SupportsSignIn()).WillByDefault(Return(true));
   CreateUnlockManager(ProximityAuthSystem::SIGN_IN);
   SimulateUserPresentState();
 
   std::string channel_binding_data = secure_context_.GetChannelBindingData();
   EXPECT_CALL(proximity_auth_client_,
               GetChallengeForUserAndDevice(remote_device_.user_id,
                                            remote_device_.public_key,
                                            channel_binding_data, _))
       .WillOnce(Invoke(
           [](const std::string& user_id, const std::string& public_key,
              const std::string& channel_binding_data,
              base::Callback<void(const std::string& challenge)> callback) {
             callback.Run(kChallenge);
           }));
 
   EXPECT_CALL(messenger_, RequestDecryption(kChallenge));
-  unlock_manager_->OnAuthAttempted(ScreenlockBridge::LockHandler::USER_CLICK);
+  unlock_manager_->OnAuthAttempted(mojom::AuthType::USER_CLICK);
 
   EXPECT_CALL(messenger_, DispatchUnlockEvent());
   unlock_manager_->OnDecryptResponse(kSignInSecret);
 
   EXPECT_CALL(proximity_auth_client_, FinalizeSignin(std::string()));
   unlock_manager_->OnUnlockEventSent(false);
 }
 
 TEST_F(ProximityAuthUnlockManagerImplTest,
        OnAuthAttempted_SignIn_DecryptRequestFails) {
   ON_CALL(messenger_, SupportsSignIn()).WillByDefault(Return(true));
   CreateUnlockManager(ProximityAuthSystem::SIGN_IN);
   SimulateUserPresentState();
 
   std::string channel_binding_data = secure_context_.GetChannelBindingData();
   EXPECT_CALL(proximity_auth_client_,
               GetChallengeForUserAndDevice(remote_device_.user_id,
                                            remote_device_.public_key,
                                            channel_binding_data, _))
       .WillOnce(Invoke(
           [](const std::string& user_id, const std::string& public_key,
              const std::string& channel_binding_data,
              base::Callback<void(const std::string& challenge)> callback) {
             callback.Run(kChallenge);
           }));
 
   EXPECT_CALL(messenger_, RequestDecryption(kChallenge));
-  unlock_manager_->OnAuthAttempted(ScreenlockBridge::LockHandler::USER_CLICK);
+  unlock_manager_->OnAuthAttempted(mojom::AuthType::USER_CLICK);
 
   EXPECT_CALL(proximity_auth_client_, FinalizeSignin(std::string()));
   unlock_manager_->OnDecryptResponse(std::string());
 }
 
 }  // namespace proximity_auth