Make ProfileSyncService's WeakPtrFactory the last member

chrome/browser/sync/profile_sync_service.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/sync/profile_sync_service.h"
 
 #include <cstddef>
 #include <map>
 #include <vector>
 
@@ skipping 213 matching lines @@
       signin_(signin_wrapper.Pass()),
       unrecoverable_error_reason_(ERROR_REASON_UNSET),
       expect_sync_configuration_aborted_(false),
       encrypted_types_(syncer::SyncEncryptionHandler::SensitiveTypes()),
       encrypt_everything_allowed_(true),
       encrypt_everything_(false),
       encryption_pending_(false),
       configure_status_(DataTypeManager::UNKNOWN),
       oauth2_token_service_(oauth2_token_service),
       request_access_token_backoff_(&kRequestAccessTokenBackoffPolicy),
-      weak_factory_(this),
-      startup_controller_weak_factory_(this),
       connection_status_(syncer::CONNECTION_NOT_ATTEMPTED),
       last_get_token_error_(GoogleServiceAuthError::AuthErrorNone()),
       network_resources_(new syncer::HttpBridgeNetworkResources),
-      startup_controller_(
-          start_behavior,
-          oauth2_token_service,
-          &sync_prefs_,
-          signin_.get(),
-          base::Bind(&ProfileSyncService::StartUpSlowBackendComponents,
-                     startup_controller_weak_factory_.GetWeakPtr(),
-                     SYNC)),
-      backup_rollback_controller_(
-          &sync_prefs_,
-          signin_.get(),
-          base::Bind(&ProfileSyncService::StartUpSlowBackendComponents,
-                     startup_controller_weak_factory_.GetWeakPtr(),
-                     BACKUP),
-          base::Bind(&ProfileSyncService::StartUpSlowBackendComponents,
-                     startup_controller_weak_factory_.GetWeakPtr(),
-                     ROLLBACK)),
       backend_mode_(IDLE),
       need_backup_(false),
       backup_finished_(false),
       clear_browsing_data_(base::Bind(&ClearBrowsingData)),
