Implement new password separated sign in flow for chrome desktop.

chrome/browser/ui/webui/signin/inline_login_handler_impl.cc

 // Copyright 2013 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/ui/webui/signin/inline_login_handler_impl.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 210 matching lines @@
  public:
   InlineSigninHelper(
       base::WeakPtr<InlineLoginHandlerImpl> handler,
       net::URLRequestContextGetter* getter,
       Profile* profile,
       const GURL& current_url,
       const std::string& email,
       const std::string& gaia_id,
       const std::string& password,
       const std::string& session_index,
+      const std::string& auth_code,
       const std::string& signin_scoped_device_id,
       bool choose_what_to_sync,
       bool confirm_untrusted_signin);
 
  private:
   // Handles cross account sign in error. If the supplied |email| does not match
   // the last signed in email of the current profile, then Chrome will show a
   // confirmation dialog before starting sync. It returns true if there is a
   // cross account error, and false otherwise.
   bool HandleCrossAccountError(
@@ skipping 17 matching lines @@
       override;
 
   GaiaAuthFetcher gaia_auth_fetcher_;
   base::WeakPtr<InlineLoginHandlerImpl> handler_;
   Profile* profile_;
   GURL current_url_;
   std::string email_;
   std::string gaia_id_;
   std::string password_;
   std::string session_index_;
+  std::string auth_code_;
   bool choose_what_to_sync_;
   bool confirm_untrusted_signin_;
 
   DISALLOW_COPY_AND_ASSIGN(InlineSigninHelper);
 };
 
 InlineSigninHelper::InlineSigninHelper(
     base::WeakPtr<InlineLoginHandlerImpl> handler,
     net::URLRequestContextGetter* getter,
     Profile* profile,
     const GURL& current_url,
     const std::string& email,
     const std::string& gaia_id,
     const std::string& password,
     const std::string& session_index,
+    const std::string& auth_code,
     const std::string& signin_scoped_device_id,
     bool choose_what_to_sync,
     bool confirm_untrusted_signin)
     : gaia_auth_fetcher_(this, GaiaConstants::kChromeSource, getter),
       handler_(handler),
       profile_(profile),
       current_url_(current_url),
       email_(email),
       gaia_id_(gaia_id),
       password_(password),
       session_index_(session_index),
