Revert of Revert of Inline sign in extracts gaia id from HTTP header and seeds account tracker

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/strings/string_number_conversions.h"
@@ skipping 15 matching lines @@
 #include "chrome/browser/ui/sync/one_click_signin_histogram.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/webui/signin/inline_login_ui.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/url_constants.h"
 #include "components/signin/core/browser/about_signin_internals.h"
 #include "components/signin/core/browser/account_tracker_service.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_error_controller.h"
-#include "components/signin/core/browser/signin_oauth_helper.h"
 #include "components/signin/core/common/profile_management_switches.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_ui.h"
+#include "google_apis/gaia/gaia_auth_consumer.h"
 #include "google_apis/gaia/gaia_auth_fetcher.h"
 #include "google_apis/gaia/gaia_auth_util.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "net/base/url_util.h"
 
 namespace {
 
-class InlineSigninHelper : public SigninOAuthHelper::Consumer {
+class InlineSigninHelper : public GaiaAuthConsumer {
  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& signin_scoped_device_id,
       bool choose_what_to_sync,
       bool confirm_untrusted_signin);
 
  private:
-  // Overriden from SigninOAuthHelper::Consumer.
-  void OnSigninOAuthInformationAvailable(
-      const std::string& email,
-      const std::string& display_email,
-      const std::string& refresh_token) override;
-  void OnSigninOAuthInformationFailure(
-      const GoogleServiceAuthError& error) override;
+  // Overridden from GaiaAuthConsumer.
+  void OnClientOAuthSuccess(const ClientOAuthResult& result) override;
+  void OnClientOAuthFailure(const GoogleServiceAuthError& error)
+      override;
 
-  SigninOAuthHelper signin_oauth_helper_;
+  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_;
   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& signin_scoped_device_id,
     bool choose_what_to_sync,
     bool confirm_untrusted_signin)
-    : signin_oauth_helper_(getter, session_index, signin_scoped_device_id,
-                           this),
+    : 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),
       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);
 }
 
