NOT FOR COMMIT: Add DeviceInfo type and ChangeProcessor

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 11 matching lines @@
 #include "sync/internal_api/public/engine/passive_model_worker.h"
 
 using content::BrowserThread;
 
 namespace browser_sync {
 
 namespace {
 
 // Returns true if the current thread is the native thread for the
 // given group (or if it is undeterminable).
-bool IsOnThreadForGroup(syncer::ModelSafeGroup group) {
+bool IsOnThreadForGroup(syncer::ModelType type, syncer::ModelSafeGroup group) {
   switch (group) {
     case syncer::GROUP_PASSIVE:
-      return false;
+      return IsControlType(type);
     case syncer::GROUP_UI:
       return BrowserThread::CurrentlyOn(BrowserThread::UI);
     case syncer::GROUP_DB:
       return BrowserThread::CurrentlyOn(BrowserThread::DB);
     case syncer::GROUP_FILE:
       return BrowserThread::CurrentlyOn(BrowserThread::FILE);
     case syncer::GROUP_HISTORY:
       // TODO(ncarter): How to determine this?
       return true;
     case syncer::GROUP_PASSWORD:
@@ skipping 131 matching lines @@
 void SyncBackendRegistrar::OnSyncerShutdownComplete() {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   ui_worker_->OnSyncerShutdownComplete();
 }
 
 void SyncBackendRegistrar::ActivateDataType(
     syncer::ModelType type,
     syncer::ModelSafeGroup group,
     ChangeProcessor* change_processor,
     syncer::UserShare* user_share) {
-  CHECK(IsOnThreadForGroup(group));
+  CHECK(IsOnThreadForGroup(type, group));
   base::AutoLock lock(lock_);
   // Ensure that the given data type is in the PASSIVE group.
   syncer::ModelSafeRoutingInfo::iterator i = routing_info_.find(type);
   DCHECK(i != routing_info_.end());
   DCHECK_EQ(i->second, syncer::GROUP_PASSIVE);
   routing_info_[type] = group;
   CHECK(IsCurrentThreadSafeForModel(type));
 
   // Add the data type's change processor to the list of change
   // processors so it can receive updates.
   DCHECK_EQ(processors_.count(type), 0U);
   processors_[type] = change_processor;
 
   // Start the change processor.
   change_processor->Start(profile_, user_share);
   DCHECK(GetProcessorUnsafe(type));
 }
 
 void SyncBackendRegistrar::DeactivateDataType(syncer::ModelType type) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) || IsControlType(type));
   base::AutoLock lock(lock_);
   ChangeProcessor* change_processor = GetProcessorUnsafe(type);
   if (change_processor)
     change_processor->Stop();
 
   routing_info_.erase(type);
   ignore_result(processors_.erase(type));
   DCHECK(!GetProcessorUnsafe(type));
 }
 
@@ skipping 69 matching lines @@
   // |processors_| list.
   if (it == processors_.end())
     return NULL;
 
   return it->second;
 }
 
 bool SyncBackendRegistrar::IsCurrentThreadSafeForModel(
     syncer::ModelType model_type) const {
   lock_.AssertAcquired();
-  return IsOnThreadForGroup(GetGroupForModelType(model_type, routing_info_));
+  return IsOnThreadForGroup(model_type,
+                            GetGroupForModelType(model_type, routing_info_));
 }
 
 }  // namespace browser_sync