[Sync] Convert DTCs to be not RefCounted and NonThreadSafe.

components/sync/driver/shared_change_processor.cc

 // Copyright 2014 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/shared_change_processor.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/threading/thread_task_runner_handle.h"
+#include "components/sync/api/data_type_error_handler.h"
 #include "components/sync/api/sync_change.h"
 #include "components/sync/api/syncable_service.h"
 #include "components/sync/base/data_type_histogram.h"
-#include "components/sync/core/data_type_error_handler.h"
 #include "components/sync/driver/generic_change_processor.h"
 #include "components/sync/driver/generic_change_processor_factory.h"
 #include "components/sync/driver/shared_change_processor_ref.h"
 #include "components/sync/driver/sync_client.h"
 
 using base::AutoLock;
 
 namespace syncer {
 class AttachmentService;
 }
 
 namespace sync_driver {
 
 SharedChangeProcessor::SharedChangeProcessor(syncer::ModelType type)
     : disconnected_(false),
       type_(type),
       frontend_task_runner_(base::ThreadTaskRunnerHandle::Get()),
-      generic_change_processor_(NULL),
-      error_handler_(NULL) {
+      generic_change_processor_(NULL) {
   DCHECK_NE(type_, syncer::UNSPECIFIED);
 }
 
 SharedChangeProcessor::~SharedChangeProcessor() {
   // We can either be deleted when the DTC is destroyed (on UI
   // thread), or when the syncer::SyncableService stops syncing (datatype
   // thread).  |generic_change_processor_|, if non-NULL, must be
   // deleted on |backend_loop_|.
   if (backend_task_runner_.get()) {
     if (backend_task_runner_->BelongsToCurrentThread()) {
       delete generic_change_processor_;
     } else {
       DCHECK(frontend_task_runner_->BelongsToCurrentThread());
       if (!backend_task_runner_->DeleteSoon(FROM_HERE,
                                             generic_change_processor_)) {
         NOTREACHED();
       }
     }
   } else {
     DCHECK(!generic_change_processor_);
   }
 }
 
 void SharedChangeProcessor::StartAssociation(
     StartDoneCallback start_done,
     SyncClient* const sync_client,
     syncer::UserShare* user_share,
-    syncer::DataTypeErrorHandler* error_handler) {
+    std::unique_ptr<syncer::DataTypeErrorHandler> error_handler) {
   DCHECK(user_share);
   syncer::SyncMergeResult local_merge_result(type_);
   syncer::SyncMergeResult syncer_merge_result(type_);
   base::WeakPtrFactory<syncer::SyncMergeResult> weak_ptr_factory(
       &syncer_merge_result);
 
   // Connect |shared_change_processor| to the syncer and get the
   // syncer::SyncableService associated with type_.
   // Note that it's possible the shared_change_processor has already been
   // disconnected at this point, so all our accesses to the syncer from this
   // point on are through it.
   GenericChangeProcessorFactory factory;
-  local_service_ = Connect(sync_client, &factory, user_share, error_handler,
-                           weak_ptr_factory.GetWeakPtr());
+  local_service_ =
+      Connect(sync_client, &factory, user_share, std::move(error_handler),
+              weak_ptr_factory.GetWeakPtr());
   if (!local_service_.get()) {
     syncer::SyncError error(FROM_HERE, syncer::SyncError::DATATYPE_ERROR,
                             "Failed to connect to syncer.", type_);
     local_merge_result.set_error(error);
     start_done.Run(DataTypeController::ASSOCIATION_FAILED, local_merge_result,
                    syncer_merge_result);
     return;
   }
 
   if (!CryptoReadyIfNecessary()) {
@@ skipping 56 matching lines @@
 
   start_done.Run(!sync_has_nodes ? DataTypeController::OK_FIRST_RUN
                                  : DataTypeController::OK,
                  local_merge_result, syncer_merge_result);
 }
 
 base::WeakPtr<syncer::SyncableService> SharedChangeProcessor::Connect(
     SyncClient* sync_client,
     GenericChangeProcessorFactory* processor_factory,
     syncer::UserShare* user_share,
-    syncer::DataTypeErrorHandler* error_handler,
+    std::unique_ptr<syncer::DataTypeErrorHandler> error_handler,
     const base::WeakPtr<syncer::SyncMergeResult>& merge_result) {
   DCHECK(sync_client);
   DCHECK(error_handler);
   backend_task_runner_ = base::ThreadTaskRunnerHandle::Get();
   AutoLock lock(monitor_lock_);
   if (disconnected_)
     return base::WeakPtr<syncer::SyncableService>();
-  error_handler_ = error_handler;
+  error_handler_ = std::move(error_handler);
   base::WeakPtr<syncer::SyncableService> local_service =
       sync_client->GetSyncableServiceForType(type_);
   if (!local_service.get()) {
     LOG(WARNING) << "SyncableService destroyed before DTC was stopped.";
     disconnected_ = true;
     return base::WeakPtr<syncer::SyncableService>();
   }
 
   generic_change_processor_ = processor_factory
                                   ->CreateGenericChangeProcessor(
-                                      type_, user_share, error_handler,
+                                      type_, user_share, error_handler_->Copy(),
                                       local_service, merge_result, sync_client)
                                   .release();
   // If available, propagate attachment service to the syncable service.
   std::unique_ptr<syncer::AttachmentService> attachment_service =
       generic_change_processor_->GetAttachmentService();
   if (attachment_service) {
     local_service->SetAttachmentService(std::move(attachment_service));
   }
   return local_service;
 }
 
 bool SharedChangeProcessor::Disconnect() {
   // May be called from any thread.
   DVLOG(1) << "Disconnecting change processor.";
   AutoLock lock(monitor_lock_);
   bool was_connected = !disconnected_;
   disconnected_ = true;
-  error_handler_ = NULL;
+  error_handler_.reset();
   return was_connected;
 }
 
 ChangeProcessor* SharedChangeProcessor::generic_change_processor() {
   return generic_change_processor_;
 }
 
 int SharedChangeProcessor::GetSyncCount() {
   DCHECK(backend_task_runner_.get());
   DCHECK(backend_task_runner_->BelongsToCurrentThread());
@@ skipping 111 matching lines @@
 #undef PER_DATA_TYPE_MACRO
 }
 
 void SharedChangeProcessor::StopLocalService() {
   if (local_service_.get())
     local_service_->StopSyncing(type_);
   local_service_.reset();
 }
 
 }  // namespace sync_driver