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"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/about_signin_internals_factory.h"
+#include "chrome/browser/signin/account_tracker_service_factory.h"
 #include "chrome/browser/signin/chrome_signin_client_factory.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/sync/one_click_signin_helper.h"
 #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_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 {
  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.
   virtual void OnSigninOAuthInformationAvailable(
       const std::string& email,
       const std::string& display_email,
       const std::string& refresh_token) OVERRIDE;
   virtual void OnSigninOAuthInformationFailure(
       const GoogleServiceAuthError& error) OVERRIDE;
 
   SigninOAuthHelper signin_oauth_helper_;
   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),
       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());
 }
 
 void InlineSigninHelper::OnSigninOAuthInformationAvailable(
     const std::string& email,
     const std::string& display_email,
     const std::string& refresh_token) {
   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(account_id, gaia_id_, email_);

[guohui, 2014/08/21 18:39:43]

why do we use email_ here and email at line 130? Are they guaranteed to be the
same?

[Roger Tawa OOO till Jul 10th, 2014/08/21 20:33:18]

|email| and |email_| are not guaranteed to be the same, especially with mixed
case email addresses.  |email_| is guaranteed to be the same as |display_email|.
 All the gaia apis we call return |display_email|, so I figured I would use that
one.

But moving forward, it should not matter which one we use.  This is for display
purposes, and any will do.  We should never be comparing these strings to
determine if two accounts are the same or not.  We should only compare the
|account_id| or the |gaia_id_|.

+
   signin::Source source = signin::GetSourceForPromoURL(current_url_);
   if (source == signin::SOURCE_AVATAR_BUBBLE_ADD_ACCOUNT ||
       source == signin::SOURCE_REAUTH) {
     ProfileOAuth2TokenServiceFactory::GetForProfile(profile_)->
-        UpdateCredentials(email, refresh_token);
+        UpdateCredentials(account_id, 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 42 matching lines @@
             email, password_, 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_, 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(
   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);
 }
 
 }  // namespace
 
 InlineLoginHandlerImpl::InlineLoginHandlerImpl()
-      : weak_factory_(this),
-        confirm_untrusted_signin_(false) {
+      : weak_factory_(this), confirm_untrusted_signin_(false) {
 }
 
 InlineLoginHandlerImpl::~InlineLoginHandlerImpl() {}
 
 bool InlineLoginHandlerImpl::HandleContextMenu(
     const content::ContextMenuParams& params) {
 #ifndef NDEBUG
   return false;
 #else
   return true;
@@ skipping 59 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());
     }
   }
 }