-      browsing_data_remover_observer_(NULL) {
+      browsing_data_remover_observer_(NULL),
+      weak_factory_(this),
+      startup_controller_weak_factory_(this) {
   DCHECK(profile);
+  startup_controller_.reset(new browser_sync::StartupController(
+      start_behavior,
+      oauth2_token_service,
+      &sync_prefs_,
+      signin_.get(),
+      base::Bind(&ProfileSyncService::StartUpSlowBackendComponents,
+                 startup_controller_weak_factory_.GetWeakPtr(),
+                 SYNC)));
+  backup_rollback_controller_.reset(new browser_sync::BackupRollbackController(
+      &sync_prefs_,
+      signin_.get(),
+      base::Bind(&ProfileSyncService::StartUpSlowBackendComponents,
+                 startup_controller_weak_factory_.GetWeakPtr(),
+                 BACKUP),
+      base::Bind(&ProfileSyncService::StartUpSlowBackendComponents,
+                 startup_controller_weak_factory_.GetWeakPtr(),
+                 ROLLBACK)));
   syncer::SyncableService::StartSyncFlare flare(
       sync_start_util::GetFlareForSyncableService(profile->GetPath()));
   scoped_ptr<browser_sync::LocalSessionEventRouter> router(
       new NotificationServiceSessionsRouter(profile, flare));
 
   DCHECK(factory_.get());
   local_device_ = factory_->CreateLocalDeviceInfoProvider();
   sessions_sync_manager_.reset(
       new SessionsSyncManager(profile, local_device_.get(), router.Pass()));
   device_info_sync_service_.reset(
@@ skipping 62 matching lines @@
 #endif
 
   bool running_rollback = false;
   if (browser_sync::BackupRollbackController::IsBackupEnabled()) {
     // Backup is needed if user's not signed in or signed in but previous
     // backup didn't finish, i.e. backend didn't switch from backup to sync.
     need_backup_ = signin_->GetEffectiveUsername().empty() ||
         sync_prefs_.GetFirstSyncTime().is_null();
 
     // Try to resume rollback if it didn't finish in last session.
-    running_rollback = backup_rollback_controller_.StartRollback();
+    running_rollback = backup_rollback_controller_->StartRollback();
   } else {
     need_backup_ = false;
   }
 
 #if defined(ENABLE_PRE_SYNC_BACKUP)
   if (!running_rollback && signin_->GetEffectiveUsername().empty()) {
     CleanUpBackup();
   }
 #else
   DCHECK(!running_rollback);
 #endif
 
-  startup_controller_.Reset(GetRegisteredDataTypes());
-  startup_controller_.TryStart();
+  startup_controller_->Reset(GetRegisteredDataTypes());
+  startup_controller_->TryStart();
 }
 
 void ProfileSyncService::TrySyncDatatypePrefRecovery() {
   DCHECK(!backend_initialized());
   if (!HasSyncSetupCompleted())
     return;
 
   // There was a bug where OnUserChoseDatatypes was not properly called on
   // configuration (see crbug.com/154940). We detect this by checking whether
   // kSyncKeepEverythingSynced has a default value. If so, and sync setup has
@@ skipping 227 matching lines @@
   }
 
   if (!GetPreferredDataTypes().Has(type)) {
     // We can get here as datatype SyncableServices are typically wired up
     // to the native datatype even if sync isn't enabled.
     DVLOG(1) << "Dropping sync startup request because type "
              << syncer::ModelTypeToString(type) << "not enabled.";
     return;
   }
 
-  startup_controller_.OnDataTypeRequestsSyncStartup(type);
+  startup_controller_->OnDataTypeRequestsSyncStartup(type);
 }
 
 void ProfileSyncService::StartUpSlowBackendComponents(
     ProfileSyncService::BackendMode mode) {
   DCHECK_NE(IDLE, mode);
   if (backend_mode_ == mode) {
     return;
   }
 
   // Backend mode transition rules:
@@ skipping 12 matching lines @@
   }
 
   if (backend_mode_ == ROLLBACK ||
       (backend_mode_ == BACKUP && !backup_finished_)) {
     // Wait for rollback/backup to finish before start new backend.
     return;
   }
 
   if (mode == SYNC && NeedBackup() && !backup_finished_) {
     if (backend_mode_ != BACKUP)
-      backup_rollback_controller_.StartBackup();
+      backup_rollback_controller_->StartBackup();
     return;
   }
 
   DVLOG(1) << "Start backend mode: " << mode;
 
   if (backend_) {
     if (mode == SYNC)
       ShutdownImpl(syncer::SWITCH_MODE_SYNC);
     else
       ShutdownImpl(syncer::STOP_SYNC);
@@ skipping 59 matching lines @@
   if (sync_prefs_.SyncHasAuthError()) {
     sync_prefs_.SetSyncAuthError(false);
     UMA_HISTOGRAM_ENUMERATION("Sync.SyncAuthError",
                               AUTH_ERROR_FIXED,
                               AUTH_ERROR_LIMIT);
   }
 
   if (HasSyncingBackend())
     backend_->UpdateCredentials(GetCredentials());
   else
-    startup_controller_.TryStart();
+    startup_controller_->TryStart();
 }
 
 void ProfileSyncService::OnGetTokenFailure(
     const OAuth2TokenService::Request* request,
     const GoogleServiceAuthError& error) {
   DCHECK_EQ(access_token_request_, request);
   DCHECK_NE(error.state(), GoogleServiceAuthError::NONE);
   access_token_request_.reset();
   last_get_token_error_ = error;
   switch (error.state()) {
@@ skipping 55 matching lines @@
 
 void ProfileSyncService::OnRefreshTokensLoaded() {
   // This notification gets fired when OAuth2TokenService loads the tokens
   // from storage.
   // Initialize the backend if sync is enabled. If the sync token was
   // not loaded, GetCredentials() will generate invalid credentials to
   // cause the backend to generate an auth error (crbug.com/121755).
   if (HasSyncingBackend()) {
     RequestAccessToken();
   } else {
-    startup_controller_.TryStart();
+    startup_controller_->TryStart();
   }
 }
 
 void ProfileSyncService::Shutdown() {
   UnregisterAuthNotifications();
 
   ShutdownImpl(syncer::BROWSER_SHUTDOWN);
   if (sync_error_controller_) {
     // Destroy the SyncErrorController when the service shuts down for good.
     RemoveObserver(sync_error_controller_.get());
@@ skipping 48 matching lines @@
   if (doomed_backend) {
     sync_thread_ = doomed_backend->Shutdown(reason);
     doomed_backend.reset();
   }
   base::TimeDelta shutdown_time = base::Time::Now() - shutdown_start_time;
   UMA_HISTOGRAM_TIMES("Sync.Shutdown.BackendDestroyedTime", shutdown_time);
 
   weak_factory_.InvalidateWeakPtrs();
 
   if (backend_mode_ == SYNC)
-    startup_controller_.Reset(GetRegisteredDataTypes());
+    startup_controller_->Reset(GetRegisteredDataTypes());
 
   // Don't let backup block sync regardless backup succeeded or not.
   if (backend_mode_ == BACKUP)
     backup_finished_ = true;
 
   // Sync could be blocked by rollback/backup. Post task to check whether sync
   // should start after shutting down rollback/backup backend.
   if ((backend_mode_ == ROLLBACK || backend_mode_ == BACKUP) &&
       reason != syncer::SWITCH_MODE_SYNC &&
       reason != syncer::BROWSER_SHUTDOWN) {
@@ skipping 120 matching lines @@
   is_first_time_sync_configure_ = !HasSyncSetupCompleted();
 
   if (is_first_time_sync_configure_) {
     UMA_HISTOGRAM_BOOLEAN("Sync.BackendInitializeFirstTimeSuccess", success);
   } else {
     UMA_HISTOGRAM_BOOLEAN("Sync.BackendInitializeRestoreSuccess", success);
   }
 
   base::Time on_backend_initialized_time = base::Time::Now();
   base::TimeDelta delta = on_backend_initialized_time -
-      startup_controller_.start_backend_time();
+      startup_controller_->start_backend_time();
   if (is_first_time_sync_configure_) {
     UMA_HISTOGRAM_LONG_TIMES("Sync.BackendInitializeFirstTime", delta);
   } else {
     UMA_HISTOGRAM_LONG_TIMES("Sync.BackendInitializeRestoreTime", delta);
   }
 }
 
 void ProfileSyncService::PostBackendInitialization() {
   // Never get here for backup / restore.
   DCHECK_EQ(backend_mode_, SYNC);
@@ skipping 19 matching lines @@
   // case this operation affects the "passphrase required" status.
   ConsumeCachedPassphraseIfPossible();
 
   // The very first time the backend initializes is effectively the first time
   // we can say we successfully "synced".  LastSyncedTime will only be null in
   // this case, because the pref wasn't restored on StartUp.
   if (sync_prefs_.GetLastSyncedTime().is_null()) {
     UpdateLastSyncedTime();
   }
 
-  if (startup_controller_.auto_start_enabled() && !FirstSetupInProgress()) {
+  if (startup_controller_->auto_start_enabled() && !FirstSetupInProgress()) {
     // Backend is initialized but we're not in sync setup, so this must be an
     // autostart - mark our sync setup as completed and we'll start syncing
     // below.
     SetSyncSetupCompleted();
   }
 
   // Check HasSyncSetupCompleted() before NotifyObservers() to avoid spurious
   // data type configuration because observer may flag setup as complete and
   // trigger data type configuration.
   if (HasSyncSetupCompleted()) {
@@ skipping 337 matching lines @@
   DCHECK_NE(last_actionable_error_.action,
             syncer::UNKNOWN_ACTION);
   switch (error.action) {
     case syncer::UPGRADE_CLIENT:
     case syncer::CLEAR_USER_DATA_AND_RESYNC:
     case syncer::ENABLE_SYNC_ON_ACCOUNT:
     case syncer::STOP_AND_RESTART_SYNC:
       // TODO(lipalani) : if setup in progress we want to display these
       // actions in the popup. The current experience might not be optimal for
       // the user. We just dismiss the dialog.
-      if (startup_controller_.setup_in_progress()) {
+      if (startup_controller_->setup_in_progress()) {
         StopSyncingPermanently();
         expect_sync_configuration_aborted_ = true;
       }
       // Trigger an unrecoverable error to stop syncing.
       OnInternalUnrecoverableError(FROM_HERE,
                                    last_actionable_error_.error_description,
                                    true,
                                    ERROR_REASON_ACTIONABLE_ERROR);
       break;
     case syncer::DISABLE_SYNC_AND_ROLLBACK:
-      backup_rollback_controller_.OnRollbackReceived();
+      backup_rollback_controller_->OnRollbackReceived();
       // Fall through to shutdown backend and sign user out.
     case syncer::DISABLE_SYNC_ON_CLIENT:
       StopSyncingPermanently();
 #if !defined(OS_CHROMEOS)
       // On desktop Chrome, sign out the user after a dashboard clear.
       // Skip sign out on ChromeOS/Android.
-      if (!startup_controller_.auto_start_enabled()) {
+      if (!startup_controller_->auto_start_enabled()) {
         SigninManagerFactory::GetForProfile(profile_)->SignOut(
             signin_metrics::SERVER_FORCED_DISABLE);
       }
 #endif
       break;
     case syncer::ROLLBACK_DONE:
-      backup_rollback_controller_.OnRollbackDone();
+      backup_rollback_controller_->OnRollbackDone();
       break;
     case syncer::STOP_SYNC_FOR_DISABLED_ACCOUNT:
       // Sync disabled by domain admin. we should stop syncing until next
       // restart.
       sync_disabled_by_admin_ = true;
       ShutdownImpl(syncer::DISABLE_SYNC);
       break;
     default:
       NOTREACHED();
   }
   NotifyObservers();
 
   if (error.action == syncer::DISABLE_SYNC_ON_CLIENT ||
       (error.action == syncer::DISABLE_SYNC_AND_ROLLBACK &&
-          !backup_rollback_controller_.StartRollback())) {
+          !backup_rollback_controller_->StartRollback())) {
     // Clean up backup data for sign-out only or when rollback is disabled.
     CleanUpBackup();
   } else if (error.action == syncer::ROLLBACK_DONE) {
     // Shut down ROLLBACK backend and delete backup DB.
     ShutdownImpl(syncer::DISABLE_SYNC);
     sync_prefs_.ClearFirstSyncTime();
   }
 }
 
 void ProfileSyncService::OnConfigureDone(
@@ skipping 154 matching lines @@
     case BACKUP_USER_DATA:
       return "Backing-up user data. Status: " + config_status_str;
     case ROLLBACK_USER_DATA:
       return "Restoring user data. Status: " + config_status_str;
     default:
       return "Status unknown: Internal error?";
   }
 }
 
 std::string ProfileSyncService::GetBackendInitializationStateString() const {
-  return startup_controller_.GetBackendInitializationStateString();
+  return startup_controller_->GetBackendInitializationStateString();
 }
 
 bool ProfileSyncService::auto_start_enabled() const {
-  return startup_controller_.auto_start_enabled();
+  return startup_controller_->auto_start_enabled();
 }
 
 bool ProfileSyncService::setup_in_progress() const {
-  return startup_controller_.setup_in_progress();
+  return startup_controller_->setup_in_progress();
 }
 
 bool ProfileSyncService::QueryDetailedSyncStatus(
     SyncBackendHost::Status* result) {
   if (backend_.get() && backend_initialized_) {
     *result = backend_->GetDetailedStatus();
     return true;
   } else {
     SyncBackendHost::Status status;
     status.sync_protocol_error = last_actionable_error_;
     *result = status;
     return false;
   }
 }
 
 const AuthError& ProfileSyncService::GetAuthError() const {
   return last_auth_error_;
 }
 
 bool ProfileSyncService::FirstSetupInProgress() const {
-  return !HasSyncSetupCompleted() && startup_controller_.setup_in_progress();
+  return !HasSyncSetupCompleted() && startup_controller_->setup_in_progress();
 }
 
 void ProfileSyncService::SetSetupInProgress(bool setup_in_progress) {
   // This method is a no-op if |setup_in_progress_| remains unchanged.
-  if (startup_controller_.setup_in_progress() == setup_in_progress)
+  if (startup_controller_->setup_in_progress() == setup_in_progress)
     return;
 
-  startup_controller_.set_setup_in_progress(setup_in_progress);
+  startup_controller_->set_setup_in_progress(setup_in_progress);
   if (!setup_in_progress && backend_initialized())
     ReconfigureDatatypeManager();
   NotifyObservers();
 }
 
 bool ProfileSyncService::SyncActive() const {
   return backend_initialized_ && backend_mode_ == SYNC &&
          directory_data_type_manager_ &&
          directory_data_type_manager_->state() != DataTypeManager::STOPPED;
 }
@@ skipping 246 matching lines @@
     directory_data_type_manager_->Configure(priority_types, reason);
   }
 }
 
 void ProfileSyncService::ConfigureDataTypeManager() {
   // Don't configure datatypes if the setup UI is still on the screen - this
   // is to help multi-screen setting UIs (like iOS) where they don't want to
   // start syncing data until the user is done configuring encryption options,
   // etc. ReconfigureDatatypeManager() will get called again once the UI calls
   // SetSetupInProgress(false).
-  if (backend_mode_ == SYNC && startup_controller_.setup_in_progress())
+  if (backend_mode_ == SYNC && startup_controller_->setup_in_progress())
     return;
 
   bool restart = false;
   if (!directory_data_type_manager_) {
     restart = true;
     directory_data_type_manager_.reset(
         factory_->CreateDataTypeManager(debug_info_listener_,
                                         &directory_data_type_controllers_,
                                         this,
                                         backend_.get(),
@@ skipping 300 matching lines @@
   // We may be called during the setup process before we're
   // initialized.  In this case, we default to the sensitive types.
   return encrypted_types_;
 }
 
 void ProfileSyncService::OnSyncManagedPrefChange(bool is_sync_managed) {
   if (is_sync_managed) {
     DisableForUser();
   } else {
     // Sync is no longer disabled by policy. Try starting it up if appropriate.
-    startup_controller_.TryStart();
+    startup_controller_->TryStart();
   }
 }
 
 void ProfileSyncService::GoogleSigninSucceeded(const std::string& account_id,
                                                const std::string& username,
                                                const std::string& password) {
   if (!sync_prefs_.IsStartSuppressed() && !password.empty()) {
     cached_passphrase_ = password;
     // Try to consume the passphrase we just cached. If the sync backend
     // is not running yet, the passphrase will remain cached until the
@@ skipping 221 matching lines @@
 SigninManagerBase* ProfileSyncService::signin() const {
   if (!signin_)
     return NULL;
   return signin_->GetOriginal();
 }
 
 void ProfileSyncService::UnsuppressAndStart() {
   DCHECK(profile_);
   sync_prefs_.SetStartSuppressed(false);
   DCHECK(!signin_.get() || signin_->GetOriginal()->IsAuthenticated());
-  startup_controller_.TryStart();
+  startup_controller_->TryStart();
 }
 
 void ProfileSyncService::AcknowledgeSyncedTypes() {
   sync_prefs_.AcknowledgeSyncedTypes(GetRegisteredDataTypes());
 }
 
 void ProfileSyncService::ReconfigureDatatypeManager() {
   // If we haven't initialized yet, don't configure the DTM as it could cause
   // association to start before a Directory has even been created.
   if (backend_initialized_) {
@@ skipping 202 matching lines @@
 }
 
 void ProfileSyncService::CheckSyncBackupCallback(base::Time backup_time) {
   last_backup_time_.reset(new base::Time(backup_time));
 
   DCHECK(device_info_sync_service_);
   device_info_sync_service_->UpdateLocalDeviceBackupTime(*last_backup_time_);
 }
 
 void ProfileSyncService::TryStartSyncAfterBackup() {
-  startup_controller_.Reset(GetRegisteredDataTypes());
-  startup_controller_.TryStart();
+  startup_controller_->Reset(GetRegisteredDataTypes());
+  startup_controller_->TryStart();
 }
 
 void ProfileSyncService::CleanUpBackup() {
   sync_prefs_.ClearFirstSyncTime();
   profile_->GetIOTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(base::IgnoreResult(base::DeleteFile),
                  profile_->GetPath().Append(kSyncBackupDataFolderName),
                  true));
 }
@@ skipping 19 matching lines @@
 
 base::MessageLoop* ProfileSyncService::GetSyncLoopForTest() const {
   if (sync_thread_) {
     return sync_thread_->message_loop();
   } else if (backend_) {
     return backend_->GetSyncLoopForTesting();
   } else {
     return NULL;
   }
 }