Added multi-login support to one-click signin.

chrome/browser/ui/sync/one_click_signin_helper.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/ui/sync/one_click_signin_helper.h"
 
 #include "base/metrics/histogram.h"
 #include "base/string_split.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/infobars/infobar_tab_helper.h"
@@ skipping 44 matching lines @@
   // The user clicked on the learn more link in the infobar.
   HISTOGRAM_LEARN_MORE,
 
   HISTOGRAM_MAX
 };
 
 // The infobar asking the user if they want to use one-click sign in.
 class OneClickLoginInfoBarDelegate : public ConfirmInfoBarDelegate {
  public:
   OneClickLoginInfoBarDelegate(InfoBarTabHelper* owner,
+                               const std::string& session_index,
                                const std::string& email,
                                const std::string& password);
   virtual ~OneClickLoginInfoBarDelegate();
 
  private:
   // ConfirmInfoBarDelegate overrides.
   virtual void InfoBarDismissed() OVERRIDE;
   virtual gfx::Image* GetIcon() const OVERRIDE;
   virtual Type GetInfoBarType() const OVERRIDE;
   virtual string16 GetMessageText() const OVERRIDE;
   virtual string16 GetButtonLabel(InfoBarButton button) const OVERRIDE;
   virtual bool Accept() OVERRIDE;
   virtual bool Cancel() OVERRIDE;
 
   void RecordHistogramAction(int action);
 
   Profile* profile_;
 
-  // Email address and password of the account that has just logged in.
+  // Information about the account that has just logged in.
+  std::string session_index_;
   std::string email_;
   std::string password_;
 
   // Whether any UI controls in the infobar were pressed or not.
   bool button_pressed_;
 
   DISALLOW_COPY_AND_ASSIGN(OneClickLoginInfoBarDelegate);
 };
 
 OneClickLoginInfoBarDelegate::OneClickLoginInfoBarDelegate(
     InfoBarTabHelper* owner,
+    const std::string& session_index,
     const std::string& email,
     const std::string& password)
     : ConfirmInfoBarDelegate(owner),
       profile_(Profile::FromBrowserContext(
           owner->web_contents()->GetBrowserContext())),
+      session_index_(session_index),
       email_(email),
       password_(password),
       button_pressed_(false) {
   DCHECK(profile_);
   RecordHistogramAction(HISTOGRAM_SHOWN);
 }
 
 OneClickLoginInfoBarDelegate::~OneClickLoginInfoBarDelegate() {
   if (!button_pressed_)
     RecordHistogramAction(HISTOGRAM_IGNORED);
@@ skipping 18 matching lines @@
 }
 
 string16 OneClickLoginInfoBarDelegate::GetButtonLabel(
     InfoBarButton button) const {
   return l10n_util::GetStringUTF16((button == BUTTON_OK) ?
       IDS_OK : IDS_ONE_CLICK_SIGNIN_INFOBAR_CANCEL_BUTTON);
 }
 
 bool OneClickLoginInfoBarDelegate::Accept() {
   RecordHistogramAction(HISTOGRAM_ACCEPTED);
-  ShowOneClickSigninDialog(profile_, email_, password_);
+  ShowOneClickSigninDialog(profile_, session_index_, email_, password_);
   button_pressed_ = true;
   return true;
 }
 
 bool OneClickLoginInfoBarDelegate::Cancel() {
   PrefService* pref_service =
       TabContentsWrapper::GetCurrentWrapperForContents(
           owner()->web_contents())->profile()->GetPrefs();
   pref_service->SetBoolean(prefs::kReverseAutologinEnabled, false);
   RecordHistogramAction(HISTOGRAM_REJECTED);
@@ skipping 21 matching lines @@
   request->GetResponseHeaderByName("X-Google-Accounts-SignIn", &value);
   if (value.empty())
     return;
 
   std::vector<std::pair<std::string, std::string> > pairs;
   if (!base::SplitStringIntoKeyValuePairs(value, '=', ',', &pairs))
     return;
 
   // Parse the information from the value string.
   std::string email;
+  std::string session_index;
   for (size_t i = 0; i < pairs.size(); ++i) {
     const std::pair<std::string, std::string>& pair = pairs[i];
-    if (pair.first == "email")
+    if (pair.first == "email") {
       TrimString(pair.second, "\"", &email);
+    } else if (pair.first == "sessionindex") {
+      session_index = pair.second;

[Andrew T Wilson (Slow), 2012/03/06 20:42:46]

Are we always guaranteed to have a session index, even if the user isn't using
multilogin?

[Roger Tawa OOO till Jul 10th, 2012/03/06 21:25:17]

Yes.

+    }
   }
 
-  if (email.empty())
+  if (email.empty() || session_index.empty())
     return;
 
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE,
-      base::Bind(&OneClickSigninHelper::ShowInfoBarUIThread, email,
-                 child_id, route_id));
+      base::Bind(&OneClickSigninHelper::ShowInfoBarUIThread, session_index,
+                 email, child_id, route_id));
 }
 
 OneClickSigninHelper::OneClickSigninHelper(content::WebContents* web_contents)
     : content::WebContentsObserver(web_contents) {
 }
 
 OneClickSigninHelper::~OneClickSigninHelper() {
 }
 
 // static
 void OneClickSigninHelper::ShowInfoBarUIThread(
+    const std::string& session_index,
     const std::string& email,
     int child_id,
     int route_id) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   content::WebContents* web_contents = tab_util::GetWebContentsByID(child_id,
                                                                     route_id);
   if (!web_contents)
     return;
 
@@ skipping 16 matching lines @@
     return;
 
   // TODO(rogerta): remove this #if once the dialog is fully implemented for
   // mac and linux.
 #if defined(ENABLE_ONE_CLICK_SIGNIN)
   // Save the email in the one-click signin manager.  The manager may
   // not exist if the contents is incognito or if the profile is already
   // connected to a Google account.
   OneClickSigninHelper* helper = wrapper->one_click_signin_helper();
   if (helper)
-    helper->SaveEmail(email);
+    helper->SaveSessionIndexAndEmail(session_index, email);
 #endif
 }
 
 void OneClickSigninHelper::DidNavigateAnyFrame(
     const content::LoadCommittedDetails& details,
     const content::FrameNavigateParams& params) {
   if (params.password_form.origin.is_valid())
     SavePassword(UTF16ToUTF8(params.password_form.password_value));
 }
 
 void OneClickSigninHelper::DidStopLoading() {
   if (email_.empty() || password_.empty())
     return;
 
   TabContentsWrapper* wrapper =
       TabContentsWrapper::GetCurrentWrapperForContents(web_contents());
 
   wrapper->infobar_tab_helper()->AddInfoBar(
       new OneClickLoginInfoBarDelegate(wrapper->infobar_tab_helper(),
-                                       email_, password_));
+                                       session_index_, email_, password_));
 
   email_.clear();
   password_.clear();
 }
 
-void OneClickSigninHelper::SaveEmail(const std::string& email) {
-  // TODO(rogerta): validate that the email address is the same as set in
-  // the form?
+void OneClickSigninHelper::SaveSessionIndexAndEmail(
+    const std::string& session_index,
+    const std::string& email) {
+  session_index_ = session_index;
   email_ = email;
 }
 
 void OneClickSigninHelper::SavePassword(const std::string& password) {
   // TODO(rogerta): in the case of a 2-factor or captcha or some other type of
   // challenge, its possible for the user to never complete the signin.
   // Should have a way to detect this and clear the password member.
   password_ = password;
 }