Get OAuth2TokenService working on Android.

chrome/browser/signin/oauth2_token_service.h

 // Copyright 2012 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.
 
 #ifndef CHROME_BROWSER_SIGNIN_OAUTH2_TOKEN_SERVICE_H_
 #define CHROME_BROWSER_SIGNIN_OAUTH2_TOKEN_SERVICE_H_
 
 #include <map>
 #include <set>
 #include <string>
@@ skipping 81 matching lines @@
   // deleted.
   // Note the refresh token has been collected from TokenService when this
   // method returns, and the request can continue even if TokenService clears
   // its tokens after this method returns. This means that outstanding
   // StartRequest actions will still complete even if the user signs out in the
   // meantime.
   virtual scoped_ptr<Request> StartRequest(
       const ScopeSet& scopes,
       OAuth2TokenService::Consumer* consumer);
 
+  // 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.
+  void InvalidateToken(const ScopeSet& scopes,
+                       const std::string& invalid_token);
+
   // content::NotificationObserver
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
   // SigninGlobalError::AuthStatusProvider implementation.
   virtual GoogleServiceAuthError GetAuthStatus() const OVERRIDE;
 
  private:
   // Class that fetches an OAuth2 access token for a given set of scopes and
   // OAuth2 refresh token.
   class Fetcher;
   friend class Fetcher;
   // Implementation of Request.
   class RequestImpl;
 
   // Informs the consumer of |request| fetch results.
   static void InformConsumer(
       base::WeakPtr<OAuth2TokenService::RequestImpl> request,
-      GoogleServiceAuthError error,
-      std::string access_token,
-      base::Time expiration_date);
+      const GoogleServiceAuthError& error,
+      const std::string& access_token,
+      const base::Time& expiration_date);
 
   // Struct that contains the information of an OAuth2 access token.
   struct CacheEntry {
     std::string access_token;
     base::Time expiration_date;
   };
 
   // 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 |scopes| is added before the usage of the
   // returned entry is done.
   const CacheEntry* GetCacheEntry(const ScopeSet& scopes);
+
   // Registers a new access token in the cache if |refresh_token| is the one
   // currently held by TokenService.
   void RegisterCacheEntry(const std::string& refresh_token,
                           const ScopeSet& scopes,
                           const std::string& access_token,
                           const base::Time& expiration_date);
 
+  // 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 OAuth2TokenService::ScopeSet& scopes,
+                        const std::string& token_to_remove);
+
+
   // Called when |fetcher| finishes fetching.
   void OnFetchComplete(Fetcher* fetcher);
 
   // Updates the internal cache of the result from the most-recently-completed
   // auth request (used for reporting errors to the user).
   void UpdateAuthError(const GoogleServiceAuthError& error);
 
   // The profile with which this instance was initialized, or NULL.
   Profile* profile_;
 
@@ skipping 14 matching lines @@
   // token using these parameters.
   std::map<FetchParameters, Fetcher*> pending_fetchers_;
 
   // Registrar for notifications from the TokenService.
   content::NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(OAuth2TokenService);
 };
 
 #endif  // CHROME_BROWSER_SIGNIN_OAUTH2_TOKEN_SERVICE_H_