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

sync/internal_api/sync_rollback_manager_base.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_base.h"
 
 #include "sync/internal_api/public/base/model_type.h"
+#include "sync/internal_api/public/internal_components_factory.h"
 #include "sync/internal_api/public/read_node.h"
 #include "sync/internal_api/public/read_transaction.h"
 #include "sync/internal_api/public/write_transaction.h"
 #include "sync/syncable/directory_backing_store.h"
 #include "sync/syncable/mutable_entry.h"
 
 namespace {
 
 // Permanent bookmark folders as defined in bookmark_model_associator.cc.
 // No mobile bookmarks because they only exists with sync enabled.
@@ skipping 27 matching lines @@
       dummy_handler_(new DummyEntryptionHandler),
       initialized_(false) {
 }
 
 SyncRollbackManagerBase::~SyncRollbackManagerBase() {
 }
 
 bool SyncRollbackManagerBase::InitInternal(
     const base::FilePath& database_location,
     InternalComponentsFactory* internal_components_factory,
-    InternalComponentsFactory::StorageOption storage,
     scoped_ptr<UnrecoverableErrorHandler> unrecoverable_error_handler,
     ReportUnrecoverableErrorFunction report_unrecoverable_error_function) {
   unrecoverable_error_handler_ = unrecoverable_error_handler.Pass();
   report_unrecoverable_error_function_ = report_unrecoverable_error_function;
 
-  if (!InitBackupDB(database_location, internal_components_factory, storage)) {
+  if (!InitBackupDB(database_location, internal_components_factory)) {
     NotifyInitializationFailure();
     return false;
   }
 
   initialized_ = true;
   NotifyInitializationSuccess();
   return true;
 }
 
 ModelTypeSet SyncRollbackManagerBase::InitialSyncEndedTypes() {
@@ skipping 61 matching lines @@
 
 SyncStatus SyncRollbackManagerBase::GetDetailedStatus() const {
   return SyncStatus();
 }
 
 void SyncRollbackManagerBase::SaveChanges() {
 }
 
 void SyncRollbackManagerBase::ShutdownOnSyncThread(ShutdownReason reason) {
   if (initialized_) {
+    SaveChanges();
     share_.directory->Close();
     share_.directory.reset();
     initialized_ = false;
   }
 }
 
 UserShare* SyncRollbackManagerBase::GetUserShare() {
   return &share_;
 }
 
@@ skipping 78 matching lines @@
     syncer::ModelType type) {
   ReadTransaction trans(FROM_HERE, GetUserShare());
   scoped_ptr<base::ListValue> nodes(
       trans.GetDirectory()->GetNodeDetailsForType(trans.GetWrappedTrans(),
                                                   type));
   return nodes.Pass();
 }
 
 bool SyncRollbackManagerBase::InitBackupDB(
     const base::FilePath& sync_folder,
-    InternalComponentsFactory* internal_components_factory,
-    InternalComponentsFactory::StorageOption storage) {
+    InternalComponentsFactory* internal_components_factory) {
   base::FilePath backup_db_path = sync_folder.Append(
       syncable::Directory::kSyncDatabaseFilename);
   scoped_ptr<syncable::DirectoryBackingStore> backing_store =
       internal_components_factory->BuildDirectoryBackingStore(
-          storage, "backup", backup_db_path).Pass();
+          "backup", backup_db_path).Pass();
 
   DCHECK(backing_store.get());
   share_.directory.reset(
       new syncable::Directory(
           backing_store.release(),
           unrecoverable_error_handler_.get(),
           report_unrecoverable_error_function_,
           NULL,
           NULL));
   return syncable::OPENED ==
@@ skipping 64 matching lines @@
 
 void SyncRollbackManagerBase::UnregisterDirectoryTypeDebugInfoObserver(
     syncer::TypeDebugInfoObserver* observer) {}
 
 bool SyncRollbackManagerBase::HasDirectoryTypeDebugInfoObserver(
     syncer::TypeDebugInfoObserver* observer) { return false; }
 
 void SyncRollbackManagerBase::RequestEmitDebugInfo() {}
 
 }  // namespace syncer