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

sync/internal_api/sync_rollback_manager_unittest.cc

 // Copyright 2014 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 "sync/internal_api/sync_rollback_manager.h"
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/run_loop.h"
 #include "sync/internal_api/public/read_node.h"
 #include "sync/internal_api/public/read_transaction.h"
@@ skipping 115 matching lines @@
     run_loop.Run();
   }
 
   // Create and persist an entry by unique tag in DB.
   void PrepopulateDb(ModelType type, const std::string& client_tag) {
     SyncBackupManager backup_manager;
     TestChangeDelegate delegate;
     InitManager(&backup_manager, ModelTypeSet(type), &delegate,
                 STORAGE_ON_DISK);
     CreateEntry(backup_manager.GetUserShare(), type, client_tag);
-    backup_manager.ShutdownOnSyncThread();
+    backup_manager.ShutdownOnSyncThread(STOP_SYNC);
   }
 
   // Verify entry with |client_tag| exists in sync directory.
   bool VerifyEntry(UserShare* user_share, ModelType type,
                    const std::string& client_tag) {
     ReadTransaction trans(FROM_HERE, user_share);
     ReadNode node(&trans);
     return BaseNode::INIT_OK == node.InitByClientTagLookup(type, client_tag);
   }
 
  private:
   void ConfigureSyncer() {
     manager_->ConfigureSyncer(
           CONFIGURE_REASON_NEW_CLIENT,
           types_,
           ModelTypeSet(), ModelTypeSet(), ModelTypeSet(),
           ModelSafeRoutingInfo(),
           base::Bind(&SyncRollbackManagerTest::OnConfigDone,
                      base::Unretained(this), true),
           base::Bind(&SyncRollbackManagerTest::OnConfigDone,
                      base::Unretained(this), false));
   }
 
   void HandleInit(bool success) {
     if (success) {
       loop_.PostTask(FROM_HERE,
                      base::Bind(&SyncRollbackManagerTest::ConfigureSyncer,
                                 base::Unretained(this)));
     } else {
-      manager_->ShutdownOnSyncThread();
+      manager_->ShutdownOnSyncThread(STOP_SYNC);
     }
   }
 
   base::ScopedTempDir temp_dir_;
   scoped_refptr<ModelSafeWorker> worker_;
   base::MessageLoop loop_;    // Needed for WeakHandle
   SyncManager* manager_;
   ModelTypeSet types_;
 };
 
@@ skipping 58 matching lines @@
   TestChangeDelegate delegate;
   scoped_ptr<SyncRollbackManager> rollback_manager(
       new SyncRollbackManager);
   InitManager(rollback_manager.get(), ModelTypeSet(PREFERENCES), &delegate,
               STORAGE_ON_DISK);
 
   // Simulate a new entry added during type initialization.
   CreateEntry(rollback_manager->GetUserShare(), PREFERENCES, "pref2");
 
   // Manager was shut down before sync starts.
-  rollback_manager->ShutdownOnSyncThread();
+  rollback_manager->ShutdownOnSyncThread(STOP_SYNC);
 
   // Verify new entry was not persisted.
   rollback_manager.reset(new SyncRollbackManager);
   InitManager(rollback_manager.get(), ModelTypeSet(PREFERENCES), &delegate,
               STORAGE_ON_DISK);
   EXPECT_FALSE(VerifyEntry(rollback_manager->GetUserShare(), PREFERENCES,
                            "pref2"));
 }
 
 TEST_F(SyncRollbackManagerTest, OnInitializationFailure) {
   // Test graceful shutdown on initialization failure.
   scoped_ptr<SyncRollbackManager> rollback_manager(
       new SyncRollbackManager);
   InitManager(rollback_manager.get(), ModelTypeSet(PREFERENCES), NULL,
               STORAGE_ON_DISK);
 }
 
 }  // anonymous namespace
 
 }  // namespace syncer