Remove IdentityGetAuthTokenFunction interface dep on IdentityAPI

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 <set>
 #include <string>
@@ skipping 23 matching lines @@
 class GoogleServiceAuthError;
 class MockGetAuthTokenFunction;
 
 namespace content {
 class BrowserContext;
 }
 
 namespace extensions {
 
 class GetAuthTokenFunctionTest;
+class IdentityGetAuthTokenFunction;
 class MockGetAuthTokenFunction;
 
 class IdentityTokenCacheValue {
  public:
   IdentityTokenCacheValue();
   explicit IdentityTokenCacheValue(const IssueAdviceInfo& issue_advice);
   IdentityTokenCacheValue(const std::string& token,
                           base::TimeDelta time_to_live);
   IdentityTokenCacheValue(const IdentityTokenCacheValue& other);
   ~IdentityTokenCacheValue();
@@ skipping 18 matching lines @@
   IssueAdviceInfo issue_advice_;
   std::string token_;
   base::Time expiration_time_;
 };
 
 class IdentityAPI : public BrowserContextKeyedAPI,
                     public gaia::AccountTracker::Observer {
  public:
   typedef std::map<ExtensionTokenKey, IdentityTokenCacheValue> CachedTokens;
 
-  class ShutdownObserver {
-   public:
-    virtual void OnShutdown() = 0;
-  };
-
   explicit IdentityAPI(content::BrowserContext* context);
   ~IdentityAPI() override;
 
   // Request serialization queue for getAuthToken.
   IdentityMintRequestQueue* mint_queue();
 
   // Token cache
   void SetCachedToken(const ExtensionTokenKey& key,
                       const IdentityTokenCacheValue& token_data);
   void EraseCachedToken(const std::string& extension_id,
@@ skipping 10 matching lines @@
   // BrowserContextKeyedAPI implementation.
   void Shutdown() override;
   static BrowserContextKeyedAPIFactory<IdentityAPI>* GetFactoryInstance();
 
   // gaia::AccountTracker::Observer implementation:
   void OnAccountAdded(const gaia::AccountIds& ids) override;
   void OnAccountRemoved(const gaia::AccountIds& ids) override;
   void OnAccountSignInChanged(const gaia::AccountIds& ids,
                               bool is_signed_in) override;
 
-  void AddShutdownObserver(ShutdownObserver* observer);
-  void RemoveShutdownObserver(ShutdownObserver* observer);
+  void SetAccountStateForTest(gaia::AccountIds ids, bool is_signed_in);
 
-  void SetAccountStateForTest(gaia::AccountIds ids, bool is_signed_in);
+  void set_get_auth_token_function(
+      IdentityGetAuthTokenFunction* get_auth_token_function) {
+    get_auth_token_function_ = get_auth_token_function;
+  }
 
  private:
   friend class BrowserContextKeyedAPIFactory<IdentityAPI>;
 
   // BrowserContextKeyedAPI implementation.
   static const char* service_name() { return "IdentityAPI"; }
   static const bool kServiceIsNULLWhileTesting = true;
 
   content::BrowserContext* browser_context_;
   IdentityMintRequestQueue mint_queue_;
   CachedTokens token_cache_;
   ProfileIdentityProvider profile_identity_provider_;
   gaia::AccountTracker account_tracker_;
-  base::ObserverList<ShutdownObserver> shutdown_observer_list_;
+
+  // May be null.
+  IdentityGetAuthTokenFunction* get_auth_token_function_;
 };
 
 template <>
 void BrowserContextKeyedAPIFactory<IdentityAPI>::DeclareFactoryDependencies();
 
 class IdentityGetAccountsFunction : public ChromeUIThreadExtensionFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("identity.getAccounts",
                              IDENTITY_GETACCOUNTS);
 
@@ skipping 21 matching lines @@
 //
 // In some cases we need to display a sign-in dialog. Normally the
 // profile will be signed in already, but if it turns out we need a
 // new login token, there is a sign-in flow. If that flow completes
 // successfully, getAuthToken proceeds to the non-interactive flow.
 class IdentityGetAuthTokenFunction : public ChromeAsyncExtensionFunction,
                                      public GaiaWebAuthFlow::Delegate,
                                      public IdentityMintRequestQueue::Request,
                                      public OAuth2MintTokenFlow::Delegate,
                                      public IdentitySigninFlow::Delegate,
-                                     public OAuth2TokenService::Consumer,
-                                     public IdentityAPI::ShutdownObserver {
+                                     public OAuth2TokenService::Consumer {
  public:
   DECLARE_EXTENSION_FUNCTION("identity.getAuthToken",
                              EXPERIMENTAL_IDENTITY_GETAUTHTOKEN);
 
   IdentityGetAuthTokenFunction();
 
   const ExtensionTokenKey* GetExtensionTokenKeyForTest() {
     return token_key_.get();
   }
 
+  void Shutdown();
+
  protected:
   ~IdentityGetAuthTokenFunction() override;
 
   // IdentitySigninFlow::Delegate implementation:
   void SigninSuccess() override;
   void SigninFailed() override;
 
   // GaiaWebAuthFlow::Delegate implementation:
   void OnGaiaFlowFailure(GaiaWebAuthFlow::Failure failure,
                          GoogleServiceAuthError service_error,
@@ skipping 45 matching lines @@
 
   // IdentityMintRequestQueue::Request implementation:
   void StartMintToken(IdentityMintRequestQueue::MintType type) override;
 
   // OAuth2MintTokenFlow::Delegate implementation:
   void OnMintTokenSuccess(const std::string& access_token,
                           int time_to_live) override;
   void OnMintTokenFailure(const GoogleServiceAuthError& error) override;
   void OnIssueAdviceSuccess(const IssueAdviceInfo& issue_advice) override;
 
-  // IdentityAPI::ShutdownObserver implementation:
-  void OnShutdown() override;
-
 #if defined(OS_CHROMEOS)
   // Starts a login access token request for device robot account. This method
   // will be called only in Chrome OS for:
   // 1. Enterprise kiosk mode.
   // 2. Whitelisted first party apps in public session.
   virtual void StartDeviceLoginAccessTokenRequest();
 
   bool IsOriginWhitelistedInPublicSession();
 #endif
 
@@ skipping 22 matching lines @@
   // 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_;
   std::unique_ptr<GaiaWebAuthFlow> gaia_web_auth_flow_;
   std::unique_ptr<IdentitySigninFlow> signin_flow_;
 };
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_API_IDENTITY_IDENTITY_API_H_