Sync: Refactor the ProfileSyncService and sync setup flow to remove use of WebUI from PSS.

chrome/browser/sync/profile_sync_service.cc

 // Copyright (c) 2011 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/sync/profile_sync_service.h"
 
 #include <stddef.h>
 #include <map>
 #include <ostream>
 #include <set>
@@ skipping 25 matching lines @@
 #include "chrome/browser/sync/js_event_details.h"
 #include "chrome/browser/sync/profile_sync_factory.h"
 #include "chrome/browser/sync/signin_manager.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/net/gaia/gaia_constants.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/time_format.h"
 #include "chrome/common/url_constants.h"
-#include "content/browser/webui/web_ui.h"
 #include "content/common/notification_details.h"
 #include "content/common/notification_source.h"
 #include "content/common/notification_type.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using browser_sync::ChangeProcessor;
 using browser_sync::DataTypeController;
 using browser_sync::DataTypeManager;
 using browser_sync::SyncBackendHost;
@@ skipping 478 matching lines @@
   // The very first time the backend initializes is effectively the first time
   // we can say we successfully "synced".  last_synced_time_ will only be null
   // in this case, because the pref wasn't restored on StartUp.
   if (last_synced_time_.is_null()) {
     UpdateLastSyncedTime();
   }
   NotifyObservers();
 
   if (!cros_user_.empty()) {
     if (profile_->GetPrefs()->GetBoolean(prefs::kSyncSuppressStart)) {
-      ShowConfigure(NULL, true);
+      ShowConfigure(true);
     } else {
       SetSyncSetupCompleted();
     }
   }
 
   if (HasSyncSetupCompleted()) {
     ConfigureDataTypeManager();
   }
 }
 
@@ skipping 146 matching lines @@
 void ProfileSyncService::OnMigrationNeededForTypes(
     const syncable::ModelTypeSet& types) {
   DCHECK(backend_initialized_);
   DCHECK(data_type_manager_.get());
 
   // Migrator must be valid, because we don't sync until it is created and this
   // callback originates from a sync cycle.
   migrator_->MigrateTypes(types);
 }
 
-void ProfileSyncService::ShowLoginDialog(WebUI* web_ui) {
+void ProfileSyncService::ShowLoginDialog() {
   if (WizardIsVisible()) {
     wizard_.Focus();
     // Force the wizard to step to the login screen (which will only actually
     // happen if the transition is valid).
     wizard_.Step(SyncSetupWizard::GAIA_LOGIN);
     return;
   }
 
   if (!auth_error_time_.is_null()) {
     UMA_HISTOGRAM_LONG_TIMES("Sync.ReauthorizationTime",
                              base::TimeTicks::Now() - auth_error_time_);
     auth_error_time_ = base::TimeTicks();  // Reset auth_error_time_ to null.
   }
 
-  ShowSyncSetup(web_ui, SyncSetupWizard::GAIA_LOGIN);
+  ShowSyncSetup(SyncSetupWizard::GAIA_LOGIN);
 
   NotifyObservers();
 }
 
-void ProfileSyncService::ShowErrorUI(WebUI* web_ui) {
-  if (IsPassphraseRequired()) {
-    if (IsUsingSecondaryPassphrase())
-      PromptForExistingPassphrase(web_ui);
-    else
-      NOTREACHED();  // Migration no longer supported.
-
+void ProfileSyncService::ShowErrorUI() {
+  if (WizardIsVisible()) {

[tim (not reviewing), 2011/06/13 22:32:01]

I like that some of the complexity here moved into the flow rather than the
service, though I'm a bit surprised that nothing has to happen if the wizard is
visible? Did you actually try out (manually) the different permutations with
passphrases here?

[James Hawkins, 2011/06/13 23:14:52]

I don't know why or if this is still necessary, only that this is what all of
the other ShowX() calls do on this object. Someone more familiar should take a
look at some point.

+    wizard_.Focus();
     return;
   }
 
-  const GoogleServiceAuthError& error = GetAuthError();
-  if (error.state() == GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS ||
-      error.state() == GoogleServiceAuthError::CAPTCHA_REQUIRED ||
-      error.state() == GoogleServiceAuthError::ACCOUNT_DELETED ||
-      error.state() == GoogleServiceAuthError::ACCOUNT_DISABLED ||
-      error.state() == GoogleServiceAuthError::SERVICE_UNAVAILABLE) {
-    ShowLoginDialog(web_ui);
-  }
+  ShowSyncSetup(SyncSetupWizard::NONFATAL_ERROR);
 }
 
-void ProfileSyncService::ShowConfigure(WebUI* web_ui, bool sync_everything) {
+void ProfileSyncService::ShowConfigure(bool sync_everything) {
   if (WizardIsVisible()) {
     wizard_.Focus();
     return;
   }
 
   if (sync_everything)
-    ShowSyncSetup(web_ui, SyncSetupWizard::SYNC_EVERYTHING);
+    ShowSyncSetup(SyncSetupWizard::SYNC_EVERYTHING);
   else
-    ShowSyncSetup(web_ui, SyncSetupWizard::CONFIGURE);
+    ShowSyncSetup(SyncSetupWizard::CONFIGURE);
 }
 
-void ProfileSyncService::PromptForExistingPassphrase(WebUI* web_ui) {
+void ProfileSyncService::PromptForExistingPassphrase() {
   if (WizardIsVisible()) {
     wizard_.Focus();
     return;
   }
 
-  ShowSyncSetup(web_ui, SyncSetupWizard::ENTER_PASSPHRASE);
+  ShowSyncSetup(SyncSetupWizard::ENTER_PASSPHRASE);
 }
 
-void ProfileSyncService::ShowSyncSetup(WebUI* web_ui,
-                                       SyncSetupWizard::State state) {
+void ProfileSyncService::ShowSyncSetup(SyncSetupWizard::State state) {
   wizard_.Step(state);
-  if (web_ui)
-    web_ui->CallJavascriptFunction("options.SyncSetupOverlay.showSyncDialog");
-  else
-    BrowserList::GetLastActive()->ShowOptionsTab(chrome::kSyncSetupSubPage);
+  BrowserList::GetLastActive()->ShowOptionsTab(chrome::kSyncSetupSubPage);
 }
 
 SyncBackendHost::StatusSummary ProfileSyncService::QuerySyncStatusSummary() {
   if (backend_.get() && backend_initialized_)
     return backend_->GetStatusSummary();
   else
     return SyncBackendHost::Status::OFFLINE_UNUSABLE;
 }
 
 SyncBackendHost::Status ProfileSyncService::QueryDetailedSyncStatus() {
@@ skipping 561 matching lines @@
   // another, and no unrecoverable error has transpired.
   if (unrecoverable_error_detected_)
     return false;
 
   if (!data_type_manager_.get())
     return false;
 
   return data_type_manager_->state() == DataTypeManager::CONFIGURED;
 }