Let SyncBackupManager keep backup data in memory until shutdown. Only persist

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 84 matching lines @@
     ReadNode type_root(&trans);
     EXPECT_EQ(BaseNode::INIT_OK, type_root.InitTypeRoot(type));
 
     WriteNode node(&trans);
     EXPECT_EQ(WriteNode::INIT_SUCCESS,
               node.InitUniqueByCreation(type, type_root, client_tag));
     return node.GetEntry()->GetMetahandle();
   }
 
   void InitManager(SyncManager* manager, ModelTypeSet types,
-                   TestChangeDelegate* delegate, StorageOption storage_option) {
+                   TestChangeDelegate* delegate,
+                   InternalComponentsFactory::StorageOption storage_option) {
     manager_ = manager;
     types_ = types;
 
     EXPECT_CALL(*this, OnInitializationComplete(_, _, _, _))
         .WillOnce(WithArgs<2>(Invoke(this,
                                      &SyncRollbackManagerTest::HandleInit)));
 
     manager->AddObserver(this);
     TestInternalComponentsFactory factory(InternalComponentsFactory::Switches(),
-                                          storage_option);
+                                          storage_option, storage_option);
 
     base::RunLoop run_loop;
     manager->Init(
         temp_dir_.path(),
         MakeWeakHandle(base::WeakPtr<JsEventHandler>()),
         GURL("https://example.com/"),
         scoped_ptr<HttpPostProviderFactory>().Pass(),
         std::vector<scoped_refptr<ModelSafeWorker> >(1, worker_.get()),
         NULL,
         delegate,
         SyncCredentials(),
         "",
         "",
         "",
         &factory,
         NULL,
         scoped_ptr<UnrecoverableErrorHandler>().Pass(),
         NULL,
         NULL);
     loop_.PostTask(FROM_HERE, run_loop.QuitClosure());
     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);
+                InternalComponentsFactory::STORAGE_ON_DISK_DEFERRED);
     CreateEntry(backup_manager.GetUserShare(), type, client_tag);
-    backup_manager.ShutdownOnSyncThread(STOP_SYNC);
+    backup_manager.ShutdownOnSyncThread(SWITCH_MODE_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);
   }
 
@@ skipping 30 matching lines @@
 bool IsRollbackDoneAction(SyncProtocolError e) {
   return e.action == syncer::ROLLBACK_DONE;
 }
 
 TEST_F(SyncRollbackManagerTest, RollbackBasic) {
   PrepopulateDb(PREFERENCES, "pref1");
 
   TestChangeDelegate delegate;
   SyncRollbackManager rollback_manager;
   InitManager(&rollback_manager, ModelTypeSet(PREFERENCES), &delegate,
-              STORAGE_ON_DISK);
+              InternalComponentsFactory::STORAGE_ON_DISK);
 
   // Simulate a new entry added during type initialization.
   int64 new_pref_id =
       CreateEntry(rollback_manager.GetUserShare(), PREFERENCES, "pref2");
 
   delegate.add_expected_delete(new_pref_id);
   EXPECT_CALL(delegate, OnChangesApplied(_, _, _, _))
       .Times(1)
       .WillOnce(DoDefault());
   EXPECT_CALL(delegate, OnChangesComplete(_)).Times(1);
   EXPECT_CALL(*this, OnActionableError(Truly(IsRollbackDoneAction))).Times(1);
 
   ModelSafeRoutingInfo routing_info;
   routing_info[PREFERENCES] = GROUP_UI;
   rollback_manager.StartSyncingNormally(routing_info);
 }
 
 TEST_F(SyncRollbackManagerTest, NoRollbackOfTypesNotBackedUp) {
   PrepopulateDb(PREFERENCES, "pref1");
 
   TestChangeDelegate delegate;
   SyncRollbackManager rollback_manager;
   InitManager(&rollback_manager, ModelTypeSet(PREFERENCES, APPS), &delegate,
-              STORAGE_ON_DISK);
+              InternalComponentsFactory::STORAGE_ON_DISK);
 
   // Simulate new entry added during type initialization.
   int64 new_pref_id =
       CreateEntry(rollback_manager.GetUserShare(), PREFERENCES, "pref2");
   CreateEntry(rollback_manager.GetUserShare(), APPS, "app1");
 
   delegate.add_expected_delete(new_pref_id);
   EXPECT_CALL(delegate, OnChangesApplied(_, _, _, _))
       .Times(1)
       .WillOnce(DoDefault());
   EXPECT_CALL(delegate, OnChangesComplete(_)).Times(1);
 
   ModelSafeRoutingInfo routing_info;
   routing_info[PREFERENCES] = GROUP_UI;
   rollback_manager.StartSyncingNormally(routing_info);
 
   // APP entry is still valid.
   EXPECT_TRUE(VerifyEntry(rollback_manager.GetUserShare(), APPS, "app1"));
 }
 
 TEST_F(SyncRollbackManagerTest, BackupDbNotChangedOnAbort) {
   PrepopulateDb(PREFERENCES, "pref1");
 
   TestChangeDelegate delegate;
   scoped_ptr<SyncRollbackManager> rollback_manager(
       new SyncRollbackManager);
   InitManager(rollback_manager.get(), ModelTypeSet(PREFERENCES), &delegate,
-              STORAGE_ON_DISK);
+              InternalComponentsFactory::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(STOP_SYNC);
 
   // Verify new entry was not persisted.
   rollback_manager.reset(new SyncRollbackManager);
   InitManager(rollback_manager.get(), ModelTypeSet(PREFERENCES), &delegate,
-              STORAGE_ON_DISK);
+              InternalComponentsFactory::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);
+              InternalComponentsFactory::STORAGE_ON_DISK);
 }
 
 }  // anonymous namespace
 
 }  // namespace syncer