Not for review: Support sync init with missing or corrupt store

chrome/browser/sync/glue/sync_backend_registrar.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 "chrome/browser/sync/glue/sync_backend_registrar.h"
 
 #include <cstddef>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
@@ skipping 35 matching lines @@
       return true;
     case MODEL_SAFE_GROUP_COUNT:
     default:
       return false;
   }
 }
 
 }  // namespace
 
 SyncBackendRegistrar::SyncBackendRegistrar(
-    syncable::ModelTypeSet initial_types,
     const std::string& name, Profile* profile,
     MessageLoop* sync_loop) :
     name_(name),
     profile_(profile),
     sync_loop_(sync_loop),
     ui_worker_(new UIModelWorker()),
     stopped_on_ui_thread_(false) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   CHECK(profile_);
   DCHECK(sync_loop_);
   workers_[GROUP_DB] = new DatabaseModelWorker();
   workers_[GROUP_FILE] = new FileModelWorker();
   workers_[GROUP_UI] = ui_worker_;
   workers_[GROUP_PASSIVE] = new PassiveModelWorker(sync_loop_);
 
-  // Any datatypes that we want the syncer to pull down must be in the
-  // routing_info map.  We set them to group passive, meaning that
-  // updates will be applied to sync, but not dispatched to the native
-  // models.
-  for (syncable::ModelTypeSet::Iterator it = initial_types.First();
-       it.Good(); it.Inc()) {
-    routing_info_[it.Get()] = GROUP_PASSIVE;
-  }
-
   HistoryService* history_service = profile->GetHistoryService(
       Profile::IMPLICIT_ACCESS);
   if (history_service) {
     workers_[GROUP_HISTORY] = new HistoryModelWorker(history_service);
-  } else {
-    LOG_IF(WARNING, initial_types.Has(syncable::TYPED_URLS))
-        << "History store disabled, cannot sync Omnibox History";
-    routing_info_.erase(syncable::TYPED_URLS);
   }
 
   scoped_refptr<PasswordStore> password_store =
       PasswordStoreFactory::GetForProfile(profile, Profile::IMPLICIT_ACCESS);
   if (password_store.get()) {
     workers_[GROUP_PASSWORD] = new PasswordModelWorker(password_store);
-  } else {
-    LOG_IF(WARNING, initial_types.Has(syncable::PASSWORDS))
-        << "Password store not initialized, cannot sync passwords";
-    routing_info_.erase(syncable::PASSWORDS);
   }
 }
 
 SyncBackendRegistrar::~SyncBackendRegistrar() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(stopped_on_ui_thread_);
 }
 
+void SyncBackendRegistrar::SetInitialTypes(
+    syncable::ModelTypeSet initial_types) {
+  // Set our initial state to reflect the current status of the sync directory.

[rlarocque, 2012/06/04 20:07:09]

I could use a flag and some DCHECKs to ensure that this function is called only
once and is called before any other public method.  I'm not convinced that would
be a good idea, though.  Thoughts?

+  // This will ensure that our calculations in ConfigureDataTypes() will always
+  // return correct results.
+  for (syncable::ModelTypeSet::Iterator it = initial_types.First();
+       it.Good(); it.Inc()) {
+    routing_info_[it.Get()] = GROUP_PASSIVE;
+  }
+
+  if (!workers_.count(GROUP_HISTORY)) {
+    LOG_IF(WARNING, initial_types.Has(syncable::TYPED_URLS))
+        << "History store disabled, cannot sync Omnibox History";
+    routing_info_.erase(syncable::TYPED_URLS);
+  }
+
+  if (!workers_.count(GROUP_PASSWORD)) {
+    LOG_IF(WARNING, initial_types.Has(syncable::PASSWORDS))
+        << "Password store not initialized, cannot sync passwords";
+    routing_info_.erase(syncable::PASSWORDS);
+  }
+}
+
 bool SyncBackendRegistrar::IsNigoriEnabled() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   base::AutoLock lock(lock_);
   return routing_info_.find(syncable::NIGORI) != routing_info_.end();
 }
 
 syncable::ModelTypeSet SyncBackendRegistrar::ConfigureDataTypes(
     syncable::ModelTypeSet types_to_add,
     syncable::ModelTypeSet types_to_remove) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 163 matching lines @@
   return it->second;
 }
 
 bool SyncBackendRegistrar::IsCurrentThreadSafeForModel(
     syncable::ModelType model_type) const {
   lock_.AssertAcquired();
   return IsOnThreadForGroup(GetGroupForModelType(model_type, routing_info_));
 }
 
 }  // namespace browser_sync