[Sync] Move thread checking into the ModelSafeWorker interface.

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 <algorithm>
 #include <cstddef>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "components/sync/driver/change_processor.h"
 #include "components/sync/driver/sync_client.h"
 #include "components/sync/syncable/user_share.h"
 
 namespace syncer {
 
-SyncBackendRegistrar::SyncBackendRegistrar(
-    const std::string& name,
-    SyncClient* sync_client,
-    const scoped_refptr<base::SingleThreadTaskRunner>& ui_thread,
-    const scoped_refptr<base::SingleThreadTaskRunner>& db_thread,
-    const scoped_refptr<base::SingleThreadTaskRunner>& file_thread)
-    : name_(name),
-      sync_client_(sync_client),
-      ui_thread_(ui_thread),
-      db_thread_(db_thread),
-      file_thread_(file_thread) {
-  DCHECK(ui_thread_->BelongsToCurrentThread());
+SyncBackendRegistrar::SyncBackendRegistrar(const std::string& name,
+                                           SyncClient* sync_client)
+    : name_(name), sync_client_(sync_client) {
   DCHECK(sync_client_);
 
   MaybeAddWorker(GROUP_DB);
   MaybeAddWorker(GROUP_FILE);
   MaybeAddWorker(GROUP_UI);
   MaybeAddWorker(GROUP_PASSIVE);
   MaybeAddWorker(GROUP_HISTORY);
   MaybeAddWorker(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(ModelType type) {
-  DCHECK(ui_thread_->BelongsToCurrentThread());
+  DCHECK(ui_thread_checker_.CalledOnValidThread());
   base::AutoLock lock(lock_);
   // There may have been a previously successful sync of a type when passive,
   // which is now NonBlocking. We're not sure what order these two sets of types
   // are being registered in, so guard against SetInitialTypes(...) having been
   // already called by undoing everything to these types.
   if (routing_info_.find(type) != routing_info_.end() &&
       routing_info_[type] != GROUP_NON_BLOCKING) {
     routing_info_.erase(type);
     last_configured_types_.Remove(type);
   }
@@ skipping 29 matching lines @@
     LOG_IF(WARNING, initial_types.Has(PASSWORDS))
         << "Password store not initialized, cannot sync passwords";
     routing_info_.erase(PASSWORDS);
   }
 
   // Although this can re-set NonBlocking types, this should be idempotent.
   last_configured_types_ = GetRoutingInfoTypes(routing_info_);
 }
 
 void SyncBackendRegistrar::AddRestoredNonBlockingType(ModelType type) {
-  DCHECK(ui_thread_->BelongsToCurrentThread());
+  DCHECK(ui_thread_checker_.CalledOnValidThread());
   base::AutoLock lock(lock_);
   DCHECK(non_blocking_types_.Has(type));
   DCHECK(routing_info_.find(type) == routing_info_.end());
   routing_info_[type] = GROUP_NON_BLOCKING;
   last_configured_types_.Put(type);
 }
 
 bool SyncBackendRegistrar::IsNigoriEnabled() const {
-  DCHECK(ui_thread_->BelongsToCurrentThread());
+  DCHECK(ui_thread_checker_.CalledOnValidThread());
   base::AutoLock lock(lock_);
   return routing_info_.find(NIGORI) != routing_info_.end();
 }
 
 ModelTypeSet SyncBackendRegistrar::ConfigureDataTypes(
     ModelTypeSet types_to_add,
     ModelTypeSet types_to_remove) {
   DCHECK(Intersection(types_to_add, types_to_remove).Empty());
   ModelTypeSet filtered_types_to_add = types_to_add;
   if (workers_.count(GROUP_HISTORY) == 0) {
@@ skipping 31 matching lines @@
   last_configured_types_ = GetRoutingInfoTypes(routing_info_);
 
   return newly_added_types;
 }
 
 ModelTypeSet SyncBackendRegistrar::GetLastConfiguredTypes() const {
   return last_configured_types_;
 }
 
 void SyncBackendRegistrar::RequestWorkerStopOnUIThread() {
-  DCHECK(ui_thread_->BelongsToCurrentThread());
+  DCHECK(ui_thread_checker_.CalledOnValidThread());
   base::AutoLock lock(lock_);
   for (WorkerMap::const_iterator it = workers_.begin(); it != workers_.end();
        ++it) {
     it->second->RequestStop();
   }
 }
 
 void SyncBackendRegistrar::ActivateDataType(ModelType type,
                                             ModelSafeGroup group,
                                             ChangeProcessor* change_processor,
@@ skipping 13 matching lines @@
   processors_[type] = change_processor;
 
   // Start the change processor.
   change_processor->Start(user_share);
   DCHECK(GetProcessorUnsafe(type));
 }
 
 void SyncBackendRegistrar::DeactivateDataType(ModelType type) {
   DVLOG(1) << "Deactivate: " << ModelTypeToString(type);
 
-  DCHECK(ui_thread_->BelongsToCurrentThread() || IsControlType(type));
+  DCHECK(ui_thread_checker_.CalledOnValidThread() || IsControlType(type));
   base::AutoLock lock(lock_);
 
   routing_info_.erase(type);
   ignore_result(processors_.erase(type));
   DCHECK(!GetProcessorUnsafe(type));
 }
 
 bool SyncBackendRegistrar::IsTypeActivatedForTest(ModelType type) const {
   return GetProcessor(type) != nullptr;
 }
@@ skipping 63 matching lines @@
   // |processors_| list.
   if (it == processors_.end())
     return nullptr;
 
   return it->second;
 }
 
 bool SyncBackendRegistrar::IsCurrentThreadSafeForModel(
     ModelType model_type) const {
   lock_.AssertAcquired();
-  return IsOnThreadForGroup(model_type,
-                            GetGroupForModelType(model_type, routing_info_));
-}
+  ModelSafeGroup group = GetGroupForModelType(model_type, routing_info_);
+  DCHECK_NE(GROUP_NON_BLOCKING, group);
 
-bool SyncBackendRegistrar::IsOnThreadForGroup(ModelType type,
-                                              ModelSafeGroup group) const {
-  switch (group) {
-    case GROUP_PASSIVE:
-      return IsControlType(type);
-    case GROUP_UI:
-      return ui_thread_->BelongsToCurrentThread();
-    case GROUP_DB:
-      return db_thread_->BelongsToCurrentThread();
-    case GROUP_FILE:
-      return file_thread_->BelongsToCurrentThread();
-    case GROUP_HISTORY:
-      // TODO(sync): How to check we're on the right thread?
-      return type == TYPED_URLS;
-    case GROUP_PASSWORD:
-      // TODO(sync): How to check we're on the right thread?
-      return type == PASSWORDS;
-    case GROUP_NON_BLOCKING:
-      // IsOnThreadForGroup shouldn't be called for non-blocking types.
-      return false;
+  if (group == GROUP_PASSIVE) {
+    return IsControlType(model_type);
   }
-  NOTREACHED();
-  return false;
+
+  auto it = workers_.find(group);
+  DCHECK(it != workers_.end());
+  return it->second->IsOnModelThread();
 }
 
 SyncBackendRegistrar::~SyncBackendRegistrar() {
   // All data types should have been deactivated by now.
   DCHECK(processors_.empty());
 }
 
 void SyncBackendRegistrar::MaybeAddWorker(ModelSafeGroup group) {
   const scoped_refptr<ModelSafeWorker> worker =
       sync_client_->CreateModelWorkerForGroup(group);
   if (worker) {
     DCHECK(workers_.find(group) == workers_.end());
     workers_[group] = worker;
   }
 }
 
 ModelSafeGroup SyncBackendRegistrar::GetInitialGroupForType(
     ModelType type) const {
   return non_blocking_types_.Has(type) ? GROUP_NON_BLOCKING : GROUP_PASSIVE;
 }
 
 }  // namespace syncer