Identity API: getAuthToken request queues (token cache prelude)

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 <set>
+#include <string>
+#include <vector>
+
 #include "base/lazy_instance.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/app_mode/app_mode_utils.h"
 #include "chrome/browser/extensions/extension_function_dispatcher.h"
 #include "chrome/browser/extensions/extension_install_prompt.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/permissions_updater.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/signin_manager.h"
@@ skipping 36 matching lines @@
 
 }  // namespace
 
 namespace GetAuthToken = api::experimental_identity::GetAuthToken;
 namespace LaunchWebAuthFlow = api::experimental_identity::LaunchWebAuthFlow;
 namespace identity = api::experimental_identity;
 
 IdentityGetAuthTokenFunction::IdentityGetAuthTokenFunction()
     : should_prompt_for_scopes_(false),
       should_prompt_for_signin_(false) {}
+
 IdentityGetAuthTokenFunction::~IdentityGetAuthTokenFunction() {}
 
 bool IdentityGetAuthTokenFunction::RunImpl() {
   scoped_ptr<GetAuthToken::Params> params(GetAuthToken::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   bool interactive = params->details.get() &&
       params->details->interactive.get() &&
       *params->details->interactive;
 
   should_prompt_for_scopes_ = interactive;
   should_prompt_for_signin_ = interactive;
 
   const OAuth2Info& oauth2_info = OAuth2Info::GetOAuth2Info(GetExtension());
 
   // Check that the necessary information is present in the manifest.
   if (oauth2_info.client_id.empty()) {
     error_ = identity_constants::kInvalidClientId;
     return false;
   }
 
   if (oauth2_info.scopes.size() == 0) {
     error_ = identity_constants::kInvalidScopes;
     return false;
   }
 
-  // Balanced in OnIssueAdviceSuccess|OnMintTokenSuccess|OnMintTokenFailure|
-  // InstallUIAbort|SigninFailed.
+  // Balanced in CompleteFunctionWithResult|CompleteFunctionWithError
   AddRef();
 
   if (!HasLoginToken()) {
     if (!should_prompt_for_signin_) {
       error_ = identity_constants::kUserNotSignedIn;
       Release();
       return false;
     }
-    // Display a login prompt. If the subsequent mint fails, don't display the
-    // prompt again.
-    should_prompt_for_signin_ = false;
-    ShowLoginPopup();
+    // Display a login prompt.
+    StartSigninFlow();
   } else {
     TokenService* token_service = TokenServiceFactory::GetForProfile(profile());
     refresh_token_ = token_service->GetOAuth2LoginRefreshToken();
-    StartFlow(OAuth2MintTokenFlow::MODE_MINT_TOKEN_NO_FORCE);
+    StartMintTokenFlow(IdentityMintRequestQueue::MINT_TYPE_NONINTERACTIVE);
   }
 
   return true;
 }
 
-void IdentityGetAuthTokenFunction::OnMintTokenSuccess(
+void IdentityGetAuthTokenFunction::CompleteFunctionWithResult(
     const std::string& access_token) {
   SetResult(Value::CreateStringValue(access_token));
   SendResponse(true);
   Release();  // Balanced in RunImpl.
 }
 
+void IdentityGetAuthTokenFunction::CompleteFunctionWithError(
+    const std::string& error) {
+  error_ = error;
+  SendResponse(false);
+  Release();  // Balanced in RunImpl.
+}
+
+void IdentityGetAuthTokenFunction::StartSigninFlow() {
+  // Display a login prompt. If the subsequent mint fails, don't display the
+  // login prompt again.
+  should_prompt_for_signin_ = false;
+  ShowLoginPopup();
+}
+
+void IdentityGetAuthTokenFunction::StartMintTokenFlow(
+    IdentityMintRequestQueue::MintType type) {
+  mint_token_flow_type_ = type;
+
+  // Flows are serialized to prevent excessive traffic to GAIA, and
+  // to consolidate UI pop-ups.
+  const OAuth2Info& oauth2_info = OAuth2Info::GetOAuth2Info(GetExtension());
+  std::set<std::string> scopes(oauth2_info.scopes.begin(),
+                               oauth2_info.scopes.end());
+  IdentityAPI* id_api =
+      extensions::IdentityAPI::GetFactoryInstance()->GetForProfile(profile_);
+
+  // If there is an interactive flow in progress, non-interactive
+  // requests should complete immediately since a consent UI is
+  // known to be required.
+  if (!should_prompt_for_scopes_ && !id_api->mint_queue()->empty(
+          IdentityMintRequestQueue::MINT_TYPE_INTERACTIVE,
+          GetExtension()->id(), scopes)) {
+    CompleteFunctionWithError(identity_constants::kNoGrant);
+    return;
+  }
+  id_api->mint_queue()->RequestStart(type,
+                                     GetExtension()->id(),
+                                     scopes,
+                                     this);
+}
+
+void IdentityGetAuthTokenFunction::CompleteMintTokenFlow() {
+  IdentityMintRequestQueue::MintType type = mint_token_flow_type_;
+
+  const OAuth2Info& oauth2_info = OAuth2Info::GetOAuth2Info(GetExtension());
+  std::set<std::string> scopes(oauth2_info.scopes.begin(),
+                               oauth2_info.scopes.end());
+
+  extensions::IdentityAPI::GetFactoryInstance()->GetForProfile(
+      profile_)->mint_queue()->RequestComplete(type,
+                                               GetExtension()->id(),
+                                               scopes,
+                                               this);
+}
+
+void IdentityGetAuthTokenFunction::StartMintToken(
+    IdentityMintRequestQueue::MintType type) {
+  switch (type) {
+    case IdentityMintRequestQueue::MINT_TYPE_NONINTERACTIVE:
+      StartGaiaRequest(OAuth2MintTokenFlow::MODE_MINT_TOKEN_NO_FORCE);
+      break;
+
+    case IdentityMintRequestQueue::MINT_TYPE_INTERACTIVE:
+      install_ui_.reset(new ExtensionInstallPrompt(GetAssociatedWebContents()));
+      ShowOAuthApprovalDialog(issue_advice_);
+      break;
+
+    default:
+      NOTREACHED() << "Unexepected mint type in StartMintToken: " << type;
+      break;
+  };
+}
+
+void IdentityGetAuthTokenFunction::OnMintTokenSuccess(
+    const std::string& access_token) {
+  CompleteMintTokenFlow();
+  CompleteFunctionWithResult(access_token);
+}
+
 void IdentityGetAuthTokenFunction::OnMintTokenFailure(
     const GoogleServiceAuthError& error) {
+  CompleteMintTokenFlow();
+
   switch (error.state()) {
     case GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS:
     case GoogleServiceAuthError::ACCOUNT_DELETED:
     case GoogleServiceAuthError::ACCOUNT_DISABLED:
       extensions::IdentityAPI::GetFactoryInstance()->GetForProfile(
           profile())->ReportAuthError(error);
       if (should_prompt_for_signin_) {
         // Display a login prompt and try again (once).
-        should_prompt_for_signin_ = false;
-        ShowLoginPopup();
+        StartSigninFlow();
         return;
       }
       break;
     default:
       // Return error to caller.
       break;
   }
 
-  error_ = std::string(identity_constants::kAuthFailure) + error.ToString();
-  SendResponse(false);
-  Release();  // Balanced in RunImpl.
+  CompleteFunctionWithError(
+      std::string(identity_constants::kAuthFailure) + error.ToString());
 }
 
 void IdentityGetAuthTokenFunction::OnIssueAdviceSuccess(
     const IssueAdviceInfo& issue_advice) {
+  CompleteMintTokenFlow();
+
   should_prompt_for_signin_ = false;
   // Existing grant was revoked and we used NO_FORCE, so we got info back
   // instead.
   if (should_prompt_for_scopes_) {
-    install_ui_.reset(new ExtensionInstallPrompt(GetAssociatedWebContents()));
-    ShowOAuthApprovalDialog(issue_advice);
+    issue_advice_ = issue_advice;
+    StartMintTokenFlow(IdentityMintRequestQueue::MINT_TYPE_INTERACTIVE);
   } else {
-    error_ = identity_constants::kNoGrant;
-    SendResponse(false);
-    Release();  // Balanced in RunImpl.
+    CompleteFunctionWithError(identity_constants::kNoGrant);
   }
 }
 
 void IdentityGetAuthTokenFunction::SigninSuccess(const std::string& token) {
   refresh_token_ = token;
-  StartFlow(OAuth2MintTokenFlow::MODE_MINT_TOKEN_NO_FORCE);
+  StartMintTokenFlow(IdentityMintRequestQueue::MINT_TYPE_NONINTERACTIVE);
 }
 
 void IdentityGetAuthTokenFunction::SigninFailed() {
-  error_ = identity_constants::kUserNotSignedIn;
-  SendResponse(false);
-  Release();
+  CompleteFunctionWithError(identity_constants::kUserNotSignedIn);
 }
 
 void IdentityGetAuthTokenFunction::InstallUIProceed() {
   DCHECK(install_ui_->record_oauth2_grant());
   // The user has accepted the scopes, so we may now force (recording a grant
   // and receiving a token).
-  StartFlow(OAuth2MintTokenFlow::MODE_MINT_TOKEN_FORCE);
+  StartGaiaRequest(OAuth2MintTokenFlow::MODE_MINT_TOKEN_FORCE);
 }
 
 void IdentityGetAuthTokenFunction::InstallUIAbort(bool user_initiated) {
-  error_ = identity_constants::kUserRejected;
-  SendResponse(false);
-  Release();  // Balanced in RunImpl.
+  CompleteMintTokenFlow();
+  CompleteFunctionWithError(identity_constants::kUserRejected);
 }
 
-void IdentityGetAuthTokenFunction::StartFlow(OAuth2MintTokenFlow::Mode mode) {
-  signin_flow_.reset(NULL);
+void IdentityGetAuthTokenFunction::StartGaiaRequest(
+    OAuth2MintTokenFlow::Mode mode) {
   mint_token_flow_.reset(CreateMintTokenFlow(mode));
   mint_token_flow_->Start();
 }
 
 void IdentityGetAuthTokenFunction::ShowLoginPopup() {
   signin_flow_.reset(new IdentitySigninFlow(this, profile()));
   signin_flow_->Start();
 }
 
 void IdentityGetAuthTokenFunction::ShowOAuthApprovalDialog(
@@ skipping 138 matching lines @@
 void IdentityAPI::Initialize() {
   signin_manager_ = SigninManagerFactory::GetForProfile(profile_);
   signin_manager_->signin_global_error()->AddProvider(this);
 
   TokenService* token_service = TokenServiceFactory::GetForProfile(profile_);
   registrar_.Add(this,
                  chrome::NOTIFICATION_TOKEN_AVAILABLE,
                  content::Source<TokenService>(token_service));
 }
 
+IdentityMintRequestQueue* IdentityAPI::mint_queue() {
+    return &mint_queue_;
+}
+
 void IdentityAPI::ReportAuthError(const GoogleServiceAuthError& error) {
   if (!signin_manager_)
     Initialize();
 
   error_ = error;
   signin_manager_->signin_global_error()->AuthStatusChanged();
 }
 
 void IdentityAPI::Shutdown() {
   if (signin_manager_)
@@ skipping 26 matching lines @@
 }
 
 template <>
 void ProfileKeyedAPIFactory<IdentityAPI>::DeclareFactoryDependencies() {
   DependsOn(ExtensionSystemFactory::GetInstance());
   DependsOn(TokenServiceFactory::GetInstance());
   DependsOn(SigninManagerFactory::GetInstance());
 }
 
 }  // namespace extensions