sync/syncable/mutable_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/mutable_entry.h"
   6
   7 #include "base/memory/scoped_ptr.h"
   8 #include "sync/internal_api/public/base/unique_position.h"
   9 #include "sync/syncable/directory.h"
  10 #include "sync/syncable/scoped_kernel_lock.h"
  11 #include "sync/syncable/scoped_parent_child_index_updater.h"
  12 #include "sync/syncable/syncable-inl.h"
  13 #include "sync/syncable/syncable_changes_version.h"
  14 #include "sync/syncable/syncable_util.h"
  15 #include "sync/syncable/syncable_write_transaction.h"
  16
  17 using std::string;
  18
  19 namespace syncer {
  20 namespace syncable {
  21
  22 void MutableEntry::Init(WriteTransaction* trans,
  23                         ModelType model_type,
  24                         const Id& parent_id,
  25                         const string& name) {
  26   scoped_ptr<EntryKernel> kernel(new EntryKernel);
  27   kernel_ = NULL;
  28
  29   kernel->put(ID, trans->directory_->NextId());
  30   kernel->put(META_HANDLE, trans->directory_->NextMetahandle());
  31   kernel->mark_dirty(&trans->directory_->kernel_->dirty_metahandles);
  32   kernel->put(PARENT_ID, parent_id);
  33   kernel->put(NON_UNIQUE_NAME, name);
  34   const base::Time& now = base::Time::Now();
  35   kernel->put(CTIME, now);
  36   kernel->put(MTIME, now);
  37   // We match the database defaults here
  38   kernel->put(BASE_VERSION, CHANGES_VERSION);
  39
  40   // Normally the SPECIFICS setting code is wrapped in logic to deal with
  41   // unknown fields and encryption.  Since all we want to do here is ensure that
  42   // GetModelType() returns a correct value from the very beginning, these
  43   // few lines are sufficient.
  44   sync_pb::EntitySpecifics specifics;
  45   AddDefaultFieldValue(model_type, &specifics);
  46   kernel->put(SPECIFICS, specifics);
  47
  48   // Because this entry is new, it was originally deleted.
  49   kernel->put(IS_DEL, true);
  50   trans->TrackChangesTo(kernel.get());
  51   kernel->put(IS_DEL, false);
  52
  53   // Now swap the pointers.
  54   kernel_ = kernel.release();
  55 }
  56
  57 MutableEntry::MutableEntry(WriteTransaction* trans,
  58                            Create,
  59                            ModelType model_type,
  60                            const Id& parent_id,
  61                            const string& name)
  62     : ModelNeutralMutableEntry(trans), write_transaction_(trans) {
  63   Init(trans, model_type, parent_id, name);
  64   // We need to have a valid position ready before we can index the item.
  65   if (model_type == BOOKMARKS) {
  66     // Base the tag off of our cache-guid and local "c-" style ID.
  67     std::string unique_tag = syncable::GenerateSyncableBookmarkHash(
  68         trans->directory()->cache_guid(), GetId().GetServerId());
  69     kernel_->put(UNIQUE_BOOKMARK_TAG, unique_tag);
  70     kernel_->put(UNIQUE_POSITION, UniquePosition::InitialPosition(unique_tag));
  71   } else {
  72     DCHECK(!ShouldMaintainPosition());
  73   }
  74
  75   bool result = trans->directory()->InsertEntry(trans, kernel_);
  76   DCHECK(result);
  77 }
  78
  79 MutableEntry::MutableEntry(WriteTransaction* trans, CreateNewUpdateItem,
  80                            const Id& id)
  81     : ModelNeutralMutableEntry(trans, CREATE_NEW_UPDATE_ITEM, id),
  82       write_transaction_(trans) {}
  83
  84 MutableEntry::MutableEntry(WriteTransaction* trans, GetById, const Id& id)
  85     : ModelNeutralMutableEntry(trans, GET_BY_ID, id),
  86       write_transaction_(trans) {
  87 }
  88
  89 MutableEntry::MutableEntry(WriteTransaction* trans, GetByHandle,
  90                            int64 metahandle)
  91     : ModelNeutralMutableEntry(trans, GET_BY_HANDLE, metahandle),
  92       write_transaction_(trans) {
  93 }
  94
  95 MutableEntry::MutableEntry(WriteTransaction* trans, GetByClientTag,
  96                            const std::string& tag)
  97     : ModelNeutralMutableEntry(trans, GET_BY_CLIENT_TAG, tag),
  98       write_transaction_(trans) {
  99 }
 100
 101 MutableEntry::MutableEntry(WriteTransaction* trans, GetByServerTag,
 102                            const string& tag)
 103     : ModelNeutralMutableEntry(trans, GET_BY_SERVER_TAG, tag),
 104       write_transaction_(trans) {
 105 }
 106
 107 void MutableEntry::PutLocalExternalId(int64 value) {
 108   DCHECK(kernel_);
 109   write_transaction()->TrackChangesTo(kernel_);
 110   if (kernel_->ref(LOCAL_EXTERNAL_ID) != value) {
 111     ScopedKernelLock lock(dir());
 112     kernel_->put(LOCAL_EXTERNAL_ID, value);
 113     kernel_->mark_dirty(&dir()->kernel_->dirty_metahandles);
 114   }
 115 }
 116
 117 void MutableEntry::PutMtime(base::Time value) {
 118   DCHECK(kernel_);
 119   write_transaction()->TrackChangesTo(kernel_);
 120   if (kernel_->ref(MTIME) != value) {
 121     kernel_->put(MTIME, value);
 122     kernel_->mark_dirty(&dir()->kernel_->dirty_metahandles);
 123   }
 124 }
 125
 126 void MutableEntry::PutCtime(base::Time value) {
 127   DCHECK(kernel_);
 128   write_transaction()->TrackChangesTo(kernel_);
 129   if (kernel_->ref(CTIME) != value) {
 130     kernel_->put(CTIME, value);
 131     kernel_->mark_dirty(&dir()->kernel_->dirty_metahandles);
 132   }
 133 }
 134
 135 void MutableEntry::PutParentId(const Id& value) {
 136   DCHECK(kernel_);
 137   write_transaction()->TrackChangesTo(kernel_);
 138   if (kernel_->ref(PARENT_ID) != value) {
 139     PutParentIdPropertyOnly(value);
 140     if (!GetIsDel()) {
 141       if (!PutPredecessor(Id())) {
 142         // TODO(lipalani) : Propagate the error to caller. crbug.com/100444.
 143         NOTREACHED();
 144       }
 145     }
 146   }
 147 }
 148
 149 void MutableEntry::PutIsDir(bool value) {
 150   DCHECK(kernel_);
 151   write_transaction()->TrackChangesTo(kernel_);
 152   bool old_value = kernel_->ref(IS_DIR);
 153   if (old_value != value) {
 154     kernel_->put(IS_DIR, value);
 155     kernel_->mark_dirty(GetDirtyIndexHelper());
 156   }
 157 }
 158
 159 void MutableEntry::PutIsDel(bool value) {
 160   DCHECK(kernel_);
 161   write_transaction()->TrackChangesTo(kernel_);
 162   if (value == kernel_->ref(IS_DEL)) {
 163     return;
 164   }
 165   if (value) {
 166     // If the server never knew about this item and it's deleted then we don't
 167     // need to keep it around.  Unsetting IS_UNSYNCED will:
 168     // - Ensure that the item is never committed to the server.
 169     // - Allow any items with the same UNIQUE_CLIENT_TAG created on other
 170     //   clients to override this entry.
 171     // - Let us delete this entry permanently through
 172     //   DirectoryBackingStore::DropDeletedEntries() when we next restart sync.
 173     //   This will save memory and avoid crbug.com/125381.
 174     if (!GetId().ServerKnows()) {
 175       PutIsUnsynced(false);
 176     }
 177   }
 178
 179   {
 180     ScopedKernelLock lock(dir());
 181     // Some indices don't include deleted items and must be updated
 182     // upon a value change.
 183     ScopedParentChildIndexUpdater updater(lock, kernel_,
 184         &dir()->kernel_->parent_child_index);
 185
 186     kernel_->put(IS_DEL, value);
 187     kernel_->mark_dirty(&dir()->kernel_->dirty_metahandles);
 188   }
 189 }
 190
 191 void MutableEntry::PutNonUniqueName(const std::string& value) {
 192   DCHECK(kernel_);
 193   write_transaction()->TrackChangesTo(kernel_);
 194
 195   if (kernel_->ref(NON_UNIQUE_NAME) != value) {
 196     kernel_->put(NON_UNIQUE_NAME, value);
 197     kernel_->mark_dirty(&dir()->kernel_->dirty_metahandles);
 198   }
 199 }
 200
 201 void MutableEntry::PutSpecifics(const sync_pb::EntitySpecifics& value) {
 202   DCHECK(kernel_);
 203   CHECK(!value.password().has_client_only_encrypted_data());
 204   write_transaction()->TrackChangesTo(kernel_);
 205   // TODO(ncarter): This is unfortunately heavyweight.  Can we do
 206   // better?
 207   if (kernel_->ref(SPECIFICS).SerializeAsString() !=
 208       value.SerializeAsString()) {
 209     kernel_->put(SPECIFICS, value);
 210     kernel_->mark_dirty(&dir()->kernel_->dirty_metahandles);
 211   }
 212 }
 213
 214 void MutableEntry::PutUniquePosition(const UniquePosition& value) {
 215   DCHECK(kernel_);
 216   write_transaction()->TrackChangesTo(kernel_);
 217   if(!kernel_->ref(UNIQUE_POSITION).Equals(value)) {
 218     // We should never overwrite a valid position with an invalid one.
 219     DCHECK(value.IsValid());
 220     ScopedKernelLock lock(dir());
 221     ScopedParentChildIndexUpdater updater(
 222         lock, kernel_, &dir()->kernel_->parent_child_index);
 223     kernel_->put(UNIQUE_POSITION, value);
 224     kernel_->mark_dirty(&dir()->kernel_->dirty_metahandles);
 225   }
 226 }
 227
 228 bool MutableEntry::PutPredecessor(const Id& predecessor_id) {
 229   MutableEntry predecessor(write_transaction(), GET_BY_ID, predecessor_id);
 230   if (!predecessor.good())
 231     return false;
 232   dir()->PutPredecessor(kernel_, predecessor.kernel_);
 233   return true;
 234 }
 235
 236 // This function sets only the flags needed to get this entry to sync.
 237 bool MarkForSyncing(MutableEntry* e) {
 238   DCHECK_NE(static_cast<MutableEntry*>(NULL), e);
 239   DCHECK(!e->IsRoot()) << "We shouldn't mark a permanent object for syncing.";
 240   if (!(e->PutIsUnsynced(true)))
 241     return false;
 242   e->PutSyncing(false);
 243   return true;
 244 }
 245
 246 }  // namespace syncable
 247 }  // namespace syncer