Revert "Making OAuth2TokenService multi-login aware:"

> Making OAuth2TokenService multi-login aware:
> * Adding account_id as a parameter to public methods, like: StartRequestXX, RefreshTokenIsAvailable, GetRefreshToken, InvalidateToken,
> * Updating callers and derived classes,
> * Updating cache handling for the OAuth2 access tokens in OAuth2TokenService
>
> BUG=277149
>
> Review URL: https://chromiumcodereview.appspot.com/23382008

TBR=fgorski@chromium.org
BUG=294624

Review URL: https://codereview.chromium.org/23800008

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@224107 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 254 insertions, 325 deletions

diff --git a/google_apis/gaia/oauth2_token_service.cc b/google_apis/gaia/oauth2_token_service.cc
index 3259e28..828f4cc6 100644
--- a/google_apis/gaia/oauth2_token_service.cc
+++ b/google_apis/gaia/oauth2_token_service.cc
@@ -19,28 +19,48 @@
 
 int OAuth2TokenService::max_fetch_retry_num_ = 5;
 
-OAuth2TokenService::RequestParameters::RequestParameters(
+OAuth2TokenService::ClientScopeSet::ClientScopeSet(
     const std::string& client_id,
-    const std::string& account_id,
     const ScopeSet& scopes)
     : client_id(client_id),
-      account_id(account_id),
       scopes(scopes) {
 }
 
-OAuth2TokenService::RequestParameters::~RequestParameters() {
+OAuth2TokenService::ClientScopeSet::~ClientScopeSet() {
 }
 
-bool OAuth2TokenService::RequestParameters::operator<(
-    const RequestParameters& p) const {
+bool OAuth2TokenService::ClientScopeSet::operator<(
+    const ClientScopeSet& s) const {
+  if (client_id < s.client_id)
+    return true;
+  else if (s.client_id < client_id)
+    return false;
+
+  return scopes < s.scopes;
+}
+
+OAuth2TokenService::FetchParameters::FetchParameters(
+    const std::string& client_id,
+    const std::string& refresh_token,
+    const ScopeSet& scopes)
+    : client_id(client_id),
+      refresh_token(refresh_token),
+      scopes(scopes) {
+}
+
+OAuth2TokenService::FetchParameters::~FetchParameters() {
+}
+
+bool OAuth2TokenService::FetchParameters::operator<(
+    const FetchParameters& p) const {
   if (client_id < p.client_id)
     return true;
   else if (p.client_id < client_id)
     return false;
 
-  if (account_id < p.account_id)
+  if (refresh_token < p.refresh_token)
     return true;
-  else if (p.account_id < account_id)
+  else if (p.refresh_token < refresh_token)
     return false;
 
   return scopes < p.scopes;
@@ -102,7 +122,6 @@ class OAuth2TokenService::Fetcher : public OAuth2AccessTokenConsumer {
   // |refresh_token| and |scopes| in the request context obtained by |getter|.
   // The given |oauth2_token_service| will be informed when fetching is done.
   static Fetcher* CreateAndStart(OAuth2TokenService* oauth2_token_service,
-                                 const std::string& account_id,
                                  net::URLRequestContextGetter* getter,
                                  const std::string& client_id,
                                  const std::string& client_secret,
@@ -122,7 +141,6 @@ class OAuth2TokenService::Fetcher : public OAuth2AccessTokenConsumer {
   const ScopeSet& GetScopeSet() const;
   const std::string& GetRefreshToken() const;
   const std::string& GetClientId() const;
-  const std::string& GetAccountId() const;
 
   // The error result from this fetcher.
   const GoogleServiceAuthError& error() const { return error_; }
@@ -136,7 +154,6 @@ class OAuth2TokenService::Fetcher : public OAuth2AccessTokenConsumer {
 
  private:
   Fetcher(OAuth2TokenService* oauth2_token_service,
-          const std::string& account_id,
           net::URLRequestContextGetter* getter,
           const std::string& client_id,
           const std::string& client_secret,
@@ -155,7 +172,6 @@ class OAuth2TokenService::Fetcher : public OAuth2AccessTokenConsumer {
   // (whichever comes first).
   OAuth2TokenService* const oauth2_token_service_;
   scoped_refptr<net::URLRequestContextGetter> getter_;
-  const std::string account_id_;
   const std::string refresh_token_;
   const ScopeSet scopes_;
   std::vector<base::WeakPtr<RequestImpl> > waiting_requests_;
@@ -181,7 +197,6 @@ class OAuth2TokenService::Fetcher : public OAuth2AccessTokenConsumer {
 // static
 OAuth2TokenService::Fetcher* OAuth2TokenService::Fetcher::CreateAndStart(
     OAuth2TokenService* oauth2_token_service,
-    const std::string& account_id,
     net::URLRequestContextGetter* getter,
     const std::string& client_id,
     const std::string& client_secret,
@@ -190,7 +205,6 @@ OAuth2TokenService::Fetcher* OAuth2TokenService::Fetcher::CreateAndStart(
     base::WeakPtr<RequestImpl> waiting_request) {
   OAuth2TokenService::Fetcher* fetcher = new Fetcher(
       oauth2_token_service,
-      account_id,
       getter,
       client_id,
       client_secret,
@@ -203,7 +217,6 @@ OAuth2TokenService::Fetcher* OAuth2TokenService::Fetcher::CreateAndStart(
 
 OAuth2TokenService::Fetcher::Fetcher(
     OAuth2TokenService* oauth2_token_service,
-    const std::string& account_id,
     net::URLRequestContextGetter* getter,
     const std::string& client_id,
     const std::string& client_secret,
@@ -212,7 +225,6 @@ OAuth2TokenService::Fetcher::Fetcher(
     base::WeakPtr<RequestImpl> waiting_request)
     : oauth2_token_service_(oauth2_token_service),
       getter_(getter),
-      account_id_(account_id),
       refresh_token_(refresh_token),
       scopes_(scopes),
       retry_number_(0),
@@ -255,7 +267,7 @@ void OAuth2TokenService::Fetcher::OnGetTokenSuccess(
   // This is intentional -- some consumers may need the token for cleanup
   // tasks. https://chromiumcodereview.appspot.com/11312124/
   oauth2_token_service_->RegisterCacheEntry(client_id_,
-                                            account_id_,
+                                            refresh_token_,
                                             scopes_,
                                             access_token_,
                                             expiration_date_);
@@ -348,10 +360,6 @@ const std::string& OAuth2TokenService::Fetcher::GetClientId() const {
   return client_id_;
 }
 
-const std::string& OAuth2TokenService::Fetcher::GetAccountId() const {
-  return account_id_;
-}
-
 OAuth2TokenService::Request::Request() {
 }
 
@@ -381,22 +389,14 @@ void OAuth2TokenService::RemoveObserver(Observer* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
-bool OAuth2TokenService::RefreshTokenIsAvailable(
-    const std::string& account_id) {
-  DCHECK(CalledOnValidThread());
-  return !GetRefreshToken(account_id).empty();
-}
-
-std::vector<std::string> OAuth2TokenService::GetAccounts() {
-  return std::vector<std::string>();
+bool OAuth2TokenService::RefreshTokenIsAvailable() {
+  return !GetRefreshToken().empty();
 }
 
 scoped_ptr<OAuth2TokenService::Request> OAuth2TokenService::StartRequest(
-    const std::string& account_id,
     const OAuth2TokenService::ScopeSet& scopes,
     OAuth2TokenService::Consumer* consumer) {
   return StartRequestForClientWithContext(
-      account_id,
       GetRequestContext(),
       GaiaUrls::GetInstance()->oauth2_chrome_client_id(),
       GaiaUrls::GetInstance()->oauth2_chrome_client_secret(),
@@ -406,13 +406,11 @@ scoped_ptr<OAuth2TokenService::Request> OAuth2TokenService::StartRequest(
 
 scoped_ptr<OAuth2TokenService::Request>
 OAuth2TokenService::StartRequestForClient(
-    const std::string& account_id,
     const std::string& client_id,
     const std::string& client_secret,
     const OAuth2TokenService::ScopeSet& scopes,
     OAuth2TokenService::Consumer* consumer) {
   return StartRequestForClientWithContext(
-      account_id,
       GetRequestContext(),
       client_id,
       client_secret,
@@ -422,12 +420,10 @@ OAuth2TokenService::StartRequestForClient(
 
 scoped_ptr<OAuth2TokenService::Request>
 OAuth2TokenService::StartRequestWithContext(
-    const std::string& account_id,
     net::URLRequestContextGetter* getter,
     const ScopeSet& scopes,
     Consumer* consumer) {
   return StartRequestForClientWithContext(
-      account_id,
       getter,
       GaiaUrls::GetInstance()->oauth2_chrome_client_id(),
       GaiaUrls::GetInstance()->oauth2_chrome_client_secret(),
@@ -437,7 +433,6 @@ OAuth2TokenService::StartRequestWithContext(
 
 scoped_ptr<OAuth2TokenService::Request>
 OAuth2TokenService::StartRequestForClientWithContext(
-    const std::string& account_id,
     net::URLRequestContextGetter* getter,
     const std::string& client_id,
     const std::string& client_secret,
@@ -447,7 +442,7 @@ OAuth2TokenService::StartRequestForClientWithContext(
 
   scoped_ptr<RequestImpl> request(new RequestImpl(consumer));
 
-  if (!RefreshTokenIsAvailable(account_id)) {
+  if (!RefreshTokenIsAvailable()) {
     base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
         &RequestImpl::InformConsumer,
         request->AsWeakPtr(),
@@ -457,14 +452,11 @@ OAuth2TokenService::StartRequestForClientWithContext(
     return request.PassAs<Request>();
   }
 
-  RequestParameters request_parameters(client_id,
-                                       account_id,
-                                       scopes);
-  if (HasCacheEntry(request_parameters)) {
-    StartCacheLookupRequest(request.get(), request_parameters, consumer);
+  ClientScopeSet client_scopes(client_id, scopes);
+  if (HasCacheEntry(client_scopes)) {
+    StartCacheLookupRequest(request.get(), client_scopes, consumer);
   } else {
     FetchOAuth2Token(request.get(),
-                     account_id,
                      getter,
                      client_id,
                      client_secret,
@@ -474,29 +466,27 @@ OAuth2TokenService::StartRequestForClientWithContext(
 }
 
 void OAuth2TokenService::FetchOAuth2Token(RequestImpl* request,
-                                          const std::string& account_id,
                                           net::URLRequestContextGetter* getter,
                                           const std::string& client_id,
                                           const std::string& client_secret,
                                           const ScopeSet& scopes) {
-  std::string refresh_token = GetRefreshToken(account_id);
+  std::string refresh_token = GetRefreshToken();
 
-  // If there is already a pending fetcher for |scopes| and |account_id|,
+  // If there is already a pending fetcher for |scopes| and |refresh_token|,
   // simply register this |request| for those results rather than starting
   // a new fetcher.
-  RequestParameters request_parameters = RequestParameters(client_id,
-                                                           account_id,
-                                                           scopes);
-  std::map<RequestParameters, Fetcher*>::iterator iter =
-      pending_fetchers_.find(request_parameters);
+  FetchParameters fetch_parameters = FetchParameters(client_id,
+                                                     refresh_token,
+                                                     scopes);
+  std::map<FetchParameters, Fetcher*>::iterator iter =
+      pending_fetchers_.find(fetch_parameters);
   if (iter != pending_fetchers_.end()) {
     iter->second->AddWaitingRequest(request->AsWeakPtr());
     return;
   }
 
-  pending_fetchers_[request_parameters] =
+  pending_fetchers_[fetch_parameters] =
       Fetcher::CreateAndStart(this,
-                              account_id,
                               getter,
                               client_id,
                               client_secret,
@@ -507,10 +497,10 @@ void OAuth2TokenService::FetchOAuth2Token(RequestImpl* request,
 
 void OAuth2TokenService::StartCacheLookupRequest(
     RequestImpl* request,
-    const OAuth2TokenService::RequestParameters& request_parameters,
+    const OAuth2TokenService::ClientScopeSet& client_scopes,
     OAuth2TokenService::Consumer* consumer) {
-  CHECK(HasCacheEntry(request_parameters));
-  const CacheEntry* cache_entry = GetCacheEntry(request_parameters);
+  CHECK(HasCacheEntry(client_scopes));
+  const CacheEntry* cache_entry = GetCacheEntry(client_scopes);
   base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
       &RequestImpl::InformConsumer,
       request->AsWeakPtr(),
@@ -519,34 +509,13 @@ void OAuth2TokenService::StartCacheLookupRequest(
       cache_entry->expiration_date));
 }
 
-void OAuth2TokenService::InvalidateToken(const std::string& account_id,
-                                         const ScopeSet& scopes,
-                                         const std::string& access_token) {
-  InvalidateOAuth2Token(account_id,
-                        GaiaUrls::GetInstance()->oauth2_chrome_client_id(),
-                        scopes,
-                        access_token);
-}
-
-void OAuth2TokenService::InvalidateTokenForClient(
-    const std::string& account_id,
-    const std::string& client_id,
-    const ScopeSet& scopes,
-    const std::string& access_token) {
-  InvalidateOAuth2Token(account_id, client_id, scopes, access_token);
-}
-
-void OAuth2TokenService::InvalidateOAuth2Token(
-    const std::string& account_id,
-    const std::string& client_id,
-    const ScopeSet& scopes,
-    const std::string& access_token) {
+void OAuth2TokenService::InvalidateToken(const ScopeSet& scopes,
+                                         const std::string& invalid_token) {
   DCHECK(CalledOnValidThread());
   RemoveCacheEntry(
-      RequestParameters(client_id,
-                        account_id,
-                        scopes),
-      access_token);
+      ClientScopeSet(GaiaUrls::GetInstance()->oauth2_chrome_client_id(),
+                     scopes),
+      invalid_token);
 }
 
 void OAuth2TokenService::OnFetchComplete(Fetcher* fetcher) {
@@ -554,7 +523,7 @@ void OAuth2TokenService::OnFetchComplete(Fetcher* fetcher) {
 
   // Update the auth error state so auth errors are appropriately communicated
   // to the user.
-  UpdateAuthError(fetcher->GetAccountId(), fetcher->error());
+  UpdateAuthError(fetcher->error());
 
   // Note |fetcher| is recorded in |pending_fetcher_| mapped to its refresh
   // token and scope set. This is guaranteed as follows; here a Fetcher is said
@@ -582,10 +551,10 @@ void OAuth2TokenService::OnFetchComplete(Fetcher* fetcher) {
   // By (1), |fetcher| is created by this service.
   // Then by (2), |fetcher| is recorded in |pending_fetchers_|.
   // Then by (3), |fetcher_| is mapped to its refresh token and ScopeSet.
-  std::map<RequestParameters, Fetcher*>::iterator iter =
-    pending_fetchers_.find(RequestParameters(
+  std::map<FetchParameters, Fetcher*>::iterator iter =
+    pending_fetchers_.find(FetchParameters(
         fetcher->GetClientId(),
-        fetcher->GetAccountId(),
+        fetcher->GetRefreshToken(),
         fetcher->GetScopeSet()));
   DCHECK(iter != pending_fetchers_.end());
   DCHECK_EQ(fetcher, iter->second);
@@ -593,15 +562,15 @@ void OAuth2TokenService::OnFetchComplete(Fetcher* fetcher) {
 }
 
 bool OAuth2TokenService::HasCacheEntry(
-    const RequestParameters& request_parameters) {
-  const CacheEntry* cache_entry = GetCacheEntry(request_parameters);
+    const ClientScopeSet& client_scopes) {
+  const CacheEntry* cache_entry = GetCacheEntry(client_scopes);
   return cache_entry && cache_entry->access_token.length();
 }
 
 const OAuth2TokenService::CacheEntry* OAuth2TokenService::GetCacheEntry(
-    const RequestParameters& request_parameters) {
+    const ClientScopeSet& client_scopes) {
   DCHECK(CalledOnValidThread());
-  TokenCache::iterator token_iterator = token_cache_.find(request_parameters);
+  TokenCache::iterator token_iterator = token_cache_.find(client_scopes);
   if (token_iterator == token_cache_.end())
     return NULL;
   if (token_iterator->second.expiration_date <= base::Time::Now()) {
@@ -612,10 +581,10 @@ const OAuth2TokenService::CacheEntry* OAuth2TokenService::GetCacheEntry(
 }
 
 bool OAuth2TokenService::RemoveCacheEntry(
-    const RequestParameters& request_parameters,
+    const ClientScopeSet& client_scopes,
     const std::string& token_to_remove) {
   DCHECK(CalledOnValidThread());
-  TokenCache::iterator token_iterator = token_cache_.find(request_parameters);
+  TokenCache::iterator token_iterator = token_cache_.find(client_scopes);
   if (token_iterator != token_cache_.end() &&
       token_iterator->second.access_token == token_to_remove) {
     token_cache_.erase(token_iterator);
@@ -626,22 +595,19 @@ bool OAuth2TokenService::RemoveCacheEntry(
 
 void OAuth2TokenService::RegisterCacheEntry(
     const std::string& client_id,
-    const std::string& account_id,
+    const std::string& refresh_token,
     const OAuth2TokenService::ScopeSet& scopes,
     const std::string& access_token,
     const base::Time& expiration_date) {
   DCHECK(CalledOnValidThread());
 
-  CacheEntry& token = token_cache_[RequestParameters(client_id,
-                                                     account_id,
-                                                     scopes)];
+  CacheEntry& token = token_cache_[ClientScopeSet(client_id,
+                                                  scopes)];
   token.access_token = access_token;
   token.expiration_date = expiration_date;
 }
 
-void OAuth2TokenService::UpdateAuthError(
-    const std::string& account_id,
-    const GoogleServiceAuthError& error) {
+void OAuth2TokenService::UpdateAuthError(const GoogleServiceAuthError& error) {
   // Default implementation does nothing.
 }
 
@@ -650,22 +616,9 @@ void OAuth2TokenService::ClearCache() {
   token_cache_.clear();
 }
 
-void OAuth2TokenService::ClearCacheForAccount(const std::string& account_id) {
-  DCHECK(CalledOnValidThread());
-  for (TokenCache::iterator iter = token_cache_.begin();
-       iter != token_cache_.end();
-       /* iter incremented in body */) {
-    if (iter->first.account_id == account_id) {
-      token_cache_.erase(iter++);
-    } else {
-      ++iter;
-    }
-  }
-}
-
 void OAuth2TokenService::CancelAllRequests() {
   std::vector<Fetcher*> fetchers_to_cancel;
-  for (std::map<RequestParameters, Fetcher*>::iterator iter =
+  for (std::map<FetchParameters, Fetcher*>::iterator iter =
            pending_fetchers_.begin();
        iter != pending_fetchers_.end();
        ++iter) {
@@ -674,14 +627,14 @@ void OAuth2TokenService::CancelAllRequests() {
   CancelFetchers(fetchers_to_cancel);
 }
 
-void OAuth2TokenService::CancelRequestsForAccount(
-    const std::string& account_id) {
+void OAuth2TokenService::CancelRequestsForToken(
+    const std::string& refresh_token) {
   std::vector<Fetcher*> fetchers_to_cancel;
-  for (std::map<RequestParameters, Fetcher*>::iterator iter =
+  for (std::map<FetchParameters, Fetcher*>::iterator iter =
            pending_fetchers_.begin();
        iter != pending_fetchers_.end();
        ++iter) {
-    if (iter->first.account_id == account_id)
+    if (iter->first.refresh_token == refresh_token)
       fetchers_to_cancel.push_back(iter->second);
   }
   CancelFetchers(fetchers_to_cancel);
@@ -713,6 +666,10 @@ void OAuth2TokenService::FireRefreshTokensLoaded() {
   FOR_EACH_OBSERVER(Observer, observer_list_, OnRefreshTokensLoaded());
 }
 
+void OAuth2TokenService::FireRefreshTokensCleared() {
+  FOR_EACH_OBSERVER(Observer, observer_list_, OnRefreshTokensCleared());
+}
+
 int OAuth2TokenService::cache_size_for_testing() const {
   return token_cache_.size();
 }
@@ -725,12 +682,12 @@ void OAuth2TokenService::set_max_authorization_token_fetch_retries_for_testing(
 
 size_t OAuth2TokenService::GetNumPendingRequestsForTesting(
     const std::string& client_id,
-    const std::string& account_id,
+    const std::string& refresh_token,
     const ScopeSet& scopes) const {
   PendingFetcherMap::const_iterator iter = pending_fetchers_.find(
-      OAuth2TokenService::RequestParameters(
+      OAuth2TokenService::FetchParameters(
           client_id,
-          account_id,
+          refresh_token,
           scopes));
   return iter == pending_fetchers_.end() ?
              0 : iter->second->GetWaitingRequestCount();
diff --git a/google_apis/gaia/oauth2_token_service.h b/google_apis/gaia/oauth2_token_service.h
index d092430..b58c563 100644
--- a/google_apis/gaia/oauth2_token_service.h
+++ b/google_apis/gaia/oauth2_token_service.h
@@ -29,8 +29,7 @@ class GoogleServiceAuthError;
 
 // Abstract base class for a service that fetches and caches OAuth2 access
 // tokens. Concrete subclasses should implement GetRefreshToken to return
-// the appropriate refresh token. Derived services might maintain refresh tokens
-// for multiple accounts.
+// the appropriate refresh token.
 //
 // All calls are expected from the UI thread.
 //
@@ -77,6 +76,8 @@ class OAuth2TokenService : public base::NonThreadSafe {
 
   // Classes that want to listen for token availability should implement this
   // interface and register with the AddObserver() call.
+  // TODO(rogerta): may get rid of |error| argument for OnRefreshTokenRevoked()
+  // once we stop supporting ClientLogin.  Need to evaluate if its still useful.
   class Observer {
    public:
     // Called whenever a new login-scoped refresh token is available for
@@ -90,6 +91,8 @@ class OAuth2TokenService : public base::NonThreadSafe {
     // Called after all refresh tokens are loaded during OAuth2TokenService
     // startup.
     virtual void OnRefreshTokensLoaded() {}
+    // Called after all refresh tokens are removed from OAuth2TokenService.
+    virtual void OnRefreshTokensCleared() {}
    protected:
     virtual ~Observer() {}
   };
@@ -104,24 +107,21 @@ class OAuth2TokenService : public base::NonThreadSafe {
   void AddObserver(Observer* observer);
   void RemoveObserver(Observer* observer);
 
-  // Checks in the cache for a valid access token for a specified |account_id|
-  // and |scopes|, and if not found starts a request for an OAuth2 access token
-  // using the OAuth2 refresh token maintained by this instance for that
-  // |account_id|. The caller owns the returned Request.
+  // Checks in the cache for a valid access token, and if not found starts
+  // a request for an OAuth2 access token using the OAuth2 refresh token
+  // maintained by this instance. The caller owns the returned Request.
   // |scopes| is the set of scopes to get an access token for, |consumer| is
   // the object that will be called back with results if the returned request
   // is not deleted.
   // TODO(atwilson): Make this non-virtual when we change
   // ProfileOAuth2TokenServiceRequestTest to use FakeProfileOAuth2TokenService.
-  virtual scoped_ptr<Request> StartRequest(const std::string& account_id,
-                                           const ScopeSet& scopes,
+  virtual scoped_ptr<Request> StartRequest(const ScopeSet& scopes,
                                            Consumer* consumer);
 
   // This method does the same as |StartRequest| except it uses |client_id| and
   // |client_secret| to identify OAuth client app instead of using
   // Chrome's default values.
   scoped_ptr<Request> StartRequestForClient(
-      const std::string& account_id,
       const std::string& client_id,
       const std::string& client_secret,
       const ScopeSet& scopes,
@@ -131,35 +131,20 @@ class OAuth2TokenService : public base::NonThreadSafe {
   // context given by |getter| instead of using the one returned by
   // |GetRequestContext| implemented by derived classes.
   scoped_ptr<Request> StartRequestWithContext(
-      const std::string& account_id,
       net::URLRequestContextGetter* getter,
       const ScopeSet& scopes,
       Consumer* consumer);
 
-  // Lists account IDs of all accounts with a refresh token maintained by this
-  // instance.
-  virtual std::vector<std::string> GetAccounts();
-
-  // Returns true if a refresh token exists for |account_id|. If false, calls to
+  // Returns true if a refresh token exists. If false, calls to
   // |StartRequest| will result in a Consumer::OnGetTokenFailure callback.
-  virtual bool RefreshTokenIsAvailable(const std::string& account_id);
-
-  // Mark an OAuth2 |access_token| issued for |account_id| and |scopes| as
-  // invalid. This should be done if the token was received from this class,
-  // but was not accepted by the server (e.g., the server returned
-  // 401 Unauthorized). The token will be removed from the cache for the given
-  // scopes.
-  void InvalidateToken(const std::string& account_id,
-                       const ScopeSet& scopes,
-                       const std::string& access_token);
-
-  // Like |InvalidateToken| except is uses |client_id| to identity OAuth2 client
-  // app that issued the request instead of Chrome's default values.
-  void InvalidateTokenForClient(const std::string& account_id,
-                                const std::string& client_id,
-                                const ScopeSet& scopes,
-                                const std::string& access_token);
+  virtual bool RefreshTokenIsAvailable();
 
+  // Mark an OAuth2 access token as invalid. This should be done if the token
+  // was received from this class, but was not accepted by the server (e.g.,
+  // the server returned 401 Unauthorized). The token will be removed from the
+  // cache for the given scopes.
+  virtual void InvalidateToken(const ScopeSet& scopes,
+                               const std::string& invalid_token);
 
   // Return the current number of entries in the cache.
   int cache_size_for_testing() const;
@@ -167,10 +152,20 @@ class OAuth2TokenService : public base::NonThreadSafe {
   // Returns the current number of pending fetchers matching given params.
   size_t GetNumPendingRequestsForTesting(
       const std::string& client_id,
-      const std::string& account_id,
+      const std::string& refresh_token,
       const ScopeSet& scopes) const;
 
  protected:
+  struct ClientScopeSet {
+    ClientScopeSet(const std::string& client_id,
+                   const ScopeSet& scopes);
+    ~ClientScopeSet();
+    bool operator<(const ClientScopeSet& set) const;
+
+    std::string client_id;
+    ScopeSet scopes;
+  };
+
   // Implements a cancelable |OAuth2TokenService::Request|, which should be
   // operated on the UI thread.
   // TODO(davidroche): move this out of header file.
@@ -192,81 +187,75 @@ class OAuth2TokenService : public base::NonThreadSafe {
     Consumer* const consumer_;
   };
 
-  // Subclasses should return the maintained refresh token for |account_id|.
+  // Subclasses should return the refresh token maintained.
   // If no token is available, return an empty string.
-  virtual std::string GetRefreshToken(const std::string& account_id) = 0;
+  virtual std::string GetRefreshToken() = 0;
 
   // Subclasses can override if they want to report errors to the user.
-  virtual void UpdateAuthError(
-      const std::string& account_id,
-      const GoogleServiceAuthError& error);
+  virtual void UpdateAuthError(const GoogleServiceAuthError& error);
 
   // Add a new entry to the cache.
   // Subclasses can override if there are implementation-specific reasons
   // that an access token should ever not be cached.
   virtual void RegisterCacheEntry(const std::string& client_id,
-                                  const std::string& account_id,
+                                  const std::string& refresh_token,
                                   const ScopeSet& scopes,
                                   const std::string& access_token,
                                   const base::Time& expiration_date);
 
+  // Returns true if GetCacheEntry would return a valid cache entry for the
+  // given scopes.
+  bool HasCacheEntry(const ClientScopeSet& client_scopes);
+
+  // Posts a task to fire the Consumer callback with the cached token.  Must
+  // Must only be called if HasCacheEntry() returns true.
+  void StartCacheLookupRequest(RequestImpl* request,
+                               const ClientScopeSet& client_scopes,
+                               Consumer* consumer);
+
   // Clears the internal token cache.
   void ClearCache();
 
-  // Clears all of the tokens belonging to |account_id| from the internal token
-  // cache. It does not matter what other parameters, like |client_id| were
-  // used to request the tokens.
-  void ClearCacheForAccount(const std::string& account_id);
-
   // Cancels all requests that are currently in progress.
   void CancelAllRequests();
 
-  // Cancels all requests related to a given |account_id|.
-  void CancelRequestsForAccount(const std::string& account_id);
+  // Cancels all requests related to a given refresh token.
+  void CancelRequestsForToken(const std::string& refresh_token);
 
   // Called by subclasses to notify observers.
   void FireRefreshTokenAvailable(const std::string& account_id);
   void FireRefreshTokenRevoked(const std::string& account_id);
   void FireRefreshTokensLoaded();
+  void FireRefreshTokensCleared();
 
   // Fetches an OAuth token for the specified client/scopes. Virtual so it can
   // be overridden for tests and for platform-specific behavior on Android.
   virtual void FetchOAuth2Token(RequestImpl* request,
-                                const std::string& account_id,
                                 net::URLRequestContextGetter* getter,
                                 const std::string& client_id,
                                 const std::string& client_secret,
                                 const ScopeSet& scopes);
-
-  // Invalidates the |access_token| issued for |account_id|, |client_id| and
-  // |scopes|. Virtual so it can be overriden for tests and for platform-
-  // specifc behavior.
-  virtual void InvalidateOAuth2Token(const std::string& account_id,
-                                     const std::string& client_id,
-                                     const ScopeSet& scopes,
-                                     const std::string& access_token);
-
  private:
   class Fetcher;
   friend class Fetcher;
 
   // The parameters used to fetch an OAuth2 access token.
-  struct RequestParameters {
-    RequestParameters(const std::string& client_id,
-                      const std::string& account_id,
-                      const ScopeSet& scopes);
-    ~RequestParameters();
-    bool operator<(const RequestParameters& params) const;
+  struct FetchParameters {
+    FetchParameters(const std::string& client_id,
+                    const std::string& refresh_token,
+                    const ScopeSet& scopes);
+    ~FetchParameters();
+    bool operator<(const FetchParameters& params) const;
 
     // OAuth2 client id.
     std::string client_id;
-    // Account id for which the request is made.
-    std::string account_id;
+    // Refresh token used for minting access tokens within this request.
+    std::string refresh_token;
     // URL scopes for the requested access token.
     ScopeSet scopes;
   };
 
-  typedef std::map<RequestParameters, Fetcher*> PendingFetcherMap;
+  typedef std::map<FetchParameters, Fetcher*> PendingFetcherMap;
 
   // Derived classes must provide a request context used for fetching access
   // tokens with the |StartRequest| method.
@@ -282,34 +271,25 @@ class OAuth2TokenService : public base::NonThreadSafe {
   // uses |client_id| and |client_secret| to identify OAuth
   // client app instead of using Chrome's default values.
   scoped_ptr<Request> StartRequestForClientWithContext(
-      const std::string& account_id,
       net::URLRequestContextGetter* getter,
       const std::string& client_id,
       const std::string& client_secret,
       const ScopeSet& scopes,
       Consumer* consumer);
 
-  // Returns true if GetCacheEntry would return a valid cache entry for the
-  // given scopes.
-  bool HasCacheEntry(const RequestParameters& client_scopes);
-
-  // Posts a task to fire the Consumer callback with the cached token.  Must
-  // Must only be called if HasCacheEntry() returns true.
-  void StartCacheLookupRequest(RequestImpl* request,
-                               const RequestParameters& client_scopes,
-                               Consumer* consumer);
-
   // Returns a currently valid OAuth2 access token for the given set of scopes,
   // or NULL if none have been cached. Note the user of this method should
   // ensure no entry with the same |client_scopes| is added before the usage of
   // the returned entry is done.
-  const CacheEntry* GetCacheEntry(const RequestParameters& client_scopes);
+  const CacheEntry* GetCacheEntry(const ClientScopeSet& client_scopes);
+
 
   // Removes an access token for the given set of scopes from the cache.
   // Returns true if the entry was removed, otherwise false.
-  bool RemoveCacheEntry(const RequestParameters& client_scopes,
+  bool RemoveCacheEntry(const ClientScopeSet& client_scopes,
                         const std::string& token_to_remove);
 
+
   // Called when |fetcher| finishes fetching.
   void OnFetchComplete(Fetcher* fetcher);
 
@@ -317,7 +297,7 @@ class OAuth2TokenService : public base::NonThreadSafe {
   void CancelFetchers(std::vector<Fetcher*> fetchers_to_cancel);
 
   // The cache of currently valid tokens.
-  typedef std::map<RequestParameters, CacheEntry> TokenCache;
+  typedef std::map<ClientScopeSet, CacheEntry> TokenCache;
   TokenCache token_cache_;
 
   // A map from fetch parameters to a fetcher that is fetching an OAuth2 access
@@ -331,7 +311,8 @@ class OAuth2TokenService : public base::NonThreadSafe {
   // Maximum number of retries in fetching an OAuth2 access token.
   static int max_fetch_retry_num_;
 
-  FRIEND_TEST_ALL_PREFIXES(OAuth2TokenServiceTest, RequestParametersOrderTest);
+  FRIEND_TEST_ALL_PREFIXES(OAuth2TokenServiceTest, ClientScopeSetOrderTest);
+  FRIEND_TEST_ALL_PREFIXES(OAuth2TokenServiceTest, FetchParametersOrderTest);
   FRIEND_TEST_ALL_PREFIXES(OAuth2TokenServiceTest,
                            SameScopesRequestedForDifferentClients);
 
diff --git a/google_apis/gaia/oauth2_token_service_unittest.cc b/google_apis/gaia/oauth2_token_service_unittest.cc
index dcd21b1..979b616 100644
--- a/google_apis/gaia/oauth2_token_service_unittest.cc
+++ b/google_apis/gaia/oauth2_token_service_unittest.cc
@@ -23,21 +23,18 @@ class RetryingTestingOAuth2TokenServiceConsumer
     : public TestingOAuth2TokenServiceConsumer {
  public:
   RetryingTestingOAuth2TokenServiceConsumer(
-      OAuth2TokenService* oauth2_service,
-      const std::string& account_id)
-      : oauth2_service_(oauth2_service),
-        account_id_(account_id) {}
+      OAuth2TokenService* oauth2_service)
+      : oauth2_service_(oauth2_service) {}
   virtual ~RetryingTestingOAuth2TokenServiceConsumer() {}
 
   virtual void OnGetTokenFailure(const OAuth2TokenService::Request* request,
                                  const GoogleServiceAuthError& error) OVERRIDE {
     TestingOAuth2TokenServiceConsumer::OnGetTokenFailure(request, error);
     request_.reset(oauth2_service_->StartRequest(
-        account_id_, OAuth2TokenService::ScopeSet(), this).release());
+        std::set<std::string>(), this).release());
   }
 
   OAuth2TokenService* oauth2_service_;
-  std::string account_id_;
   scoped_ptr<OAuth2TokenService::Request> request_;
 };
 
@@ -49,21 +46,17 @@ class TestOAuth2TokenService : public OAuth2TokenService {
 
   void CancelAllRequestsForTest() { CancelAllRequests(); }
 
-  void CancelRequestsForAccountForTest(const std::string& account_id) {
-    CancelRequestsForAccount(account_id);
+  void CancelRequestsForTokenForTest(const std::string& refresh_token) {
+    CancelRequestsForToken(refresh_token);
   }
 
   // For testing: set the refresh token to be used.
-  void set_refresh_token(const std::string& account_id,
-                         const std::string& refresh_token) {
-    refresh_tokens_[account_id] = refresh_token;
+  void set_refresh_token(const std::string& refresh_token) {
+    refresh_token_ = refresh_token;
   }
 
  protected:
-  virtual std::string GetRefreshToken(const std::string& account_id) OVERRIDE {
-    // account_id explicitly ignored.
-    return refresh_tokens_[account_id];
-  }
+  virtual std::string GetRefreshToken() OVERRIDE { return refresh_token_; }
 
  private:
   // OAuth2TokenService implementation.
@@ -71,7 +64,7 @@ class TestOAuth2TokenService : public OAuth2TokenService {
     return request_context_getter_.get();
   }
 
-  std::map<std::string, std::string> refresh_tokens_;
+  std::string refresh_token_;
   scoped_refptr<net::TestURLRequestContextGetter> request_context_getter_;
 };
 
@@ -81,7 +74,6 @@ class OAuth2TokenServiceTest : public testing::Test {
     oauth2_service_.reset(
         new TestOAuth2TokenService(new net::TestURLRequestContextGetter(
             message_loop_.message_loop_proxy())));
-    account_id_ = "test_user@gmail.com";
   }
 
   virtual void TearDown() OVERRIDE {
@@ -93,14 +85,12 @@ class OAuth2TokenServiceTest : public testing::Test {
   base::MessageLoopForIO message_loop_;  // net:: stuff needs IO message loop.
   net::TestURLFetcherFactory factory_;
   scoped_ptr<TestOAuth2TokenService> oauth2_service_;
-  std::string account_id_;
   TestingOAuth2TokenServiceConsumer consumer_;
 };
 
 TEST_F(OAuth2TokenServiceTest, NoOAuth2RefreshToken) {
   scoped_ptr<OAuth2TokenService::Request> request(
-      oauth2_service_->StartRequest(account_id_, OAuth2TokenService::ScopeSet(),
-          &consumer_));
+      oauth2_service_->StartRequest(std::set<std::string>(), &consumer_));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
@@ -108,11 +98,9 @@ TEST_F(OAuth2TokenServiceTest, NoOAuth2RefreshToken) {
 }
 
 TEST_F(OAuth2TokenServiceTest, FailureShouldNotRetry) {
-  oauth2_service_->set_refresh_token(account_id_, "refreshToken");
+  oauth2_service_->set_refresh_token("refreshToken");
   scoped_ptr<OAuth2TokenService::Request> request(
-      oauth2_service_->StartRequest(account_id_,
-                                    OAuth2TokenService::ScopeSet(),
-                                    &consumer_));
+      oauth2_service_->StartRequest(std::set<std::string>(), &consumer_));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
@@ -128,11 +116,9 @@ TEST_F(OAuth2TokenServiceTest, FailureShouldNotRetry) {
 }
 
 TEST_F(OAuth2TokenServiceTest, SuccessWithoutCaching) {
-  oauth2_service_->set_refresh_token(account_id_, "refreshToken");
+  oauth2_service_->set_refresh_token("refreshToken");
   scoped_ptr<OAuth2TokenService::Request> request(
-      oauth2_service_->StartRequest(account_id_,
-                                    OAuth2TokenService::ScopeSet(),
-                                    &consumer_));
+      oauth2_service_->StartRequest(std::set<std::string>(), &consumer_));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
@@ -148,20 +134,20 @@ TEST_F(OAuth2TokenServiceTest, SuccessWithoutCaching) {
 }
 
 TEST_F(OAuth2TokenServiceTest, SuccessWithCaching) {
-  OAuth2TokenService::ScopeSet scopes1;
+  std::set<std::string> scopes1;
   scopes1.insert("s1");
   scopes1.insert("s2");
-  OAuth2TokenService::ScopeSet scopes1_same;
+  std::set<std::string> scopes1_same;
   scopes1_same.insert("s2");
   scopes1_same.insert("s1");
-  OAuth2TokenService::ScopeSet scopes2;
+  std::set<std::string> scopes2;
   scopes2.insert("s3");
 
-  oauth2_service_->set_refresh_token(account_id_, "refreshToken");
+  oauth2_service_->set_refresh_token("refreshToken");
 
   // First request.
-  scoped_ptr<OAuth2TokenService::Request> request(
-      oauth2_service_->StartRequest(account_id_, scopes1, &consumer_));
+  scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest(
+      scopes1, &consumer_));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
@@ -178,7 +164,7 @@ TEST_F(OAuth2TokenServiceTest, SuccessWithCaching) {
   // Second request to the same set of scopes, should return the same token
   // without needing a network request.
   scoped_ptr<OAuth2TokenService::Request> request2(
-      oauth2_service_->StartRequest(account_id_, scopes1_same, &consumer_));
+      oauth2_service_->StartRequest(scopes1_same, &consumer_));
   base::RunLoop().RunUntilIdle();
 
   // No new network fetcher.
@@ -188,7 +174,7 @@ TEST_F(OAuth2TokenServiceTest, SuccessWithCaching) {
 
   // Third request to a new set of scopes, should return another token.
   scoped_ptr<OAuth2TokenService::Request> request3(
-      oauth2_service_->StartRequest(account_id_, scopes2, &consumer_));
+      oauth2_service_->StartRequest(scopes2, &consumer_));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(2, consumer_.number_of_successful_tokens_);
   EXPECT_EQ(0, consumer_.number_of_errors_);
@@ -203,13 +189,11 @@ TEST_F(OAuth2TokenServiceTest, SuccessWithCaching) {
 }
 
 TEST_F(OAuth2TokenServiceTest, SuccessAndExpirationAndFailure) {
-  oauth2_service_->set_refresh_token(account_id_, "refreshToken");
+  oauth2_service_->set_refresh_token("refreshToken");
 
   // First request.
-  scoped_ptr<OAuth2TokenService::Request> request(
-      oauth2_service_->StartRequest(account_id_,
-                                    OAuth2TokenService::ScopeSet(),
-                                    &consumer_));
+  scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest(
+      std::set<std::string>(), &consumer_));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
   EXPECT_EQ(0, consumer_.number_of_errors_);
@@ -224,9 +208,7 @@ TEST_F(OAuth2TokenServiceTest, SuccessAndExpirationAndFailure) {
 
   // Second request must try to access the network as the token has expired.
   scoped_ptr<OAuth2TokenService::Request> request2(
-      oauth2_service_->StartRequest(account_id_,
-                                    OAuth2TokenService::ScopeSet(),
-                                    &consumer_));
+      oauth2_service_->StartRequest(std::set<std::string>(), &consumer_));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, consumer_.number_of_successful_tokens_);
   EXPECT_EQ(0, consumer_.number_of_errors_);
@@ -242,13 +224,11 @@ TEST_F(OAuth2TokenServiceTest, SuccessAndExpirationAndFailure) {
 }
 
 TEST_F(OAuth2TokenServiceTest, SuccessAndExpirationAndSuccess) {
-  oauth2_service_->set_refresh_token(account_id_, "refreshToken");
+  oauth2_service_->set_refresh_token("refreshToken");
 
   // First request.
-  scoped_ptr<OAuth2TokenService::Request> request(
-      oauth2_service_->StartRequest(account_id_,
-                                    OAuth2TokenService::ScopeSet(),
-                                    &consumer_));
+  scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest(
+      std::set<std::string>(), &consumer_));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
   EXPECT_EQ(0, consumer_.number_of_errors_);
@@ -263,9 +243,7 @@ TEST_F(OAuth2TokenServiceTest, SuccessAndExpirationAndSuccess) {
 
   // Second request must try to access the network as the token has expired.
   scoped_ptr<OAuth2TokenService::Request> request2(
-      oauth2_service_->StartRequest(account_id_,
-                                    OAuth2TokenService::ScopeSet(),
-                                    &consumer_));
+      oauth2_service_->StartRequest(std::set<std::string>(), &consumer_));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, consumer_.number_of_successful_tokens_);
   EXPECT_EQ(0, consumer_.number_of_errors_);
@@ -281,12 +259,10 @@ TEST_F(OAuth2TokenServiceTest, SuccessAndExpirationAndSuccess) {
 }
 
 TEST_F(OAuth2TokenServiceTest, RequestDeletedBeforeCompletion) {
-  oauth2_service_->set_refresh_token(account_id_, "refreshToken");
+  oauth2_service_->set_refresh_token("refreshToken");
 
-  scoped_ptr<OAuth2TokenService::Request> request(
-      oauth2_service_->StartRequest(account_id_,
-                                    OAuth2TokenService::ScopeSet(),
-                                    &consumer_));
+  scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest(
+      std::set<std::string>(), &consumer_));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
   EXPECT_EQ(0, consumer_.number_of_errors_);
@@ -303,10 +279,10 @@ TEST_F(OAuth2TokenServiceTest, RequestDeletedBeforeCompletion) {
 }
 
 TEST_F(OAuth2TokenServiceTest, RequestDeletedAfterCompletion) {
-  oauth2_service_->set_refresh_token(account_id_, "refreshToken");
+  oauth2_service_->set_refresh_token("refreshToken");
 
   scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest(
-      account_id_, OAuth2TokenService::ScopeSet(), &consumer_));
+      std::set<std::string>(), &consumer_));
   base::RunLoop().RunUntilIdle();
   net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
@@ -325,14 +301,13 @@ TEST_F(OAuth2TokenServiceTest, RequestDeletedAfterCompletion) {
 }
 
 TEST_F(OAuth2TokenServiceTest, MultipleRequestsForTheSameScopesWithOneDeleted) {
-  oauth2_service_->set_refresh_token(account_id_, "refreshToken");
+  oauth2_service_->set_refresh_token("refreshToken");
 
   scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest(
-      account_id_, OAuth2TokenService::ScopeSet(), &consumer_));
+      std::set<std::string>(), &consumer_));
   base::RunLoop().RunUntilIdle();
   scoped_ptr<OAuth2TokenService::Request> request2(
-      oauth2_service_->StartRequest(account_id_, OAuth2TokenService::ScopeSet(),
-          &consumer_));
+      oauth2_service_->StartRequest(std::set<std::string>(), &consumer_));
   base::RunLoop().RunUntilIdle();
 
   request.reset();
@@ -348,9 +323,9 @@ TEST_F(OAuth2TokenServiceTest, MultipleRequestsForTheSameScopesWithOneDeleted) {
 
 TEST_F(OAuth2TokenServiceTest, ClearedRefreshTokenFailsSubsequentRequests) {
   // We have a valid refresh token; the first request is successful.
-  oauth2_service_->set_refresh_token(account_id_, "refreshToken");
+  oauth2_service_->set_refresh_token("refreshToken");
   scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest(
-      account_id_, OAuth2TokenService::ScopeSet(), &consumer_));
+      std::set<std::string>(), &consumer_));
   base::RunLoop().RunUntilIdle();
   net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
@@ -362,9 +337,8 @@ TEST_F(OAuth2TokenServiceTest, ClearedRefreshTokenFailsSubsequentRequests) {
   EXPECT_EQ("token", consumer_.last_token_);
 
   // The refresh token is no longer available; subsequent requests fail.
-  oauth2_service_->set_refresh_token(account_id_, "");
-  request = oauth2_service_->StartRequest(account_id_,
-      OAuth2TokenService::ScopeSet(), &consumer_);
+  oauth2_service_->set_refresh_token("");
+  request = oauth2_service_->StartRequest(std::set<std::string>(), &consumer_);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, consumer_.number_of_successful_tokens_);
   EXPECT_EQ(1, consumer_.number_of_errors_);
@@ -372,28 +346,25 @@ TEST_F(OAuth2TokenServiceTest, ClearedRefreshTokenFailsSubsequentRequests) {
 
 TEST_F(OAuth2TokenServiceTest,
        ChangedRefreshTokenDoesNotAffectInFlightRequests) {
-  oauth2_service_->set_refresh_token(account_id_, "first refreshToken");
-  OAuth2TokenService::ScopeSet scopes;
+  oauth2_service_->set_refresh_token("first refreshToken");
+  std::set<std::string> scopes;
   scopes.insert("s1");
   scopes.insert("s2");
-  OAuth2TokenService::ScopeSet scopes1;
-  scopes.insert("s3");
-  scopes.insert("s4");
 
   scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest(
-      account_id_, scopes, &consumer_));
+      scopes, &consumer_));
   base::RunLoop().RunUntilIdle();
   net::TestURLFetcher* fetcher1 = factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher1);
 
   // Note |request| is still pending when the refresh token changes.
-  oauth2_service_->set_refresh_token(account_id_, "second refreshToken");
+  oauth2_service_->set_refresh_token("second refreshToken");
 
   // A 2nd request (using the new refresh token) that occurs and completes
   // while the 1st request is in flight is successful.
   TestingOAuth2TokenServiceConsumer consumer2;
   scoped_ptr<OAuth2TokenService::Request> request2(
-      oauth2_service_->StartRequest(account_id_, scopes1, &consumer2));
+      oauth2_service_->StartRequest(scopes, &consumer2));
   base::RunLoop().RunUntilIdle();
 
   net::TestURLFetcher* fetcher2 = factory_.GetFetcherByID(0);
@@ -413,9 +384,9 @@ TEST_F(OAuth2TokenServiceTest,
 }
 
 TEST_F(OAuth2TokenServiceTest, ServiceShutDownBeforeFetchComplete) {
-  oauth2_service_->set_refresh_token(account_id_, "refreshToken");
+  oauth2_service_->set_refresh_token("refreshToken");
   scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest(
-      account_id_, OAuth2TokenService::ScopeSet(), &consumer_));
+      std::set<std::string>(), &consumer_));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
   EXPECT_EQ(0, consumer_.number_of_errors_);
@@ -428,11 +399,10 @@ TEST_F(OAuth2TokenServiceTest, ServiceShutDownBeforeFetchComplete) {
 }
 
 TEST_F(OAuth2TokenServiceTest, RetryingConsumer) {
-  oauth2_service_->set_refresh_token(account_id_, "refreshToken");
-  RetryingTestingOAuth2TokenServiceConsumer consumer(oauth2_service_.get(),
-      account_id_);
+  oauth2_service_->set_refresh_token("refreshToken");
+  RetryingTestingOAuth2TokenServiceConsumer consumer(oauth2_service_.get());
   scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest(
-      account_id_, OAuth2TokenService::ScopeSet(), &consumer));
+      std::set<std::string>(), &consumer));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0, consumer.number_of_successful_tokens_);
   EXPECT_EQ(0, consumer.number_of_errors_);
@@ -455,12 +425,12 @@ TEST_F(OAuth2TokenServiceTest, RetryingConsumer) {
 }
 
 TEST_F(OAuth2TokenServiceTest, InvalidateToken) {
-  OAuth2TokenService::ScopeSet scopes;
-  oauth2_service_->set_refresh_token(account_id_, "refreshToken");
+  std::set<std::string> scopes;
+  oauth2_service_->set_refresh_token("refreshToken");
 
   // First request.
   scoped_ptr<OAuth2TokenService::Request> request(
-      oauth2_service_->StartRequest(account_id_, scopes, &consumer_));
+      oauth2_service_->StartRequest(scopes, &consumer_));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
@@ -477,7 +447,7 @@ TEST_F(OAuth2TokenServiceTest, InvalidateToken) {
   // Second request, should return the same token without needing a network
   // request.
   scoped_ptr<OAuth2TokenService::Request> request2(
-      oauth2_service_->StartRequest(account_id_, scopes, &consumer_));
+      oauth2_service_->StartRequest(scopes, &consumer_));
   base::RunLoop().RunUntilIdle();
 
   // No new network fetcher.
@@ -486,9 +456,9 @@ TEST_F(OAuth2TokenServiceTest, InvalidateToken) {
   EXPECT_EQ("token", consumer_.last_token_);
 
   // Invalidating the token should return a new token on the next request.
-  oauth2_service_->InvalidateToken(account_id_, scopes, consumer_.last_token_);
+  oauth2_service_->InvalidateToken(scopes, consumer_.last_token_);
   scoped_ptr<OAuth2TokenService::Request> request3(
-      oauth2_service_->StartRequest(account_id_, scopes, &consumer_));
+      oauth2_service_->StartRequest(scopes, &consumer_));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(2, consumer_.number_of_successful_tokens_);
   EXPECT_EQ(0, consumer_.number_of_errors_);
@@ -503,15 +473,13 @@ TEST_F(OAuth2TokenServiceTest, InvalidateToken) {
 }
 
 TEST_F(OAuth2TokenServiceTest, CancelAllRequests) {
-  oauth2_service_->set_refresh_token(account_id_, "refreshToken");
+  oauth2_service_->set_refresh_token("refreshToken");
   scoped_ptr<OAuth2TokenService::Request> request(
-      oauth2_service_->StartRequest(account_id_, OAuth2TokenService::ScopeSet(),
-          &consumer_));
+      oauth2_service_->StartRequest(std::set<std::string>(), &consumer_));
 
-  oauth2_service_->set_refresh_token("account_id_2", "refreshToken2");
+  oauth2_service_->set_refresh_token("refreshToken2");
   scoped_ptr<OAuth2TokenService::Request> request2(
-      oauth2_service_->StartRequest(account_id_, OAuth2TokenService::ScopeSet(),
-          &consumer_));
+      oauth2_service_->StartRequest(std::set<std::string>(), &consumer_));
 
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
@@ -523,35 +491,33 @@ TEST_F(OAuth2TokenServiceTest, CancelAllRequests) {
   EXPECT_EQ(2, consumer_.number_of_errors_);
 }
 
-TEST_F(OAuth2TokenServiceTest, CancelRequestsForAccount) {
-  OAuth2TokenService::ScopeSet scope_set_1;
+TEST_F(OAuth2TokenServiceTest, CancelRequestsForToken) {
+  std::set<std::string> scope_set_1;
   scope_set_1.insert("scope1");
   scope_set_1.insert("scope2");
-  OAuth2TokenService::ScopeSet scope_set_2(scope_set_1.begin(),
-                                           scope_set_1.end());
+  std::set<std::string> scope_set_2(scope_set_1.begin(), scope_set_1.end());
   scope_set_2.insert("scope3");
 
-  oauth2_service_->set_refresh_token(account_id_, "refreshToken");
+  oauth2_service_->set_refresh_token("refreshToken");
   scoped_ptr<OAuth2TokenService::Request> request1(
-      oauth2_service_->StartRequest(account_id_, scope_set_1, &consumer_));
+      oauth2_service_->StartRequest(scope_set_1, &consumer_));
   scoped_ptr<OAuth2TokenService::Request> request2(
-      oauth2_service_->StartRequest(account_id_, scope_set_2, &consumer_));
+      oauth2_service_->StartRequest(scope_set_2, &consumer_));
 
-  std::string account_id_2("account_id_2");
-  oauth2_service_->set_refresh_token(account_id_2, "refreshToken2");
+  oauth2_service_->set_refresh_token("refreshToken2");
   scoped_ptr<OAuth2TokenService::Request> request3(
-      oauth2_service_->StartRequest(account_id_2, scope_set_1, &consumer_));
+      oauth2_service_->StartRequest(scope_set_1, &consumer_));
 
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
   EXPECT_EQ(0, consumer_.number_of_errors_);
 
-  oauth2_service_->CancelRequestsForAccountForTest(account_id_);
+  oauth2_service_->CancelRequestsForTokenForTest("refreshToken");
 
   EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
   EXPECT_EQ(2, consumer_.number_of_errors_);
 
-  oauth2_service_->CancelRequestsForAccountForTest(account_id_2);
+  oauth2_service_->CancelRequestsForTokenForTest("refreshToken2");
 
   EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
   EXPECT_EQ(3, consumer_.number_of_errors_);
@@ -567,24 +533,21 @@ TEST_F(OAuth2TokenServiceTest, SameScopesRequestedForDifferentClients) {
   scope_set.insert("scope2");
 
   std::string refresh_token("refreshToken");
-  oauth2_service_->set_refresh_token(account_id_, refresh_token);
+  oauth2_service_->set_refresh_token(refresh_token);
 
   scoped_ptr<OAuth2TokenService::Request> request1(
-      oauth2_service_->StartRequestForClient(account_id_,
-                                             client_id_1,
+      oauth2_service_->StartRequestForClient(client_id_1,
                                              client_secret_1,
                                              scope_set,
                                              &consumer_));
   scoped_ptr<OAuth2TokenService::Request> request2(
-      oauth2_service_->StartRequestForClient(account_id_,
-                                             client_id_2,
+      oauth2_service_->StartRequestForClient(client_id_2,
                                              client_secret_2,
                                              scope_set,
                                              &consumer_));
   // Start a request that should be duplicate of |request1|.
   scoped_ptr<OAuth2TokenService::Request> request3(
-      oauth2_service_->StartRequestForClient(account_id_,
-                                             client_id_1,
+      oauth2_service_->StartRequestForClient(client_id_1,
                                              client_secret_1,
                                              scope_set,
                                              &consumer_));
@@ -593,29 +556,57 @@ TEST_F(OAuth2TokenServiceTest, SameScopesRequestedForDifferentClients) {
   ASSERT_EQ(2U,
             oauth2_service_->GetNumPendingRequestsForTesting(
                 client_id_1,
-                account_id_,
+                refresh_token,
                 scope_set));
    ASSERT_EQ(1U,
              oauth2_service_->GetNumPendingRequestsForTesting(
                 client_id_2,
-                account_id_,
+                refresh_token,
                 scope_set));
 }
 
-TEST_F(OAuth2TokenServiceTest, RequestParametersOrderTest) {
+TEST_F(OAuth2TokenServiceTest, ClientScopeSetOrderTest) {
+  OAuth2TokenService::ScopeSet set_0;
+  OAuth2TokenService::ScopeSet set_1;
+  set_1.insert("1");
+
+  OAuth2TokenService::ClientScopeSet sets[] = {
+      OAuth2TokenService::ClientScopeSet("0", set_0),
+      OAuth2TokenService::ClientScopeSet("0", set_1),
+      OAuth2TokenService::ClientScopeSet("1", set_0),
+      OAuth2TokenService::ClientScopeSet("1", set_1),
+  };
+
+  for (size_t i = 0; i < arraysize(sets); i++) {
+    for (size_t j = 0; j < arraysize(sets); j++) {
+      if (i == j) {
+        EXPECT_FALSE(sets[i] < sets[j]) << " i=" << i << ", j=" << j;
+        EXPECT_FALSE(sets[j] < sets[i]) << " i=" << i << ", j=" << j;
+      } else if (i < j) {
+        EXPECT_TRUE(sets[i] < sets[j]) << " i=" << i << ", j=" << j;
+        EXPECT_FALSE(sets[j] < sets[i]) << " i=" << i << ", j=" << j;
+      } else {
+        EXPECT_TRUE(sets[j] < sets[i]) << " i=" << i << ", j=" << j;
+        EXPECT_FALSE(sets[i] < sets[j]) << " i=" << i << ", j=" << j;
+      }
+    }
+  }
+}
+
+TEST_F(OAuth2TokenServiceTest, FetchParametersOrderTest) {
   OAuth2TokenService::ScopeSet set_0;
   OAuth2TokenService::ScopeSet set_1;
   set_1.insert("1");
 
-  OAuth2TokenService::RequestParameters params[] = {
-      OAuth2TokenService::RequestParameters("0", "0", set_0),
-      OAuth2TokenService::RequestParameters("0", "0", set_1),
-      OAuth2TokenService::RequestParameters("0", "1", set_0),
-      OAuth2TokenService::RequestParameters("0", "1", set_1),
-      OAuth2TokenService::RequestParameters("1", "0", set_0),
-      OAuth2TokenService::RequestParameters("1", "0", set_1),
-      OAuth2TokenService::RequestParameters("1", "1", set_0),
-      OAuth2TokenService::RequestParameters("1", "1", set_1),
+  OAuth2TokenService::FetchParameters params[] = {
+      OAuth2TokenService::FetchParameters("0", "0", set_0),
+      OAuth2TokenService::FetchParameters("0", "0", set_1),
+      OAuth2TokenService::FetchParameters("0", "1", set_0),
+      OAuth2TokenService::FetchParameters("0", "1", set_1),
+      OAuth2TokenService::FetchParameters("1", "0", set_0),
+      OAuth2TokenService::FetchParameters("1", "0", set_1),
+      OAuth2TokenService::FetchParameters("1", "1", set_0),
+      OAuth2TokenService::FetchParameters("1", "1", set_1),
   };
 
   for (size_t i = 0; i < arraysize(params); i++) {