Add cross account error detection to inline 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 <algorithm>
 #include <functional>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback_forward.h"
 #include "base/callback_helpers.h"
+#include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 64 matching lines @@
 
 // Arguments used with StartSync function.  base::Bind() cannot support too
 // many args for performance reasons, so they are packaged up into a struct.
 struct StartSyncArgs {
   StartSyncArgs(Profile* profile,
                 Browser* browser,
                 OneClickSigninHelper::AutoAccept auto_accept,
                 const std::string& session_index,
                 const std::string& email,
                 const std::string& password,
+                const std::string& oauth_code,
                 content::WebContents* web_contents,
                 bool untrusted_confirmation_required,
                 signin::Source source,
                 OneClickSigninSyncStarter::Callback callback);
 
   Profile* profile;
   Browser* browser;
   OneClickSigninHelper::AutoAccept auto_accept;
   std::string session_index;
   std::string email;
   std::string password;
+  std::string oauth_code;
 
   // Web contents in which the sync setup page should be displayed,
   // if necessary. Can be NULL.
   content::WebContents* web_contents;
 
   OneClickSigninSyncStarter::ConfirmationRequired confirmation_required;
   signin::Source source;
   OneClickSigninSyncStarter::Callback callback;
 };
 
 StartSyncArgs::StartSyncArgs(Profile* profile,
                              Browser* browser,
                              OneClickSigninHelper::AutoAccept auto_accept,
                              const std::string& session_index,
                              const std::string& email,
                              const std::string& password,
+                             const std::string& oauth_code,
                              content::WebContents* web_contents,
                              bool untrusted_confirmation_required,
                              signin::Source source,
                              OneClickSigninSyncStarter::Callback callback)
     : profile(profile),
       browser(browser),
       auto_accept(auto_accept),
       session_index(session_index),
       email(email),
       password(password),