-void InlineSigninHelper::OnSigninOAuthInformationAvailable(
-    const std::string& email,
-    const std::string& display_email,
-    const std::string& refresh_token) {
+void InlineSigninHelper::OnClientOAuthSuccess(const ClientOAuthResult& result) {
   content::WebContents* contents = NULL;
   Browser* browser = NULL;
   if (handler_) {
     contents = handler_->web_ui()->GetWebContents();
     browser = handler_->GetDesktopBrowser();
   }
 
   AboutSigninInternals* about_signin_internals =
       AboutSigninInternalsFactory::GetForProfile(profile_);
   about_signin_internals->OnRefreshTokenReceived("Successful");
 
+  AccountTrackerService* account_tracker =
+      AccountTrackerServiceFactory::GetForProfile(profile_);
+  std::string account_id =
+      account_tracker->PickAccountIdForAccount(gaia_id_, email_);
+
+  // Prime the account tracker with this combination of gaia id/display email.
+  account_tracker->SeedAccountInfo(gaia_id_, email_);
+
   signin::Source source = signin::GetSourceForPromoURL(current_url_);
 
   std::string primary_email =
       SigninManagerFactory::GetForProfile(profile_)->GetAuthenticatedUsername();
-  if (gaia::AreEmailsSame(email, primary_email) &&
+  if (gaia::AreEmailsSame(email_, primary_email) &&
       source == signin::SOURCE_REAUTH &&
       switches::IsNewProfileManagement()) {
     chrome::SetLocalAuthCredentials(profile_, password_);
   }
 
   if (source == signin::SOURCE_AVATAR_BUBBLE_ADD_ACCOUNT ||
       source == signin::SOURCE_REAUTH) {
-    // TODO(rogerta): the javascript code will need to pass in the gaia-id
-    // of the account instead of the email when chrome uses gaia-id as key.
-    DCHECK_EQ(AccountTrackerService::MIGRATION_NOT_STARTED,
-              AccountTrackerServiceFactory::GetForProfile(profile_)->
-                  GetMigrationState());
-    const std::string account_id = gaia::CanonicalizeEmail(email);
     ProfileOAuth2TokenServiceFactory::GetForProfile(profile_)->
-        UpdateCredentials(account_id, refresh_token);
+        UpdateCredentials(account_id, result.refresh_token);
 
     if (signin::IsAutoCloseEnabledInURL(current_url_)) {
       // Close the gaia sign in tab via a task to make sure we aren't in the
       // middle of any webui handler code.
       base::MessageLoop::current()->PostTask(
           FROM_HERE,
           base::Bind(&InlineLoginHandlerImpl::CloseTab,
           handler_,
           signin::ShouldShowAccountManagement(current_url_)));
     }
@@ skipping 31 matching lines @@
       confirmation_required =
           source == signin::SOURCE_SETTINGS ||
           choose_what_to_sync_ ?
               OneClickSigninSyncStarter::NO_CONFIRMATION :
               OneClickSigninSyncStarter::CONFIRM_AFTER_SIGNIN;
     }
 
     bool start_signin =
         !OneClickSigninHelper::HandleCrossAccountError(
             profile_, "",
-            email, password_, refresh_token,
+            email_, password_, result.refresh_token,
             OneClickSigninHelper::AUTO_ACCEPT_EXPLICIT,
             source, start_mode,
             base::Bind(&InlineLoginHandlerImpl::SyncStarterCallback,
                        handler_));
     if (start_signin) {
       // Call OneClickSigninSyncStarter to exchange oauth code for tokens.
       // OneClickSigninSyncStarter will delete itself once the job is done.
       new OneClickSigninSyncStarter(
           profile_, browser,
-          email, password_, refresh_token,
+          account_id, password_, result.refresh_token,
           start_mode,
           contents,
           confirmation_required,
           signin::GetNextPageURLForPromoURL(current_url_),
           base::Bind(&InlineLoginHandlerImpl::SyncStarterCallback, handler_));
     }
   }
 
   base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 }
 
-void InlineSigninHelper::OnSigninOAuthInformationFailure(
+void InlineSigninHelper::OnClientOAuthFailure(
   const GoogleServiceAuthError& error) {
   if (handler_)
     handler_->HandleLoginError(error.ToString());
 
   AboutSigninInternals* about_signin_internals =
     AboutSigninInternalsFactory::GetForProfile(profile_);
   about_signin_internals->OnRefreshTokenReceived("Failure");
 
   base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 }
@@ skipping 77 matching lines @@
 
   base::string16 email_string16;
   dict->GetString("email", &email_string16);
   DCHECK(!email_string16.empty());
   std::string email(base::UTF16ToASCII(email_string16));
 
   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);
+
   // When doing a SAML sign in, this email check may result in a false
   // positive.  This happens when the user types one email address in the
   // gaia sign in page, but signs in to a different account in the SAML sign in
   // page.
   std::string default_email;
   std::string validate_email;
   if (net::GetValueForKeyInQuery(current_url, "email", &default_email) &&
       net::GetValueForKeyInQuery(current_url, "validateEmail",
                                  &validate_email) &&
       validate_email == "1") {
@@ skipping 58 matching lines @@
           contents->GetBrowserContext(),
           GURL(chrome::kChromeUIChromeSigninURL));
 
   SigninClient* signin_client =
       ChromeSigninClientFactory::GetForProfile(Profile::FromWebUI(web_ui()));
   std::string signin_scoped_device_id =
       signin_client->GetSigninScopedDeviceId();
   // InlineSigninHelper will delete itself.
   new InlineSigninHelper(GetWeakPtr(), partition->GetURLRequestContext(),
                          Profile::FromWebUI(web_ui()), current_url,
-                         email, password, session_index,
+                         email, gaia_id, password, session_index,
                          signin_scoped_device_id, choose_what_to_sync,
                          confirm_untrusted_signin_);
 
   web_ui()->CallJavascriptFunction("inline.login.closeDialog");
 }
 
 void InlineLoginHandlerImpl::HandleLoginError(const std::string& error_msg) {
   SyncStarterCallback(OneClickSigninSyncStarter::SYNC_SETUP_FAILURE);
 
   Browser* browser = GetDesktopBrowser();
@@ skipping 54 matching lines @@
       }
     }
 
     if (show_account_management) {
       browser->window()->ShowAvatarBubbleFromAvatarButton(
             BrowserWindow::AVATAR_BUBBLE_MODE_ACCOUNT_MANAGEMENT,
             signin::ManageAccountsParams());
     }
   }
 }