Refactor AO2TS to make it easier to componentize.

chrome/browser/signin/fake_profile_oauth2_token_service.cc

 // Copyright 2013 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/fake_profile_oauth2_token_service.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
+#include "chrome/browser/signin/fake_profile_oauth2_token_service_delegate.h"
 
 FakeProfileOAuth2TokenService::PendingRequest::PendingRequest() {
 }
 
 FakeProfileOAuth2TokenService::PendingRequest::~PendingRequest() {
 }
 
 FakeProfileOAuth2TokenService::FakeProfileOAuth2TokenService()
-    : auto_post_fetch_response_on_message_loop_(false),
+    : ProfileOAuth2TokenService(new FakeProfileOAuth2TokenServiceDelegate()),
+      auto_post_fetch_response_on_message_loop_(false),
       weak_ptr_factory_(this) {
 }
 
 FakeProfileOAuth2TokenService::~FakeProfileOAuth2TokenService() {
 }
 
-bool FakeProfileOAuth2TokenService::RefreshTokenIsAvailable(
-    const std::string& account_id) const {
-  return !GetRefreshToken(account_id).empty();
-}
-
-void FakeProfileOAuth2TokenService::LoadCredentials(
-    const std::string& primary_account_id) {
-  // Empty implementation as FakeProfileOAuth2TokenService does not have any
-  // credentials to load.
-}
-
-std::vector<std::string> FakeProfileOAuth2TokenService::GetAccounts() {
-  std::vector<std::string> account_ids;
-  for (std::map<std::string, std::string>::const_iterator iter =
-           refresh_tokens_.begin(); iter != refresh_tokens_.end(); ++iter) {
-    account_ids.push_back(iter->first);
-  }
-  return account_ids;
-}
-
-void FakeProfileOAuth2TokenService::UpdateCredentials(
-    const std::string& account_id,
-    const std::string& refresh_token) {
-  IssueRefreshTokenForUser(account_id, refresh_token);
-}
-
 void FakeProfileOAuth2TokenService::IssueRefreshToken(
     const std::string& token) {
-  IssueRefreshTokenForUser("account_id", token);
+  static_cast<FakeProfileOAuth2TokenServiceDelegate*>(GetDelegate())
+      ->IssueRefreshToken(token);
 }
 
 void FakeProfileOAuth2TokenService::IssueRefreshTokenForUser(
     const std::string& account_id,
     const std::string& token) {
-  ScopedBatchChange batch(this);
-  if (token.empty()) {
-    refresh_tokens_.erase(account_id);
-    FireRefreshTokenRevoked(account_id);
-  } else {
-    refresh_tokens_[account_id] = token;
-    FireRefreshTokenAvailable(account_id);
-    // TODO(atwilson): Maybe we should also call FireRefreshTokensLoaded() here?
-  }
+  static_cast<FakeProfileOAuth2TokenServiceDelegate*>(GetDelegate())
+      ->IssueRefreshTokenForUser(account_id, token);
 }
 
 void FakeProfileOAuth2TokenService::IssueAllRefreshTokensLoaded() {
-  FireRefreshTokensLoaded();
+  static_cast<FakeProfileOAuth2TokenServiceDelegate*>(GetDelegate())
+      ->IssueAllRefreshTokensLoaded();
 }
 
 void FakeProfileOAuth2TokenService::IssueAllTokensForAccount(
     const std::string& account_id,
     const std::string& access_token,
     const base::Time& expiration) {
   CompleteRequests(account_id,
                    true,
                    ScopeSet(),
                    GoogleServiceAuthError::AuthErrorNone(),
@@ skipping 61 matching lines @@
        it != requests.end(); ++it) {
     DCHECK(it->request);
 
     bool scope_matches = all_scopes || it->scopes == scope;
     bool account_matches = account_id.empty() || account_id == it->account_id;
     if (account_matches && scope_matches)
       it->request->InformConsumer(error, access_token, expiration);
   }
 }
 
-std::string FakeProfileOAuth2TokenService::GetRefreshToken(
-    const std::string& account_id) const {
-  std::map<std::string, std::string>::const_iterator it =
-      refresh_tokens_.find(account_id);
-  if (it != refresh_tokens_.end())
-    return it->second;
-  return std::string();
-}
-
-net::URLRequestContextGetter*
-FakeProfileOAuth2TokenService::GetRequestContext() {
-  return NULL;
-}
-
 std::vector<FakeProfileOAuth2TokenService::PendingRequest>
 FakeProfileOAuth2TokenService::GetPendingRequests() {
   std::vector<PendingRequest> valid_requests;
   for (std::vector<PendingRequest>::iterator it = pending_requests_.begin();
        it != pending_requests_.end(); ++it) {
     if (it->request)
       valid_requests.push_back(*it);
   }
   return valid_requests;
 }
@@ skipping 16 matching lines @@
   if (auto_post_fetch_response_on_message_loop_) {
     base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
         &FakeProfileOAuth2TokenService::IssueAllTokensForAccount,
         weak_ptr_factory_.GetWeakPtr(),
         account_id,
         "access_token",
         base::Time::Max()));
   }
 }
 
-OAuth2AccessTokenFetcher*
-FakeProfileOAuth2TokenService::CreateAccessTokenFetcher(
-    const std::string& account_id,
-    net::URLRequestContextGetter* getter,
-    OAuth2AccessTokenConsumer* consumer) {
-  NOTREACHED();
-  return NULL;
-}
-
 void FakeProfileOAuth2TokenService::InvalidateOAuth2Token(
     const std::string& account_id,
     const std::string& client_id,
     const ScopeSet& scopes,
     const std::string& access_token) {
   // Do nothing, as we don't have a cache from which to remove the token.
 }