Revert 94128 - [Sync] Refactor sync datatype error handling.

chrome/browser/sync/glue/generic_change_processor.cc

 // Copyright (c) 2011 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/generic_change_processor.h"
 
 #include "base/tracked.h"
 #include "chrome/browser/sync/api/syncable_service.h"
 #include "chrome/browser/sync/api/sync_change.h"
-#include "chrome/browser/sync/api/sync_error.h"
 #include "chrome/browser/sync/engine/syncapi.h"
 #include "chrome/browser/sync/syncable/nigori_util.h"
 
 namespace browser_sync {
 
 GenericChangeProcessor::GenericChangeProcessor(
     SyncableService* local_service,
     UnrecoverableErrorHandler* error_handler,
     sync_api::UserShare* user_share)
     : ChangeProcessor(error_handler),
@@ skipping 42 matching lines @@
           SyncChange(action, SyncData::CreateRemoteData(*specifics)));
     }
   }
 }
 
 void GenericChangeProcessor::CommitChangesFromSyncModel() {
   if (!running())
     return;
   if (syncer_changes_.empty())
     return;
-  SyncError error = local_service_->ProcessSyncChanges(FROM_HERE,
-                                                        syncer_changes_);
+  local_service_->ProcessSyncChanges(FROM_HERE, syncer_changes_);
   syncer_changes_.clear();
-  if (error.IsSet()) {
-    error_handler()->OnUnrecoverableError(error.location(), error.message());
-  }
 }
 
