Merge 198866 "Move post-signin confirmation bubble to OneClickSi..."

chrome/browser/ui/sync/one_click_signin_sync_starter.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_sync_starter.h"
 
 #include "base/prefs/pref_service.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 
@@ skipping 13 matching lines @@
 #include "chrome/browser/sync/sync_prefs.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/chrome_pages.h"
 #include "chrome/browser/ui/webui/signin/login_ui_service.h"
 #include "chrome/browser/ui/webui/signin/login_ui_service_factory.h"
 #include "chrome/browser/ui/webui/signin/profile_signin_confirmation_dialog.h"
 #include "chrome/common/url_constants.h"
+#include "grit/chromium_strings.h"
+#include "grit/generated_resources.h"
+#include "ui/base/l10n/l10n_util.h"
+#include "ui/base/resource/resource_bundle.h"
 
 OneClickSigninSyncStarter::OneClickSigninSyncStarter(
     Profile* profile,
     Browser* browser,
     const std::string& session_index,
     const std::string& email,
     const std::string& password,
     StartSyncMode start_mode,
     bool force_same_tab_navigation,
-    bool confirmation_required)
+    ConfirmationRequired confirmation_required)
     : start_mode_(start_mode),
       force_same_tab_navigation_(force_same_tab_navigation),
       confirmation_required_(confirmation_required),
       weak_pointer_factory_(this) {
   DCHECK(profile);
   Initialize(profile, browser);
 
   // Start the signin process using the cookies in the cookie jar.
   SigninManager* manager = SigninManagerFactory::GetForProfile(profile_);
   SigninManager::OAuthTokenFetchedCallback callback;
@@ skipping 46 matching lines @@
 #if defined(ENABLE_CONFIGURATION_POLICY)
     policy::UserPolicySigninService* policy_service =
         policy::UserPolicySigninServiceFactory::GetForProfile(profile_);
     policy_service->RegisterPolicyClient(
         signin->GetUsernameForAuthInProgress(),
         oauth_token,
         base::Bind(&OneClickSigninSyncStarter::OnRegisteredForPolicy,
                    weak_pointer_factory_.GetWeakPtr()));
     return;
 #else
-    SigninAfterSAMLConfirmation();
+    ConfirmAndSignin();
 #endif
   } else {
     // The user is already signed in - just tell SigninManager to continue
     // with its re-auth flow.
     signin->CompletePendingSignin();
   }
 }
 
 #if defined(ENABLE_CONFIGURATION_POLICY)
 void OneClickSigninSyncStarter::OnRegisteredForPolicy(
     scoped_ptr<policy::CloudPolicyClient> client) {
   SigninManager* signin = SigninManagerFactory::GetForProfile(profile_);
   // If there's no token for the user (policy registration did not succeed) just
   // finish signing in.
   if (!client.get()) {
     DVLOG(1) << "Policy registration failed";
-    SigninAfterSAMLConfirmation();
+    ConfirmAndSignin();
     return;
   }
 
   DCHECK(client->is_registered());
   DVLOG(1) << "Policy registration succeeded: dm_token=" << client->dm_token();
 
   // Stash away a copy of our CloudPolicyClient (should not already have one).
   DCHECK(!policy_client_);
   policy_client_.swap(client);
 
@@ skipping 90 matching lines @@
     // object will get freed when the signin on the old profile is cancelled.
     old_signin_manager->SignOut();
 
     // Load policy for the just-created profile - once policy has finished
     // loading the signin process will complete.
     LoadPolicyWithCachedClient();
   }
 }
 #endif
 
