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

sync/api/sync_data.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 "sync/api/sync_data.h"
 
 #include <ostream>
 
 #include "base/json/json_writer.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 45 matching lines @@
 sync_pb::SyncEntity* SyncData::ImmutableSyncEntityTraits::UnwrapMutable(
     Wrapper* wrapper) {
   return *wrapper;
 }
 
 void SyncData::ImmutableSyncEntityTraits::Swap(sync_pb::SyncEntity* t1,
                                                sync_pb::SyncEntity* t2) {
   t1->Swap(t2);
 }
 
-SyncData::SyncData() : is_valid_(false), id_(kInvalidId) {}
+SyncData::SyncData()
+    : local_(NULL), remote_(NULL), is_valid_(false), id_(kInvalidId) {}
 
-SyncData::SyncData(
-    int64 id,
-    sync_pb::SyncEntity* entity,
-    AttachmentList* attachments,
-    const base::Time& remote_modification_time,
-    const syncer::AttachmentServiceProxy& attachment_service)
-    : is_valid_(true),
+SyncData::SyncData(int64 id,
+                   sync_pb::SyncEntity* entity,
+                   AttachmentList* attachments,
+                   const base::Time& remote_modification_time,
+                   const syncer::AttachmentServiceProxy& attachment_service)
+    : local_(this),
+      remote_(this),
+      is_valid_(true),
       id_(id),
       remote_modification_time_(remote_modification_time),
       immutable_entity_(entity),
       attachments_(attachments),
-      attachment_service_(attachment_service) {}
+      attachment_service_(attachment_service) {
+  if (IsLocal()) {
+    remote_ = Remote(NULL);
+  } else {
+    local_ = Local(NULL);
+  }
+}
 
 SyncData::~SyncData() {}
 
 // Static.
 SyncData SyncData::CreateLocalDelete(const std::string& sync_tag,
                                      ModelType datatype) {
   sync_pb::EntitySpecifics specifics;
   AddDefaultFieldValue(datatype, &specifics);
   return CreateLocalData(sync_tag, std::string(), specifics);
 }
@@ skipping 68 matching lines @@
 bool SyncData::IsValid() const { return is_valid_; }
 
 const sync_pb::EntitySpecifics& SyncData::GetSpecifics() const {
   return immutable_entity_.Get().specifics();
 }
 
 ModelType SyncData::GetDataType() const {
   return GetModelTypeFromSpecifics(GetSpecifics());
 }
 
-const std::string& SyncData::GetTag() const {
-  DCHECK(IsLocal());
-  return immutable_entity_.Get().client_defined_unique_tag();
-}
-
 const std::string& SyncData::GetTitle() const {
   // TODO(zea): set this for data coming from the syncer too.
   DCHECK(immutable_entity_.Get().has_non_unique_name());
   return immutable_entity_.Get().non_unique_name();
 }
 
-const base::Time& SyncData::GetRemoteModifiedTime() const {
-  DCHECK(!IsLocal());
-  return remote_modification_time_;
-}
-
-int64 SyncData::GetRemoteId() const {
-  DCHECK(!IsLocal());
-  return id_;
-}
-
 bool SyncData::IsLocal() const { return id_ == kInvalidId; }
 
 std::string SyncData::ToString() const {
   if (!IsValid())
     return "<Invalid SyncData>";
 
   std::string type = ModelTypeToString(GetDataType());
   std::string specifics;
   scoped_ptr<base::DictionaryValue> value(
       EntitySpecificsToValue(GetSpecifics()));
   base::JSONWriter::WriteWithOptions(
       value.get(), base::JSONWriter::OPTIONS_PRETTY_PRINT, &specifics);
 
   if (IsLocal()) {
-    return "{ isLocal: true, type: " + type + ", tag: " + GetTag() +
+    return "{ isLocal: true, type: " + type + ", tag: " + local().GetTag() +
            ", title: " + GetTitle() + ", specifics: " + specifics + "}";
   }
 
-  std::string id = base::Int64ToString(GetRemoteId());
+  std::string id = base::Int64ToString(remote().GetRemoteId());
   return "{ isLocal: false, type: " + type + ", specifics: " + specifics +
          ", id: " + id + "}";
 }
 
 void PrintTo(const SyncData& sync_data, std::ostream* os) {
   *os << sync_data.ToString();
 }
 
 AttachmentIdList SyncData::GetAttachmentIds() const {
   AttachmentIdList result;
   const sync_pb::SyncEntity& entity = immutable_entity_.Get();
   std::transform(entity.attachment_id().begin(),
                  entity.attachment_id().end(),
                  std::back_inserter(result),
                  ProtoToId);
   return result;
 }
 
-const AttachmentList& SyncData::GetLocalAttachmentsForUpload() const {
-  DCHECK(IsLocal());
-  return attachments_.Get();
+const AttachmentList& SyncData::Local::GetLocalAttachmentsForUpload() const {
+  return sync_data_->attachments_.Get();
 }
 
-void SyncData::GetOrDownloadAttachments(
+const std::string& SyncData::Local::GetTag() const {
+  return sync_data_->immutable_entity_.Get().client_defined_unique_tag();
+}
+
+const SyncData::Local& SyncData::local() const {
+  DCHECK(IsLocal());
+    return local_;
+}
+
+const base::Time& SyncData::Remote::GetRemoteModifiedTime() const {
+  return sync_data_->remote_modification_time_;
+}
+
+int64 SyncData::Remote::GetRemoteId() const {
+  return sync_data_->id_;
+}
+
+void SyncData::Remote::GetOrDownloadAttachments(
     const AttachmentIdList& attachment_ids,
     const AttachmentService::GetOrDownloadCallback& callback) {
-  DCHECK(!IsLocal());
-  attachment_service_.GetOrDownloadAttachments(attachment_ids, callback);
+  sync_data_->attachment_service_.GetOrDownloadAttachments(attachment_ids,
+                                                           callback);
 }
 
-void SyncData::DropAttachments(
+void SyncData::Remote::DropAttachments(
     const AttachmentIdList& attachment_ids,
     const AttachmentService::DropCallback& callback) {
+  sync_data_->attachment_service_.DropAttachments(attachment_ids, callback);
+}
+
+SyncData::Remote& SyncData::remote() {
   DCHECK(!IsLocal());
-  attachment_service_.DropAttachments(attachment_ids, callback);
+  return remote_;
+}
+
+const SyncData::Remote& SyncData::remote() const {
+  DCHECK(!IsLocal());
+  return remote_;
 }
 
 }  // namespace syncer