sync/syncable/entry.cc

   1 // Copyright 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/syncable/entry.h"
   6
   7 #include <iomanip>
   8
   9 #include "base/json/string_escape.h"
  10 #include "base/strings/string_util.h"
  11 #include "sync/syncable/directory.h"
  12 #include "sync/syncable/syncable_base_transaction.h"
  13 #include "sync/syncable/syncable_columns.h"
  14
  15 using std::string;
  16
  17 namespace syncer {
  18 namespace syncable {
  19
  20 Entry::Entry(BaseTransaction* trans, GetById, const Id& id)
  21     : basetrans_(trans) {
  22   kernel_ = trans->directory()->GetEntryById(id);
  23 }
  24
  25 Entry::Entry(BaseTransaction* trans, GetByClientTag, const string& tag)
  26     : basetrans_(trans) {
  27   kernel_ = trans->directory()->GetEntryByClientTag(tag);
  28 }
  29
  30 Entry::Entry(BaseTransaction* trans, GetTypeRoot, ModelType type)
  31     : basetrans_(trans) {
  32   const std::string& tag = ModelTypeToRootTag(type);
  33   kernel_ = trans->directory()->GetEntryByServerTag(tag);
  34 }
  35
  36 Entry::Entry(BaseTransaction* trans, GetByHandle, int64 metahandle)
  37     : basetrans_(trans) {
  38   kernel_ = trans->directory()->GetEntryByHandle(metahandle);
  39 }
  40
  41 Entry::Entry(BaseTransaction* trans, GetByServerTag, const string& tag)
  42     : basetrans_(trans) {
  43   kernel_ = trans->directory()->GetEntryByServerTag(tag);
  44 }
  45
  46 Directory* Entry::dir() const {
  47   return basetrans_->directory();
  48 }
  49
  50 base::DictionaryValue* Entry::ToValue(Cryptographer* cryptographer) const {
  51   base::DictionaryValue* entry_info = new base::DictionaryValue();
  52   entry_info->SetBoolean("good", good());
  53   if (good()) {
  54     entry_info->Set("kernel", kernel_->ToValue(cryptographer));
  55     entry_info->Set("modelType",
  56                     ModelTypeToValue(GetModelType()));
  57     entry_info->SetBoolean("existsOnClientBecauseNameIsNonEmpty",
  58                            ExistsOnClientBecauseNameIsNonEmpty());
  59     entry_info->SetBoolean("isRoot", IsRoot());
  60   }
  61   return entry_info;
  62 }
  63
  64 bool Entry::GetSyncing() const {
  65     DCHECK(kernel_);
  66     return kernel_->ref(SYNCING);
  67 }
  68
  69 bool Entry::GetDirtySync() const {
  70     DCHECK(kernel_);
  71     return kernel_->ref(DIRTY_SYNC);
  72 }
  73
  74 ModelType Entry::GetServerModelType() const {
  75   ModelType specifics_type = kernel_->GetServerModelType();
  76   if (specifics_type != UNSPECIFIED)
  77     return specifics_type;
  78
  79   // Otherwise, we don't have a server type yet.  That should only happen
  80   // if the item is an uncommitted locally created item.
  81   // It's possible we'll need to relax these checks in the future; they're
  82   // just here for now as a safety measure.
  83   DCHECK(GetIsUnsynced());
  84   DCHECK_EQ(GetServerVersion(), 0);
  85   DCHECK(GetServerIsDel());
  86   // Note: can't enforce !GetId().ServerKnows() here because that could
  87   // actually happen if we hit AttemptReuniteLostCommitResponses.
  88   return UNSPECIFIED;
  89 }
  90
  91 ModelType Entry::GetModelType() const {
  92   ModelType specifics_type = GetModelTypeFromSpecifics(GetSpecifics());
  93   if (specifics_type != UNSPECIFIED)
  94     return specifics_type;
  95   if (IsRoot())
  96     return TOP_LEVEL_FOLDER;
  97   // Loose check for server-created top-level folders that aren't
  98   // bound to a particular model type.
  99   if (!GetUniqueServerTag().empty() && GetIsDir())
 100     return TOP_LEVEL_FOLDER;
 101
 102   return UNSPECIFIED;
 103 }
 104
 105 Id Entry::GetPredecessorId() const {
 106   return dir()->GetPredecessorId(kernel_);
 107 }
 108
 109 Id Entry::GetSuccessorId() const {
 110   return dir()->GetSuccessorId(kernel_);
 111 }
 112
 113 Id Entry::GetFirstChildId() const {
 114   return dir()->GetFirstChildId(basetrans_, kernel_);
 115 }
 116
 117 void Entry::GetChildHandles(std::vector<int64>* result) const {
 118   dir()->GetChildHandlesById(basetrans_, GetId(), result);
 119 }
 120
 121 int Entry::GetTotalNodeCount() const {
 122   return dir()->GetTotalNodeCount(basetrans_, kernel_);
 123 }
 124
 125 int Entry::GetPositionIndex() const {
 126   return dir()->GetPositionIndex(basetrans_, kernel_);
 127 }
 128
 129 bool Entry::ShouldMaintainPosition() const {
 130   return kernel_->ShouldMaintainPosition();
 131 }
 132
 133 bool Entry::ShouldMaintainHierarchy() const {
 134   return kernel_->ShouldMaintainHierarchy();
 135 }
 136
 137 std::ostream& operator<<(std::ostream& os, const Entry& entry) {
 138   int i;
 139   EntryKernel* const kernel = entry.kernel_;
 140   for (i = BEGIN_FIELDS; i < INT64_FIELDS_END; ++i) {
 141     os << g_metas_columns[i].name << ": "
 142        << kernel->ref(static_cast<Int64Field>(i)) << ", ";
 143   }
 144   for ( ; i < TIME_FIELDS_END; ++i) {
 145     os << g_metas_columns[i].name << ": "
 146        << GetTimeDebugString(kernel->ref(static_cast<TimeField>(i))) << ", ";
 147   }
 148   for ( ; i < ID_FIELDS_END; ++i) {
 149     os << g_metas_columns[i].name << ": "
 150        << kernel->ref(static_cast<IdField>(i)) << ", ";
 151   }
 152   os << "Flags: ";
 153   for ( ; i < BIT_FIELDS_END; ++i) {
 154     if (kernel->ref(static_cast<BitField>(i)))
 155       os << g_metas_columns[i].name << ", ";
 156   }
 157   for ( ; i < STRING_FIELDS_END; ++i) {
 158     const std::string& field = kernel->ref(static_cast<StringField>(i));
 159     os << g_metas_columns[i].name << ": " << field << ", ";
 160   }
 161   for ( ; i < PROTO_FIELDS_END; ++i) {
 162     std::string escaped_str = base::EscapeBytesAsInvalidJSONString(
 163         kernel->ref(static_cast<ProtoField>(i)).SerializeAsString(),
 164         false);
 165     os << g_metas_columns[i].name << ": " << escaped_str << ", ";
 166   }
 167   for ( ; i < UNIQUE_POSITION_FIELDS_END; ++i) {
 168     os << g_metas_columns[i].name << ": "
 169        << kernel->ref(static_cast<UniquePositionField>(i)).ToDebugString()
 170        << ", ";
 171   }
 172   for ( ; i < ATTACHMENT_METADATA_FIELDS_END; ++i) {
 173     std::string escaped_str = base::EscapeBytesAsInvalidJSONString(
 174         kernel->ref(static_cast<AttachmentMetadataField>(i))
 175             .SerializeAsString(),
 176         false);
 177     os << g_metas_columns[i].name << ": " << escaped_str << ", ";
 178   }
 179   os << "TempFlags: ";
 180   for ( ; i < BIT_TEMPS_END; ++i) {
 181     if (kernel->ref(static_cast<BitTemp>(i)))
 182       os << "#" << i - BIT_TEMPS_BEGIN << ", ";
 183   }
 184   return os;
 185 }
 186
 187 }  // namespace syncable
 188 }  // namespace syncer