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

components/sync_bookmarks/bookmark_change_processor.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_change_processor.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <stack>
 #include <string>
-#include <vector>
+#include <utility>
 
 #include "base/location.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/bookmarks/browser/bookmark_client.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "components/bookmarks/browser/bookmark_utils.h"
 #include "components/favicon/core/favicon_service.h"
@@ skipping 15 matching lines @@
 using syncer::ChangeRecord;
 using syncer::ChangeRecordList;
 
 namespace browser_sync {
 
 static const char kMobileBookmarksTag[] = "synced_bookmarks";
 
 BookmarkChangeProcessor::BookmarkChangeProcessor(
     sync_driver::SyncClient* sync_client,
     BookmarkModelAssociator* model_associator,
-    syncer::DataTypeErrorHandler* error_handler)
-    : sync_driver::ChangeProcessor(error_handler),
+    std::unique_ptr<syncer::DataTypeErrorHandler> err_handler)
+    : sync_driver::ChangeProcessor(std::move(err_handler)),
       bookmark_model_(NULL),
       sync_client_(sync_client),
       model_associator_(model_associator) {
   DCHECK(model_associator);
   DCHECK(sync_client);
-  DCHECK(error_handler);
+  DCHECK(error_handler());
 }
 
 BookmarkChangeProcessor::~BookmarkChangeProcessor() {
   if (bookmark_model_)
     bookmark_model_->RemoveObserver(this);
 }
 
 void BookmarkChangeProcessor::StartImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!bookmark_model_);
@@ skipping 63 matching lines @@
   int64_t new_version = syncer::syncable::kInvalidTransactionVersion;
   {
     syncer::WriteTransaction trans(FROM_HERE, share_handle(), &new_version);
     syncer::WriteNode topmost_sync_node(&trans);
     if (!model_associator_->InitSyncNodeFromChromeId(topmost->id(),
                                                      &topmost_sync_node)) {
       syncer::SyncError error(FROM_HERE,
                               syncer::SyncError::DATATYPE_ERROR,
                               "Failed to init sync node from chrome node",
                               syncer::BOOKMARKS);
-      error_handler()->OnSingleDataTypeUnrecoverableError(error);
+      error_handler()->OnUnrecoverableError(error);
       return;
     }
     RemoveSyncNodeHierarchy(&trans, &topmost_sync_node, model_associator_);
   }
 
   // Don't need to update versions of deleted nodes.
   UpdateTransactionVersion(new_version, bookmark_model_,
                            std::vector<const BookmarkNode*>());
 }
 
@@ skipping 153 matching lines @@
   const BookmarkNode* child = parent->GetChild(index);
   DCHECK(child);
 
   // Create a WriteNode container to hold the new node.
   syncer::WriteNode sync_child(trans);
 
   // Actually create the node with the appropriate initial position.
   if (!PlaceSyncNode(CREATE, parent, index, trans, &sync_child, associator)) {
     syncer::SyncError error(FROM_HERE, syncer::SyncError::DATATYPE_ERROR,
                             "Failed to create sync node.", syncer::BOOKMARKS);
-    error_handler->OnSingleDataTypeUnrecoverableError(error);
+    error_handler->OnUnrecoverableError(error);
     return syncer::kInvalidId;
   }
 
   UpdateSyncNodeProperties(child, model, &sync_child, error_handler);
 
   // Associate the ID from the sync domain with the bookmark node, so that we
   // can refer back to this item later.
   associator->Associate(child, sync_child);
 
   return sync_child.GetId();
@@ skipping 43 matching lines @@
     syncer::WriteTransaction* trans,
     BookmarkModelAssociator* associator,
     syncer::DataTypeErrorHandler* error_handler) {
   // Lookup the sync node that's associated with |node|.
   syncer::WriteNode sync_node(trans);
   if (!associator->InitSyncNodeFromChromeId(node->id(), &sync_node)) {
     syncer::SyncError error(FROM_HERE,
                             syncer::SyncError::DATATYPE_ERROR,
                             "Failed to init sync node from chrome node",
                             syncer::BOOKMARKS);
-    error_handler->OnSingleDataTypeUnrecoverableError(error);
+    error_handler->OnUnrecoverableError(error);
     return syncer::kInvalidId;
   }
   UpdateSyncNodeProperties(node, model, &sync_node, error_handler);
   DCHECK_EQ(sync_node.GetIsFolder(), node->is_folder());
   DCHECK_EQ(associator->GetChromeNodeFromSyncId(sync_node.GetParentId()),
             node->parent());
   DCHECK_EQ(node->parent()->GetIndexOf(node), sync_node.GetPositionIndex());
   return sync_node.GetId();
 }
 
