Sync: Change Local IDs to GUID based to avoid ID collision

sync/syncable/directory.cc

 // Copyright 2013 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/directory.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/base64.h"
+#include "base/guid.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "sync/internal_api/public/base/attachment_id_proto.h"
 #include "sync/internal_api/public/base/unique_position.h"
 #include "sync/internal_api/public/util/unrecoverable_error_handler.h"
 #include "sync/syncable/entry.h"
 #include "sync/syncable/entry_kernel.h"
 #include "sync/syncable/in_memory_directory_backing_store.h"
 #include "sync/syncable/on_disk_directory_backing_store.h"
 #include "sync/syncable/scoped_kernel_lock.h"
 #include "sync/syncable/scoped_parent_child_index_updater.h"
 #include "sync/syncable/syncable-inl.h"
 #include "sync/syncable/syncable_base_transaction.h"
 #include "sync/syncable/syncable_changes_version.h"
 #include "sync/syncable/syncable_read_transaction.h"
 #include "sync/syncable/syncable_util.h"
 #include "sync/syncable/syncable_write_transaction.h"
 
 using std::string;
 
 namespace syncer {
 namespace syncable {
 
 // static
 const base::FilePath::CharType Directory::kSyncDatabaseFilename[] =
     FILE_PATH_LITERAL("SyncData.sqlite3");
 
-Directory::PersistedKernelInfo::PersistedKernelInfo()
-    : next_id(0) {
+Directory::PersistedKernelInfo::PersistedKernelInfo() {
   ModelTypeSet protocol_types = ProtocolTypes();
   for (ModelTypeSet::Iterator iter = protocol_types.First(); iter.Good();
        iter.Inc()) {
     ResetDownloadProgress(iter.Get());
     transaction_version[iter.Get()] = 0;
   }
 }
 
 Directory::PersistedKernelInfo::~PersistedKernelInfo() {}
 
@@ skipping 138 matching lines @@
   JournalIndex delete_journals;
   MetahandleSet metahandles_to_purge;
 
   DirOpenResult result = store_->Load(&tmp_handles_map, &delete_journals,
                                       &metahandles_to_purge, &info);
   if (OPENED != result)
     return result;
 
   DCHECK(!kernel_);
   kernel_ = new Kernel(name, info, delegate, transaction_observer);
+  kernel_->metahandles_to_purge.swap(metahandles_to_purge);
   delete_journal_.reset(new DeleteJournal(&delete_journals));
   InitializeIndices(&tmp_handles_map);
 
-  // Write back the share info to reserve some space in 'next_id'.  This will
-  // prevent local ID reuse in the case of an early crash.  See the comments in
-  // TakeSnapshotForSaveChanges() or crbug.com/142987 for more information.
-  kernel_->info_status = KERNEL_SHARE_INFO_DIRTY;
-
-  kernel_->metahandles_to_purge.swap(metahandles_to_purge);
+  // Save changes back in case there are any metahandles to purge.
   if (!SaveChanges())
     return FAILED_INITIAL_WRITE;
 
   // Now that we've successfully opened the store, install an error handler to
   // deal with catastrophic errors that may occur later on. Use a weak pointer
   // because we cannot guarantee that this Directory will outlive the Closure.
   store_->SetCatastrophicErrorHandler(base::Bind(
       &Directory::OnCatastrophicError, weak_ptr_factory_.GetWeakPtr()));
 
   return OPENED;
@@ skipping 349 matching lines @@
     entry->clear_dirty(NULL);
   }
   ClearDirtyMetahandles(lock);
 
   // Set purged handles.
   DCHECK(snapshot->metahandles_to_purge.empty());
   snapshot->metahandles_to_purge.swap(kernel_->metahandles_to_purge);
 
   // Fill kernel_info_status and kernel_info.
   snapshot->kernel_info = kernel_->persisted_info;
-  // To avoid duplicates when the process crashes, we record the next_id to be
-  // greater magnitude than could possibly be reached before the next save
-  // changes.  In other words, it's effectively impossible for the user to
-  // generate 65536 new bookmarks in 3 seconds.
-  snapshot->kernel_info.next_id -= 65536;
   snapshot->kernel_info_status = kernel_->info_status;
   // This one we reset on failure.
   kernel_->info_status = KERNEL_SHARE_INFO_VALID;
 
   delete_journal_->TakeSnapshotAndClear(
       &trans, &snapshot->delete_journals, &snapshot->delete_journals_to_purge);
 }
 
 bool Directory::SaveChanges() {
   bool success = false;
@@ skipping 355 matching lines @@
 }
 
 int64 Directory::GetTransactionVersion(ModelType type) const {
   kernel_->transaction_mutex.AssertAcquired();
   return kernel_->persisted_info.transaction_version[type];
 }
 
 void Directory::IncrementTransactionVersion(ModelType type) {
   kernel_->transaction_mutex.AssertAcquired();
   kernel_->persisted_info.transaction_version[type]++;
+  kernel_->info_status = KERNEL_SHARE_INFO_DIRTY;
 }
 
 void Directory::GetDataTypeContext(BaseTransaction* trans,
                                    ModelType type,
                                    sync_pb::DataTypeContext* context) const {
   ScopedKernelLock lock(this);
   context->CopyFrom(kernel_->persisted_info.datatype_context[type]);
 }
 
 void Directory::SetDataTypeContext(
@@ skipping 364 matching lines @@
 void Directory::SetInvariantCheckLevel(InvariantCheckLevel check_level) {
   invariant_check_level_ = check_level;
 }
 
 int64 Directory::NextMetahandle() {
   ScopedKernelLock lock(this);
   int64 metahandle = (kernel_->next_metahandle)++;
   return metahandle;
 }
 
-// Always returns a client ID that is the string representation of a negative
-// number.
+// Generates next client ID based on a randomly generated GUID.
 Id Directory::NextId() {
-  int64 result;
-  {
-    ScopedKernelLock lock(this);
-    result = (kernel_->persisted_info.next_id)--;
-    kernel_->info_status = KERNEL_SHARE_INFO_DIRTY;
-  }
-  DCHECK_LT(result, 0);
-  return Id::CreateFromClientString(base::Int64ToString(result));
+  return Id::CreateFromClientString(base::GenerateGUID());
 }
 
 bool Directory::HasChildren(BaseTransaction* trans, const Id& id) {
   ScopedKernelLock lock(this);
   return kernel_->parent_child_index.GetChildren(id) != NULL;
 }
 
 Id Directory::GetFirstChildId(BaseTransaction* trans,
                               const EntryKernel* parent) {
   DCHECK(parent);
@@ skipping 208 matching lines @@
 Directory::Kernel* Directory::kernel() {
   return kernel_;
 }
 
 const Directory::Kernel* Directory::kernel() const {
   return kernel_;
 }
 
 }  // namespace syncable
 }  // namespace syncer