implement sign in dialog

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 "base/values.h"
 #include "chrome/browser/extensions/extension_install_prompt.h"
 #include "chrome/browser/extensions/extension_function_dispatcher.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/permissions_updater.h"
 #include "chrome/browser/signin/token_service.h"
 #include "chrome/browser/signin/token_service_factory.h"
 #include "chrome/browser/ui/browser.h"
-#include "chrome/browser/ui/tab_contents/tab_contents.h"
+#include "chrome/browser/ui/browser_navigator.h"
+#include "chrome/browser/ui/webui/signin/login_ui_service.h"
+#include "chrome/browser/ui/webui/signin/login_ui_service_factory.h"
 #include "chrome/common/extensions/extension.h"
+#include "chrome/common/url_constants.h"
+#include "content/public/common/page_transition_types.h"
 #include "googleurl/src/gurl.h"
+#include "webkit/glue/window_open_disposition.h"
 
 namespace extensions {
 
-namespace {
-
-const char kInvalidClientId[] = "Invalid OAuth2 Client ID.";
-const char kInvalidScopes[] = "Invalid OAuth2 scopes.";
-const char kInvalidRedirect[] = "Did not redirect to the right URL.";
-const char kAuthFailure[] = "OAuth2 request failed: ";
-const char kNoGrant[] = "OAuth2 not granted or revoked.";
-const char kUserRejected[] = "The user did not approve access.";
-
-}  // namespace
+const char GetAuthTokenFunction::kInvalidClientId[] =
+    "Invalid OAuth2 Client ID.";
+const char GetAuthTokenFunction::kInvalidScopes[] = "Invalid OAuth2 scopes.";
+const char GetAuthTokenFunction::kAuthFailure[] = "OAuth2 request failed: ";
+const char GetAuthTokenFunction::kNoGrant[] = "OAuth2 not granted or revoked.";
+const char GetAuthTokenFunction::kUserRejected[] =
+    "The user did not approve access.";
+const char GetAuthTokenFunction::kUserNotSignedIn[] =
+    "The user is not signed in.";
 
 GetAuthTokenFunction::GetAuthTokenFunction() : interactive_(false) {}
 GetAuthTokenFunction::~GetAuthTokenFunction() {}
 
 bool GetAuthTokenFunction::RunImpl() {
   DictionaryValue* arg = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &arg));
   arg->GetBoolean("interactive", &interactive_);
 
+  const Extension::OAuth2Info& oauth2_info = GetOAuth2Info();
+
+  // Check that the necessary information is present in the manfist.
+  if (oauth2_info.client_id.empty()) {
+    error_ = kInvalidClientId;
+    return false;
+  }
+
+  if (oauth2_info.scopes.size() == 0) {
+    error_ = kInvalidScopes;
+    return false;
+  }
+
   // Balanced in OnIssueAdviceSuccess|OnMintTokenSuccess|OnMintTokenFailure|
-  // InstallUIAbort.
+  // InstallUIAbort|OnLoginUIClosed.
   AddRef();
 
-  if (StartFlow(ExtensionInstallPrompt::ShouldAutomaticallyApproveScopes() ?
-                    OAuth2MintTokenFlow::MODE_MINT_TOKEN_FORCE :
-                    OAuth2MintTokenFlow::MODE_MINT_TOKEN_NO_FORCE)) {
+  if (!HasLoginToken()) {
+    if (StartLogin()) {
+      return true;
+    } else {
+      Release();
+      return false;
+    }
+  }
+
+  if (StartFlow(GetTokenFlowMode())) {
     return true;
   } else {
     Release();
     return false;
   }
 }
 
 void GetAuthTokenFunction::OnMintTokenSuccess(const std::string& access_token) {
   result_.reset(Value::CreateStringValue(access_token));
   SendResponse(true);
   Release();  // Balanced in RunImpl.
 }
 
 void GetAuthTokenFunction::OnMintTokenFailure(
     const GoogleServiceAuthError& error) {
   error_ = std::string(kAuthFailure) + error.ToString();
   SendResponse(false);
   Release();  // Balanced in RunImpl.
 }
 
 void GetAuthTokenFunction::OnIssueAdviceSuccess(
     const IssueAdviceInfo& issue_advice) {
   // Existing grant was revoked and we used NO_FORCE, so we got info back
   // instead.
   if (interactive_) {
     install_ui_.reset(
         chrome::CreateExtensionInstallPromptWithBrowser(GetCurrentBrowser()));
-    install_ui_->ConfirmIssueAdvice(this, GetExtension(), issue_advice);
+    ShowOAuthApprovalDialog(issue_advice);
   } else {
     error_ = kNoGrant;
     SendResponse(false);
     Release();  // Balanced in RunImpl.
   }
 }
 