@@ skipping 21 matching lines @@
     // Acquire a scoped write lock via a transaction.
     syncer::WriteTransaction trans(FROM_HERE, share_handle(), &new_version);
 
     // Lookup the sync node that's associated with |child|.
     syncer::WriteNode sync_node(&trans);
     if (!model_associator_->InitSyncNodeFromChromeId(child->id(), &sync_node)) {
       syncer::SyncError error(FROM_HERE,
                               syncer::SyncError::DATATYPE_ERROR,
                               "Failed to init sync node from chrome node",
                               syncer::BOOKMARKS);
-      error_handler()->OnSingleDataTypeUnrecoverableError(error);
+      error_handler()->OnUnrecoverableError(error);
       return;
     }
 
     if (!PlaceSyncNode(MOVE, new_parent, new_index, &trans, &sync_node,
                        model_associator_)) {
       syncer::SyncError error(FROM_HERE,
                               syncer::SyncError::DATATYPE_ERROR,
                               "Failed to place sync node",
                               syncer::BOOKMARKS);
-      error_handler()->OnSingleDataTypeUnrecoverableError(error);
+      error_handler()->OnUnrecoverableError(error);
       return;
     }
   }
 
   UpdateTransactionVersion(new_version, model,
                            std::vector<const BookmarkNode*>(1, child));
 }
 
 void BookmarkChangeProcessor::BookmarkNodeFaviconChanged(
     BookmarkModel* model,
@@ skipping 41 matching lines @@
       const BookmarkNode* child = node->GetChild(i);
       children.push_back(child);
 
       syncer::WriteNode sync_child(&trans);
       if (!model_associator_->InitSyncNodeFromChromeId(child->id(),
                                                        &sync_child)) {
         syncer::SyncError error(FROM_HERE,
                                 syncer::SyncError::DATATYPE_ERROR,
                                 "Failed to init sync node from chrome node",
                                 syncer::BOOKMARKS);
-        error_handler()->OnSingleDataTypeUnrecoverableError(error);
+        error_handler()->OnUnrecoverableError(error);
         return;
       }
       DCHECK_EQ(sync_child.GetParentId(),
                 model_associator_->GetSyncIdFromChromeId(node->id()));
 
       if (!PlaceSyncNode(MOVE, node, i, &trans, &sync_child,
                          model_associator_)) {
         syncer::SyncError error(FROM_HERE,
                                 syncer::SyncError::DATATYPE_ERROR,
                                 "Failed to place sync node",
                                 syncer::BOOKMARKS);
-        error_handler()->OnSingleDataTypeUnrecoverableError(error);
+        error_handler()->OnUnrecoverableError(error);
         return;
       }
     }
   }
 
   // TODO(haitaol): Filter out children that didn't actually change.
   UpdateTransactionVersion(new_version, model, children);
 }
 
 // static
@@ skipping 104 matching lines @@
     if (!dst->empty()) {
       if (!foster_parent) {
         foster_parent = model->AddFolder(model->other_node(),
                                          model->other_node()->child_count(),
                                          base::string16());
         if (!foster_parent) {
           syncer::SyncError error(FROM_HERE,
                                   syncer::SyncError::DATATYPE_ERROR,
                                   "Failed to create foster parent",
                                   syncer::BOOKMARKS);
-          error_handler()->OnSingleDataTypeUnrecoverableError(error);
+          error_handler()->OnUnrecoverableError(error);
           return;
         }
       }
       for (int i = dst->child_count() - 1; i >= 0; --i) {
         model->Move(dst->GetChild(i), foster_parent,
                     foster_parent->child_count());
       }
     }
     DCHECK_EQ(dst->child_count(), 0) << "Node being deleted has children";
 
@@ skipping 40 matching lines @@
 
     DCHECK_NE(it->action, ChangeRecord::ACTION_DELETE)
         << "We should have passed all deletes by this point.";
 
     syncer::ReadNode src(trans);
     if (src.InitByIdLookup(it->id) != syncer::BaseNode::INIT_OK) {
       syncer::SyncError error(FROM_HERE,
                               syncer::SyncError::DATATYPE_ERROR,
                               "Failed to load sync node",
                               syncer::BOOKMARKS);
-      error_handler()->OnSingleDataTypeUnrecoverableError(error);
+      error_handler()->OnUnrecoverableError(error);
       return;
     }
 
     const BookmarkNode* parent =
         model_associator_->GetChromeNodeFromSyncId(src.GetParentId());
     if (!parent) {
       LOG(ERROR) << "Could not find parent of node being added/updated."
         << " Node title: " << src.GetTitle()
         << ", parent id = " << src.GetParentId();
       continue;
@@ skipping 271 matching lines @@
     updated_specifics.set_icon_url(bookmark_node->icon_url().spec());
     sync_node->SetBookmarkSpecifics(updated_specifics);
   }
 }
 
 bool BookmarkChangeProcessor::CanSyncNode(const BookmarkNode* node) {
   return bookmark_model_->client()->CanSyncNode(node);
 }
 
 }  // namespace browser_sync