Revert of [Sync] Make directory types registration explicit in ModelTypeRegistry

components/sync/engine_impl/syncer_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.
 
 #include "components/sync/engine_impl/syncer.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <limits>
@@ skipping 201 matching lines @@
       last_bookmarks_commit_delay_ = iter->second;
   }
   void OnReceivedClientInvalidationHintBufferSize(int size) override {
     last_client_invalidation_hint_buffer_size_ = size;
   }
   void OnReceivedGuRetryDelay(const base::TimeDelta& delay) override {}
   void OnReceivedMigrationRequest(ModelTypeSet types) override {}
   void OnProtocolEvent(const ProtocolEvent& event) override {}
   void OnSyncProtocolError(const SyncProtocolError& error) override {}
 
+  void GetModelSafeRoutingInfo(ModelSafeRoutingInfo* out) {
+    // We're just testing the sync engine here, so we shunt everything to
+    // the SyncerThread.  Datatypes which aren't enabled aren't in the map.
+    for (ModelTypeSet::Iterator it = enabled_datatypes_.First(); it.Good();
+         it.Inc()) {
+      (*out)[it.Get()] = GROUP_PASSIVE;
+    }
+  }
+
   void OnSyncCycleEvent(const SyncCycleEvent& event) override {
     DVLOG(1) << "HandleSyncEngineEvent in unittest " << event.what_happened;
     // we only test for entry-specific events, not status changed ones.
     switch (event.what_happened) {
       case SyncCycleEvent::SYNC_CYCLE_BEGIN:  // Fall through.
       case SyncCycleEvent::STATUS_CHANGED:
       case SyncCycleEvent::SYNC_CYCLE_ENDED:
         return;
       default:
         FAIL() << "Handling unknown error type in unit tests!!";
@@ skipping 23 matching lines @@
     return syncer_->ConfigureSyncShare(
         context_->GetEnabledTypes(),
         sync_pb::GetUpdatesCallerInfo::RECONFIGURATION, cycle_.get());
   }
 
   void SetUp() override {
     test_user_share_.SetUp();
     mock_server_ = base::MakeUnique<MockConnectionManager>(
         directory(), &cancelation_signal_);
     debug_info_getter_ = base::MakeUnique<MockDebugInfoGetter>();
+    EnableDatatype(BOOKMARKS);
+    EnableDatatype(EXTENSIONS);
+    EnableDatatype(NIGORI);
+    EnableDatatype(PREFERENCES);
+    EnableDatatype(NIGORI);
     workers_.push_back(
         scoped_refptr<ModelSafeWorker>(new FakeModelWorker(GROUP_PASSIVE)));
     std::vector<SyncEngineEventListener*> listeners;
     listeners.push_back(this);
 
+    ModelSafeRoutingInfo routing_info;
+    GetModelSafeRoutingInfo(&routing_info);
+
     model_type_registry_ = base::MakeUnique<ModelTypeRegistry>(
         workers_, test_user_share_.user_share(), &mock_nudge_handler_,
         UssMigrator());
     model_type_registry_->RegisterDirectoryTypeDebugInfoObserver(
         &debug_info_cache_);
 
-    EnableDatatype(BOOKMARKS);
-    EnableDatatype(EXTENSIONS);
-    EnableDatatype(NIGORI);
-    EnableDatatype(PREFERENCES);
-
     context_ = base::MakeUnique<SyncCycleContext>(
         mock_server_.get(), directory(), extensions_activity_.get(), listeners,
         debug_info_getter_.get(), model_type_registry_.get(),
         true,   // enable keystore encryption
         false,  // force enable pre-commit GU avoidance experiment
         "fake_invalidator_client_id");
+    context_->SetRoutingInfo(routing_info);
     syncer_ = new Syncer(&cancelation_signal_);
     scheduler_ = base::MakeUnique<SyncSchedulerImpl>(
         "TestSyncScheduler", BackoffDelayProvider::FromDefaults(),
         context_.get(),
         // scheduler_ owned syncer_ now and will manage the memory of syncer_
         syncer_, false);
 
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Directory::Metahandles children;
     directory()->GetChildHandlesById(&trans, trans.root_id(), &children);
@@ skipping 193 matching lines @@
     entry.PutIsUnsynced(true);
     entry.PutIsDir(true);
     entry.PutSpecifics(DefaultBookmarkSpecifics());
     entry.PutBaseVersion(id.ServerKnows() ? 1 : 0);
     entry.PutId(id);
     return entry.GetMetahandle();
   }
 
   void EnableDatatype(ModelType model_type) {
     enabled_datatypes_.Put(model_type);
-    model_type_registry_->RegisterDirectoryType(model_type, GROUP_PASSIVE);
+
+    ModelSafeRoutingInfo routing_info;
+    GetModelSafeRoutingInfo(&routing_info);
+
+    if (context_) {
+      context_->SetRoutingInfo(routing_info);
+    }
+
     mock_server_->ExpectGetUpdatesRequestTypes(enabled_datatypes_);
   }
 
   void DisableDatatype(ModelType model_type) {
     enabled_datatypes_.Remove(model_type);
-    model_type_registry_->UnregisterDirectoryType(model_type);
+
+    ModelSafeRoutingInfo routing_info;
+    GetModelSafeRoutingInfo(&routing_info);
+
+    if (context_) {
+      context_->SetRoutingInfo(routing_info);
+    }
+
     mock_server_->ExpectGetUpdatesRequestTypes(enabled_datatypes_);
   }
 
   Cryptographer* GetCryptographer(syncable::BaseTransaction* trans) {
     return directory()->GetCryptographer(trans);
   }
 
   // Configures SyncCycleContext and NudgeTracker so Syncer won't call
   // GetUpdates prior to Commit. This method can be used to ensure a Commit is
   // not preceeded by GetUpdates.
@@ skipping 4345 matching lines @@
     ASSERT_TRUE(!hurdle.GetIsDel());
     ASSERT_TRUE(hurdle.GetUniqueServerTag().empty());
     ASSERT_EQ("bob", hurdle.GetNonUniqueName());
   }
 }
 
 TEST_F(SyncerTest, GetUpdatesSetsRequestedTypes) {
   // The expectations of this test happen in the MockConnectionManager's
   // GetUpdates handler.  EnableDatatype sets the expectation value from our
   // set of enabled/disabled datatypes.
+  EnableDatatype(BOOKMARKS);
   EXPECT_TRUE(SyncShareNudge());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
 
   EnableDatatype(AUTOFILL);
   EXPECT_TRUE(SyncShareNudge());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
 
+  EnableDatatype(PREFERENCES);
+  EXPECT_TRUE(SyncShareNudge());
+  EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
+
   DisableDatatype(BOOKMARKS);
   EXPECT_TRUE(SyncShareNudge());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
 
   DisableDatatype(AUTOFILL);
   EXPECT_TRUE(SyncShareNudge());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
 
   DisableDatatype(PREFERENCES);
   EnableDatatype(AUTOFILL);
@@ skipping 1004 matching lines @@
     EXPECT_EQ("xyz", final_monitor_records["xyz"].extension_id);
     EXPECT_EQ(2049U, final_monitor_records["ABC"].bookmark_write_count);
     EXPECT_EQ(4U, final_monitor_records["xyz"].bookmark_write_count);
   } else {
     EXPECT_TRUE(final_monitor_records.empty())
         << "Should not restore records after successful bookmark commit.";
   }
 }
 
 }  // namespace syncer