-SyncError GenericChangeProcessor::GetSyncDataForType(
+bool GenericChangeProcessor::GetSyncDataForType(
     syncable::ModelType type,
     SyncDataList* current_sync_data) {
   std::string type_name = syncable::ModelTypeToString(type);
   sync_api::ReadTransaction trans(FROM_HERE, share_handle());
   sync_api::ReadNode root(&trans);
   if (!root.InitByTagLookup(syncable::ModelTypeToRootTag(type))) {
-    SyncError error(FROM_HERE,
-                    "Server did not create the top-level " + type_name +
-                    " node. We might be running against an out-of-date server.",
-                    type);
-    return error;
+    LOG(ERROR) << "Server did not create the top-level " + type_name + " node."
+               << " We might be running against an out-of-date server.";
+    return false;
   }
 
   int64 sync_child_id = root.GetFirstChildId();
   while (sync_child_id != sync_api::kInvalidId) {
     sync_api::ReadNode sync_child_node(&trans);
     if (!sync_child_node.InitByIdLookup(sync_child_id)) {
-      SyncError error(FROM_HERE,
-                      "Failed to fetch child node for type " + type_name + ".",
-                       type);
-      return error;
+      LOG(ERROR) << "Failed to fetch child node for type " + type_name + ".";
+      return false;
     }
     current_sync_data->push_back(SyncData::CreateRemoteData(
         sync_child_node.GetEntitySpecifics()));
     sync_child_id = sync_child_node.GetSuccessorId();
   }
-  return SyncError();
+  return true;
 }
 
-SyncError GenericChangeProcessor::ProcessSyncChanges(
+void GenericChangeProcessor::ProcessSyncChanges(
     const tracked_objects::Location& from_here,
     const SyncChangeList& list_of_changes) {
   sync_api::WriteTransaction trans(from_here, share_handle());
 
   for (SyncChangeList::const_iterator iter = list_of_changes.begin();
        iter != list_of_changes.end();
        ++iter) {
     const SyncChange& change = *iter;
     DCHECK_NE(change.sync_data().GetDataType(), syncable::UNSPECIFIED);
-    syncable::ModelType type = change.sync_data().GetDataType();
-    std::string type_str = syncable::ModelTypeToString(type);
+    std::string type_str = syncable::ModelTypeToString(
+        change.sync_data().GetDataType());
     sync_api::WriteNode sync_node(&trans);
     if (change.change_type() == SyncChange::ACTION_DELETE) {
       if (change.sync_data().GetTag() == "" ||
           !sync_node.InitByClientTagLookup(change.sync_data().GetDataType(),
                                            change.sync_data().GetTag())) {
         NOTREACHED();
-        SyncError error(FROM_HERE,
-                        "Failed to delete " + type_str + " node.",
-                        type);
-        error_handler()->OnUnrecoverableError(error.location(),
-                                              error.message());
-        return error;
+        error_handler()->OnUnrecoverableError(FROM_HERE,
+            "Failed to delete " + type_str + " node.");
+        return;
       }
       sync_node.Remove();
     } else if (change.change_type() == SyncChange::ACTION_ADD) {
       // TODO(sync): Handle other types of creation (custom parents, folders,
       // etc.).
       sync_api::ReadNode root_node(&trans);
       if (!root_node.InitByTagLookup(
               syncable::ModelTypeToRootTag(change.sync_data().GetDataType()))) {
         NOTREACHED();
-        SyncError error(FROM_HERE,
-                        "Failed to look up root node for type " + type_str,
-                        type);
-        error_handler()->OnUnrecoverableError(error.location(),
-                                              error.message());
-        return error;
+        error_handler()->OnUnrecoverableError(FROM_HERE,
+            "Failed to look up root node for type " + type_str);
+        return;
       }
       if (!sync_node.InitUniqueByCreation(change.sync_data().GetDataType(),
                                           root_node,
                                           change.sync_data().GetTag())) {
-        NOTREACHED();
-        SyncError error(FROM_HERE,
-                        "Failed to create " + type_str + " node.",
-                        type);
-        error_handler()->OnUnrecoverableError(error.location(),
-                                              error.message());
-        return error;
+        error_handler()->OnUnrecoverableError(FROM_HERE,
+            "Failed to create " + type_str + " node.");
+        return;
       }
       sync_node.SetTitle(UTF8ToWide(change.sync_data().GetTitle()));
       sync_node.SetEntitySpecifics(change.sync_data().GetSpecifics());
     } else if (change.change_type() == SyncChange::ACTION_UPDATE) {
       if (change.sync_data().GetTag() == "" ||
           !sync_node.InitByClientTagLookup(change.sync_data().GetDataType(),
                                            change.sync_data().GetTag())) {
         NOTREACHED();
-        SyncError error(FROM_HERE,
-                        "Failed to update " + type_str + " node.",
-                        type);
-        error_handler()->OnUnrecoverableError(error.location(),
-                                              error.message());
-        return error;
+        error_handler()->OnUnrecoverableError(FROM_HERE,
+            "Failed to update " + type_str + " node");
+        return;
       }
       sync_node.SetTitle(UTF8ToWide(change.sync_data().GetTitle()));
       sync_node.SetEntitySpecifics(change.sync_data().GetSpecifics());
       // TODO(sync): Support updating other parts of the sync node (title,
       // successor, parent, etc.).
     } else {
       NOTREACHED();
-      SyncError error(FROM_HERE,
-                      "Received unset SyncChange in the change processor.",
-                      type);
-      error_handler()->OnUnrecoverableError(error.location(),
-                                            error.message());
-      return error;
+      error_handler()->OnUnrecoverableError(FROM_HERE,
+          "Received unset SyncChange in the change processor.");
+      return;
     }
   }
-  return SyncError();
 }
 
 bool GenericChangeProcessor::SyncModelHasUserCreatedNodes(
     syncable::ModelType type,
     bool* has_nodes) {
   DCHECK(has_nodes);
   DCHECK_NE(type, syncable::UNSPECIFIED);
   std::string type_name = syncable::ModelTypeToString(type);
   std::string err_str = "Server did not create the top-level " + type_name +
       " node. We might be running against an out-of-date server.";
@@ skipping 23 matching lines @@
 
 void GenericChangeProcessor::StartImpl(Profile* profile) {}
 
 void GenericChangeProcessor::StopImpl() {}
 
 sync_api::UserShare* GenericChangeProcessor::share_handle() {
   return user_share_;
 }
 
 }  // namespace browser_sync