[Sync] Add support for sync Persistence Errors

chrome/browser/sync/glue/generic_change_processor.cc

 // Copyright (c) 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 "chrome/browser/sync/glue/generic_change_processor.h"
 
 #include "base/location.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 65 matching lines @@
     }
   }
 }
 
 void GenericChangeProcessor::CommitChangesFromSyncModel() {
   DCHECK(CalledOnValidThread());
   if (syncer_changes_.empty())
     return;
   if (!local_service_.get()) {
     syncer::ModelType type = syncer_changes_[0].sync_data().GetDataType();
-    syncer::SyncError error(FROM_HERE, "Local service destroyed.", type);
+    syncer::SyncError error(FROM_HERE,
+                            syncer::SyncError::DATATYPE_ERROR,
+                            "Local service destroyed.",
+                            type);
     error_handler()->OnSingleDatatypeUnrecoverableError(error.location(),
                                                         error.message());
     return;
   }
   syncer::SyncError error = local_service_->ProcessSyncChanges(FROM_HERE,
                                                        syncer_changes_);
   syncer_changes_.clear();
   if (error.IsSet()) {
     error_handler()->OnSingleDatatypeUnrecoverableError(
         error.location(), error.message());
   }
 }
 
 syncer::SyncError GenericChangeProcessor::GetSyncDataForType(
     syncer::ModelType type,
     syncer::SyncDataList* current_sync_data) {
   DCHECK(CalledOnValidThread());
   std::string type_name = syncer::ModelTypeToString(type);
   syncer::ReadTransaction trans(FROM_HERE, share_handle());
   syncer::ReadNode root(&trans);
   if (root.InitByTagLookup(syncer::ModelTypeToRootTag(type)) !=
           syncer::BaseNode::INIT_OK) {
     syncer::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);
+                            syncer::SyncError::DATATYPE_ERROR,
+                            "Server did not create the top-level " + type_name +
+                                " node. We might be running against an out-of-"
+                                "date server.",
+                            type);
     return error;
   }
 
   // TODO(akalin): We'll have to do a tree traversal for bookmarks.
   DCHECK_NE(type, syncer::BOOKMARKS);
 
   std::vector<int64> child_ids;
   root.GetChildIds(&child_ids);
 
   for (std::vector<int64>::iterator it = child_ids.begin();
        it != child_ids.end(); ++it) {
     syncer::ReadNode sync_child_node(&trans);
     if (sync_child_node.InitByIdLookup(*it) !=
             syncer::BaseNode::INIT_OK) {
       syncer::SyncError error(FROM_HERE,
-                      "Failed to fetch child node for type " + type_name + ".",
-                       type);
+                              syncer::SyncError::DATATYPE_ERROR,
+                              "Failed to fetch child node for type " +
+                                  type_name + ".",
+                              type);
       return error;
     }
     current_sync_data->push_back(syncer::SyncData::CreateRemoteData(
         sync_child_node.GetId(), sync_child_node.GetEntitySpecifics()));
   }
   return syncer::SyncError();
 }
 
 int GenericChangeProcessor::GetSyncCountForType(syncer::ModelType type) {
   syncer::ReadTransaction trans(FROM_HERE, share_handle());
@@ skipping 74 matching lines @@
     syncer::ModelType type,
     const std::string& type_str,
     syncer::WriteNode* node,
     DataTypeErrorHandler* error_handler) {
   DCHECK_EQ(change.change_type(), syncer::SyncChange::ACTION_DELETE);
   if (change.sync_data().IsLocal()) {
     const std::string& tag = change.sync_data().GetTag();
     if (tag.empty()) {
       syncer::SyncError error(
           FROM_HERE,
+          syncer::SyncError::DATATYPE_ERROR,
           "Failed to delete " + type_str + " node. Local data, empty tag. " +
               change.location().ToString(),
           type);
       error_handler->OnSingleDatatypeUnrecoverableError(error.location(),
                                                         error.message());
       NOTREACHED();
       return error;
     }
 
     syncer::BaseNode::InitByLookupResult result =
@@ skipping 56 matching lines @@
             merge_result_->num_items_deleted() + 1);
       }
     } else if (change.change_type() == syncer::SyncChange::ACTION_ADD) {
       // TODO(sync): Handle other types of creation (custom parents, folders,
       // etc.).
       syncer::ReadNode root_node(&trans);
       if (root_node.InitByTagLookup(
               syncer::ModelTypeToRootTag(change.sync_data().GetDataType())) !=
                   syncer::BaseNode::INIT_OK) {
         syncer::SyncError error(FROM_HERE,
-                        "Failed to look up root node for type " + type_str,
-                        type);
+                                syncer::SyncError::DATATYPE_ERROR,
+                                "Failed to look up root node for type " +
+                                    type_str,
+                                type);
         error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
                                                             error.message());
         NOTREACHED();
         LOG(ERROR) << "Create: no root node.";
         return error;
       }
       syncer::WriteNode::InitUniqueByCreationResult result =
           sync_node.InitUniqueByCreation(change.sync_data().GetDataType(),
                                           root_node,
                                           change.sync_data().GetTag());
@@ skipping 142 matching lines @@
       sync_node.SetEntitySpecifics(change.sync_data().GetSpecifics());
       if (merge_result_.get()) {
         merge_result_->set_num_items_modified(
             merge_result_->num_items_modified() + 1);
       }
       // TODO(sync): Support updating other parts of the sync node (title,
       // successor, parent, etc.).
     } else {
       syncer::SyncError error(
           FROM_HERE,
+          syncer::SyncError::DATATYPE_ERROR,
           "Received unset SyncChange in the change processor, " +
               change.location().ToString(),
           type);
       error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
                                                           error.message());
       NOTREACHED();
       LOG(ERROR) << "Unset sync change.";
       return error;
     }
   }
@@ skipping 37 matching lines @@
 void GenericChangeProcessor::StartImpl(Profile* profile) {
   DCHECK(CalledOnValidThread());
 }
 
 syncer::UserShare* GenericChangeProcessor::share_handle() const {
   DCHECK(CalledOnValidThread());
   return share_handle_;
 }
 
 }  // namespace browser_sync