src/chrome/browser/signin/fake_profile_oauth2_token_service.cc

   1 // Copyright 2013 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/signin/fake_profile_oauth2_token_service.h"
   6
   7 #include "base/message_loop/message_loop.h"
   8 #include "components/signin/core/browser/signin_account_id_helper.h"
   9
  10 FakeProfileOAuth2TokenService::PendingRequest::PendingRequest() {
  11 }
  12
  13 FakeProfileOAuth2TokenService::PendingRequest::~PendingRequest() {
  14 }
  15
  16 FakeProfileOAuth2TokenService::FakeProfileOAuth2TokenService()
  17     : auto_post_fetch_response_on_message_loop_(false),
  18       weak_ptr_factory_(this) {
  19   SigninAccountIdHelper::SetDisableForTest(true);
  20 }
  21
  22 FakeProfileOAuth2TokenService::~FakeProfileOAuth2TokenService() {
  23   SigninAccountIdHelper::SetDisableForTest(false);
  24 }
  25
  26 bool FakeProfileOAuth2TokenService::RefreshTokenIsAvailable(
  27     const std::string& account_id) const {
  28   return !GetRefreshToken(account_id).empty();
  29 }
  30
  31 void FakeProfileOAuth2TokenService::LoadCredentials(
  32     const std::string& primary_account_id) {
  33   // Empty implementation as FakeProfileOAuth2TokenService does not have any
  34   // credentials to load.
  35 }
  36
  37 std::vector<std::string> FakeProfileOAuth2TokenService::GetAccounts() {
  38   std::vector<std::string> account_ids;
  39   for (std::map<std::string, std::string>::const_iterator iter =
  40            refresh_tokens_.begin(); iter != refresh_tokens_.end(); ++iter) {
  41     account_ids.push_back(iter->first);
  42   }
  43   return account_ids;
  44 }
  45
  46 void FakeProfileOAuth2TokenService::UpdateCredentials(
  47     const std::string& account_id,
  48     const std::string& refresh_token) {
  49   IssueRefreshTokenForUser(account_id, refresh_token);
  50 }
  51
  52 void FakeProfileOAuth2TokenService::IssueRefreshToken(
  53     const std::string& token) {
  54   IssueRefreshTokenForUser("account_id", token);
  55 }
  56
  57 void FakeProfileOAuth2TokenService::IssueRefreshTokenForUser(
  58     const std::string& account_id,
  59     const std::string& token) {
  60   if (token.empty()) {
  61     refresh_tokens_.erase(account_id);
  62     FireRefreshTokenRevoked(account_id);
  63   } else {
  64     refresh_tokens_[account_id] = token;
  65     FireRefreshTokenAvailable(account_id);
  66     // TODO(atwilson): Maybe we should also call FireRefreshTokensLoaded() here?
  67   }
  68 }
  69
  70 void FakeProfileOAuth2TokenService::IssueAllRefreshTokensLoaded() {
  71   FireRefreshTokensLoaded();
  72 }
  73
  74 void FakeProfileOAuth2TokenService::IssueAllTokensForAccount(
  75     const std::string& account_id,
  76     const std::string& access_token,
  77     const base::Time& expiration) {
  78   CompleteRequests(account_id,
  79                    true,
  80                    ScopeSet(),
  81                    GoogleServiceAuthError::AuthErrorNone(),
  82                    access_token,
  83                    expiration);
  84 }
  85
  86 void FakeProfileOAuth2TokenService::IssueErrorForAllPendingRequestsForAccount(
  87     const std::string& account_id,
  88     const GoogleServiceAuthError& error) {
  89   CompleteRequests(account_id,
  90                    true,
  91                    ScopeSet(),
  92                    error,
  93                    std::string(),
  94                    base::Time());
  95 }
  96
  97 void FakeProfileOAuth2TokenService::IssueTokenForScope(
  98     const ScopeSet& scope,
  99     const std::string& access_token,
 100     const base::Time& expiration) {
 101   CompleteRequests("",
 102                    false,
 103                    scope,
 104                    GoogleServiceAuthError::AuthErrorNone(),
 105                    access_token,
 106                    expiration);
 107 }
 108
 109 void FakeProfileOAuth2TokenService::IssueErrorForScope(
 110     const ScopeSet& scope,
 111     const GoogleServiceAuthError& error) {
 112   CompleteRequests("", false, scope, error, std::string(), base::Time());
 113 }
 114
 115 void FakeProfileOAuth2TokenService::IssueErrorForAllPendingRequests(
 116     const GoogleServiceAuthError& error) {
 117   CompleteRequests("", true, ScopeSet(), error, std::string(), base::Time());
 118 }
 119
 120 void FakeProfileOAuth2TokenService::IssueTokenForAllPendingRequests(
 121     const std::string& access_token,
 122     const base::Time& expiration) {
 123   CompleteRequests("",
 124                    true,
 125                    ScopeSet(),
 126                    GoogleServiceAuthError::AuthErrorNone(),
 127                    access_token,
 128                    expiration);
 129 }
 130
 131 void FakeProfileOAuth2TokenService::CompleteRequests(
 132     const std::string& account_id,
 133     bool all_scopes,
 134     const ScopeSet& scope,
 135     const GoogleServiceAuthError& error,
 136     const std::string& access_token,
 137     const base::Time& expiration) {
 138   std::vector<FakeProfileOAuth2TokenService::PendingRequest> requests =
 139       GetPendingRequests();
 140
 141   // Walk the requests and notify the callbacks.
 142   for (std::vector<PendingRequest>::iterator it = pending_requests_.begin();
 143        it != pending_requests_.end(); ++it) {
 144     if (!it->request)
 145       continue;
 146
 147     bool scope_matches = all_scopes || it->scopes == scope;
 148     bool account_matches = account_id.empty() || account_id == it->account_id;
 149     if (account_matches && scope_matches)
 150       it->request->InformConsumer(error, access_token, expiration);
 151   }
 152 }
 153
 154 std::string FakeProfileOAuth2TokenService::GetRefreshToken(
 155     const std::string& account_id) const {
 156   std::map<std::string, std::string>::const_iterator it =
 157       refresh_tokens_.find(account_id);
 158   if (it != refresh_tokens_.end())
 159     return it->second;
 160   return std::string();
 161 }
 162
 163 net::URLRequestContextGetter*
 164 FakeProfileOAuth2TokenService::GetRequestContext() {
 165   return NULL;
 166 }
 167
 168 std::vector<FakeProfileOAuth2TokenService::PendingRequest>
 169 FakeProfileOAuth2TokenService::GetPendingRequests() {
 170   std::vector<PendingRequest> valid_requests;
 171   for (std::vector<PendingRequest>::iterator it = pending_requests_.begin();
 172        it != pending_requests_.end(); ++it) {
 173     if (it->request)
 174       valid_requests.push_back(*it);
 175   }
 176   return valid_requests;
 177 }
 178
 179 void FakeProfileOAuth2TokenService::FetchOAuth2Token(
 180     RequestImpl* request,
 181     const std::string& account_id,
 182     net::URLRequestContextGetter* getter,
 183     const std::string& client_id,
 184     const std::string& client_secret,
 185     const ScopeSet& scopes) {
 186   PendingRequest pending_request;
 187   pending_request.account_id = account_id;
 188   pending_request.client_id = client_id;
 189   pending_request.client_secret = client_secret;
 190   pending_request.scopes = scopes;
 191   pending_request.request = request->AsWeakPtr();
 192   pending_requests_.push_back(pending_request);
 193
 194   if (auto_post_fetch_response_on_message_loop_) {
 195     base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
 196         &FakeProfileOAuth2TokenService::IssueAllTokensForAccount,
 197         weak_ptr_factory_.GetWeakPtr(),
 198         account_id,
 199         "access_token",
 200         base::Time::Max()));
 201   }
 202 }
 203
 204 OAuth2AccessTokenFetcher*
 205 FakeProfileOAuth2TokenService::CreateAccessTokenFetcher(
 206     const std::string& account_id,
 207     net::URLRequestContextGetter* getter,
 208     OAuth2AccessTokenConsumer* consumer) {
 209   NOTREACHED();
 210   return NULL;
 211 }
 212
 213 void FakeProfileOAuth2TokenService::InvalidateOAuth2Token(
 214     const std::string& account_id,
 215     const std::string& client_id,
 216     const ScopeSet& scopes,
 217     const std::string& access_token) {
 218   // Do nothing, as we don't have a cache from which to remove the token.
 219 }