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

chrome/browser/sync/sync_setup_flow.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/sync_setup_flow.h"
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
@@ skipping 17 matching lines @@
 namespace {
 
 // Helper function to disable password sync.
 void DisablePasswordSync(ProfileSyncService* service) {
   syncable::ModelTypeSet types;
   service->GetPreferredDataTypes(&types);
   types.erase(syncable::PASSWORDS);
   service->OnUserChoseDatatypes(false, types);
 }
 
+// Fills |args| for the enter passphrase screen.
+void GetArgsForEnterPassphrase(bool tried_creating_explicit_passphrase,
+                               bool tried_setting_explicit_passphrase,
+                               DictionaryValue* args) {
+  args->SetBoolean("show_passphrase", true);
+  args->SetBoolean("passphrase_creation_rejected",
+                   tried_creating_explicit_passphrase);
+  args->SetBoolean("passphrase_setting_rejected",
+                   tried_setting_explicit_passphrase);
+}
+
+// Returns the next step for the non-fatal error case.
+SyncSetupWizard::State GetStepForNonFatalError(ProfileSyncService* service) {
+  if (service->IsPassphraseRequired() && service->IsUsingSecondaryPassphrase())
+      return SyncSetupWizard::ENTER_PASSPHRASE;
+
+  const GoogleServiceAuthError& error = service->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)
+    return SyncSetupWizard::GAIA_LOGIN;
+
+  NOTREACHED();
+  return SyncSetupWizard::FATAL_ERROR;
+}
+
 }  // namespace
 
 SyncConfiguration::SyncConfiguration()
     : sync_everything(false),
       use_secondary_passphrase(false) {
 }
 
 SyncConfiguration::~SyncConfiguration() {}
 
 SyncSetupFlow::~SyncSetupFlow() {
   flow_handler_->SetFlow(NULL);
 }
 
 // static
 SyncSetupFlow* SyncSetupFlow::Run(ProfileSyncService* service,
                                   SyncSetupFlowContainer* container,
                                   SyncSetupWizard::State start,
                                   SyncSetupWizard::State end) {
+  if (start == SyncSetupWizard::NONFATAL_ERROR)
+    start = GetStepForNonFatalError(service);
+
   DictionaryValue args;
   if (start == SyncSetupWizard::GAIA_LOGIN)
     SyncSetupFlow::GetArgsForGaiaLogin(service, &args);
   else if (start == SyncSetupWizard::CONFIGURE)
     SyncSetupFlow::GetArgsForConfigure(service, &args);
   else if (start == SyncSetupWizard::ENTER_PASSPHRASE)
-    SyncSetupFlow::GetArgsForEnterPassphrase(false, false, &args);
+    GetArgsForEnterPassphrase(false, false, &args);
 
   std::string json_args;
   base::JSONWriter::Write(&args, false, &json_args);
 
   return new SyncSetupFlow(start, end, json_args, container, service);
 }
 
 // static
 void SyncSetupFlow::GetArgsForGaiaLogin(const ProfileSyncService* service,
                                         DictionaryValue* args) {
@@ skipping 66 matching lines @@
   syncable::ModelTypeSet encrypted_types;
   service->GetEncryptedDataTypes(&encrypted_types);
   bool encrypt_all =
       encrypted_types.upper_bound(syncable::PASSWORDS) != encrypted_types.end();
   args->SetBoolean("encryptAllData", encrypt_all);
 
   // Load the parameters for the encryption tab.
   args->SetBoolean("usePassphrase", service->IsUsingSecondaryPassphrase());
 }
 
