Remove IdentityGetAuthTokenFunction interface dep on IdentityAPI

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

 // 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.
 
 #include "chrome/browser/extensions/api/identity/identity_api.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <set>
@@ skipping 125 matching lines @@
 IdentityAPI::IdentityAPI(content::BrowserContext* context)
     : browser_context_(context),
       profile_identity_provider_(
           SigninManagerFactory::GetForProfile(
               Profile::FromBrowserContext(context)),
           ProfileOAuth2TokenServiceFactory::GetForProfile(
               Profile::FromBrowserContext(context)),
           LoginUIServiceFactory::GetShowLoginPopupCallbackForProfile(
               Profile::FromBrowserContext(context))),
       account_tracker_(&profile_identity_provider_,
-                       g_browser_process->system_request_context()) {
+                       g_browser_process->system_request_context()),
+      get_auth_token_function_(nullptr) {
   account_tracker_.AddObserver(this);
 }
 
 IdentityAPI::~IdentityAPI() {}
 
 IdentityMintRequestQueue* IdentityAPI::mint_queue() { return &mint_queue_; }
 
 void IdentityAPI::SetCachedToken(const ExtensionTokenKey& key,
                                  const IdentityTokenCacheValue& token_data) {
   CachedTokens::iterator it = token_cache_.find(key);
@@ skipping 43 matching lines @@
   }
 
   return gaia_ids;
 }
 
 std::string IdentityAPI::FindAccountKeyByGaiaId(const std::string& gaia_id) {
   return account_tracker_.FindAccountIdsByGaiaId(gaia_id).account_key;
 }
 
 void IdentityAPI::Shutdown() {
-  for (auto& observer : shutdown_observer_list_)
-    observer.OnShutdown();
+  if (get_auth_token_function_)
+    get_auth_token_function_->Shutdown();
   account_tracker_.RemoveObserver(this);
   account_tracker_.Shutdown();
 }
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<IdentityAPI> >
     g_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<IdentityAPI>* IdentityAPI::GetFactoryInstance() {
   return g_factory.Pointer();
@@ skipping 13 matching lines @@
   std::unique_ptr<base::ListValue> args =
       api::identity::OnSignInChanged::Create(account_info, is_signed_in);
   std::unique_ptr<Event> event(
       new Event(events::IDENTITY_ON_SIGN_IN_CHANGED,
                 api::identity::OnSignInChanged::kEventName, std::move(args),
                 browser_context_));
 
   EventRouter::Get(browser_context_)->BroadcastEvent(std::move(event));
 }
 
-void IdentityAPI::AddShutdownObserver(ShutdownObserver* observer) {
-  shutdown_observer_list_.AddObserver(observer);
-}
-
-void IdentityAPI::RemoveShutdownObserver(ShutdownObserver* observer) {
-  shutdown_observer_list_.RemoveObserver(observer);
-}
-
 void IdentityAPI::SetAccountStateForTest(gaia::AccountIds ids,
                                          bool is_signed_in) {
   account_tracker_.SetAccountStateForTest(ids, is_signed_in);
 }
 
 template <>
 void BrowserContextKeyedAPIFactory<IdentityAPI>::DeclareFactoryDependencies() {
   DependsOn(ExtensionsBrowserClient::Get()->GetExtensionSystemFactory());
   DependsOn(ProfileOAuth2TokenServiceFactory::GetInstance());
 }
@@ skipping 138 matching lines @@
   }
 
   return true;
 }
 
 void IdentityGetAuthTokenFunction::StartAsyncRun() {
   // Balanced in CompleteAsyncRun
   AddRef();
   extensions::IdentityAPI::GetFactoryInstance()
       ->Get(GetProfile())
-      ->AddShutdownObserver(this);
+      ->set_get_auth_token_function(this);
 }
 
 void IdentityGetAuthTokenFunction::CompleteAsyncRun(bool success) {
   extensions::IdentityAPI::GetFactoryInstance()
       ->Get(GetProfile())
-      ->RemoveShutdownObserver(this);
+      ->set_get_auth_token_function(nullptr);
 
   SendResponse(success);
   Release();  // Balanced in StartAsyncRun
 }
 
 void IdentityGetAuthTokenFunction::CompleteFunctionWithResult(
     const std::string& access_token) {
   SetResult(base::MakeUnique<base::StringValue>(access_token));
   CompleteAsyncRun(true);
 }
@@ skipping 311 matching lines @@
   TRACE_EVENT_ASYNC_STEP_PAST1("identity",
                                "IdentityGetAuthTokenFunction",
                                this,
                                "OnGetTokenFailure",
                                "error",
                                error.ToString());
   login_token_request_.reset();
   OnGaiaFlowFailure(GaiaWebAuthFlow::SERVICE_AUTH_ERROR, error, std::string());
 }
 
-void IdentityGetAuthTokenFunction::OnShutdown() {
+void IdentityGetAuthTokenFunction::Shutdown() {
   gaia_web_auth_flow_.reset();
   signin_flow_.reset();
   login_token_request_.reset();
   extensions::IdentityAPI::GetFactoryInstance()
       ->Get(GetProfile())
       ->mint_queue()
       ->RequestCancel(*token_key_, this);
   CompleteFunctionWithError(identity_constants::kCanceled);
 }
 
@@ skipping 114 matching lines @@
   // Component apps using auto_approve may use Chrome's client ID by
   // omitting the field.
   if (client_id.empty() && extension()->location() == Manifest::COMPONENT &&
       oauth2_info.auto_approve) {
     client_id = GaiaUrls::GetInstance()->oauth2_chrome_client_id();
   }
   return client_id;
 }
 
 }  // namespace extensions