sync: add InternalComponentsFactory::Switches to simplify passing switches to internal components.

sync/internal_api/sync_manager_impl_unittest.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.
 
 // 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 707 matching lines @@
   };
 
   enum EncryptionStatus {
     UNINITIALIZED,
     DEFAULT_ENCRYPTION,
     FULL_ENCRYPTION
   };
 
   SyncManagerTest()
       : sync_notifier_mock_(NULL),
-        sync_manager_("Test sync manager") {}
+        sync_manager_("Test sync manager") {
+    switches_.encryption_method =
+        InternalComponentsFactory::ENCRYPTION_KEYSTORE;
+  }
 
   virtual ~SyncManagerTest() {
     EXPECT_FALSE(sync_notifier_mock_);
   }
 
   // Test implementation.
   void SetUp() {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 
     SyncCredentials credentials;
@@ skipping 24 matching lines @@
     sync_manager_.Init(temp_dir_.path(),
                        WeakHandle<JsEventHandler>(),
                        "bogus", 0, false,
                        base::MessageLoopProxy::current(),
                        scoped_ptr<HttpPostProviderFactory>(
                            new TestHttpPostProviderFactory()),
                        workers, &extensions_activity_monitor_, this,
                        credentials,
                        scoped_ptr<SyncNotifier>(sync_notifier_mock_),
                        "", "",  // bootstrap tokens
-                       true,  // enable keystore encryption
                        scoped_ptr<InternalComponentsFactory>(GetFactory()),
                        &encryptor_,
                        &handler_,
                        NULL);
 
     EXPECT_TRUE(js_backend_.IsInitialized());
 
     for (ModelSafeRoutingInfo::iterator i = routing_info.begin();
          i != routing_info.end(); ++i) {
       type_roots_[i->first] = MakeServerNodeForType(
@@ skipping 97 matching lines @@
     syncable::MutableEntry entry(&trans, syncable::GET_BY_CLIENT_TAG,
                                  hash);
     EXPECT_TRUE(entry.good());
     if (!entry.Get(IS_UNSYNCED))
       return false;
     entry.Put(IS_UNSYNCED, false);
     return true;
   }
 
   virtual InternalComponentsFactory* GetFactory() {
-    return new TestInternalComponentsFactory(STORAGE_IN_MEMORY);
+    return new TestInternalComponentsFactory(GetSwitches(), STORAGE_IN_MEMORY);
   }
 
   // Returns true if we are currently encrypting all sync data.  May
   // be called on any thread.
   bool EncryptEverythingEnabledForTest() {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     return trans.GetCryptographer()->encrypt_everything();
   }
 
   // Gets the set of encrypted types from the cryptographer
@@ skipping 32 matching lines @@
     } else {
       sync_pb::DataTypeProgressMarker marker;
       sync_manager_.directory()->SetDownloadProgress(type, marker);
     }
   }
 
   void SetInitialSyncEndedForType(ModelType type, bool value) {
     sync_manager_.directory()->set_initial_sync_ended_for_type(type, value);
   }
 
+  InternalComponentsFactory::Switches GetSwitches() const {
+    return switches_;
+  }
+
  private:
   // Needed by |sync_manager_|.
   MessageLoop message_loop_;
   // Needed by |sync_manager_|.
   ScopedTempDir temp_dir_;
   // Sync Id's for the roots of the enabled datatypes.
   std::map<ModelType, int64> type_roots_;
   FakeExtensionsActivityMonitor extensions_activity_monitor_;
 
  protected:
   FakeEncryptor encryptor_;
   TestUnrecoverableErrorHandler handler_;
   StrictMock<SyncNotifierMock>* sync_notifier_mock_;
   SyncManagerImpl sync_manager_;
   WeakHandle<JsBackend> js_backend_;
   StrictMock<SyncManagerObserverMock> observer_;
+  InternalComponentsFactory::Switches switches_;
 };
 
 TEST_F(SyncManagerTest, UpdateEnabledTypes) {
   ModelSafeRoutingInfo routes;
   GetModelSafeRoutingInfo(&routes);
   const ModelTypeSet enabled_types = GetRoutingInfoTypes(routes);
   EXPECT_CALL(*sync_notifier_mock_,
               UpdateRegisteredIds(
                   _, ModelTypeSetToObjectIdSet(enabled_types)));
 
@@ skipping 1564 matching lines @@
  public:
   MockSyncScheduler() : FakeSyncScheduler() {}
   virtual ~MockSyncScheduler() {}
 
   MOCK_METHOD1(Start, void(SyncScheduler::Mode));
   MOCK_METHOD1(ScheduleConfiguration, bool(const ConfigurationParams&));
 };
 
 class ComponentsFactory : public TestInternalComponentsFactory {
  public:
-  ComponentsFactory(SyncScheduler* scheduler_to_use,
+  ComponentsFactory(const Switches& switches,
+                    SyncScheduler* scheduler_to_use,
                     sessions::SyncSessionContext** session_context)
-      : TestInternalComponentsFactory(
-            syncer::STORAGE_IN_MEMORY),
+      : TestInternalComponentsFactory(switches, syncer::STORAGE_IN_MEMORY),
         scheduler_to_use_(scheduler_to_use),
         session_context_(session_context) {}
   virtual ~ComponentsFactory() {}
 
   virtual scoped_ptr<SyncScheduler> BuildScheduler(
       const std::string& name,
       sessions::SyncSessionContext* context) 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(scheduler_, &session_context_);
+    return new ComponentsFactory(GetSwitches(), scheduler_, &session_context_);
   }
 
   MockSyncScheduler* scheduler() { return scheduler_; }
   sessions::SyncSessionContext* session_context() {
       return session_context_;
   }
 
  private:
   MockSyncScheduler* scheduler_;
   sessions::SyncSessionContext* session_context_;
@@ skipping 220 matching lines @@
 
   // Verify only the non-disabled types remain after cleanup.
   sync_manager_.PurgeDisabledTypes(enabled_types, new_enabled_types);
   EXPECT_TRUE(new_enabled_types.Equals(
       Union(sync_manager_.InitialSyncEndedTypes(), partial_enabled_types)));
   EXPECT_TRUE(disabled_types.Equals(
       sync_manager_.GetTypesWithEmptyProgressMarkerToken(ModelTypeSet::All())));
 }
 
 }  // namespace