Wire sync shutdown reason from PSS all the way down to sync manager.

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 <set>
 #include <utility>
@@ skipping 71 matching lines @@
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "grit/generated_resources.h"
 #include "net/cookies/cookie_monster.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "sync/api/sync_error.h"
 #include "sync/internal_api/public/configure_reason.h"
 #include "sync/internal_api/public/http_bridge_network_resources.h"
 #include "sync/internal_api/public/network_resources.h"
 #include "sync/internal_api/public/sessions/type_debug_info_observer.h"
+#include "sync/internal_api/public/shutdown_reason.h"
 #include "sync/internal_api/public/sync_context_proxy.h"
 #include "sync/internal_api/public/sync_encryption_handler.h"
 #include "sync/internal_api/public/util/experiments.h"
 #include "sync/internal_api/public/util/sync_db_util.h"
 #include "sync/internal_api/public/util/sync_string_conversions.h"
 #include "sync/js/js_event_details.h"
 #include "sync/util/cryptographer.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/l10n/time_format.h"
 
@@ skipping 536 matching lines @@
 
 void ProfileSyncService::StartUpSlowBackendComponents(
     ProfileSyncService::BackendMode mode) {
   DCHECK_NE(IDLE, mode);
   if (backend_mode_ == mode) {
     return;
   }
 
   DVLOG(1) << "Start backend mode: " << mode;
 
-  if (backend_)
-    ShutdownImpl(browser_sync::SyncBackendHost::STOP_AND_CLAIM_THREAD);
+  if (backend_) {
+    if (mode == SYNC)
+      ShutdownImpl(syncer::SWITCH_MODE_SYNC);
+    else
+      ShutdownImpl(syncer::STOP_SYNC);
+  }
 
   backend_mode_ = mode;
 
   if (backend_mode_ == ROLLBACK)
     ClearBrowsingDataSinceFirstSync();
   else if (backend_mode_ == SYNC)
     CheckSyncBackupIfNeeded();
 
   base::FilePath sync_folder = backend_mode_ == SYNC ?
       base::FilePath(kSyncDataFolderName) :
@@ skipping 116 matching lines @@
   if (HasSyncingBackend()) {
     RequestAccessToken();
   } else {
     startup_controller_.TryStart();
   }
 }
 
 void ProfileSyncService::Shutdown() {
   UnregisterAuthNotifications();
 
-  ShutdownImpl(browser_sync::SyncBackendHost::STOP);
+  ShutdownImpl(syncer::BROWSER_SHUTDOWN);
   if (sync_error_controller_) {
     // Destroy the SyncErrorController when the service shuts down for good.
     RemoveObserver(sync_error_controller_.get());
     sync_error_controller_.reset();
   }
 
   if (sync_thread_)
     sync_thread_->Stop();
 }
 
-void ProfileSyncService::ShutdownImpl(
-    browser_sync::SyncBackendHost::ShutdownOption option) {
+void ProfileSyncService::ShutdownImpl(syncer::ShutdownReason reason) {
   if (!backend_)
     return;
 
   non_blocking_data_type_manager_.DisconnectSyncBackend();
 
   // First, we spin down the backend to stop change processing as soon as
   // possible.
   base::Time shutdown_start_time = base::Time::Now();
   backend_->StopSyncingForShutdown();
 
@@ skipping 14 matching lines @@
 
   // Shutdown the migrator before the backend to ensure it doesn't pull a null
   // snapshot.
   migrator_.reset();
   sync_js_controller_.AttachJsBackend(WeakHandle<syncer::JsBackend>());
 
   // Move aside the backend so nobody else tries to use it while we are
   // shutting it down.
   scoped_ptr<SyncBackendHost> doomed_backend(backend_.release());
   if (doomed_backend) {
-    sync_thread_ = doomed_backend->Shutdown(option);
+    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());
 
@@ skipping 14 matching lines @@
     UpdateAuthErrorState(GoogleServiceAuthError::AuthErrorNone());
 
   NotifyObservers();
 }
 
 void ProfileSyncService::DisableForUser() {
   // Clear prefs (including SyncSetupHasCompleted) before shutting down so
   // PSS clients don't think we're set up while we're shutting down.
   sync_prefs_.ClearPreferences();
   ClearUnrecoverableError();
-  ShutdownImpl(browser_sync::SyncBackendHost::DISABLE_AND_CLAIM_THREAD);
+  ShutdownImpl(syncer::DISABLE_SYNC);
 }
 
 bool ProfileSyncService::HasSyncSetupCompleted() const {
   return sync_prefs_.HasSyncSetupCompleted();
 }
 
 void ProfileSyncService::SetSyncSetupCompleted() {
   sync_prefs_.SetSyncSetupCompleted();
 }
 
@@ skipping 58 matching lines @@
   from_here.Write(true, true, &location);
   LOG(ERROR)
       << "Unrecoverable error detected at " << location
       << " -- ProfileSyncService unusable: " << message;
 
   // Shut all data types down.
   base::MessageLoop::current()->PostTask(FROM_HERE,
       base::Bind(&ProfileSyncService::ShutdownImpl,
                  weak_factory_.GetWeakPtr(),
                  delete_sync_database ?
-                     browser_sync::SyncBackendHost::DISABLE_AND_CLAIM_THREAD :
-                     browser_sync::SyncBackendHost::STOP_AND_CLAIM_THREAD));
+                     syncer::DISABLE_SYNC : syncer::STOP_SYNC));
 }
 
 // TODO(zea): Move this logic into the DataTypeController/DataTypeManager.
 void ProfileSyncService::DisableDatatype(const syncer::SyncError& error) {
   // First deactivate the type so that no further server changes are
   // passed onto the change processor.
   DeactivateDataType(error.model_type());
 
   std::map<syncer::ModelType, syncer::SyncError> errors;
   errors[error.model_type()] = error;
@@ skipping 482 matching lines @@
       }
 #endif
       break;
     case syncer::ROLLBACK_DONE:
       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(browser_sync::SyncBackendHost::DISABLE_AND_CLAIM_THREAD);
