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

chrome/browser/signin/easy_unlock_auth_attempt_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 "chrome/browser/signin/easy_unlock_auth_attempt.h"
 
 #include <stddef.h>
 
 #include "base/macros.h"
 #include "build/build_config.h"
@@ skipping 99 matching lines @@
     STATE_NONE,
     STATE_ATTEMPTING_UNLOCK,
     STATE_UNLOCK_CANCELED,
     STATE_UNLOCK_DONE,
     STATE_ATTEMPTING_SIGNIN,
     STATE_SIGNIN_CANCELED,
     STATE_SIGNIN_DONE
   };
 
   explicit TestLockHandler(const AccountId& account_id)
-      : state_(STATE_NONE), auth_type_(USER_CLICK), account_id_(account_id) {}
+      : state_(STATE_NONE),
+        auth_type_(proximity_auth::mojom::AuthType::USER_CLICK),
+        account_id_(account_id) {}
 
   ~TestLockHandler() override {}
 
   void set_state(AuthState value) { state_ = value; }
   AuthState state() const { return state_; }
 
   // Sets the secret that is expected to be sent to |AttemptEasySignin|
   void set_expected_secret(const std::string& value) {
     expected_secret_ = value;
   }
 
   // Not using |SetAuthType| to make sure it's not called during tests.
-  void set_auth_type(AuthType value) { auth_type_ = value; }
+  void set_auth_type(proximity_auth::mojom::AuthType value) {
+    auth_type_ = value;
+  }
 
   // proximity_auth::ScreenlockBridge::LockHandler implementation:
   void ShowBannerMessage(const base::string16& message) override {
     ADD_FAILURE() << "Should not be reached.";
   }
 
   void ShowUserPodCustomIcon(
       const AccountId& account_id,
       const proximity_auth::ScreenlockBridge::UserPodCustomIconOptions& icon)
       override {
     ADD_FAILURE() << "Should not be reached.";
   }
 
   void HideUserPodCustomIcon(const AccountId& account_id) override {
     ADD_FAILURE() << "Should not be reached.";
   }
 
   void EnableInput() override {
     ASSERT_EQ(STATE_ATTEMPTING_UNLOCK, state_);
     state_ = STATE_UNLOCK_CANCELED;
   }
 
   void SetAuthType(const AccountId& account_id,
-                   AuthType auth_type,
+                   proximity_auth::mojom::AuthType auth_type,
                    const base::string16& auth_value) override {
     ADD_FAILURE() << "Should not be reached.";
   }
 
-  AuthType GetAuthType(const AccountId& account_id) const override {
+  proximity_auth::mojom::AuthType GetAuthType(
+      const AccountId& account_id) const override {
     return auth_type_;
   }
 
   ScreenType GetScreenType() const override {
     // Return an arbitrary value; this is not used by the test code.
     return LOCK_SCREEN;
   }
 
   void Unlock(const AccountId& account_id) override {
     ASSERT_TRUE(account_id_ == account_id)
@@ skipping 19 matching lines @@
       ASSERT_EQ(chromeos::EasyUnlockKeyManager::GetKeyLabel(0u), key_label);
       state_ = STATE_SIGNIN_DONE;
     }
 #else  // if !defined(OS_CHROMEOS)
     ADD_FAILURE() << "Should not be reached.";
 #endif
   }
 
  private:
   AuthState state_;
-  AuthType auth_type_;
+  proximity_auth::mojom::AuthType auth_type_;
   const AccountId account_id_;
   std::string expected_secret_;
 
   DISALLOW_COPY_AND_ASSIGN(TestLockHandler);
 };
 
 class EasyUnlockAuthAttemptUnlockTest : public testing::Test {
  public:
   EasyUnlockAuthAttemptUnlockTest() {}
   ~EasyUnlockAuthAttemptUnlockTest() override {}
@@ skipping 36 matching lines @@
   EXPECT_FALSE(auth_attempt_->Start());
   EXPECT_EQ(0u, app_manager_->auth_attempt_count());
 }
 
 TEST_F(EasyUnlockAuthAttemptUnlockTest, StartWhenAuthTypeIsPassword) {
   InitScreenLock();
   ASSERT_TRUE(proximity_auth::ScreenlockBridge::Get()->IsLocked());
   ASSERT_EQ(TestLockHandler::STATE_ATTEMPTING_UNLOCK, lock_handler_->state());
 
   lock_handler_->set_auth_type(
-      proximity_auth::ScreenlockBridge::LockHandler::OFFLINE_PASSWORD);
+      proximity_auth::mojom::AuthType::OFFLINE_PASSWORD);
 
   EXPECT_FALSE(auth_attempt_->Start());
 
   EXPECT_EQ(0u, app_manager_->auth_attempt_count());
   EXPECT_EQ(TestLockHandler::STATE_UNLOCK_CANCELED, lock_handler_->state());
 }
 
 TEST_F(EasyUnlockAuthAttemptUnlockTest,
        StartWhenDispatchingAuthAttemptEventFails) {
   InitScreenLock();
@@ skipping 137 matching lines @@
   EXPECT_FALSE(auth_attempt_->Start());
   EXPECT_EQ(0u, app_manager_->auth_attempt_count());
 }
 
 TEST_F(EasyUnlockAuthAttemptSigninTest, StartWhenAuthTypeIsPassword) {
   InitScreenLock();
   ASSERT_TRUE(proximity_auth::ScreenlockBridge::Get()->IsLocked());
   ASSERT_EQ(TestLockHandler::STATE_ATTEMPTING_SIGNIN, lock_handler_->state());
 
   lock_handler_->set_auth_type(
-      proximity_auth::ScreenlockBridge::LockHandler::OFFLINE_PASSWORD);
+      proximity_auth::mojom::AuthType::OFFLINE_PASSWORD);
 
   EXPECT_FALSE(auth_attempt_->Start());
 
   EXPECT_EQ(0u, app_manager_->auth_attempt_count());
   EXPECT_EQ(TestLockHandler::STATE_SIGNIN_CANCELED, lock_handler_->state());
 }
 
 TEST_F(EasyUnlockAuthAttemptSigninTest,
        StartWhenDispatchingAuthAttemptEventFails) {
   InitScreenLock();
@@ skipping 135 matching lines @@
   EXPECT_EQ(TestLockHandler::STATE_ATTEMPTING_SIGNIN, lock_handler_->state());
 
   auth_attempt_->FinalizeSignin(test_account_id1_, GetWrappedSecret(),
                                 GetSessionKey());
 
   EXPECT_EQ(TestLockHandler::STATE_SIGNIN_DONE, lock_handler_->state());
 }
 #endif  // defined(OS_CHROMEOS)
 
 }  // namespace