+void GetAuthTokenFunction::OnLoginUIClosed(LoginUIService::LoginUI* ui) {
+  StopObservingLoginService();
+  if (!StartFlow(GetTokenFlowMode())) {
+    SendResponse(false);
+    Release();
+  }
+}
+
 void GetAuthTokenFunction::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).
   bool success = StartFlow(OAuth2MintTokenFlow::MODE_MINT_TOKEN_FORCE);
   DCHECK(success);
 }
 
 void GetAuthTokenFunction::InstallUIAbort(bool user_initiated) {
   error_ = kUserRejected;
   SendResponse(false);
   Release();  // Balanced in RunImpl.
 }
 
 bool GetAuthTokenFunction::StartFlow(OAuth2MintTokenFlow::Mode mode) {
-  const Extension* extension = GetExtension();
-  Extension::OAuth2Info oauth2_info = extension->oauth2_info();
-
-  if (oauth2_info.client_id.empty()) {
-    error_ = kInvalidClientId;
+  if (!HasLoginToken()) {
+    error_ = kUserNotSignedIn;
     return false;
   }
 
-  if (oauth2_info.scopes.size() == 0) {
-    error_ = kInvalidScopes;
+  flow_.reset(CreateMintTokenFlow(mode));
+  flow_->Start();
+  return true;
+}
+
+bool GetAuthTokenFunction::StartLogin() {
+  if (!interactive_) {
+    error_ = kUserNotSignedIn;
     return false;
   }
 
+  ShowLoginPopup();
+  return true;
+}
+
+void GetAuthTokenFunction::StartObservingLoginService() {
+  LoginUIService* login_ui_service =
+      LoginUIServiceFactory::GetForProfile(profile());
+  login_ui_service->AddObserver(this);
+}
+
+void GetAuthTokenFunction::StopObservingLoginService() {
+  LoginUIService* login_ui_service =
+      LoginUIServiceFactory::GetForProfile(profile());
+  login_ui_service->RemoveObserver(this);
+}
+
+void GetAuthTokenFunction::ShowLoginPopup() {
+  StartObservingLoginService();
+
+  LoginUIService* login_ui_service =
+      LoginUIServiceFactory::GetForProfile(profile());
+  LoginUIService::LoginUI* login_ui = login_ui_service->current_login_ui();
+  if (login_ui) {
+    login_ui->FocusUI();
+  } else {
+    chrome::NavigateParams params(NULL,
+                                  GURL(chrome::kChromeUISyncPromoURL),
+                                  content::PAGE_TRANSITION_START_PAGE);
+    params.profile = profile();
+    params.disposition = NEW_POPUP;
+    chrome::Navigate(&params);
+  }
+}
+
+void GetAuthTokenFunction::ShowOAuthApprovalDialog(
+    const IssueAdviceInfo& issue_advice) {
+  install_ui_->ConfirmIssueAdvice(this, GetExtension(), issue_advice);
+}
+
+const std::string& GetAuthTokenFunction::GetExtensionId() const {
+  return GetExtension()->id();

[Mihai Parparita -not on Chrome, 2012/07/17 01:01:00]

You can override the Extension instance used in a RunFunctionAndReturnResult
call by calling function->set_extension()

Rather than having to pull out these simple getters into standalone methods that
you can override, you could just have (in your test) a helper method like
CreateGetAuthTokenFunction(OAuth2Info) that makes an Extension with the right
OAuth2Info, creates the GetAuthTokenFunction, sets the extension for it (and any
other shared setup work) and returns it, ready to called.

[Munjal (Google), 2012/07/19 22:35:42]

Done.

+}
+
+const Extension::OAuth2Info& GetAuthTokenFunction::GetOAuth2Info() const {
+  return GetExtension()->oauth2_info();
+}
+
+OAuth2MintTokenFlow* GetAuthTokenFunction::CreateMintTokenFlow(
+    OAuth2MintTokenFlow::Mode mode) {
+  const Extension::OAuth2Info& oauth2_info = GetOAuth2Info();
   TokenService* token_service = TokenServiceFactory::GetForProfile(profile());
-  flow_.reset(new OAuth2MintTokenFlow(
+  return new OAuth2MintTokenFlow(
       profile()->GetRequestContext(),
       this,
       OAuth2MintTokenFlow::Parameters(
           token_service->GetOAuth2LoginRefreshToken(),
-          extension->id(),
+          GetExtensionId(),
           oauth2_info.client_id,
           oauth2_info.scopes,
-          mode)));
-  flow_->Start();
-  return true;
+          mode));
 }
 
+bool GetAuthTokenFunction::HasLoginToken() const {
+  TokenService* token_service = TokenServiceFactory::GetForProfile(profile());
+  return token_service->HasOAuthLoginToken();
+}
+
+OAuth2MintTokenFlow::Mode GetAuthTokenFunction::GetTokenFlowMode() const {
+  return ExtensionInstallPrompt::ShouldAutomaticallyApproveScopes() ?
+      OAuth2MintTokenFlow::MODE_MINT_TOKEN_FORCE :
+      OAuth2MintTokenFlow::MODE_MINT_TOKEN_NO_FORCE;
+}
+
+const char LaunchWebAuthFlowFunction::kInvalidRedirect[] =
+    "Did not redirect to the right URL.";
+
 LaunchWebAuthFlowFunction::LaunchWebAuthFlowFunction() {}
 LaunchWebAuthFlowFunction::~LaunchWebAuthFlowFunction() {}
 
 bool LaunchWebAuthFlowFunction::RunImpl() {
   DictionaryValue* arg = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &arg));
 
   std::string url;
   EXTENSION_FUNCTION_VALIDATE(arg->GetString("url", &url));
 
@@ skipping 18 matching lines @@
   Release();  // Balanced in RunImpl.
 }
 
 void LaunchWebAuthFlowFunction::OnAuthFlowFailure() {
   error_ = kInvalidRedirect;
   SendResponse(false);
   Release();  // Balanced in RunImpl.
 }
 
 }  // namespace extensions