chrome/browser/ui/webui/sync_setup_handler.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/ui/webui/sync_setup_handler.h"
   6
   7 #include "base/basictypes.h"
   8 #include "base/bind.h"
   9 #include "base/bind_helpers.h"
  10 #include "base/command_line.h"
  11 #include "base/compiler_specific.h"
  12 #include "base/i18n/time_formatting.h"
  13 #include "base/json/json_reader.h"
  14 #include "base/json/json_writer.h"
  15 #include "base/metrics/histogram.h"
  16 #include "base/prefs/pref_service.h"
  17 #include "base/strings/utf_string_conversions.h"
  18 #include "base/values.h"
  19 #include "chrome/app/chrome_command_ids.h"
  20 #include "chrome/browser/browser_process.h"
  21 #include "chrome/browser/lifetime/application_lifetime.h"
  22 #include "chrome/browser/profiles/profile.h"
  23 #include "chrome/browser/profiles/profile_info_cache.h"
  24 #include "chrome/browser/profiles/profile_manager.h"
  25 #include "chrome/browser/profiles/profile_metrics.h"
  26 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
  27 #include "chrome/browser/signin/signin_header_helper.h"
  28 #include "chrome/browser/signin/signin_manager_factory.h"
  29 #include "chrome/browser/signin/signin_promo.h"
  30 #include "chrome/browser/sync/profile_sync_service.h"
  31 #include "chrome/browser/sync/profile_sync_service_factory.h"
  32 #include "chrome/browser/ui/browser_finder.h"
  33 #include "chrome/browser/ui/browser_navigator.h"
  34 #include "chrome/browser/ui/browser_window.h"
  35 #include "chrome/browser/ui/singleton_tabs.h"
  36 #include "chrome/browser/ui/sync/signin_histogram.h"
  37 #include "chrome/browser/ui/webui/options/options_handlers_helper.h"
  38 #include "chrome/browser/ui/webui/signin/login_ui_service.h"
  39 #include "chrome/browser/ui/webui/signin/login_ui_service_factory.h"
  40 #include "chrome/common/chrome_switches.h"
  41 #include "chrome/common/pref_names.h"
  42 #include "chrome/common/url_constants.h"
  43 #include "chrome/grit/chromium_strings.h"
  44 #include "chrome/grit/generated_resources.h"
  45 #include "chrome/grit/locale_settings.h"
  46 #include "components/google/core/browser/google_util.h"
  47 #include "components/signin/core/browser/profile_oauth2_token_service.h"
  48 #include "components/signin/core/browser/signin_error_controller.h"
  49 #include "components/signin/core/browser/signin_metrics.h"
  50 #include "components/signin/core/common/profile_management_switches.h"
  51 #include "components/sync_driver/sync_prefs.h"
  52 #include "content/public/browser/render_view_host.h"
  53 #include "content/public/browser/web_contents.h"
  54 #include "content/public/browser/web_contents_delegate.h"
  55 #include "google_apis/gaia/gaia_auth_util.h"
  56 #include "google_apis/gaia/gaia_constants.h"
  57 #include "grit/components_strings.h"
  58 #include "net/base/url_util.h"
  59 #include "ui/base/l10n/l10n_util.h"
  60
  61 #if defined(OS_CHROMEOS)
  62 #include "components/signin/core/browser/signin_manager_base.h"
  63 #else
  64 #include "components/signin/core/browser/signin_manager.h"
  65 #endif
  66
  67 using content::WebContents;
  68 using l10n_util::GetStringFUTF16;
  69 using l10n_util::GetStringUTF16;
  70
  71 namespace {
  72
  73 // A structure which contains all the configuration information for sync.
  74 struct SyncConfigInfo {
  75   SyncConfigInfo();
  76   ~SyncConfigInfo();
  77
  78   bool encrypt_all;
  79   bool sync_everything;
  80   bool sync_nothing;
  81   syncer::ModelTypeSet data_types;
  82   std::string passphrase;
  83   bool passphrase_is_gaia;
  84 };
  85
  86 SyncConfigInfo::SyncConfigInfo()
  87     : encrypt_all(false),
  88       sync_everything(false),
  89       sync_nothing(false),
  90       passphrase_is_gaia(false) {
  91 }
  92
  93 SyncConfigInfo::~SyncConfigInfo() {}
  94
  95 // Note: The order of these types must match the ordering of
  96 // the respective types in ModelType
  97 const char* kDataTypeNames[] = {
  98   "bookmarks",
  99   "preferences",
 100   "passwords",
 101   "autofill",
 102   "themes",
 103   "typedUrls",
 104   "extensions",
 105   "apps",
 106   "tabs"
 107 };
 108
 109 COMPILE_ASSERT(33 == syncer::MODEL_TYPE_COUNT,
 110                update_kDataTypeNames_to_match_UserSelectableTypes);
 111
 112 typedef std::map<syncer::ModelType, const char*> ModelTypeNameMap;
 113
 114 ModelTypeNameMap GetSelectableTypeNameMap() {
 115   ModelTypeNameMap type_names;
 116   syncer::ModelTypeSet type_set = syncer::UserSelectableTypes();
 117   syncer::ModelTypeSet::Iterator it = type_set.First();
 118   DCHECK_EQ(arraysize(kDataTypeNames), type_set.Size());
 119   for (size_t i = 0; i < arraysize(kDataTypeNames) && it.Good();
 120        ++i, it.Inc()) {
 121     type_names[it.Get()] = kDataTypeNames[i];
 122   }
 123   return type_names;
 124 }
 125
 126 bool GetConfiguration(const std::string& json, SyncConfigInfo* config) {
 127   scoped_ptr<base::Value> parsed_value(base::JSONReader::Read(json));
 128   base::DictionaryValue* result;
 129   if (!parsed_value || !parsed_value->GetAsDictionary(&result)) {
 130     DLOG(ERROR) << "GetConfiguration() not passed a Dictionary";
 131     return false;
 132   }
 133
 134   if (!result->GetBoolean("syncAllDataTypes", &config->sync_everything)) {
 135     DLOG(ERROR) << "GetConfiguration() not passed a syncAllDataTypes value";
 136     return false;
 137   }
 138
 139   if (!result->GetBoolean("syncNothing", &config->sync_nothing)) {
 140     DLOG(ERROR) << "GetConfiguration() not passed a syncNothing value";
 141     return false;
 142   }
 143
 144   DCHECK(!(config->sync_everything && config->sync_nothing))
 145       << "syncAllDataTypes and syncNothing cannot both be true";
 146
 147   ModelTypeNameMap type_names = GetSelectableTypeNameMap();
 148
 149   for (ModelTypeNameMap::const_iterator it = type_names.begin();
 150        it != type_names.end(); ++it) {
 151     std::string key_name = it->second + std::string("Synced");
 152     bool sync_value;
 153     if (!result->GetBoolean(key_name, &sync_value)) {
 154       DLOG(ERROR) << "GetConfiguration() not passed a value for " << key_name;
 155       return false;
 156     }
 157     if (sync_value)
 158       config->data_types.Put(it->first);
 159   }
 160
 161   // Encryption settings.
 162   if (!result->GetBoolean("encryptAllData", &config->encrypt_all)) {
 163     DLOG(ERROR) << "GetConfiguration() not passed a value for encryptAllData";
 164     return false;
 165   }
 166
 167   // Passphrase settings.
 168   bool have_passphrase;
 169   if (!result->GetBoolean("usePassphrase", &have_passphrase)) {
 170     DLOG(ERROR) << "GetConfiguration() not passed a usePassphrase value";
 171     return false;
 172   }
 173
 174   if (have_passphrase) {
 175     if (!result->GetBoolean("isGooglePassphrase",
 176                             &config->passphrase_is_gaia)) {
 177       DLOG(ERROR) << "GetConfiguration() not passed isGooglePassphrase value";
 178       return false;
 179     }
 180     if (!result->GetString("passphrase", &config->passphrase)) {
 181       DLOG(ERROR) << "GetConfiguration() not passed a passphrase value";
 182       return false;
 183     }
 184   }
 185   return true;
 186 }
 187
 188 }  // namespace
 189
 190 SyncSetupHandler::SyncSetupHandler(ProfileManager* profile_manager)
 191     : configuring_sync_(false),
 192       profile_manager_(profile_manager) {
 193 }
 194
 195 SyncSetupHandler::~SyncSetupHandler() {
 196   // Just exit if running unit tests (no actual WebUI is attached).
 197   if (!web_ui())
 198     return;
 199
 200   // This case is hit when the user performs a back navigation.
 201   CloseSyncSetup();
 202 }
 203
 204 void SyncSetupHandler::GetLocalizedValues(
 205     base::DictionaryValue* localized_strings) {
 206   GetStaticLocalizedValues(localized_strings, web_ui());
 207 }
 208
 209 void SyncSetupHandler::GetStaticLocalizedValues(
 210     base::DictionaryValue* localized_strings,
 211     content::WebUI* web_ui) {
 212   DCHECK(localized_strings);
 213
 214   base::string16 product_name(GetStringUTF16(IDS_PRODUCT_NAME));
 215   localized_strings->SetString(
 216       "chooseDataTypesInstructions",
 217       GetStringFUTF16(IDS_SYNC_CHOOSE_DATATYPES_INSTRUCTIONS, product_name));
 218   localized_strings->SetString(
 219       "encryptionInstructions",
 220       GetStringFUTF16(IDS_SYNC_ENCRYPTION_INSTRUCTIONS, product_name));
 221   localized_strings->SetString(
 222       "encryptionHelpURL", chrome::kSyncEncryptionHelpURL);
 223   localized_strings->SetString(
 224       "encryptionSectionMessage",
 225       GetStringFUTF16(IDS_SYNC_ENCRYPTION_SECTION_MESSAGE, product_name));
 226   localized_strings->SetString(
 227       "passphraseRecover",
 228       GetStringFUTF16(
 229           IDS_SYNC_PASSPHRASE_RECOVER,
 230           base::ASCIIToUTF16(
 231               google_util::AppendGoogleLocaleParam(
 232                   GURL(chrome::kSyncGoogleDashboardURL),
 233                   g_browser_process->GetApplicationLocale()).spec())));
 234   localized_strings->SetString(
 235       "stopSyncingExplanation",
 236       l10n_util::GetStringFUTF16(
 237           IDS_SYNC_STOP_SYNCING_EXPLANATION_LABEL,
 238           l10n_util::GetStringUTF16(IDS_PRODUCT_NAME),
 239           base::ASCIIToUTF16(
 240               google_util::AppendGoogleLocaleParam(
 241                   GURL(chrome::kSyncGoogleDashboardURL),
 242                   g_browser_process->GetApplicationLocale()).spec())));
 243   localized_strings->SetString("deleteProfileLabel",
 244       l10n_util::GetStringUTF16(IDS_SYNC_STOP_DELETE_PROFILE_LABEL));
 245   localized_strings->SetString("stopSyncingTitle",
 246       l10n_util::GetStringUTF16(IDS_SYNC_STOP_SYNCING_DIALOG_TITLE));
 247   localized_strings->SetString("stopSyncingConfirm",
 248         l10n_util::GetStringUTF16(IDS_SYNC_STOP_SYNCING_CONFIRM_BUTTON_LABEL));
 249
 250   localized_strings->SetString(
 251       "syncEverythingHelpURL", chrome::kSyncEverythingLearnMoreURL);
 252   localized_strings->SetString(
 253       "syncErrorHelpURL", chrome::kSyncErrorsHelpURL);
 254
 255   static OptionsStringResource resources[] = {
 256     { "syncSetupConfigureTitle", IDS_SYNC_SETUP_CONFIGURE_TITLE },
 257     { "syncSetupSpinnerTitle", IDS_SYNC_SETUP_SPINNER_TITLE },
 258     { "syncSetupTimeoutTitle", IDS_SYNC_SETUP_TIME_OUT_TITLE },
 259     { "syncSetupTimeoutContent", IDS_SYNC_SETUP_TIME_OUT_CONTENT },
 260     { "errorLearnMore", IDS_LEARN_MORE },
 261     { "cancel", IDS_CANCEL },
 262     { "loginSuccess", IDS_SYNC_SUCCESS },
 263     { "settingUp", IDS_SYNC_LOGIN_SETTING_UP },
 264     { "syncAllDataTypes", IDS_SYNC_EVERYTHING },
 265     { "chooseDataTypes", IDS_SYNC_CHOOSE_DATATYPES },
 266     { "syncNothing", IDS_SYNC_NOTHING },
 267     { "bookmarks", IDS_SYNC_DATATYPE_BOOKMARKS },
 268     { "preferences", IDS_SYNC_DATATYPE_PREFERENCES },
 269     { "autofill", IDS_SYNC_DATATYPE_AUTOFILL },
 270     { "themes", IDS_SYNC_DATATYPE_THEMES },
 271     { "passwords", IDS_SYNC_DATATYPE_PASSWORDS },
 272     { "extensions", IDS_SYNC_DATATYPE_EXTENSIONS },
 273     { "typedURLs", IDS_SYNC_DATATYPE_TYPED_URLS },
 274     { "apps", IDS_SYNC_DATATYPE_APPS },
 275     { "openTabs", IDS_SYNC_DATATYPE_TABS },
 276     { "serviceUnavailableError", IDS_SYNC_SETUP_ABORTED_BY_PENDING_CLEAR },
 277     { "confirmLabel", IDS_SYNC_CONFIRM_PASSPHRASE_LABEL },
 278     { "emptyErrorMessage", IDS_SYNC_EMPTY_PASSPHRASE_ERROR },
 279     { "mismatchErrorMessage", IDS_SYNC_PASSPHRASE_MISMATCH_ERROR },
 280     { "customizeLinkLabel", IDS_SYNC_CUSTOMIZE_LINK_LABEL },
 281     { "confirmSyncPreferences", IDS_SYNC_CONFIRM_SYNC_PREFERENCES },
 282     { "syncEverything", IDS_SYNC_SYNC_EVERYTHING },
 283     { "useDefaultSettings", IDS_SYNC_USE_DEFAULT_SETTINGS },
 284     { "enterPassphraseBody", IDS_SYNC_ENTER_PASSPHRASE_BODY },
 285     { "enterGooglePassphraseBody", IDS_SYNC_ENTER_GOOGLE_PASSPHRASE_BODY },
 286     { "passphraseLabel", IDS_SYNC_PASSPHRASE_LABEL },
 287     { "incorrectPassphrase", IDS_SYNC_INCORRECT_PASSPHRASE },
 288     { "passphraseWarning", IDS_SYNC_PASSPHRASE_WARNING },
 289     { "yes", IDS_SYNC_PASSPHRASE_CANCEL_YES },
 290     { "no", IDS_SYNC_PASSPHRASE_CANCEL_NO },
 291     { "sectionExplicitMessagePrefix", IDS_SYNC_PASSPHRASE_MSG_EXPLICIT_PREFIX },
 292     { "sectionExplicitMessagePostfix",
 293         IDS_SYNC_PASSPHRASE_MSG_EXPLICIT_POSTFIX },
 294     // TODO(rogerta): browser/resource/sync_promo/sync_promo.html and related
 295     // file may not be needed any more.  If not, then the following promo
 296     // strings can also be removed.
 297     { "promoPageTitle", IDS_SYNC_PROMO_TAB_TITLE },
 298     { "promoSkipButton", IDS_SYNC_PROMO_SKIP_BUTTON },
 299     { "promoAdvanced", IDS_SYNC_PROMO_ADVANCED },
 300     { "promoLearnMore", IDS_LEARN_MORE },
 301     { "promoTitleShort", IDS_SYNC_PROMO_MESSAGE_TITLE_SHORT },
 302     { "encryptionSectionTitle", IDS_SYNC_ENCRYPTION_SECTION_TITLE },
 303     { "basicEncryptionOption", IDS_SYNC_BASIC_ENCRYPTION_DATA },
 304     { "fullEncryptionOption", IDS_SYNC_FULL_ENCRYPTION_DATA },
 305   };
 306
 307   RegisterStrings(localized_strings, resources, arraysize(resources));
 308   RegisterTitle(localized_strings, "syncSetupOverlay", IDS_SYNC_SETUP_TITLE);
 309 }
 310
 311 void SyncSetupHandler::DisplayConfigureSync(bool show_advanced,
 312                                             bool passphrase_failed) {
 313   // Should never call this when we are not signed in.
 314   DCHECK(SigninManagerFactory::GetForProfile(
 315       GetProfile())->IsAuthenticated());
 316   ProfileSyncService* service = GetSyncService();
 317   DCHECK(service);
 318   if (!service->backend_initialized()) {
 319     service->UnsuppressAndStart();
 320
 321     // See if it's even possible to bring up the sync backend - if not
 322     // (unrecoverable error?), don't bother displaying a spinner that will be
 323     // immediately closed because this leads to some ugly infinite UI loop (see
 324     // http://crbug.com/244769).
 325     if (SyncStartupTracker::GetSyncServiceState(GetProfile()) !=
 326         SyncStartupTracker::SYNC_STARTUP_ERROR) {
 327       DisplaySpinner();
 328     }
 329
 330     // Start SyncSetupTracker to wait for sync to initialize.
 331     sync_startup_tracker_.reset(
 332         new SyncStartupTracker(GetProfile(), this));
 333     return;
 334   }
 335
 336   // Should only get here if user is signed in and sync is initialized, so no
 337   // longer need a SyncStartupTracker.
 338   sync_startup_tracker_.reset();
 339   configuring_sync_ = true;
 340   DCHECK(service->backend_initialized()) <<
 341       "Cannot configure sync until the sync backend is initialized";
 342
 343   // Setup args for the sync configure screen:
 344   //   showSyncEverythingPage: false to skip directly to the configure screen
 345   //   syncAllDataTypes: true if the user wants to sync everything
 346   //   syncNothing: true if the user wants to sync nothing
 347   //   <data_type>Registered: true if the associated data type is supported
 348   //   <data_type>Synced: true if the user wants to sync that specific data type
 349   //   encryptionEnabled: true if sync supports encryption
 350   //   encryptAllData: true if user wants to encrypt all data (not just
 351   //       passwords)
 352   //   usePassphrase: true if the data is encrypted with a secondary passphrase
 353   //   show_passphrase: true if a passphrase is needed to decrypt the sync data
 354   base::DictionaryValue args;
 355
 356   // Tell the UI layer which data types are registered/enabled by the user.
 357   const syncer::ModelTypeSet registered_types =
 358       service->GetRegisteredDataTypes();
 359   const syncer::ModelTypeSet preferred_types = service->GetPreferredDataTypes();
 360   const syncer::ModelTypeSet enforced_types = service->GetForcedDataTypes();
 361   ModelTypeNameMap type_names = GetSelectableTypeNameMap();
 362   for (ModelTypeNameMap::const_iterator it = type_names.begin();
 363        it != type_names.end(); ++it) {
 364     syncer::ModelType sync_type = it->first;
 365     const std::string key_name = it->second;
 366     args.SetBoolean(key_name + "Registered", registered_types.Has(sync_type));
 367     args.SetBoolean(key_name + "Synced", preferred_types.Has(sync_type));
 368     args.SetBoolean(key_name + "Enforced", enforced_types.Has(sync_type));
 369     // TODO(treib): How do we want to handle pref groups, i.e. when only some of
 370     // the sync types behind a checkbox are force-enabled? crbug.com/403326
 371   }
 372   sync_driver::SyncPrefs sync_prefs(GetProfile()->GetPrefs());
 373   args.SetBoolean("passphraseFailed", passphrase_failed);
 374   args.SetBoolean("showSyncEverythingPage", !show_advanced);
 375   args.SetBoolean("syncAllDataTypes", sync_prefs.HasKeepEverythingSynced());
 376   args.SetBoolean("syncNothing", false);  // Always false during initial setup.
 377   args.SetBoolean("encryptAllData", service->EncryptEverythingEnabled());
 378   args.SetBoolean("encryptAllDataAllowed", service->EncryptEverythingAllowed());
 379
 380   // We call IsPassphraseRequired() here, instead of calling
 381   // IsPassphraseRequiredForDecryption(), because we want to show the passphrase
 382   // UI even if no encrypted data types are enabled.
 383   args.SetBoolean("showPassphrase", service->IsPassphraseRequired());
 384
 385   // To distinguish between FROZEN_IMPLICIT_PASSPHRASE and CUSTOM_PASSPHRASE
 386   // we only set usePassphrase for CUSTOM_PASSPHRASE.
 387   args.SetBoolean("usePassphrase",
 388                   service->GetPassphraseType() == syncer::CUSTOM_PASSPHRASE);
 389   base::Time passphrase_time = service->GetExplicitPassphraseTime();
 390   syncer::PassphraseType passphrase_type = service->GetPassphraseType();
 391   if (!passphrase_time.is_null()) {
 392     base::string16 passphrase_time_str =
 393         base::TimeFormatShortDate(passphrase_time);
 394     args.SetString(
 395         "enterPassphraseBody",
 396         GetStringFUTF16(IDS_SYNC_ENTER_PASSPHRASE_BODY_WITH_DATE,
 397                         passphrase_time_str));
 398     args.SetString(
 399         "enterGooglePassphraseBody",
 400         GetStringFUTF16(IDS_SYNC_ENTER_GOOGLE_PASSPHRASE_BODY_WITH_DATE,
 401                         passphrase_time_str));
 402     switch (passphrase_type) {
 403       case syncer::FROZEN_IMPLICIT_PASSPHRASE:
 404         args.SetString(
 405             "fullEncryptionBody",
 406             GetStringFUTF16(IDS_SYNC_FULL_ENCRYPTION_BODY_GOOGLE_WITH_DATE,
 407                             passphrase_time_str));
 408         break;
 409       case syncer::CUSTOM_PASSPHRASE:
 410         args.SetString(
 411             "fullEncryptionBody",
 412             GetStringFUTF16(IDS_SYNC_FULL_ENCRYPTION_BODY_CUSTOM_WITH_DATE,
 413                             passphrase_time_str));
 414         break;
 415       default:
 416         args.SetString(
 417             "fullEncryptionBody",
 418             GetStringUTF16(IDS_SYNC_FULL_ENCRYPTION_BODY_CUSTOM));
 419         break;
 420     }
 421   } else if (passphrase_type == syncer::CUSTOM_PASSPHRASE) {
 422     args.SetString(
 423         "fullEncryptionBody",
 424         GetStringUTF16(IDS_SYNC_FULL_ENCRYPTION_BODY_CUSTOM));
 425   } else {
 426     args.SetString(
 427         "fullEncryptionBody",
 428         GetStringUTF16(IDS_SYNC_FULL_ENCRYPTION_DATA));
 429   }
 430
 431   base::StringValue page("configure");
 432   web_ui()->CallJavascriptFunction(
 433       "SyncSetupOverlay.showSyncSetupPage", page, args);
 434
 435   // Make sure the tab used for the Gaia sign in does not cover the settings
 436   // tab.
 437   FocusUI();
 438 }
 439
 440 void SyncSetupHandler::ConfigureSyncDone() {
 441   base::StringValue page("done");
 442   web_ui()->CallJavascriptFunction(
 443       "SyncSetupOverlay.showSyncSetupPage", page);
 444
 445   // Suppress the sign in promo once the user starts sync. This way the user
 446   // doesn't see the sign in promo even if they sign out later on.
 447   signin::SetUserSkippedPromo(GetProfile());
 448
 449   ProfileSyncService* service = GetSyncService();
 450   DCHECK(service);
 451   if (!service->HasSyncSetupCompleted()) {
 452     // This is the first time configuring sync, so log it.
 453     base::FilePath profile_file_path = GetProfile()->GetPath();
 454     ProfileMetrics::LogProfileSyncSignIn(profile_file_path);
 455
 456     // We're done configuring, so notify ProfileSyncService that it is OK to
 457     // start syncing.
 458     service->SetSetupInProgress(false);
 459     service->SetSyncSetupCompleted();
 460   }
 461 }
 462
 463 bool SyncSetupHandler::IsActiveLogin() const {
 464   // LoginUIService can be NULL if page is brought up in incognito mode
 465   // (i.e. if the user is running in guest mode in cros and brings up settings).
 466   LoginUIService* service = GetLoginUIService();
 467   return service && (service->current_login_ui() == this);
 468 }
 469
 470 void SyncSetupHandler::RegisterMessages() {
 471   web_ui()->RegisterMessageCallback(
 472       "SyncSetupDidClosePage",
 473       base::Bind(&SyncSetupHandler::OnDidClosePage,
 474                  base::Unretained(this)));
 475   web_ui()->RegisterMessageCallback(
 476       "SyncSetupConfigure",
 477       base::Bind(&SyncSetupHandler::HandleConfigure,
 478                  base::Unretained(this)));
 479   web_ui()->RegisterMessageCallback(
 480       "SyncSetupShowSetupUI",
 481       base::Bind(&SyncSetupHandler::HandleShowSetupUI,
 482                  base::Unretained(this)));
 483   web_ui()->RegisterMessageCallback("CloseTimeout",
 484       base::Bind(&SyncSetupHandler::HandleCloseTimeout,
 485                  base::Unretained(this)));
 486 #if defined(OS_CHROMEOS)
 487   web_ui()->RegisterMessageCallback(
 488       "SyncSetupDoSignOutOnAuthError",
 489       base::Bind(&SyncSetupHandler::HandleDoSignOutOnAuthError,
 490                  base::Unretained(this)));
 491 #else
 492   web_ui()->RegisterMessageCallback("SyncSetupStopSyncing",
 493       base::Bind(&SyncSetupHandler::HandleStopSyncing,
 494                  base::Unretained(this)));
 495   web_ui()->RegisterMessageCallback("SyncSetupStartSignIn",
 496       base::Bind(&SyncSetupHandler::HandleStartSignin,
 497                  base::Unretained(this)));
 498 #endif
 499 }
 500
 501 #if !defined(OS_CHROMEOS)
 502 void SyncSetupHandler::DisplayGaiaLogin() {
 503   DCHECK(!sync_startup_tracker_);
 504   // Advanced options are no longer being configured if the login screen is
 505   // visible. If the user exits the signin wizard after this without
 506   // configuring sync, CloseSyncSetup() will ensure they are logged out.
 507   configuring_sync_ = false;
 508   DisplayGaiaLoginInNewTabOrWindow();
 509 }
 510
 511 void SyncSetupHandler::DisplayGaiaLoginInNewTabOrWindow() {
 512   Browser* browser = chrome::FindBrowserWithWebContents(
 513       web_ui()->GetWebContents());
 514   bool force_new_tab = false;
 515   if (!browser) {
 516     // Settings is not displayed in a browser window. Open a new window.
 517     browser = new Browser(Browser::CreateParams(
 518         Browser::TYPE_TABBED, GetProfile(), chrome::GetActiveDesktop()));
 519     force_new_tab = true;
 520   }
 521
 522   // If the signin manager already has an authenticated username, this is a
 523   // re-auth scenario, and we need to ensure that the user signs in with the
 524   // same email address.
 525   GURL url;
 526   if (SigninManagerFactory::GetForProfile(
 527       browser->profile())->IsAuthenticated()) {
 528     UMA_HISTOGRAM_ENUMERATION("Signin.Reauth",
 529                               signin::HISTOGRAM_SHOWN,
 530                               signin::HISTOGRAM_MAX);
 531
 532     SigninErrorController* error_controller =
 533         ProfileOAuth2TokenServiceFactory::GetForProfile(browser->profile())->
 534             signin_error_controller();
 535     DCHECK(error_controller->HasError());
 536     if (switches::IsNewAvatarMenu() && !force_new_tab) {
 537       browser->window()->ShowAvatarBubbleFromAvatarButton(
 538           BrowserWindow::AVATAR_BUBBLE_MODE_REAUTH,
 539           signin::ManageAccountsParams());
 540     } else {
 541       url = signin::GetReauthURL(browser->profile(),
 542                                  error_controller->error_account_id());
 543     }
 544   } else {
 545     if (switches::IsNewAvatarMenu() && !force_new_tab) {
 546       browser->window()->ShowAvatarBubbleFromAvatarButton(
 547           BrowserWindow::AVATAR_BUBBLE_MODE_SIGNIN,
 548           signin::ManageAccountsParams());
 549     } else {
 550       url = signin::GetPromoURL(signin::SOURCE_SETTINGS, true);
 551     }
 552   }
 553
 554   if (url.is_valid())
 555     chrome::ShowSingletonTab(browser, url);
 556 }
 557 #endif
 558
 559 bool SyncSetupHandler::PrepareSyncSetup() {
 560   // If the wizard is already visible, just focus that one.
 561   if (FocusExistingWizardIfPresent()) {
 562     if (!IsActiveLogin())
 563       CloseSyncSetup();
 564     return false;
 565   }
 566
 567   // Notify services that login UI is now active.
 568   GetLoginUIService()->SetLoginUI(this);
 569
 570   ProfileSyncService* service = GetSyncService();
 571   if (service)
 572     service->SetSetupInProgress(true);
 573
 574   return true;
 575 }
 576
 577 void SyncSetupHandler::DisplaySpinner() {
 578   configuring_sync_ = true;
 579   base::StringValue page("spinner");
 580   base::DictionaryValue args;
 581
 582   const int kTimeoutSec = 30;
 583   DCHECK(!backend_start_timer_);
 584   backend_start_timer_.reset(new base::OneShotTimer<SyncSetupHandler>());
 585   backend_start_timer_->Start(FROM_HERE,
 586                               base::TimeDelta::FromSeconds(kTimeoutSec),
 587                               this, &SyncSetupHandler::DisplayTimeout);
 588
 589   web_ui()->CallJavascriptFunction(
 590       "SyncSetupOverlay.showSyncSetupPage", page, args);
 591 }
 592
 593 // TODO(kochi): Handle error conditions other than timeout.
 594 // http://crbug.com/128692
 595 void SyncSetupHandler::DisplayTimeout() {
 596   // Stop a timer to handle timeout in waiting for checking network connection.
 597   backend_start_timer_.reset();
 598
 599   // Do not listen to sync startup events.
 600   sync_startup_tracker_.reset();
 601
 602   base::StringValue page("timeout");
 603   base::DictionaryValue args;
 604   web_ui()->CallJavascriptFunction(
 605       "SyncSetupOverlay.showSyncSetupPage", page, args);
 606 }
 607
 608 void SyncSetupHandler::OnDidClosePage(const base::ListValue* args) {
 609   CloseSyncSetup();
 610 }
 611
 612 void SyncSetupHandler::SyncStartupFailed() {
 613   // Stop a timer to handle timeout in waiting for checking network connection.
 614   backend_start_timer_.reset();
 615
 616   // Just close the sync overlay (the idea is that the base settings page will
 617   // display the current error.)
 618   CloseUI();
 619 }
 620
 621 void SyncSetupHandler::SyncStartupCompleted() {
 622   ProfileSyncService* service = GetSyncService();
 623   DCHECK(service->backend_initialized());
 624
 625   // Stop a timer to handle timeout in waiting for checking network connection.
 626   backend_start_timer_.reset();
 627
 628   DisplayConfigureSync(true, false);
 629 }
 630
 631 Profile* SyncSetupHandler::GetProfile() const {
 632   return Profile::FromWebUI(web_ui());
 633 }
 634
 635 ProfileSyncService* SyncSetupHandler::GetSyncService() const {
 636   Profile* profile = GetProfile();
 637   return profile->IsSyncAccessible() ?
 638       ProfileSyncServiceFactory::GetForProfile(GetProfile()) : NULL;
 639 }
 640
 641 void SyncSetupHandler::HandleConfigure(const base::ListValue* args) {
 642   DCHECK(!sync_startup_tracker_);
 643   std::string json;
 644   if (!args->GetString(0, &json)) {
 645     NOTREACHED() << "Could not read JSON argument";
 646     return;
 647   }
 648   if (json.empty()) {
 649     NOTREACHED();
 650     return;
 651   }
 652
 653   SyncConfigInfo configuration;
 654   if (!GetConfiguration(json, &configuration)) {
 655     // The page sent us something that we didn't understand.
 656     // This probably indicates a programming error.
 657     NOTREACHED();
 658     return;
 659   }
 660
 661   // Start configuring the ProfileSyncService using the configuration passed
 662   // to us from the JS layer.
 663   ProfileSyncService* service = GetSyncService();
 664
 665   // If the sync engine has shutdown for some reason, just close the sync
 666   // dialog.
 667   if (!service || !service->backend_initialized()) {
 668     CloseUI();
 669     return;
 670   }
 671
 672   // Disable sync, but remain signed in if the user selected "Sync nothing" in
 673   // the advanced settings dialog. Note: In order to disable sync across
 674   // restarts on Chrome OS, we must call StopSyncingPermanently(), which
 675   // suppresses sync startup in addition to disabling it.
 676   if (configuration.sync_nothing) {
 677     ProfileSyncService::SyncEvent(
 678         ProfileSyncService::STOP_FROM_ADVANCED_DIALOG);
 679     CloseUI();
 680     service->StopSyncingPermanently();
 681     service->SetSetupInProgress(false);
 682     return;
 683   }
 684
 685   // Don't allow "encrypt all" if the ProfileSyncService doesn't allow it.
 686   // The UI is hidden, but the user may have enabled it e.g. by fiddling with
 687   // the web inspector.
 688   if (!service->EncryptEverythingAllowed())
 689     configuration.encrypt_all = false;
 690
 691   // Note: Data encryption will not occur until configuration is complete
 692   // (when the PSS receives its CONFIGURE_DONE notification from the sync
 693   // backend), so the user still has a chance to cancel out of the operation
 694   // if (for example) some kind of passphrase error is encountered.
 695   if (configuration.encrypt_all)
 696     service->EnableEncryptEverything();
 697
 698   bool passphrase_failed = false;
 699   if (!configuration.passphrase.empty()) {
 700     // We call IsPassphraseRequired() here (instead of
 701     // IsPassphraseRequiredForDecryption()) because the user may try to enter
 702     // a passphrase even though no encrypted data types are enabled.
 703     if (service->IsPassphraseRequired()) {
 704       // If we have pending keys, try to decrypt them with the provided
 705       // passphrase. We track if this succeeds or fails because a failed
 706       // decryption should result in an error even if there aren't any encrypted
 707       // data types.
 708       passphrase_failed =
 709           !service->SetDecryptionPassphrase(configuration.passphrase);
 710     } else {
 711       // OK, the user sent us a passphrase, but we don't have pending keys. So
 712       // it either means that the pending keys were resolved somehow since the
 713       // time the UI was displayed (re-encryption, pending passphrase change,
 714       // etc) or the user wants to re-encrypt.
 715       if (!configuration.passphrase_is_gaia &&
 716           !service->IsUsingSecondaryPassphrase()) {
 717         // User passed us a secondary passphrase, and the data is encrypted
 718         // with a GAIA passphrase so they must want to encrypt.
 719         service->SetEncryptionPassphrase(configuration.passphrase,
 720                                          ProfileSyncService::EXPLICIT);
 721       }
 722     }
 723   }
 724
 725   bool user_was_prompted_for_passphrase =
 726       service->IsPassphraseRequiredForDecryption();
 727   service->OnUserChoseDatatypes(configuration.sync_everything,
 728                                 configuration.data_types);
 729
 730   // Need to call IsPassphraseRequiredForDecryption() *after* calling
 731   // OnUserChoseDatatypes() because the user may have just disabled the
 732   // encrypted datatypes (in which case we just want to exit, not prompt the
 733   // user for a passphrase).
 734   if (passphrase_failed || service->IsPassphraseRequiredForDecryption()) {
 735     // We need a passphrase, or the user's attempt to set a passphrase failed -
 736     // prompt them again. This covers a few subtle cases:
 737     // 1) The user enters an incorrect passphrase *and* disabled the encrypted
 738     //    data types. In that case we want to notify the user that the
 739     //    passphrase was incorrect even though there are no longer any encrypted
 740     //    types enabled (IsPassphraseRequiredForDecryption() == false).
 741     // 2) The user doesn't enter any passphrase. In this case, we won't call
 742     //    SetDecryptionPassphrase() (passphrase_failed == false), but we still
 743     //    want to display an error message to let the user know that their
 744     //    blank passphrase entry is not acceptable.
 745     // 3) The user just enabled an encrypted data type - in this case we don't
 746     //    want to display an "invalid passphrase" error, since it's the first
 747     //    time the user is seeing the prompt.
 748     DisplayConfigureSync(
 749         true, passphrase_failed || user_was_prompted_for_passphrase);
 750   } else {
 751     // No passphrase is required from the user so mark the configuration as
 752     // complete and close the sync setup overlay.
 753     ConfigureSyncDone();
 754   }
 755
 756   ProfileMetrics::LogProfileSyncInfo(ProfileMetrics::SYNC_CUSTOMIZE);
 757   if (configuration.encrypt_all)
 758     ProfileMetrics::LogProfileSyncInfo(ProfileMetrics::SYNC_ENCRYPT);
 759   if (configuration.passphrase_is_gaia && !configuration.passphrase.empty())
 760     ProfileMetrics::LogProfileSyncInfo(ProfileMetrics::SYNC_PASSPHRASE);
 761   if (!configuration.sync_everything)
 762     ProfileMetrics::LogProfileSyncInfo(ProfileMetrics::SYNC_CHOOSE);
 763 }
 764
 765 void SyncSetupHandler::HandleShowSetupUI(const base::ListValue* args) {
 766   if (!GetSyncService()) {
 767     DLOG(WARNING) << "Cannot display sync UI when sync is disabled";
 768     CloseUI();
 769     return;
 770   }
 771
 772   SigninManagerBase* signin =
 773       SigninManagerFactory::GetForProfile(GetProfile());
 774   if (!signin->IsAuthenticated()) {
 775     // For web-based signin, the signin page is not displayed in an overlay
 776     // on the settings page. So if we get here, it must be due to the user
 777     // cancelling signin (by reloading the sync settings page during initial
 778     // signin) or by directly navigating to settings/syncSetup
 779     // (http://crbug.com/229836). So just exit and go back to the settings page.
 780     DLOG(WARNING) << "Cannot display sync setup UI when not signed in";
 781     CloseUI();
 782     return;
 783   }
 784
 785   // If a setup wizard is already present, but not on this page, close the
 786   // blank setup overlay on this page by showing the "done" page. This can
 787   // happen if the user navigates to chrome://settings/syncSetup in more than
 788   // one tab. See crbug.com/261566.
 789   // Note: The following block will transfer focus to the existing wizard.
 790   if (IsExistingWizardPresent() && !IsActiveLogin()) {
 791     CloseUI();
 792   }
 793
 794   // If a setup wizard is present on this page or another, bring it to focus.
 795   // Otherwise, display a new one on this page.
 796   if (!FocusExistingWizardIfPresent())
 797     OpenSyncSetup();
 798 }
 799
 800 #if defined(OS_CHROMEOS)
 801 // On ChromeOS, we need to sign out the user session to fix an auth error, so
 802 // the user goes through the real signin flow to generate a new auth token.
 803 void SyncSetupHandler::HandleDoSignOutOnAuthError(const base::ListValue* args) {
 804   DVLOG(1) << "Signing out the user to fix a sync error.";
 805   chrome::AttemptUserExit();
 806 }
 807 #endif
 808
 809 #if !defined(OS_CHROMEOS)
 810 void SyncSetupHandler::HandleStartSignin(const base::ListValue* args) {
 811   // Should only be called if the user is not already signed in.
 812   DCHECK(!SigninManagerFactory::GetForProfile(GetProfile())->
 813       IsAuthenticated());
 814   OpenSyncSetup();
 815 }
 816
 817 void SyncSetupHandler::HandleStopSyncing(const base::ListValue* args) {
 818   if (GetSyncService())
 819     ProfileSyncService::SyncEvent(ProfileSyncService::STOP_FROM_OPTIONS);
 820   SigninManagerFactory::GetForProfile(GetProfile())->SignOut(
 821       signin_metrics::USER_CLICKED_SIGNOUT_SETTINGS);
 822
 823   bool delete_profile = false;
 824   if (args->GetBoolean(0, &delete_profile) && delete_profile) {
 825     // Do as BrowserOptionsHandler::DeleteProfile().
 826     options::helper::DeleteProfileAtPath(GetProfile()->GetPath(), web_ui());
 827   }
 828 }
 829 #endif
 830
 831 void SyncSetupHandler::HandleCloseTimeout(const base::ListValue* args) {
 832   CloseSyncSetup();
 833 }
 834
 835 void SyncSetupHandler::CloseSyncSetup() {
 836   // Stop a timer to handle timeout in waiting for checking network connection.
 837   backend_start_timer_.reset();
 838
 839   // Clear the sync startup tracker, since the setup wizard is being closed.
 840   sync_startup_tracker_.reset();
 841
 842   ProfileSyncService* sync_service = GetSyncService();
 843   if (IsActiveLogin()) {
 844     // Don't log a cancel event if the sync setup dialog is being
 845     // automatically closed due to an auth error.
 846     if (!sync_service || (!sync_service->HasSyncSetupCompleted() &&
 847         sync_service->GetAuthError().state() == GoogleServiceAuthError::NONE)) {
 848       if (configuring_sync_) {
 849         ProfileSyncService::SyncEvent(
 850             ProfileSyncService::CANCEL_DURING_CONFIGURE);
 851
 852         // If the user clicked "Cancel" while setting up sync, disable sync
 853         // because we don't want the sync backend to remain in the
 854         // first-setup-incomplete state.
 855         // Note: In order to disable sync across restarts on Chrome OS,
 856         // we must call StopSyncingPermanently(), which suppresses sync startup
 857         // in addition to disabling it.
 858         if (sync_service) {
 859           DVLOG(1) << "Sync setup aborted by user action";
 860           sync_service->StopSyncingPermanently();
 861   #if !defined(OS_CHROMEOS)
 862           // Sign out the user on desktop Chrome if they click cancel during
 863           // initial setup.
 864           // TODO(rsimha): Revisit this for M30. See http://crbug.com/252049.
 865           if (sync_service->FirstSetupInProgress()) {
 866             SigninManagerFactory::GetForProfile(GetProfile())->SignOut(
 867                 signin_metrics::ABORT_SIGNIN);
 868           }
 869   #endif
 870         }
 871       }
 872     }
 873
 874     GetLoginUIService()->LoginUIClosed(this);
 875   }
 876
 877   // Alert the sync service anytime the sync setup dialog is closed. This can
 878   // happen due to the user clicking the OK or Cancel button, or due to the
 879   // dialog being closed by virtue of sync being disabled in the background.
 880   if (sync_service)
 881     sync_service->SetSetupInProgress(false);
 882
 883   configuring_sync_ = false;
 884 }
 885
 886 void SyncSetupHandler::OpenSyncSetup() {
 887   if (!PrepareSyncSetup())
 888     return;
 889
 890   // There are several different UI flows that can bring the user here:
 891   // 1) Signin promo.
 892   // 2) Normal signin through settings page (IsAuthenticated() is false).
 893   // 3) Previously working credentials have expired.
 894   // 4) User is signed in, but has stopped sync via the google dashboard, and
 895   //    signout is prohibited by policy so we need to force a re-auth.
 896   // 5) User clicks [Advanced Settings] button on options page while already
 897   //    logged in.
 898   // 6) One-click signin (credentials are already available, so should display
 899   //    sync configure UI, not login UI).
 900   // 7) User re-enables sync after disabling it via advanced settings.
 901 #if !defined(OS_CHROMEOS)
 902   SigninManagerBase* signin =
 903       SigninManagerFactory::GetForProfile(GetProfile());
 904
 905   if (!signin->IsAuthenticated() ||
 906       ProfileOAuth2TokenServiceFactory::GetForProfile(GetProfile())->
 907           signin_error_controller()->HasError()) {
 908     // User is not logged in (cases 1-2), or login has been specially requested
 909     // because previously working credentials have expired (case 3). Close sync
 910     // setup including any visible overlays, and display the gaia auth page.
 911     // Control will be returned to the sync settings page once auth is complete.
 912     CloseUI();
 913     DisplayGaiaLogin();
 914     return;
 915   }
 916 #endif
 917   if (!GetSyncService()) {
 918     // This can happen if the user directly navigates to /settings/syncSetup.
 919     DLOG(WARNING) << "Cannot display sync UI when sync is disabled";
 920     CloseUI();
 921     return;
 922   }
 923
 924   // User is already logged in. They must have brought up the config wizard
 925   // via the "Advanced..." button or through One-Click signin (cases 4-6), or
 926   // they are re-enabling sync after having disabled it (case 7).
 927   DisplayConfigureSync(true, false);
 928 }
 929
 930 void SyncSetupHandler::OpenConfigureSync() {
 931   if (!PrepareSyncSetup())
 932     return;
 933
 934   DisplayConfigureSync(true, false);
 935 }
 936
 937 void SyncSetupHandler::FocusUI() {
 938   DCHECK(IsActiveLogin());
 939   WebContents* web_contents = web_ui()->GetWebContents();
 940   web_contents->GetDelegate()->ActivateContents(web_contents);
 941 }
 942
 943 void SyncSetupHandler::CloseUI() {
 944   CloseSyncSetup();
 945   base::StringValue page("done");
 946   web_ui()->CallJavascriptFunction(
 947       "SyncSetupOverlay.showSyncSetupPage", page);
 948 }
 949
 950 bool SyncSetupHandler::IsExistingWizardPresent() {
 951   LoginUIService* service = GetLoginUIService();
 952   DCHECK(service);
 953   return service->current_login_ui() != NULL;
 954 }
 955
 956 bool SyncSetupHandler::FocusExistingWizardIfPresent() {
 957   if (!IsExistingWizardPresent())
 958     return false;
 959
 960   LoginUIService* service = GetLoginUIService();
 961   DCHECK(service);
 962   service->current_login_ui()->FocusUI();
 963   return true;
 964 }
 965
 966 LoginUIService* SyncSetupHandler::GetLoginUIService() const {
 967   return LoginUIServiceFactory::GetForProfile(GetProfile());
 968 }