Identity API: Add token cache and identity.invalidateAuthToken.

chrome/browser/extensions/api/identity/identity_api.h

 // Copyright (c) 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_EXTENSIONS_API_IDENTITY_IDENTITY_API_H_
 #define CHROME_BROWSER_EXTENSIONS_API_IDENTITY_IDENTITY_API_H_
 
 #include <map>
 #include <string>
 #include <vector>
@@ skipping 71 matching lines @@
 
   // Initiate/complete the sub-flows.
   void StartSigninFlow();
   void StartMintTokenFlow(IdentityMintRequestQueue::MintType type);
   void CompleteMintTokenFlow();
 
   // IdentityMintRequestQueue::Request implementation:
   virtual void StartMintToken(IdentityMintRequestQueue::MintType type) OVERRIDE;
 
   // OAuth2MintTokenFlow::Delegate implementation:
-  virtual void OnMintTokenSuccess(const std::string& access_token) OVERRIDE;
+  virtual void OnMintTokenSuccess(const std::string& access_token,
+                                  int time_to_live) OVERRIDE;
   virtual void OnMintTokenFailure(
       const GoogleServiceAuthError& error) OVERRIDE;
   virtual void OnIssueAdviceSuccess(
       const IssueAdviceInfo& issue_advice) OVERRIDE;
 
   // IdentitySigninFlow::Delegate implementation:
   virtual void SigninSuccess(const std::string& token) OVERRIDE;
   virtual void SigninFailed() OVERRIDE;
 
   // ExtensionInstallPrompt::Delegate implementation:
@@ skipping 19 matching lines @@
   std::string refresh_token_;
   bool should_prompt_for_signin_;
 
   // When launched in interactive mode, and if there is no existing grant,
   // a permissions prompt will be popped up to the user.
   IssueAdviceInfo issue_advice_;
   scoped_ptr<ExtensionInstallPrompt> install_ui_;
   scoped_ptr<IdentitySigninFlow> signin_flow_;
 };
 
+class IdentityInvalidateAuthTokenFunction : public SyncExtensionFunction {
+ public:
+  DECLARE_EXTENSION_FUNCTION("experimental.identity.invalidateAuthToken",
+                             EXPERIMENTAL_IDENTITY_INVALIDATEAUTHTOKEN)
+  IdentityInvalidateAuthTokenFunction();
+
+ protected:
+  virtual ~IdentityInvalidateAuthTokenFunction();
+
+  // SyncExtensionFunction implementation:
+  virtual bool RunImpl() OVERRIDE;
+};
+
 class IdentityLaunchWebAuthFlowFunction : public AsyncExtensionFunction,
                                           public WebAuthFlow::Delegate {
  public:
   DECLARE_EXTENSION_FUNCTION("experimental.identity.launchWebAuthFlow",
                              EXPERIMENTAL_IDENTITY_LAUNCHWEBAUTHFLOW)
 
   IdentityLaunchWebAuthFlowFunction();
 
   // URL checking helpers. Public for testing.
   // Checks to see if the current URL ends the flow.
@@ skipping 10 matching lines @@
   virtual void OnAuthFlowFailure(WebAuthFlow::Failure failure) OVERRIDE;
   virtual void OnAuthFlowURLChange(const GURL& redirect_url) OVERRIDE;
 
   // Helper to initialize final URLs vector.
   void InitFinalRedirectURLPrefixes(const std::string& extension_id);
 
   scoped_ptr<WebAuthFlow> auth_flow_;
   std::vector<GURL> final_prefixes_;
 };
 
+class IdentityTokenCacheValue {
+ public:
+  IdentityTokenCacheValue();
+  explicit IdentityTokenCacheValue(const IssueAdviceInfo& issue_advice);
+  IdentityTokenCacheValue(const std::string& token,
+                          base::TimeDelta time_to_live);
+  ~IdentityTokenCacheValue();
+
+  // Order of these entries is used to determine whether or not new
+  // entries supercede older ones in SetCachedToken.
+  enum CacheValueStatus {
+    CACHE_STATUS_NOTFOUND,
+    CACHE_STATUS_ADVICE,
+    CACHE_STATUS_TOKEN
+  };
+
+  CacheValueStatus status() const;
+  const IssueAdviceInfo& issue_advice() const;
+  const std::string& token() const;
+
+ private:
+  bool is_expired() const;
+
+  CacheValueStatus status_;
+  IssueAdviceInfo issue_advice_;
+  std::string token_;
+  base::Time expiration_time_;
+};
+
 class IdentityAPI : public ProfileKeyedAPI,
                     public SigninGlobalError::AuthStatusProvider,
                     public content::NotificationObserver {
  public:
   explicit IdentityAPI(Profile* profile);
   virtual ~IdentityAPI();
   void Initialize();
 
   // Request serialization queue for getAuthToken.
   IdentityMintRequestQueue* mint_queue();
 
+  // Token cache
+  void SetCachedToken(const std::string& extension_id,
+                      const std::vector<std::string> scopes,
+                      const IdentityTokenCacheValue& token_data);
+  void EraseCachedToken(const std::string& extension_id,
+                        const std::string& token);
+  void EraseAllCachedTokens();
+  const IdentityTokenCacheValue& GetCachedToken(
+      const std::string& extension_id, const std::vector<std::string> scopes);
+
   void ReportAuthError(const GoogleServiceAuthError& error);
 
   // ProfileKeyedAPI implementation.
   virtual void Shutdown() OVERRIDE;
   static ProfileKeyedAPIFactory<IdentityAPI>* GetFactoryInstance();
 
   // AuthStatusProvider implementation.
   virtual GoogleServiceAuthError GetAuthStatus() const OVERRIDE;
 
   // content::NotificationObserver implementation.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
  private:
   friend class ProfileKeyedAPIFactory<IdentityAPI>;
 
+  struct TokenCacheKey {
+    TokenCacheKey(const std::string& extension_id,
+                  const std::set<std::string> scopes);
+    ~TokenCacheKey();
+    bool operator<(const TokenCacheKey& rhs) const;
+    std::string extension_id;
+    std::set<std::string> scopes;
+  };
+
   // ProfileKeyedAPI implementation.
   static const char* service_name() {
     return "IdentityAPI";
   }
   static const bool kServiceIsNULLWhileTesting = true;
 
   Profile* profile_;
   SigninManager* signin_manager_;
   GoogleServiceAuthError error_;
   // Used to listen to notifications from the TokenService.
   content::NotificationRegistrar registrar_;
   IdentityMintRequestQueue mint_queue_;
+  std::map<TokenCacheKey, IdentityTokenCacheValue> token_cache_;
 };
 
 template <>
 void ProfileKeyedAPIFactory<IdentityAPI>::DeclareFactoryDependencies();
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_API_IDENTITY_IDENTITY_API_H_