sync: Introduce control data types

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"
 #include "base/message_loop.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/password_manager/password_store.h"
 #include "chrome/browser/password_manager/password_store_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/glue/browser_thread_model_worker.h"
 #include "chrome/browser/sync/glue/change_processor.h"
 #include "chrome/browser/sync/glue/history_model_worker.h"
 #include "chrome/browser/sync/glue/password_model_worker.h"
 #include "chrome/browser/sync/glue/ui_model_worker.h"
 #include "content/public/browser/browser_thread.h"
+#include "sync/internal_api/public/engine/control_model_worker.h"
 #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) {
   switch (group) {
     case syncer::GROUP_PASSIVE:
       return false;
+    case syncer::GROUP_CONTROL:
+      return false;
     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 15 matching lines @@
     sync_loop_(sync_loop),
     ui_worker_(new UIModelWorker()),
     stopped_on_ui_thread_(false) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   CHECK(profile_);
   DCHECK(sync_loop_);
   workers_[syncer::GROUP_DB] = new DatabaseModelWorker();
   workers_[syncer::GROUP_FILE] = new FileModelWorker();
   workers_[syncer::GROUP_UI] = ui_worker_;
   workers_[syncer::GROUP_PASSIVE] = new syncer::PassiveModelWorker(sync_loop_);
+  workers_[syncer::GROUP_CONTROL] = new syncer::ControlModelWorker(sync_loop_);
 
   HistoryService* history_service =
       HistoryServiceFactory::GetForProfile(profile, Profile::IMPLICIT_ACCESS);
   if (history_service) {
     workers_[syncer::GROUP_HISTORY] = new HistoryModelWorker(history_service);
   }
 
   scoped_refptr<PasswordStore> password_store =
       PasswordStoreFactory::GetForProfile(profile, Profile::IMPLICIT_ACCESS);
   if (password_store.get()) {
     workers_[syncer::GROUP_PASSWORD] = new PasswordModelWorker(password_store);
   }
 }
 
 void SyncBackendRegistrar::SetInitialTypes(syncer::ModelTypeSet initial_types) {

[tim (not reviewing), 2012/08/30 20:18:33]

nit - shouldn't this be a const ModelTypeSet&?

   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   base::AutoLock lock(lock_);
 
   // This function should be called only once, shortly after construction.  The
   // routing info at that point is expected to be emtpy.
   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;
+    if (IsControlType(it.Get())) {
+      routing_info_[it.Get()] = syncer::GROUP_CONTROL;
+    } else {
+      routing_info_[it.Get()] = syncer::GROUP_PASSIVE;
+    }
   }
 
   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 29 matching lines @@
   }
 
   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;
+      if (IsControlType(it.Get())) {
+        routing_info_[it.Get()] = syncer::GROUP_CONTROL;
+      } else {
+        routing_info_[it.Get()] = syncer::GROUP_PASSIVE;
+      }
       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 132 matching lines @@
   return it->second;
 }
 
 bool SyncBackendRegistrar::IsCurrentThreadSafeForModel(
     syncer::ModelType model_type) const {
   lock_.AssertAcquired();
   return IsOnThreadForGroup(GetGroupForModelType(model_type, routing_info_));
 }
 
 }  // namespace browser_sync