-void OneClickSigninSyncStarter::SigninAfterSAMLConfirmation() {
+void OneClickSigninSyncStarter::ConfirmAndSignin() {
   SigninManager* signin = SigninManagerFactory::GetForProfile(profile_);
   // browser_ can be null for unit tests.
-  if (!browser_ || !confirmation_required_) {
-    // No confirmation required - just sign in the user.
-    signin->CompletePendingSignin();
-  } else {
+  if (browser_ && confirmation_required_ == CONFIRM_UNTRUSTED_SIGNIN) {
     // Display a confirmation dialog to the user.
     browser_->window()->ShowOneClickSigninBubble(
         BrowserWindow::ONE_CLICK_SIGNIN_BUBBLE_TYPE_SAML_MODAL_DIALOG,
         UTF8ToUTF16(signin->GetUsernameForAuthInProgress()),
         string16(), // No error message to display.
-        base::Bind(&OneClickSigninSyncStarter::SigninConfirmationComplete,
+        base::Bind(&OneClickSigninSyncStarter::UntrustedSigninConfirmed,
                    weak_pointer_factory_.GetWeakPtr()));
+  } else {
+    // No confirmation required - just sign in the user.
+    signin->CompletePendingSignin();
   }
 }
 
-void OneClickSigninSyncStarter::SigninConfirmationComplete(
+void OneClickSigninSyncStarter::UntrustedSigninConfirmed(
     StartSyncMode response) {
   if (response == UNDO_SYNC) {
     CancelSigninAndDelete();
   } else {
     // If the user clicked the "Advanced" link in the confirmation dialog, then
     // override the current start_mode_ to bring up the advanced sync settings.
     if (response == CONFIGURE_SYNC_FIRST)
       start_mode_ = response;
     SigninManager* signin = SigninManagerFactory::GetForProfile(profile_);
     signin->CompletePendingSignin();
   }
 }
 
 
 void OneClickSigninSyncStarter::SigninFailed(
     const GoogleServiceAuthError& error) {
   ProfileSyncService* profile_sync_service = GetProfileSyncService();
   if (profile_sync_service)
     profile_sync_service->SetSetupInProgress(false);
+  if (confirmation_required_ == CONFIRM_AFTER_SIGNIN) {
+    switch (error.state()) {
+      case GoogleServiceAuthError::SERVICE_UNAVAILABLE:
+        DisplayFinalConfirmationBubble(l10n_util::GetStringUTF16(
+            IDS_SYNC_UNRECOVERABLE_ERROR));
+        break;
+      case GoogleServiceAuthError::REQUEST_CANCELED:
+        // No error notification needed if the user manually cancelled signin.
+        break;
+      default:
+        DisplayFinalConfirmationBubble(l10n_util::GetStringUTF16(
+            IDS_SYNC_ERROR_SIGNING_IN));
+        break;
+    }
+  }
   delete this;
 }
 
 void OneClickSigninSyncStarter::SigninSuccess() {
   ProfileSyncService* profile_sync_service = GetProfileSyncService();
   switch (start_mode_) {
     case SYNC_WITH_DEFAULT_SETTINGS:
       if (profile_sync_service) {
         // Just kick off the sync machine, no need to configure it first.
         profile_sync_service->OnUserChoseDatatypes(true,
                                                    syncer::ModelTypeSet());
         profile_sync_service->SetSyncSetupCompleted();
         profile_sync_service->SetSetupInProgress(false);
       }
+      if (confirmation_required_ == CONFIRM_AFTER_SIGNIN) {
+        string16 message;
+        if (!profile_sync_service) {
+          // Sync is disabled by policy.
+          message = l10n_util::GetStringUTF16(
+              IDS_ONE_CLICK_SIGNIN_BUBBLE_SYNC_DISABLED_MESSAGE);
+        }
+        DisplayFinalConfirmationBubble(message);
+      }
       break;
     case CONFIGURE_SYNC_FIRST:
       ConfigureSync();
       break;
     default:
       NOTREACHED() << "Invalid start_mode=" << start_mode_;
   }
+  delete this;
+}
 
-  delete this;
+void OneClickSigninSyncStarter::DisplayFinalConfirmationBubble(
+    const string16& custom_message) {
+  EnsureBrowser();
+  browser_->window()->ShowOneClickSigninBubble(
+      BrowserWindow::ONE_CLICK_SIGNIN_BUBBLE_TYPE_BUBBLE,
+      string16(),  // No email required - this is not a SAML confirmation.
+      custom_message,
+      // Callback is ignored.
+      BrowserWindow::StartSyncCallback());
+}
+
+void OneClickSigninSyncStarter::EnsureBrowser() {
+  if (!browser_) {
+    // The user just created a new profile so we need to figure out what
+    // browser to use to display settings. Grab the most recently active
+    // browser or else create a new one.
+    browser_ = chrome::FindLastActiveWithProfile(profile_, desktop_type_);
+    if (!browser_) {
+      browser_ = new Browser(Browser::CreateParams(profile_,
+                                                   desktop_type_));
+    }
+    browser_->window()->Show();
+  }
 }
 
 void OneClickSigninSyncStarter::ConfigureSync() {
   // Give the user a chance to configure things. We don't clear the
   // ProfileSyncService::setup_in_progress flag because we don't want sync
   // to start up until after the configure UI is displayed (the configure UI
   // will clear the flag when the user is done setting up sync).
   ProfileSyncService* profile_sync_service = GetProfileSyncService();
   LoginUIService* login_ui = LoginUIServiceFactory::GetForProfile(profile_);
   if (login_ui->current_login_ui()) {
     login_ui->current_login_ui()->FocusUI();
   } else {
-    if (!browser_) {
-      // The user just created a new profile so we need to figure out what
-      // browser to use to display settings. Grab the most recently active
-      // browser or else create a new one.
-      browser_ = chrome::FindLastActiveWithProfile(profile_, desktop_type_);
-      if (!browser_) {
-        browser_ = new Browser(Browser::CreateParams(profile_,
-                                                     desktop_type_));
-      }
-      browser_->window()->Show();
-    }
+    EnsureBrowser();
     if (profile_sync_service) {
       // Need to navigate to the settings page and display the sync UI.
       if (force_same_tab_navigation_) {
         ShowSyncSettingsPageOnSameTab();
       } else {
         chrome::ShowSettingsSubPage(browser_, chrome::kSyncSetupSubPage);
       }
     } else {
       // Sync is disabled - just display the settings page.
       chrome::ShowSettings(browser_);
@@ skipping 10 matching lines @@
 
 void OneClickSigninSyncStarter::ShowSyncSettingsPageOnSameTab() {
   std::string url = std::string(chrome::kChromeUISettingsURL) +
       chrome::kSyncSetupSubPage;
   chrome::NavigateParams params(
       browser_, GURL(url), content::PAGE_TRANSITION_AUTO_TOPLEVEL);
   params.disposition = CURRENT_TAB;
   params.window_action = chrome::NavigateParams::SHOW_WINDOW;
   chrome::Navigate(&params);
 }