[Sync] Register USS types with ModelTypeRegistry before download

components/sync_driver/glue/sync_backend_registrar.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_driver/glue/sync_backend_registrar.h"
 
 #include <cstddef>
 #include <utility>
 
 #include "base/compiler_specific.h"
@@ skipping 33 matching lines @@
   MaybeAddWorker(syncer::GROUP_UI);
   MaybeAddWorker(syncer::GROUP_PASSIVE);
   MaybeAddWorker(syncer::GROUP_HISTORY);
   MaybeAddWorker(syncer::GROUP_PASSWORD);
 
   // Must have at least one worker for SyncBackendRegistrar to be destroyed
   // correctly, as it is destroyed after the last worker dies.
   DCHECK_GT(workers_.size(), 0u);
 }
 
+void SyncBackendRegistrar::RegisterNonBlockingType(syncer::ModelType type) {
+  DCHECK(routing_info_.find(type) == routing_info_.end() ||
+         routing_info_[type] == syncer::GROUP_NON_BLOCKING);
+  non_blocking_types_.Put(type);
+}
+
 void SyncBackendRegistrar::SetInitialTypes(syncer::ModelTypeSet initial_types) {
   base::AutoLock lock(lock_);
 
   // This function should be called only once, shortly after construction. The
   // routing info at that point is expected to be empty.
   DCHECK(routing_info_.empty());
 
   // Set our initial state to reflect the current status of the sync directory.
   // This will ensure that our calculations in ConfigureDataTypes() will always
   // return correct results.
   for (syncer::ModelTypeSet::Iterator it = initial_types.First(); it.Good();
        it.Inc()) {
-    routing_info_[it.Get()] = syncer::GROUP_PASSIVE;
+    routing_info_[it.Get()] = GetInitialGroupForType(it.Get());
   }
 
   if (!workers_.count(syncer::GROUP_HISTORY)) {
     LOG_IF(WARNING, initial_types.Has(syncer::TYPED_URLS))
         << "History store disabled, cannot sync Omnibox History";
     routing_info_.erase(syncer::TYPED_URLS);
   }
 
   if (!workers_.count(syncer::GROUP_PASSWORD)) {
     LOG_IF(WARNING, initial_types.Has(syncer::PASSWORDS))
@@ skipping 24 matching lines @@
     filtered_types_to_add.Remove(syncer::PASSWORDS);
   }
 
   base::AutoLock lock(lock_);
   syncer::ModelTypeSet newly_added_types;
   for (syncer::ModelTypeSet::Iterator it = filtered_types_to_add.First();
        it.Good(); it.Inc()) {
     // Add a newly specified data type as syncer::GROUP_PASSIVE into the
     // routing_info, if it does not already exist.
     if (routing_info_.count(it.Get()) == 0) {
-      routing_info_[it.Get()] = syncer::GROUP_PASSIVE;
+      routing_info_[it.Get()] = GetInitialGroupForType(it.Get());
       newly_added_types.Put(it.Get());
     }
   }
   for (syncer::ModelTypeSet::Iterator it = types_to_remove.First(); it.Good();
        it.Inc()) {
     routing_info_.erase(it.Get());
   }
 
   // TODO(akalin): Use SVLOG/SLOG if we add any more logging.
   DVLOG(1) << name_ << ": Adding types "
@@ skipping 151 matching lines @@
     case syncer::GROUP_DB:
       return db_thread_->BelongsToCurrentThread();
     case syncer::GROUP_FILE:
       return file_thread_->BelongsToCurrentThread();
     case syncer::GROUP_HISTORY:
       // TODO(sync): How to check we're on the right thread?
       return type == syncer::TYPED_URLS;
     case syncer::GROUP_PASSWORD:
       // TODO(sync): How to check we're on the right thread?
       return type == syncer::PASSWORDS;
-    case syncer::MODEL_SAFE_GROUP_COUNT:
-    default:
+    case syncer::GROUP_NON_BLOCKING:
+      // IsOnThreadForGroup shouldn't be called for non-blocking types.
       return false;
   }
+  NOTREACHED();
+  return false;
 }
 
 SyncBackendRegistrar::~SyncBackendRegistrar() {
   DCHECK(workers_.empty());
 }
 
 void SyncBackendRegistrar::OnWorkerLoopDestroyed(syncer::ModelSafeGroup group) {
   RemoveWorker(group);
 }
 
@@ skipping 47 matching lines @@
     it->second->UnregisterForLoopDestruction(
         base::Bind(&SyncBackendRegistrar::OnWorkerUnregistrationDone,
                    base::Unretained(this)));
   }
 }
 
 base::Thread* SyncBackendRegistrar::sync_thread() {
   return sync_thread_.get();
 }
 
+syncer::ModelSafeGroup SyncBackendRegistrar::GetInitialGroupForType(
+    syncer::ModelType type) const {
+  if (non_blocking_types_.Has(type))
+    return syncer::GROUP_NON_BLOCKING;
+  else
+    return syncer::GROUP_PASSIVE;
+}
+
 }  // namespace browser_sync