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

sync/internal_api/sync_manager_impl_unittest.cc

 // Copyright 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.
 
 // Unit tests for the SyncApi. Note that a lot of the underlying
 // functionality is provided by the Syncable layer, which has its own
 // unit tests. We'll test SyncApi specific things in this harness.
 
 #include <cstddef>
 #include <map>
@@ skipping 816 matching lines @@
     args.invalidator_client_id = "fake_invalidator_client_id";
     args.internal_components_factory.reset(GetFactory());
     args.encryptor = &encryptor_;
     args.unrecoverable_error_handler.reset(new TestUnrecoverableErrorHandler);
     args.cancelation_signal = &cancelation_signal_;
     sync_manager_.Init(&args);
 
     sync_manager_.GetEncryptionHandler()->AddObserver(&encryption_observer_);
 
     EXPECT_TRUE(js_backend_.IsInitialized());
+    EXPECT_EQ(InternalComponentsFactory::STORAGE_ON_DISK,
+              storage_used_);
 
     if (initialization_succeeded_) {
       for (ModelSafeRoutingInfo::iterator i = routing_info.begin();
            i != routing_info.end(); ++i) {
         type_roots_[i->first] = MakeServerNodeForType(
             sync_manager_.GetUserShare(), i->first);
       }
     }
 
     PumpLoop();
@@ skipping 97 matching lines @@
     syncable::MutableEntry entry(&trans, syncable::GET_BY_CLIENT_TAG,
                                  hash);
     EXPECT_TRUE(entry.good());
     if (!entry.GetIsUnsynced())
       return false;
     entry.PutIsUnsynced(false);
     return true;
   }
 
   virtual InternalComponentsFactory* GetFactory() {
-    return new TestInternalComponentsFactory(GetSwitches(), STORAGE_IN_MEMORY);
+    return new TestInternalComponentsFactory(
+        GetSwitches(), InternalComponentsFactory::STORAGE_IN_MEMORY,
+        &storage_used_);
   }
 
   // Returns true if we are currently encrypting all sync data.  May
   // be called on any thread.
   bool EncryptEverythingEnabledForTest() {
     return sync_manager_.GetEncryptionHandler()->EncryptEverythingEnabled();
   }
 
   // Gets the set of encrypted types from the cryptographer
   // Note: opens a transaction.  May be called from any thread.
@@ skipping 39 matching lines @@
 
  protected:
   FakeEncryptor encryptor_;
   SyncManagerImpl sync_manager_;
   CancelationSignal cancelation_signal_;
   WeakHandle<JsBackend> js_backend_;
   bool initialization_succeeded_;
   StrictMock<SyncManagerObserverMock> manager_observer_;
   StrictMock<SyncEncryptionHandlerObserverMock> encryption_observer_;
   InternalComponentsFactory::Switches switches_;
+  InternalComponentsFactory::StorageOption storage_used_;
 };
 
 TEST_F(SyncManagerTest, GetAllNodesForTypeTest) {
   ModelSafeRoutingInfo routing_info;
   GetModelSafeRoutingInfo(&routing_info);
   sync_manager_.StartSyncingNormally(routing_info);
 
   scoped_ptr<base::ListValue> node_list(
       sync_manager_.GetAllNodesForType(syncer::PREFERENCES));
 
@@ skipping 1378 matching lines @@
   virtual ~MockSyncScheduler() {}
 
   MOCK_METHOD1(Start, void(SyncScheduler::Mode));
   MOCK_METHOD1(ScheduleConfiguration, void(const ConfigurationParams&));
 };
 
 class ComponentsFactory : public TestInternalComponentsFactory {
  public:
   ComponentsFactory(const Switches& switches,
                     SyncScheduler* scheduler_to_use,
-                    sessions::SyncSessionContext** session_context)
-      : TestInternalComponentsFactory(switches, syncer::STORAGE_IN_MEMORY),
+                    sessions::SyncSessionContext** session_context,
+                    InternalComponentsFactory::StorageOption* storage_used)
+      : TestInternalComponentsFactory(
+          switches, InternalComponentsFactory::STORAGE_IN_MEMORY, storage_used),
         scheduler_to_use_(scheduler_to_use),
         session_context_(session_context) {}
   virtual ~ComponentsFactory() {}
 
   virtual scoped_ptr<SyncScheduler> BuildScheduler(
       const std::string& name,
       sessions::SyncSessionContext* context,
       CancelationSignal* stop_handle) OVERRIDE {
     *session_context_ = context;
     return scheduler_to_use_.Pass();
   }
 
  private:
   scoped_ptr<SyncScheduler> scheduler_to_use_;
   sessions::SyncSessionContext** session_context_;
 };
 
 class SyncManagerTestWithMockScheduler : public SyncManagerTest {
  public:
   SyncManagerTestWithMockScheduler() : scheduler_(NULL) {}
   virtual InternalComponentsFactory* GetFactory() OVERRIDE {
     scheduler_ = new MockSyncScheduler();
-    return new ComponentsFactory(GetSwitches(), scheduler_, &session_context_);
+    return new ComponentsFactory(GetSwitches(), scheduler_, &session_context_,
+                                 &storage_used_);
   }
 
   MockSyncScheduler* scheduler() { return scheduler_; }
   sessions::SyncSessionContext* session_context() {
       return session_context_;
   }
 
  private:
   MockSyncScheduler* scheduler_;
   sessions::SyncSessionContext* session_context_;
@@ skipping 723 matching lines @@
 // do so it should fail initialization. This test verifies this behavior.
 // Test reuses SyncManagerImpl initialization from SyncManagerTest but overrides
 // InternalComponentsFactory to return DirectoryBackingStore that always fails
 // to load.
 class SyncManagerInitInvalidStorageTest : public SyncManagerTest {
  public:
   SyncManagerInitInvalidStorageTest() {
   }
 
   virtual InternalComponentsFactory* GetFactory() OVERRIDE {
-    return new TestInternalComponentsFactory(GetSwitches(), STORAGE_INVALID);
+    return new TestInternalComponentsFactory(
+        GetSwitches(), InternalComponentsFactory::STORAGE_INVALID,
+        &storage_used_);
   }
 };
 
 // SyncManagerInitInvalidStorageTest::GetFactory will return
 // DirectoryBackingStore that ensures that SyncManagerImpl::OpenDirectory fails.
 // SyncManagerImpl initialization is done in SyncManagerTest::SetUp. This test's
 // task is to ensure that SyncManagerImpl reported initialization failure in
 // OnInitializationComplete callback.
 TEST_F(SyncManagerInitInvalidStorageTest, FailToOpenDatabase) {
   EXPECT_FALSE(initialization_succeeded_);
 }
 
 }  // namespace syncer