src/sync/api/sync_data.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "sync/api/sync_data.h"
   6
   7 #include <ostream>
   8
   9 #include "base/json/json_writer.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "base/strings/string_number_conversions.h"
  12 #include "base/values.h"
  13 #include "sync/internal_api/public/base/model_type.h"
  14 #include "sync/internal_api/public/base_node.h"
  15 #include "sync/protocol/proto_value_conversions.h"
  16 #include "sync/protocol/sync.pb.h"
  17
  18 namespace syncer {
  19
  20 void SyncData::ImmutableSyncEntityTraits::InitializeWrapper(
  21     Wrapper* wrapper) {
  22   *wrapper = new sync_pb::SyncEntity();
  23 }
  24
  25 void SyncData::ImmutableSyncEntityTraits::DestroyWrapper(
  26     Wrapper* wrapper) {
  27   delete *wrapper;
  28 }
  29
  30 const sync_pb::SyncEntity& SyncData::ImmutableSyncEntityTraits::Unwrap(
  31     const Wrapper& wrapper) {
  32   return *wrapper;
  33 }
  34
  35 sync_pb::SyncEntity* SyncData::ImmutableSyncEntityTraits::UnwrapMutable(
  36     Wrapper* wrapper) {
  37   return *wrapper;
  38 }
  39
  40 void SyncData::ImmutableSyncEntityTraits::Swap(sync_pb::SyncEntity* t1,
  41                                                sync_pb::SyncEntity* t2) {
  42   t1->Swap(t2);
  43 }
  44
  45 SyncData::SyncData()
  46     : is_valid_(false),
  47       id_(kInvalidId) {}
  48
  49 SyncData::SyncData(int64 id,
  50                    sync_pb::SyncEntity* entity,
  51                    const base::Time& remote_modification_time)
  52     : is_valid_(true),
  53       id_(id),
  54       remote_modification_time_(remote_modification_time),
  55       immutable_entity_(entity) {}
  56
  57 SyncData::~SyncData() {}
  58
  59 // Static.
  60 SyncData SyncData::CreateLocalDelete(
  61     const std::string& sync_tag,
  62     ModelType datatype) {
  63   sync_pb::EntitySpecifics specifics;
  64   AddDefaultFieldValue(datatype, &specifics);
  65   return CreateLocalData(sync_tag, std::string(), specifics);
  66 }
  67
  68 // Static.
  69 SyncData SyncData::CreateLocalData(
  70     const std::string& sync_tag,
  71     const std::string& non_unique_title,
  72     const sync_pb::EntitySpecifics& specifics) {
  73   sync_pb::SyncEntity entity;
  74   entity.set_client_defined_unique_tag(sync_tag);
  75   entity.set_non_unique_name(non_unique_title);
  76   entity.mutable_specifics()->CopyFrom(specifics);
  77   return SyncData(kInvalidId, &entity, base::Time());
  78 }
  79
  80 // Static.
  81 SyncData SyncData::CreateRemoteData(
  82     int64 id, const sync_pb::EntitySpecifics& specifics,
  83     const base::Time& modification_time) {
  84   DCHECK_NE(id, kInvalidId);
  85   sync_pb::SyncEntity entity;
  86   entity.mutable_specifics()->CopyFrom(specifics);
  87   return SyncData(id, &entity, modification_time);
  88 }
  89
  90 bool SyncData::IsValid() const {
  91   return is_valid_;
  92 }
  93
  94 const sync_pb::EntitySpecifics& SyncData::GetSpecifics() const {
  95   return immutable_entity_.Get().specifics();
  96 }
  97
  98 ModelType SyncData::GetDataType() const {
  99   return GetModelTypeFromSpecifics(GetSpecifics());
 100 }
 101
 102 const std::string& SyncData::GetTag() const {
 103   DCHECK(IsLocal());
 104   return immutable_entity_.Get().client_defined_unique_tag();
 105 }
 106
 107 const std::string& SyncData::GetTitle() const {
 108   // TODO(zea): set this for data coming from the syncer too.
 109   DCHECK(immutable_entity_.Get().has_non_unique_name());
 110   return immutable_entity_.Get().non_unique_name();
 111 }
 112
 113 const base::Time& SyncData::GetRemoteModifiedTime() const {
 114   DCHECK(!IsLocal());
 115   return remote_modification_time_;
 116 }
 117
 118 int64 SyncData::GetRemoteId() const {
 119   DCHECK(!IsLocal());
 120   return id_;
 121 }
 122
 123 bool SyncData::IsLocal() const {
 124   return id_ == kInvalidId;
 125 }
 126
 127 std::string SyncData::ToString() const {
 128   if (!IsValid())
 129     return "<Invalid SyncData>";
 130
 131   std::string type = ModelTypeToString(GetDataType());
 132   std::string specifics;
 133   scoped_ptr<base::DictionaryValue> value(
 134       EntitySpecificsToValue(GetSpecifics()));
 135   base::JSONWriter::WriteWithOptions(value.get(),
 136                                      base::JSONWriter::OPTIONS_PRETTY_PRINT,
 137                                      &specifics);
 138
 139   if (IsLocal()) {
 140     return "{ isLocal: true, type: " + type + ", tag: " + GetTag() +
 141         ", title: " + GetTitle() + ", specifics: " + specifics + "}";
 142   }
 143
 144   std::string id = base::Int64ToString(GetRemoteId());
 145   return "{ isLocal: false, type: " + type + ", specifics: " + specifics +
 146       ", id: " + id + "}";
 147 }
 148
 149 void PrintTo(const SyncData& sync_data, std::ostream* os) {
 150   *os << sync_data.ToString();
 151 }
 152
 153 }  // namespace syncer