+      auth_code_(auth_code),
       choose_what_to_sync_(choose_what_to_sync),
       confirm_untrusted_signin_(confirm_untrusted_signin) {
   DCHECK(profile_);
   DCHECK(!email_.empty());
-  gaia_auth_fetcher_.StartCookieForOAuthLoginTokenExchangeWithDeviceId(
-      session_index, signin_scoped_device_id);
+  if (!auth_code_.empty()) {
+    gaia_auth_fetcher_.StartAuthCodeForOAuth2TokenExchangeWithDeviceId(
+        auth_code, signin_scoped_device_id);
+  } else {
+    DCHECK(!session_index_.empty());
+    gaia_auth_fetcher_.StartCookieForOAuthLoginTokenExchangeWithDeviceId(
+        session_index_, signin_scoped_device_id);
+  }
 }
 
 void InlineSigninHelper::OnClientOAuthSuccess(const ClientOAuthResult& result) {
   content::WebContents* contents = NULL;
   Browser* browser = NULL;
   if (handler_) {
     contents = handler_->web_ui()->GetWebContents();
     browser = handler_->GetDesktopBrowser();
   }
 
@@ skipping 283 matching lines @@
     }
   }
 
   return true;
 }
 
 void InlineLoginHandlerImpl::SetExtraInitParams(base::DictionaryValue& params) {
   params.SetString("service", "chromiumsync");
 
   content::WebContents* contents = web_ui()->GetWebContents();
+  const GURL& current_url = contents->GetURL();
+  signin_metrics::Source source = signin::GetSourceForPromoURL(current_url);
+
+  std::string is_constrained;
+  net::GetValueForKeyInQuery(current_url, "constrained", &is_constrained);
+
+  // Use new embedded flow if in constrained window.
+  if (is_constrained == "1") {
+    const bool is_new_gaia_flow = switches::UsePasswordSeparatedSigninFlow();
+    const GURL url = is_new_gaia_flow
+            ? GaiaUrls::GetInstance()->embedded_signin_url()
+            : GaiaUrls::GetInstance()->password_combined_embedded_signin_url();
+    params.SetBoolean("isNewGaiaFlow", is_new_gaia_flow);
+    params.SetString("clientId",
+                     GaiaUrls::GetInstance()->oauth2_chrome_client_id());
+    params.SetString("gaiaPath", url.path().substr(1));
+
+    std::string flow;
+    switch (source) {
+      case signin_metrics::SOURCE_AVATAR_BUBBLE_ADD_ACCOUNT:
+        flow = "addaccount";
+        break;
+      case signin_metrics::SOURCE_REAUTH:
+        flow = "reauth";
+        break;
+      default:
+        flow = "signin";
+        break;
+    }
+    params.SetString("flow", flow);
+  }
+
   content::WebContentsObserver::Observe(contents);
   LogHistogramValue(signin_metrics::HISTOGRAM_SHOWN);
 }
 
 void InlineLoginHandlerImpl::CompleteLogin(const base::ListValue* args) {
   content::WebContents* contents = web_ui()->GetWebContents();
   const GURL& current_url = contents->GetURL();
 
   const base::DictionaryValue* dict = NULL;
   args->GetDictionary(0, &dict);
@@ skipping 18 matching lines @@
 
   base::string16 password_string16;
   dict->GetString("password", &password_string16);
   std::string password(base::UTF16ToASCII(password_string16));
 
   base::string16 gaia_id_string16;
   dict->GetString("gaiaId", &gaia_id_string16);
   DCHECK(!gaia_id_string16.empty());
   std::string gaia_id = base::UTF16ToASCII(gaia_id_string16);
 
+  std::string is_constrained;
+  net::GetValueForKeyInQuery(current_url, "constrained", &is_constrained);
+  const bool is_password_separated_signin_flow = is_constrained == "1" &&
+      switches::UsePasswordSeparatedSigninFlow();
+
   base::string16 session_index_string16;
   dict->GetString("sessionIndex", &session_index_string16);
   std::string session_index = base::UTF16ToASCII(session_index_string16);
-  DCHECK(!session_index.empty());
+  DCHECK(is_password_separated_signin_flow || !session_index.empty());
+
+  base::string16 auth_code_string16;
+  dict->GetString("authCode", &auth_code_string16);
+  std::string auth_code = base::UTF16ToASCII(auth_code_string16);
+  DCHECK(!is_password_separated_signin_flow || !auth_code.empty());
 
   bool choose_what_to_sync = false;
   dict->GetBoolean("chooseWhatToSync", &choose_what_to_sync);
 
   content::StoragePartition* partition =
       content::BrowserContext::GetStoragePartitionForSite(
           contents->GetBrowserContext(), signin::GetSigninPartitionURL());
 
   // If this was called from the user manager to reauthenticate the profile,
   // the current profile is the system profile.  In this case, use the email to
   // find the right profile to reauthenticate.  Otherwise the profile can be
   // taken from web_ui().
   Profile* profile = Profile::FromWebUI(web_ui());
   if (profile->GetOriginalProfile()->IsSystemProfile()) {
     // Switch to the profile and finish the login.  Don't pass a handler pointer
     // since it will be destroyed before the callback runs.
     ProfileManager* manager = g_browser_process->profile_manager();
     base::FilePath path = profiles::GetPathOfProfileWithEmail(manager, email);
     if (!path.empty()) {
       FinishCompleteLoginParams params(nullptr, partition, current_url, path,
                                        confirm_untrusted_signin_, email,
                                        gaia_id, password, session_index,
-                                       choose_what_to_sync);
+                                       auth_code, choose_what_to_sync);
       ProfileManager::CreateCallback callback = base::Bind(
           &InlineLoginHandlerImpl::FinishCompleteLogin, params);
       profiles::SwitchToProfile(path, chrome::GetActiveDesktop(), true,
           callback, ProfileMetrics::SWITCH_PROFILE_UNLOCK);
     }
   } else {
     FinishCompleteLogin(
         FinishCompleteLoginParams(this, partition, current_url,
                                   base::FilePath(), confirm_untrusted_signin_,
                                   email, gaia_id, password, session_index,
-                                  choose_what_to_sync),
+                                  auth_code, choose_what_to_sync),
         profile,
         Profile::CREATE_STATUS_CREATED);
   }
 }
 
 InlineLoginHandlerImpl::FinishCompleteLoginParams::FinishCompleteLoginParams(
     InlineLoginHandlerImpl* handler,
     content::StoragePartition* partition,
     const GURL& url,
     const base::FilePath& profile_path,
     bool confirm_untrusted_signin,
     const std::string& email,
     const std::string& gaia_id,
     const std::string& password,
     const std::string& session_index,
+    const std::string& auth_code,
     bool choose_what_to_sync)
     : handler(handler),
       partition(partition),
       url(url),
       profile_path(profile_path),
       confirm_untrusted_signin(confirm_untrusted_signin),
       email(email),
       gaia_id(gaia_id),
       password(password),
       session_index(session_index),
+      auth_code(auth_code),
       choose_what_to_sync(choose_what_to_sync) {}
 
 InlineLoginHandlerImpl::
     FinishCompleteLoginParams::~FinishCompleteLoginParams() {}
 
 // static
 void InlineLoginHandlerImpl::FinishCompleteLogin(
     const FinishCompleteLoginParams& params,
     Profile* profile,
     Profile::CreateStatus status) {
@@ skipping 63 matching lines @@
       signin_client->GetSigninScopedDeviceId();
   base::WeakPtr<InlineLoginHandlerImpl> handler_weak_ptr;
   if (params.handler)
     handler_weak_ptr = params.handler->GetWeakPtr();
 
   // InlineSigninHelper will delete itself.
   new InlineSigninHelper(handler_weak_ptr,
                          params.partition->GetURLRequestContext(), profile,
                          params.url,
                          params.email, params.gaia_id, params.password,
-                         params.session_index, signin_scoped_device_id,
+                         params.session_index, params.auth_code,
+                         signin_scoped_device_id,
                          params.choose_what_to_sync,
                          params.confirm_untrusted_signin);
 
   // If opened from user manager to reauthenticate, make sure the user manager
   // is closed and that the profile is marked as unlocked.
   if (!params.profile_path.empty()) {
     UserManager::Hide();
     ProfileManager* profile_manager = g_browser_process->profile_manager();
     if (profile_manager) {
       ProfileAttributesEntry* entry;
@@ skipping 70 matching lines @@
       }
     }
 
     if (show_account_management) {
       browser->window()->ShowAvatarBubbleFromAvatarButton(
             BrowserWindow::AVATAR_BUBBLE_MODE_ACCOUNT_MANAGEMENT,
             signin::ManageAccountsParams());
     }
   }
 }