mutable_entry.cc revision 116680a4aac90f2aa7413d9095a592090648e557 
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
17using std::string;
18
19namespace syncer {
20namespace syncable {
21
22void 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
57MutableEntry::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
79MutableEntry::MutableEntry(WriteTransaction* trans, CreateNewUpdateItem,
80                           const Id& id)
81    : ModelNeutralMutableEntry(trans, CREATE_NEW_UPDATE_ITEM, id),
82      write_transaction_(trans) {}
83
84MutableEntry::MutableEntry(WriteTransaction* trans, GetById, const Id& id)
85    : ModelNeutralMutableEntry(trans, GET_BY_ID, id),
86      write_transaction_(trans) {
87}
88
89MutableEntry::MutableEntry(WriteTransaction* trans, GetByHandle,
90                           int64 metahandle)
91    : ModelNeutralMutableEntry(trans, GET_BY_HANDLE, metahandle),
92      write_transaction_(trans) {
93}
94
95MutableEntry::MutableEntry(WriteTransaction* trans, GetByClientTag,
96                           const std::string& tag)
97    : ModelNeutralMutableEntry(trans, GET_BY_CLIENT_TAG, tag),
98      write_transaction_(trans) {
99}
100
101MutableEntry::MutableEntry(WriteTransaction* trans, GetTypeRoot, ModelType type)
102    : ModelNeutralMutableEntry(trans, GET_TYPE_ROOT, type),
103      write_transaction_(trans) {
104}
105
106void MutableEntry::PutLocalExternalId(int64 value) {
107  DCHECK(kernel_);
108  write_transaction()->TrackChangesTo(kernel_);
109  if (kernel_->ref(LOCAL_EXTERNAL_ID) != value) {
110    ScopedKernelLock lock(dir());
111    kernel_->put(LOCAL_EXTERNAL_ID, value);
112    kernel_->mark_dirty(&dir()->kernel_->dirty_metahandles);
113  }
114}
115
116void MutableEntry::PutMtime(base::Time value) {
117  DCHECK(kernel_);
118  write_transaction()->TrackChangesTo(kernel_);
119  if (kernel_->ref(MTIME) != value) {
120    kernel_->put(MTIME, value);
121    kernel_->mark_dirty(&dir()->kernel_->dirty_metahandles);
122  }
123}
124
125void MutableEntry::PutCtime(base::Time value) {
126  DCHECK(kernel_);
127  write_transaction()->TrackChangesTo(kernel_);
128  if (kernel_->ref(CTIME) != value) {
129    kernel_->put(CTIME, value);
130    kernel_->mark_dirty(&dir()->kernel_->dirty_metahandles);
131  }
132}
133
134void MutableEntry::PutParentId(const Id& value) {
135  DCHECK(kernel_);
136  write_transaction()->TrackChangesTo(kernel_);
137  if (kernel_->ref(PARENT_ID) != value) {
138    PutParentIdPropertyOnly(value);
139    if (!GetIsDel()) {
140      if (!PutPredecessor(Id())) {
141        // TODO(lipalani) : Propagate the error to caller. crbug.com/100444.
142        NOTREACHED();
143      }
144    }
145  }
146}
147
148void MutableEntry::PutIsDir(bool value) {
149  DCHECK(kernel_);
150  write_transaction()->TrackChangesTo(kernel_);
151  bool old_value = kernel_->ref(IS_DIR);
152  if (old_value != value) {
153    kernel_->put(IS_DIR, value);
154    kernel_->mark_dirty(GetDirtyIndexHelper());
155  }
156}
157
158void MutableEntry::PutIsDel(bool value) {
159  DCHECK(kernel_);
160  write_transaction()->TrackChangesTo(kernel_);
161  if (value == kernel_->ref(IS_DEL)) {
162    return;
163  }
164  if (value) {
165    // If the server never knew about this item and it's deleted then we don't
166    // need to keep it around.  Unsetting IS_UNSYNCED will:
167    // - Ensure that the item is never committed to the server.
168    // - Allow any items with the same UNIQUE_CLIENT_TAG created on other
169    //   clients to override this entry.
170    // - Let us delete this entry permanently through
171    //   DirectoryBackingStore::DropDeletedEntries() when we next restart sync.
172    //   This will save memory and avoid crbug.com/125381.
173    if (!GetId().ServerKnows()) {
174      PutIsUnsynced(false);
175    }
176  }
177
178  {
179    ScopedKernelLock lock(dir());
180    // Some indices don't include deleted items and must be updated
181    // upon a value change.
182    ScopedParentChildIndexUpdater updater(lock, kernel_,
183        &dir()->kernel_->parent_child_index);
184
185    kernel_->put(IS_DEL, value);
186    kernel_->mark_dirty(&dir()->kernel_->dirty_metahandles);
187  }
188}
189
190void MutableEntry::PutNonUniqueName(const std::string& value) {
191  DCHECK(kernel_);
192  write_transaction()->TrackChangesTo(kernel_);
193
194  if (kernel_->ref(NON_UNIQUE_NAME) != value) {
195    kernel_->put(NON_UNIQUE_NAME, value);
196    kernel_->mark_dirty(&dir()->kernel_->dirty_metahandles);
197  }
198}
199
200void MutableEntry::PutSpecifics(const sync_pb::EntitySpecifics& value) {
201  DCHECK(kernel_);
202  CHECK(!value.password().has_client_only_encrypted_data());
203  write_transaction()->TrackChangesTo(kernel_);
204  // TODO(ncarter): This is unfortunately heavyweight.  Can we do
205  // better?
206  if (kernel_->ref(SPECIFICS).SerializeAsString() !=
207      value.SerializeAsString()) {
208    kernel_->put(SPECIFICS, value);
209    kernel_->mark_dirty(&dir()->kernel_->dirty_metahandles);
210  }
211}
212
213void MutableEntry::PutUniquePosition(const UniquePosition& value) {
214  DCHECK(kernel_);
215  write_transaction()->TrackChangesTo(kernel_);
216  if(!kernel_->ref(UNIQUE_POSITION).Equals(value)) {
217    // We should never overwrite a valid position with an invalid one.
218    DCHECK(value.IsValid());
219    ScopedKernelLock lock(dir());
220    ScopedParentChildIndexUpdater updater(
221        lock, kernel_, &dir()->kernel_->parent_child_index);
222    kernel_->put(UNIQUE_POSITION, value);
223    kernel_->mark_dirty(&dir()->kernel_->dirty_metahandles);
224  }
225}
226
227bool MutableEntry::PutPredecessor(const Id& predecessor_id) {
228  MutableEntry predecessor(write_transaction(), GET_BY_ID, predecessor_id);
229  if (!predecessor.good())
230    return false;
231  dir()->PutPredecessor(kernel_, predecessor.kernel_);
232  return true;
233}
234
235void MutableEntry::PutAttachmentMetadata(
236    const sync_pb::AttachmentMetadata& attachment_metadata) {
237  DCHECK(kernel_);
238  write_transaction()->TrackChangesTo(kernel_);
239  if (kernel_->ref(ATTACHMENT_METADATA).SerializeAsString() !=
240      attachment_metadata.SerializeAsString()) {
241    dir()->UpdateAttachmentIndex(GetMetahandle(),
242                                 kernel_->ref(ATTACHMENT_METADATA),
243                                 attachment_metadata);
244    kernel_->put(ATTACHMENT_METADATA, attachment_metadata);
245    kernel_->mark_dirty(&dir()->kernel_->dirty_metahandles);
246  }
247}
248
249void MutableEntry::MarkAttachmentAsOnServer(
250    const sync_pb::AttachmentIdProto& attachment_id) {
251  DCHECK(kernel_);
252  DCHECK(!attachment_id.unique_id().empty());
253  write_transaction()->TrackChangesTo(kernel_);
254  sync_pb::AttachmentMetadata& attachment_metadata =
255      kernel_->mutable_ref(ATTACHMENT_METADATA);
256  for (int i = 0; i < attachment_metadata.record_size(); ++i) {
257    sync_pb::AttachmentMetadataRecord* record =
258        attachment_metadata.mutable_record(i);
259    if (record->id().unique_id() != attachment_id.unique_id())
260      continue;
261    record->set_is_on_server(true);
262  }
263  kernel_->mark_dirty(&dir()->kernel_->dirty_metahandles);
264  MarkForSyncing(this);
265}
266
267// This function sets only the flags needed to get this entry to sync.
268bool MarkForSyncing(MutableEntry* e) {
269  DCHECK_NE(static_cast<MutableEntry*>(NULL), e);
270  DCHECK(!e->IsRoot()) << "We shouldn't mark a permanent object for syncing.";
271  if (!(e->PutIsUnsynced(true)))
272    return false;
273  e->PutSyncing(false);
274  return true;
275}
276
277}  // namespace syncable
278}  // namespace syncer
279