chrome/browser/chromeos/login/mock_authenticator.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/chromeos/login/mock_authenticator.h"
   6
   7 #include "base/bind.h"
   8 #include "chrome/browser/chromeos/login/user.h"
   9 #include "content/public/browser/browser_thread.h"
  10
  11 using content::BrowserThread;
  12
  13 namespace chromeos {
  14
  15 void MockAuthenticator::AuthenticateToLogin(Profile* profile,
  16                                             const UserContext& user_context) {
  17   if (expected_username_ == user_context.username &&
  18       expected_password_ == user_context.password) {
  19     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
  20         base::Bind(&MockAuthenticator::OnLoginSuccess, this));
  21     return;
  22   }
  23   GoogleServiceAuthError error(
  24       GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS);
  25   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
  26       base::Bind(&MockAuthenticator::OnLoginFailure, this,
  27                  LoginFailure::FromNetworkAuthFailure(error)));
  28 }
  29
  30 void MockAuthenticator::CompleteLogin(Profile* profile,
  31                                       const UserContext& user_context) {
  32   CHECK_EQ(expected_username_, user_context.username);
  33   CHECK_EQ(expected_password_, user_context.password);
  34   OnLoginSuccess();
  35 }
  36
  37 void MockAuthenticator::AuthenticateToUnlock(
  38     const UserContext& user_context) {
  39   AuthenticateToLogin(NULL /* not used */, user_context);
  40 }
  41
  42 void MockAuthenticator::LoginAsLocallyManagedUser(
  43     const UserContext& user_context) {
  44   consumer_->OnLoginSuccess(UserContext(expected_username_,
  45                                         std::string(),
  46                                         std::string(),
  47                                         user_context.username)); // hash
  48 }
  49
  50 void MockAuthenticator::LoginRetailMode() {
  51   consumer_->OnRetailModeLoginSuccess(UserContext("demo-mode",
  52                                                   std::string(),
  53                                                   std::string(),
  54                                                   "demo-mode"));
  55 }
  56
  57 void MockAuthenticator::LoginAsPublicAccount(const std::string& username) {
  58   consumer_->OnLoginSuccess(UserContext(expected_username_,
  59                                         std::string(),
  60                                         std::string(),
  61                                         expected_username_));
  62 }
  63
  64 void MockAuthenticator::LoginAsKioskAccount(
  65     const std::string& app_user_id) {
  66   consumer_->OnLoginSuccess(UserContext(expected_username_,
  67                                         std::string(),
  68                                         std::string(),
  69                                         expected_username_));
  70 }
  71
  72 void MockAuthenticator::LoginOffTheRecord() {
  73   consumer_->OnOffTheRecordLoginSuccess();
  74 }
  75
  76 void MockAuthenticator::OnRetailModeLoginSuccess() {
  77   consumer_->OnRetailModeLoginSuccess(UserContext(expected_username_,
  78                                                   std::string(),
  79                                                   std::string(),
  80                                                   expected_username_));
  81 }
  82
  83 void MockAuthenticator::OnLoginSuccess() {
  84   // If we want to be more like the real thing, we could save username
  85   // in AuthenticateToLogin, but there's not much of a point.
  86   consumer_->OnLoginSuccess(UserContext(expected_username_,
  87                                         expected_password_,
  88                                         std::string(),
  89                                         expected_username_));
  90 }
  91
  92 void MockAuthenticator::OnLoginFailure(const LoginFailure& failure) {
  93     consumer_->OnLoginFailure(failure);
  94 }
  95
  96 void MockAuthenticator::SetExpectedCredentials(
  97     const std::string& expected_username,
  98     const std::string& expected_password) {
  99   expected_username_ = expected_username;
 100   expected_password_ = expected_password;
 101 }
 102
 103 }  // namespace chromeos