+      ShutdownImpl(syncer::DISABLE_SYNC);
       break;
     default:
       NOTREACHED();
   }
   NotifyObservers();
 
   backup_rollback_controller_.Start(base::TimeDelta());
 }
 
 void ProfileSyncService::OnConfigureDone(
     const DataTypeManager::ConfigureResult& result) {
   // We should have cleared our cached passphrase before we get here (in
   // OnBackendInitialized()).
   DCHECK(cached_passphrase_.empty());
 
   configure_status_ = result.status;
 
   if (backend_mode_ != SYNC) {
     if (configure_status_ == DataTypeManager::OK ||
         configure_status_ == DataTypeManager::PARTIAL_SUCCESS) {
       StartSyncingWithServer();
     } else if (!expect_sync_configuration_aborted_) {
       DVLOG(1) << "Backup/rollback backend failed to configure.";
-      ShutdownImpl(browser_sync::SyncBackendHost::STOP_AND_CLAIM_THREAD);
+      ShutdownImpl(syncer::STOP_SYNC);
     }
 
     return;
   }
 
   if (!sync_configure_start_time_.is_null()) {
     if (result.status == DataTypeManager::OK ||
         result.status == DataTypeManager::PARTIAL_SUCCESS) {
       base::Time sync_configure_stop_time = base::Time::Now();
       base::TimeDelta delta = sync_configure_stop_time -
@@ skipping 940 matching lines @@
     return false;
 
   return directory_data_type_manager_->state() == DataTypeManager::CONFIGURED;
 }
 
 void ProfileSyncService::StopAndSuppress() {
   sync_prefs_.SetStartSuppressed(true);
   if (HasSyncingBackend()) {
     backend_->UnregisterInvalidationIds();
   }
-  ShutdownImpl(browser_sync::SyncBackendHost::STOP_AND_CLAIM_THREAD);
+  ShutdownImpl(syncer::STOP_SYNC);
 }
 
 bool ProfileSyncService::IsStartSuppressed() const {
   return sync_prefs_.IsStartSuppressed();
 }
 
 SigninManagerBase* ProfileSyncService::signin() const {
   if (!signin_)
     return NULL;
   return signin_->GetOriginal();
@@ skipping 162 matching lines @@
         LOG(WARNING) << "The following sync URL specified at the command-line "
                      << "is invalid: " << value;
       }
     }
   }
   return result;
 }
 
 void ProfileSyncService::StartStopBackupForTesting() {
   if (backend_mode_ == BACKUP)
-    ShutdownImpl(browser_sync::SyncBackendHost::STOP_AND_CLAIM_THREAD);
+    ShutdownImpl(syncer::STOP_SYNC);
   else
     backup_rollback_controller_.Start(base::TimeDelta());
 }
 
 void ProfileSyncService::CheckSyncBackupIfNeeded() {
   DCHECK_EQ(backend_mode_, SYNC);
 
 #if defined(ENABLE_PRE_SYNC_BACKUP)
   // Check backup once a day.
   if (!last_backup_time_ &&
@@ skipping 30 matching lines @@
     browser_sync::SyncedDeviceTracker* device_tracker =
         backend_->GetSyncedDeviceTracker();
     if (device_tracker)
       device_tracker->UpdateLocalDeviceBackupTime(*last_backup_time_);
   }
 }
 
 base::Time ProfileSyncService::GetDeviceBackupTimeForTesting() const {
   return backend_->GetSyncedDeviceTracker()->GetLocalDeviceBackupTime();
 }