-// static
-void SyncSetupFlow::GetArgsForEnterPassphrase(
-    bool tried_creating_explicit_passphrase,
-    bool tried_setting_explicit_passphrase,
-    DictionaryValue* args) {
-  args->SetBoolean("show_passphrase", true);
-  args->SetBoolean("passphrase_creation_rejected",
-                   tried_creating_explicit_passphrase);
-  args->SetBoolean("passphrase_setting_rejected",
-                   tried_setting_explicit_passphrase);
-}
-
 void SyncSetupFlow::AttachSyncSetupHandler(SyncSetupFlowHandler* handler) {
   flow_handler_ = handler;
   ActivateState(current_state_);
 }
 
 void SyncSetupFlow::Advance(SyncSetupWizard::State advance_state) {
   if (!ShouldAdvance(advance_state)) {
     LOG(WARNING) << "Invalid state change from "
                  << current_state_ << " to " << advance_state;
     return;
@@ skipping 132 matching lines @@
              current_state_ == SyncSetupWizard::CONFIGURE ||
              current_state_ == SyncSetupWizard::SETTING_UP;
     case SyncSetupWizard::SETUP_ABORTED_BY_PENDING_CLEAR:
       DCHECK(current_state_ != SyncSetupWizard::GAIA_LOGIN &&
              current_state_ != SyncSetupWizard::GAIA_SUCCESS);
       return true;
     case SyncSetupWizard::SETTING_UP:
       return current_state_ == SyncSetupWizard::SYNC_EVERYTHING ||
              current_state_ == SyncSetupWizard::CONFIGURE ||
              current_state_ == SyncSetupWizard::ENTER_PASSPHRASE;
+    case SyncSetupWizard::NONFATAL_ERROR:
     case SyncSetupWizard::FATAL_ERROR:
       return true;  // You can always hit the panic button.
     case SyncSetupWizard::DONE:
       return current_state_ == SyncSetupWizard::SETTING_UP ||
              current_state_ == SyncSetupWizard::ENTER_PASSPHRASE;
     default:
       NOTREACHED() << "Unhandled State: " << state;
       return false;
   }
 }
 
 void SyncSetupFlow::ActivateState(SyncSetupWizard::State state) {
+  if (state == SyncSetupWizard::NONFATAL_ERROR)
+    state = GetStepForNonFatalError(service_);
+
   switch (state) {
     case SyncSetupWizard::GAIA_LOGIN: {
       DictionaryValue args;
       SyncSetupFlow::GetArgsForGaiaLogin(service_, &args);
       flow_handler_->ShowGaiaLogin(args);
       break;
     }
     case SyncSetupWizard::GAIA_SUCCESS:
       if (end_state_ == SyncSetupWizard::GAIA_SUCCESS) {
         flow_handler_->ShowGaiaSuccessAndClose();
@@ skipping 10 matching lines @@
     }
     case SyncSetupWizard::CONFIGURE: {
       DictionaryValue args;
       SyncSetupFlow::GetArgsForConfigure(service_, &args);
       flow_handler_->ShowConfigure(args);
       break;
     }
     case SyncSetupWizard::ENTER_PASSPHRASE: {
       DictionaryValue args;
       SyncSetupFlow::GetArgsForConfigure(service_, &args);
-      SyncSetupFlow::GetArgsForEnterPassphrase(
-          tried_creating_explicit_passphrase_,
-          tried_setting_explicit_passphrase_,
-          &args);
+      GetArgsForEnterPassphrase(tried_creating_explicit_passphrase_,
+                                tried_setting_explicit_passphrase_,
+                                &args);
       flow_handler_->ShowPassphraseEntry(args);
       break;
     }
     case SyncSetupWizard::SETUP_ABORTED_BY_PENDING_CLEAR: {
       DictionaryValue args;
       SyncSetupFlow::GetArgsForConfigure(service_, &args);
       args.SetBoolean("was_aborted", true);
       flow_handler_->ShowConfigure(args);
       break;
     }
@@ skipping 12 matching lines @@
     }
     case SyncSetupWizard::DONE:
       flow_handler_->ShowSetupDone(
           UTF16ToWide(service_->GetAuthenticatedUsername()));
       break;
     default:
       NOTREACHED() << "Invalid advance state: " << state;
   }
   current_state_ = state;
 }