Separate SyncData methods into three groups, local, remote, and common.

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 273 matching lines @@
 }
 
 syncer::SyncError AttemptDelete(
     const syncer::SyncChange& change,
     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();
+    const std::string& tag = syncer::SyncDataLocal(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 =
         node->InitByClientTagLookup(change.sync_data().GetDataType(), tag);
     if (result != syncer::BaseNode::INIT_OK) {
       return LogLookupFailure(
           result, FROM_HERE,
           "Failed to delete " + type_str + " node. Local data. " +
               change.location().ToString(),
           type, error_handler);
     }
   } else {
-    syncer::BaseNode::InitByLookupResult result =
-        node->InitByIdLookup(change.sync_data().GetRemoteId());
+    syncer::BaseNode::InitByLookupResult result = node->InitByIdLookup(
+        syncer::SyncDataRemote(change.sync_data()).GetId());
     if (result != syncer::BaseNode::INIT_OK) {
       return LogLookupFailure(
           result, FROM_HERE,
           "Failed to delete " + type_str + " node. Non-local data. " +
               change.location().ToString(),
           type, error_handler);
     }
   }
   if (IsActOnceDataType(type))
     node->Drop();
@@ skipping 78 matching lines @@
                             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());
+      sync_node->InitUniqueByCreation(
+          change.sync_data().GetDataType(),
+          root_node,
+          syncer::SyncDataLocal(change.sync_data()).GetTag());
   if (result != syncer::WriteNode::INIT_SUCCESS) {
     std::string error_prefix = "Failed to create " + type_str + " node: " +
                                change.location().ToString() + ", ";
     switch (result) {
       case syncer::WriteNode::INIT_FAILED_EMPTY_TAG: {
         syncer::SyncError error;
         error.Reset(FROM_HERE, error_prefix + "empty tag", type);
         error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
                                                             error.message());
         LOG(ERROR) << "Create: Empty tag.";
@@ skipping 47 matching lines @@
 // the compiler attempts to merge it with other calls, losing useful information
 // in breakpad uploads.
 syncer::SyncError GenericChangeProcessor::HandleActionUpdate(
     const syncer::SyncChange& change,
     const std::string& type_str,
     const syncer::ModelType& type,
     const syncer::WriteTransaction& trans,
     syncer::WriteNode* sync_node) {
   // TODO(zea): consider having this logic for all possible changes?
   syncer::BaseNode::InitByLookupResult result =
-      sync_node->InitByClientTagLookup(change.sync_data().GetDataType(),
-                                       change.sync_data().GetTag());
+      sync_node->InitByClientTagLookup(
+          change.sync_data().GetDataType(),
+          syncer::SyncDataLocal(change.sync_data()).GetTag());
   if (result != syncer::BaseNode::INIT_OK) {
     std::string error_prefix = "Failed to load " + type_str + " node. " +
                                change.location().ToString() + ", ";
     if (result == syncer::BaseNode::INIT_FAILED_PRECONDITION) {
       syncer::SyncError error;
       error.Reset(FROM_HERE, error_prefix + "empty tag", type);
       error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
                                                           error.message());
       LOG(ERROR) << "Update: Empty tag.";
       return error;
@@ skipping 117 matching lines @@
 void GenericChangeProcessor::StartImpl(Profile* profile) {
   DCHECK(CalledOnValidThread());
 }
 
 syncer::UserShare* GenericChangeProcessor::share_handle() const {
   DCHECK(CalledOnValidThread());
   return share_handle_;
 }
 
 }  // namespace browser_sync