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

sync/internal_api/test/test_internal_components_factory.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 "sync/internal_api/public/test/test_internal_components_factory.h"
 
 #include "sync/sessions/sync_session_context.h"
+#include "sync/syncable/deferred_on_disk_directory_backing_store.h"
 #include "sync/syncable/in_memory_directory_backing_store.h"
 #include "sync/syncable/on_disk_directory_backing_store.h"
 #include "sync/syncable/invalid_directory_backing_store.h"
 #include "sync/test/engine/fake_sync_scheduler.h"
 
 namespace syncer {
 
 TestInternalComponentsFactory::TestInternalComponentsFactory(
     const Switches& switches,
-    StorageOption option)
+    StorageOption option,
+    StorageOption expected_storage)
     : switches_(switches),
-      storage_option_(option) {
+      storage_override_(option),
+      expected_storage_(expected_storage) {
 }
 
 TestInternalComponentsFactory::~TestInternalComponentsFactory() { }
 
 scoped_ptr<SyncScheduler> TestInternalComponentsFactory::BuildScheduler(
     const std::string& name,
     sessions::SyncSessionContext* context,
     syncer::CancelationSignal* cancelation_signal) {
   return scoped_ptr<SyncScheduler>(new FakeSyncScheduler());
 }
@@ skipping 17 matching lines @@
           model_type_registry,
           switches_.encryption_method == ENCRYPTION_KEYSTORE,
           switches_.pre_commit_updates_policy ==
               FORCE_ENABLE_PRE_COMMIT_UPDATE_AVOIDANCE,
           invalidator_client_id));
 
 }
 
 scoped_ptr<syncable::DirectoryBackingStore>
 TestInternalComponentsFactory::BuildDirectoryBackingStore(
-      const std::string& dir_name, const base::FilePath& backing_filepath) {
-  switch (storage_option_) {
+    StorageOption storage, const std::string& dir_name,
+    const base::FilePath& backing_filepath) {
+  CHECK_EQ(expected_storage_, storage);

[Nicolas Zea, 2014/08/13 20:32:05]

I prefer keeping the verification of expectations in the test itself, and just
exposing the storage that was used. Having this here starts changing what it is
the factory is trying to do.

[haitaol1, 2014/08/14 01:30:34]

Done.

+
+  switch (storage_override_) {
     case STORAGE_IN_MEMORY:
       return scoped_ptr<syncable::DirectoryBackingStore>(
           new syncable::InMemoryDirectoryBackingStore(dir_name));
     case STORAGE_ON_DISK:
       return scoped_ptr<syncable::DirectoryBackingStore>(
           new syncable::OnDiskDirectoryBackingStore(dir_name,
                                                     backing_filepath));
+    case STORAGE_ON_DISK_DEFERRED:
+      return scoped_ptr<syncable::DirectoryBackingStore>(
+          new syncable::DeferredOnDiskDirectoryBackingStore(dir_name,
+                                                            backing_filepath));
     case STORAGE_INVALID:
       return scoped_ptr<syncable::DirectoryBackingStore>(
           new syncable::InvalidDirectoryBackingStore());
   }
   NOTREACHED();
   return scoped_ptr<syncable::DirectoryBackingStore>();
 }
 
 InternalComponentsFactory::Switches
 TestInternalComponentsFactory::GetSwitches() const {
   return switches_;
 }
 
 }  // namespace syncer