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

components/sync_bookmarks/bookmark_model_associator.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_bookmarks/bookmark_model_associator.h"
 
-#include <memory>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/containers/hash_tables.h"
 #include "base/format_macros.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
@@ skipping 285 matching lines @@
 
 void BookmarkModelAssociator::Context::MarkForVersionUpdate(
     const bookmarks::BookmarkNode* node) {
   bookmarks_for_version_update_.push_back(node);
 }
 
 BookmarkModelAssociator::BookmarkModelAssociator(
     BookmarkModel* bookmark_model,
     sync_driver::SyncClient* sync_client,
     syncer::UserShare* user_share,
-    syncer::DataTypeErrorHandler* unrecoverable_error_handler,
+    std::unique_ptr<syncer::DataTypeErrorHandler> unrecoverable_error_handler,
     bool expect_mobile_bookmarks_folder)
     : bookmark_model_(bookmark_model),
       sync_client_(sync_client),
       user_share_(user_share),
-      unrecoverable_error_handler_(unrecoverable_error_handler),
+      unrecoverable_error_handler_(std::move(unrecoverable_error_handler)),
       expect_mobile_bookmarks_folder_(expect_mobile_bookmarks_folder),
       weak_factory_(this) {
   DCHECK(bookmark_model_);
   DCHECK(user_share_);
   DCHECK(unrecoverable_error_handler_);
 }
 
 BookmarkModelAssociator::~BookmarkModelAssociator() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
@@ skipping 393 matching lines @@
   }
 
   // At this point all the children nodes of the parent sync node have
   // corresponding children in the parent bookmark node and they are all in
   // the right positions: from 0 to index - 1.
   // So the children starting from index in the parent bookmark node are the
   // ones that are not present in the parent sync node. So create them.
   for (int i = index; i < parent_node->child_count(); ++i) {
     int64_t sync_child_id = BookmarkChangeProcessor::CreateSyncNode(
         parent_node, bookmark_model_, i, trans, this,
-        unrecoverable_error_handler_);
+        unrecoverable_error_handler_.get());
     if (syncer::kInvalidId == sync_child_id) {
       return unrecoverable_error_handler_->CreateAndUploadError(
           FROM_HERE, "Failed to create sync node.", model_type());
     }
 
     context->IncrementSyncItemsAdded();
     const BookmarkNode* child_node = parent_node->GetChild(i);
     context->MarkForVersionUpdate(child_node);
     if (child_node->is_folder())
       context->PushNode(sync_child_id);
@@ skipping 41 matching lines @@
 }
 
 int BookmarkModelAssociator::RemoveSyncNodeHierarchy(
     syncer::WriteTransaction* trans,
     int64_t sync_id) {
   syncer::WriteNode sync_node(trans);
   if (sync_node.InitByIdLookup(sync_id) != syncer::BaseNode::INIT_OK) {
     syncer::SyncError error(FROM_HERE, syncer::SyncError::DATATYPE_ERROR,
                             "Could not lookup bookmark node for ID deletion.",
                             syncer::BOOKMARKS);
-    unrecoverable_error_handler_->OnSingleDataTypeUnrecoverableError(error);
+    unrecoverable_error_handler_->OnUnrecoverableError(error);
     return 0;
   }
 
   return BookmarkChangeProcessor::RemoveSyncNodeHierarchy(trans, &sync_node,
                                                           this);
 }
 
 struct FolderInfo {
   FolderInfo(const BookmarkNode* f, const BookmarkNode* p, int64_t id)
       : folder(f), parent(p), sync_id(id) {}
@@ skipping 134 matching lines @@
          iter != dirty_associations_sync_ids_.end();
          ++iter) {
       int64_t sync_id = *iter;
       syncer::WriteNode sync_node(&trans);
       if (sync_node.InitByIdLookup(sync_id) != syncer::BaseNode::INIT_OK) {
         syncer::SyncError error(
             FROM_HERE,
             syncer::SyncError::DATATYPE_ERROR,
             "Could not lookup bookmark node for ID persistence.",
             syncer::BOOKMARKS);
-        unrecoverable_error_handler_->OnSingleDataTypeUnrecoverableError(error);
+        unrecoverable_error_handler_->OnUnrecoverableError(error);
         return;
       }
       const BookmarkNode* node = GetChromeNodeFromSyncId(sync_id);
       if (node && sync_node.GetExternalId() != node->id()) {
         sync_node.SetExternalId(node->id());
         bnodes.push_back(node);
       }
     }
     dirty_associations_sync_ids_.clear();
   }
@@ skipping 49 matching lines @@
                                  syncer::BOOKMARKS);
       } else {
         context->set_native_model_sync_state(BEHIND);
       }
     }
   }
   return syncer::SyncError();
 }
 
 }  // namespace browser_sync