+      oauth_code(oauth_code),
       web_contents(web_contents),
       source(source),
       callback(callback) {
   if (untrusted_confirmation_required) {
     confirmation_required = OneClickSigninSyncStarter::CONFIRM_UNTRUSTED_SIGNIN;
   } else if (source == signin::SOURCE_SETTINGS ||
              source == signin::SOURCE_WEBSTORE_INSTALL) {
     // Do not display a status confirmation for webstore installs or re-auth.
     confirmation_required = OneClickSigninSyncStarter::NO_CONFIRMATION;
   } else {
@@ skipping 223 matching lines @@
 void StartSync(const StartSyncArgs& args,
                OneClickSigninSyncStarter::StartSyncMode start_mode) {
   if (start_mode == OneClickSigninSyncStarter::UNDO_SYNC) {
     LogOneClickHistogramValue(one_click_signin::HISTOGRAM_UNDO);
     return;
   }
 
   // The starter deletes itself once its done.
   new OneClickSigninSyncStarter(args.profile, args.browser, args.session_index,
                                 args.email, args.password,
-                                "" /* oauth_code */, start_mode,
+                                args.oauth_code, start_mode,
                                 args.web_contents,
                                 args.confirmation_required,
                                 args.callback);
 
   int action = one_click_signin::HISTOGRAM_MAX;
   switch (args.auto_accept) {
     case OneClickSigninHelper::AUTO_ACCEPT_EXPLICIT:
       break;
     case OneClickSigninHelper::AUTO_ACCEPT_ACCEPTED:
       action =
@@ skipping 10 matching lines @@
       break;
   }
   if (action != one_click_signin::HISTOGRAM_MAX)
     LogOneClickHistogramValue(action);
 }
 
 void StartExplicitSync(const StartSyncArgs& args,
                        content::WebContents* contents,
                        OneClickSigninSyncStarter::StartSyncMode start_mode,
                        ConfirmEmailDialogDelegate::Action action) {
+  bool enable_inline = CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kEnableInlineSignin);
   if (action == ConfirmEmailDialogDelegate::START_SYNC) {
     StartSync(args, start_mode);
-    OneClickSigninHelper::RedirectToNtpOrAppsPageIfNecessary(
-        contents, args.source);
+    if (!enable_inline) {
+      // Redirect/tab closing for inline flow is handled by the sync callback.
+      OneClickSigninHelper::RedirectToNtpOrAppsPageIfNecessary(
+          contents, args.source);
+    }
   } else {
     // Perform a redirection to the NTP/Apps page to hide the blank page when
     // the action is CLOSE or CREATE_NEW_USER. The redirection is useful when
     // the action is CREATE_NEW_USER because the "Create new user" page might
     // be opened in a different tab that is already showing settings.
-    //
-    // Don't redirect when the visible URL is not a blank page: if the
-    // source is SOURCE_WEBSTORE_INSTALL, |contents| might be showing an app
-    // page that shouldn't be hidden.
-    //
-    // If redirecting, don't do so immediately, otherwise there may be 2 nested
-    // navigations and a crash would occur (crbug.com/293261).  Post the task
-    // to the current thread instead.
-    if (signin::IsContinueUrlForWebBasedSigninFlow(
-            contents->GetVisibleURL())) {
-      base::MessageLoopProxy::current()->PostNonNestableTask(
-          FROM_HERE,
-          base::Bind(RedirectToNtpOrAppsPageWithIds,
-                     contents->GetRenderProcessHost()->GetID(),
-                     contents->GetRoutingID(),
-                     args.source));
+    if (enable_inline) {
+      // Redirect/tab closing for inline flow is handled by the sync callback.
+      args.callback.Run(OneClickSigninSyncStarter::SYNC_SETUP_FAILURE);
+    } else {
+      // Don't redirect when the visible URL is not a blank page: if the
+      // source is SOURCE_WEBSTORE_INSTALL, |contents| might be showing an app
+      // page that shouldn't be hidden.
+      //
+      // If redirecting, don't do so immediately, otherwise there may be 2
+      // nested navigations and a crash would occur (crbug.com/293261).  Post
+      // the task to the current thread instead.
+      if (signin::IsContinueUrlForWebBasedSigninFlow(
+              contents->GetVisibleURL())) {
+        base::MessageLoopProxy::current()->PostNonNestableTask(
+            FROM_HERE,
+            base::Bind(RedirectToNtpOrAppsPageWithIds,
+                       contents->GetRenderProcessHost()->GetID(),
+                       contents->GetRoutingID(),
+                       args.source));
+      }
     }
     if (action == ConfirmEmailDialogDelegate::CREATE_NEW_USER) {
       chrome::ShowSettingsSubPage(args.browser,
                                   std::string(chrome::kSearchUsersSubPage));
     }
   }
 }
 
 void ClearPendingEmailOnIOThread(content::ResourceContext* context) {
   ProfileIOData* io_data = ProfileIOData::FromResourceContext(context);
@@ skipping 585 matching lines @@
       BrowserWindow::ONE_CLICK_SIGNIN_BUBBLE_TYPE_BUBBLE,
       base::string16(), /* no SAML email */
       UTF8ToUTF16(error),
       // This callback is never invoked.
       // TODO(rogerta): Separate out the bubble API so we don't have to pass
       // ignored |email| and |callback| params.
       BrowserWindow::StartSyncCallback());
 }
 
 // static
+bool OneClickSigninHelper::HandleCrossAccountError(
+    content::WebContents* contents,
+    const std::string& session_index,
+    const std::string& email,
+    const std::string& password,
+    const std::string& oauth_code,
+    OneClickSigninHelper::AutoAccept auto_accept,
+    signin::Source source,
+    OneClickSigninSyncStarter::StartSyncMode start_mode,
+    OneClickSigninSyncStarter::Callback sync_callback) {
+  Profile* profile =
+      Profile::FromBrowserContext(contents->GetBrowserContext());
+  std::string last_email =
+      profile->GetPrefs()->GetString(prefs::kGoogleServicesLastUsername);
+
+  if (!last_email.empty() && !gaia::AreEmailsSame(last_email, email)) {
+    // If the new email address is different from the email address that
+    // just signed in, show a confirmation dialog.
+
+    // No need to display a second confirmation so pass false below.
+    // TODO(atwilson): Move this into OneClickSigninSyncStarter.
+    // The tab modal dialog always executes its callback before |contents|
+    // is deleted.
+    Browser* browser = chrome::FindBrowserWithWebContents(contents);
+    ConfirmEmailDialogDelegate::AskForConfirmation(
+        contents,
+        last_email,
+        email,
+        base::Bind(
+            &StartExplicitSync,
+            StartSyncArgs(profile, browser, auto_accept,
+                          session_index, email, password, oauth_code, contents,
+                          false /* confirmation_required */, source,
+                          sync_callback),
+            contents,
+            start_mode));
+    return true;
+  }
+
+  return false;
+}
+
+// static
 void OneClickSigninHelper::RedirectToNtpOrAppsPageIfNecessary(
     content::WebContents* contents, signin::Source source) {
   if (source != signin::SOURCE_SETTINGS &&
       source != signin::SOURCE_WEBSTORE_INSTALL) {
     RedirectToNtpOrAppsPage(contents, source);
   }
 }
 
 void OneClickSigninHelper::RedirectToSignin() {
   VLOG(1) << "OneClickSigninHelper::RedirectToSignin";
@@ skipping 236 matching lines @@
     case AUTO_ACCEPT_ACCEPTED:
       LogOneClickHistogramValue(one_click_signin::HISTOGRAM_ACCEPTED);
       LogOneClickHistogramValue(one_click_signin::HISTOGRAM_WITH_DEFAULTS);
       SigninManager::DisableOneClickSignIn(profile);
       // Start syncing with the default settings - prompt the user to sign in
       // first.
       if (!do_not_start_sync_for_testing_) {
         StartSync(
             StartSyncArgs(profile, browser, auto_accept_,
                           session_index_, email_, password_,
+                          "" /* oauth_code */,
                           NULL /* don't force to show sync setup in same tab */,
                           true /* confirmation_required */, source_,
                           CreateSyncStarterCallback()),
             OneClickSigninSyncStarter::SYNC_WITH_DEFAULT_SETTINGS);
       }
       break;
     case AUTO_ACCEPT_CONFIGURE:
       LogOneClickHistogramValue(one_click_signin::HISTOGRAM_ACCEPTED);
       LogOneClickHistogramValue(one_click_signin::HISTOGRAM_WITH_ADVANCED);
       SigninManager::DisableOneClickSignIn(profile);
       // Display the extra confirmation (even in the SAML case) in case this
       // was an untrusted renderer.
       if (!do_not_start_sync_for_testing_) {
         StartSync(
             StartSyncArgs(profile, browser, auto_accept_,
                           session_index_, email_, password_,
+                          "" /* oauth_code */,
                           NULL  /* don't force sync setup in same tab */,
                           true  /* confirmation_required */, source_,
                           CreateSyncStarterCallback()),
             OneClickSigninSyncStarter::CONFIGURE_SYNC_FIRST);
       }
       break;
     case AUTO_ACCEPT_EXPLICIT: {
       signin::Source original_source =
           signin::GetSourceForPromoURL(original_continue_url_);
       if (switched_to_advanced_) {
@@ skipping 15 matching lines @@
       ProfileSyncService* sync_service =
           ProfileSyncServiceFactory::GetForProfile(profile);
       OneClickSigninSyncStarter::StartSyncMode start_mode =
           source_ == signin::SOURCE_SETTINGS ?
               (SigninGlobalError::GetForProfile(profile)->HasMenuItem() &&
                sync_service && sync_service->HasSyncSetupCompleted()) ?
                   OneClickSigninSyncStarter::SHOW_SETTINGS_WITHOUT_CONFIGURE :
                   OneClickSigninSyncStarter::CONFIGURE_SYNC_FIRST :
               OneClickSigninSyncStarter::SYNC_WITH_DEFAULT_SETTINGS;
 
-      std::string last_email =
-          profile->GetPrefs()->GetString(prefs::kGoogleServicesLastUsername);
-
-      if (!last_email.empty() && !gaia::AreEmailsSame(last_email, email_)) {
-        // If the new email address is different from the email address that
-        // just signed in, show a confirmation dialog.
-
-        // No need to display a second confirmation so pass false below.
-        // TODO(atwilson): Move this into OneClickSigninSyncStarter.
-        // The tab modal dialog always executes its callback before |contents|
-        // is deleted.
-        ConfirmEmailDialogDelegate::AskForConfirmation(
-            contents,
-            last_email,
-            email_,
-            base::Bind(
-                &StartExplicitSync,
-                StartSyncArgs(profile, browser, auto_accept_,
-                              session_index_, email_, password_, contents,
-                              false /* confirmation_required */, source_,
-                              CreateSyncStarterCallback()),
-                contents,
-                start_mode));
-      } else {
+      if (!HandleCrossAccountError(contents, session_index_, email_, password_,
+              "" /* oauth_code */, auto_accept_, source_, start_mode,
+              CreateSyncStarterCallback())) {
         if (!do_not_start_sync_for_testing_) {
           StartSync(
               StartSyncArgs(profile, browser, auto_accept_,
-                            session_index_, email_, password_, contents,
+                            session_index_, email_, password_,
+                            "" /* oauth_code */, contents,
                             untrusted_confirmation_required_, source_,
                             CreateSyncStarterCallback()),
               start_mode);
         }
 
         // If this explicit sign in is not from settings page/webstore, show
         // the NTP/Apps page after sign in completes. In the case of the
         // settings page, it will get auto-closed after sync setup. In the case
         // of webstore, it will redirect back to webstore.
         RedirectToNtpOrAppsPageIfNecessary(web_contents(), source_);
@@ skipping 97 matching lines @@
     // If the web contents is showing a blank page and not about to be closed,
     // redirect to the NTP or apps page.
     if (signin::IsContinueUrlForWebBasedSigninFlow(current_url) &&
         !signin::IsAutoCloseEnabledInURL(original_continue_url_)) {
       RedirectToNtpOrAppsPage(
           web_contents(),
           signin::GetSourceForPromoURL(original_continue_url_));
     }
   }
 }