fake_profile_oauth2_token_service.cc revision 46d4c2bc3267f3f028f39e7e311b0f89aba2e4fd 
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
10FakeProfileOAuth2TokenService::PendingRequest::PendingRequest() {
11}
12
13FakeProfileOAuth2TokenService::PendingRequest::~PendingRequest() {
14}
15
16FakeProfileOAuth2TokenService::FakeProfileOAuth2TokenService()
17    : auto_post_fetch_response_on_message_loop_(false),
18      weak_ptr_factory_(this) {
19  SigninAccountIdHelper::SetDisableForTest(true);
20}
21
22FakeProfileOAuth2TokenService::~FakeProfileOAuth2TokenService() {
23  SigninAccountIdHelper::SetDisableForTest(false);
24}
25
26bool FakeProfileOAuth2TokenService::RefreshTokenIsAvailable(
27    const std::string& account_id) const {
28  return !GetRefreshToken(account_id).empty();
29}
30
31void FakeProfileOAuth2TokenService::LoadCredentials(
32    const std::string& primary_account_id) {
33  // Empty implementation as FakeProfileOAuth2TokenService does not have any
34  // credentials to load.
35}
36
37std::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
46void FakeProfileOAuth2TokenService::UpdateCredentials(
47    const std::string& account_id,
48    const std::string& refresh_token) {
49  IssueRefreshTokenForUser(account_id, refresh_token);
50}
51
52void FakeProfileOAuth2TokenService::IssueRefreshToken(
53    const std::string& token) {
54  IssueRefreshTokenForUser("account_id", token);
55}
56
57void 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
70void FakeProfileOAuth2TokenService::IssueAllRefreshTokensLoaded() {
71  FireRefreshTokensLoaded();
72}
73
74void 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
86void 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
97void 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
109void FakeProfileOAuth2TokenService::IssueErrorForScope(
110    const ScopeSet& scope,
111    const GoogleServiceAuthError& error) {
112  CompleteRequests("", false, scope, error, std::string(), base::Time());
113}
114
115void FakeProfileOAuth2TokenService::IssueErrorForAllPendingRequests(
116    const GoogleServiceAuthError& error) {
117  CompleteRequests("", true, ScopeSet(), error, std::string(), base::Time());
118}
119
120void 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
131void 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
154std::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
163net::URLRequestContextGetter*
164FakeProfileOAuth2TokenService::GetRequestContext() {
165  return NULL;
166}
167
168std::vector<FakeProfileOAuth2TokenService::PendingRequest>
169FakeProfileOAuth2TokenService::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
179void 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
204OAuth2AccessTokenFetcher*
205FakeProfileOAuth2TokenService::CreateAccessTokenFetcher(
206    const std::string& account_id,
207    net::URLRequestContextGetter* getter,
208    OAuth2AccessTokenConsumer* consumer) {
209  NOTREACHED();
210  return NULL;
211}
212
213void 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}
220