[Sync] Add support for loading, updating and querying delete journals in

sync/syncable/delete_journal.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/syncable/delete_journal.h"
+
+#include "base/stl_util.h"
+#include "sync/internal_api/public/base/model_type.h"
+
+namespace syncer {
+namespace syncable {
+
+DeleteJournal::DeleteJournal(JournalIndex* initial_journal) {
+  CHECK(initial_journal);
+  delete_journals_.swap(*initial_journal);
+}
+
+DeleteJournal::~DeleteJournal() {
+  STLDeleteElements(&delete_journals_);
+}
+
+size_t DeleteJournal::GetDeleteJournalSize() const {
+  return delete_journals_.size();

[tim (not reviewing), 2013/01/04 15:35:46]

Shouldn't you be using journal_lock_ here?

[haitaol1, 2013/01/04 18:49:20]

Require a transaction param now.

On 2013/01/04 15:35:46, timsteele wrote:

+}
+
+void DeleteJournal::UpdateDeleteJournalForServerDelete(
+    BaseTransaction* trans, bool was_deleted, const EntryKernel& entry) {
+  // Should be sufficient to check server type only but check for local
+  // type too because of incomplete test setup.
+  if (!(IsDeleteJournalEnabled(entry.GetServerModelType()) ||
+      IsDeleteJournalEnabled(
+          GetModelTypeFromSpecifics(entry.ref(SPECIFICS))))) {
+    return;
+  }
+
+  base::AutoLock lock(journal_lock_);

[tim (not reviewing), 2013/01/04 15:35:46]

It looks like we're trying to acquire a lock while holding a lock
(BaseTransaction* parameter)... in fact, this is true of the other methods (as
far as I can tell) as well, it's just more explicit here due to the parameter
being passed in.  If we can avoid this it would do wonders for simplifying the
code (see comment in .h). 

[haitaol1, 2013/01/04 18:49:20]

Done.

+  JournalIndex::const_iterator it = delete_journals_.find(&entry);
+
+  if (entry.ref(SERVER_IS_DEL)) {
+    if (it == delete_journals_.end()) {
+      // New delete.
+      EntryKernel* t = new EntryKernel(entry);
+      delete_journals_.insert(t);
+      delete_journals_to_purge_.erase(t->ref(META_HANDLE));
+    }
+  } else {
+    // Undelete. This could happen in two cases:
+    // * An entry was deleted then undeleted, i.e. server delete was
+    //   overwritten because of entry has unsynced data locally.
+    // * A data type was broken, i.e. encountered unrecoverable error, in last
+    //   sync session and all its entries were duplicated in delete journals.
+    //   On restart, entries are recreated from downloads and recreation calls
+    //   UpdateDeleteJournals() to remove live entries from delete journals,
+    //   thus only deleted entries remain in journals.
+    if (it != delete_journals_.end()) {
+      delete_journals_to_purge_.insert((*it)->ref(META_HANDLE));
+      delete *it;
+      delete_journals_.erase(it);
+    } else if (was_deleted) {
+      delete_journals_to_purge_.insert(entry.ref(META_HANDLE));
+    }
+  }
+}
+
+void DeleteJournal::GetDeleteJournals(BaseTransaction* trans,
+                                      ModelType type,
+                                      EntryKernelSet* deleted_entries) {
+  base::AutoLock lock(journal_lock_);
+  DCHECK(!passive_delete_journal_types_.Has(type));
+  for (JournalIndex::const_iterator it = delete_journals_.begin();
+      it != delete_journals_.end(); ++it) {
+    if ((*it)->GetServerModelType() == type ||
+        GetModelTypeFromSpecifics((*it)->ref(SPECIFICS)) == type) {
+      deleted_entries->insert(*it);
+    }
+  }
+  passive_delete_journal_types_.Put(type);
+}
+
+void DeleteJournal::PurgeDeleteJournals(BaseTransaction* trans,
+                                        const MetahandleSet& to_purge) {
+  base::AutoLock lock(journal_lock_);
+  JournalIndex::const_iterator it = delete_journals_.begin();
+  while (it != delete_journals_.end()) {
+    int64 handle = (*it)->ref(META_HANDLE);
+    if (to_purge.count(handle)) {
+      delete *it;
+      delete_journals_.erase(it++);
+    } else {
+      ++it;
+    }
+  }
+  delete_journals_to_purge_.insert(to_purge.begin(), to_purge.end());
+}
+
+void DeleteJournal::TakeSnapshotAndClear(EntryKernelSet* journal_entries,
+                                         MetahandleSet* journals_to_purge) {
+  base::AutoLock lock(journal_lock_);
+
+  // Move passive delete journals to snapshot. Will copy back if snapshot fails
+  // to save.
+  JournalIndex::const_iterator it = delete_journals_.begin();
+  while (it != delete_journals_.end()) {
+    if (passive_delete_journal_types_.Has((*it)->GetServerModelType()) ||
+        passive_delete_journal_types_.Has(GetModelTypeFromSpecifics(
+            (*it)->ref(SPECIFICS)))) {
+      journal_entries->insert(*it);
+      delete_journals_.erase(it++);
+    } else {
+      ++it;
+    }
+  }
+  *journals_to_purge = delete_journals_to_purge_;
+  delete_journals_to_purge_.clear();
+}
+
+void DeleteJournal::AddJournals(BaseTransaction* trans,

[tim (not reviewing), 2013/01/04 15:35:46]

I think AddJournalBatch would be a better / more specialized sounding name
(since this isn't the common way journals are added).

[haitaol1, 2013/01/04 18:49:20]

Done.

+                                const EntryKernelSet& entries) {
+  base::AutoLock lock(journal_lock_);
+  EntryKernel needle;
+  for (EntryKernelSet::const_iterator i = entries.begin();
+       i != entries.end(); ++i) {
+    needle.put(ID, (*i)->ref(ID));
+    if (delete_journals_.find(&needle) == delete_journals_.end()) {
+      delete_journals_.insert(new EntryKernel(**i));
+    }
+    delete_journals_to_purge_.erase((*i)->ref(META_HANDLE));
+  }
+}
+
+/* static */
+bool DeleteJournal::IsDeleteJournalEnabled(ModelType type) {
+  switch (type) {
+    case BOOKMARKS:
+      return true;
+    default:
+      return false;
+  }
+}
+
+}  // namespace syncable
+}  // namespace syncer