sync: Attempt to recover from directory corruption

sync/syncable/directory.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/directory.h"
 
 #include "base/debug/trace_event.h"
 #include "base/perftimer.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
@@ skipping 18 matching lines @@
 namespace {
 // Helper function to add an item to the index, if it ought to be added.
 template<typename Indexer>
 void InitializeIndexEntry(EntryKernel* entry,
                           typename Index<Indexer>::Set* index) {
   if (Indexer::ShouldInclude(entry)) {
     index->insert(entry);
   }
 }
 
-// This function checks to see if the given list of Metahandles has any nodes
-// whose PREV_ID, PARENT_ID or NEXT_ID values refer to ID values that do not
-// actually exist.  Returns true on success.
-//
-// This function is "Unsafe" because it does not attempt to acquire any locks
-// that may be protecting this list that gets passed in.  The caller is
-// responsible for ensuring that no one modifies this list while the function is
-// running.
-bool VerifyReferenceIntegrityUnsafe(const syncable::MetahandlesIndex &index) {
-  TRACE_EVENT0("sync", "SyncDatabaseIntegrityCheck");
-  using namespace syncable;
-  typedef base::hash_set<std::string> IdsSet;
-
-  IdsSet ids_set;
-  bool is_ok = true;
-
-  for (MetahandlesIndex::const_iterator it = index.begin();
-       it != index.end(); ++it) {
-    EntryKernel* entry = *it;
-    bool is_duplicate_id = !(ids_set.insert(entry->ref(ID).value()).second);
-    is_ok = is_ok && !is_duplicate_id;
-  }
-
-  IdsSet::iterator end = ids_set.end();
-  for (MetahandlesIndex::const_iterator it = index.begin();
-       it != index.end(); ++it) {
-    EntryKernel* entry = *it;
-    bool prev_exists = (ids_set.find(entry->ref(PREV_ID).value()) != end);
-    bool parent_exists = (ids_set.find(entry->ref(PARENT_ID).value()) != end);
-    bool next_exists = (ids_set.find(entry->ref(NEXT_ID).value()) != end);
-    is_ok = is_ok && prev_exists && parent_exists && next_exists;
-  }
-  return is_ok;
-}
-
 }
 
 // static
 bool ClientTagIndexer::ShouldInclude(const EntryKernel* a) {
   return !a->ref(UNIQUE_CLIENT_TAG).empty();
 }
 
 bool ParentIdAndHandleIndexer::Comparator::operator() (
     const syncable::EntryKernel* a,
     const syncable::EntryKernel* b) const {
@@ skipping 145 matching lines @@
         transaction_observer) {
 
   KernelLoadInfo info;
   // Temporary indices before kernel_ initialized in case Load fails. We 0(1)
   // swap these later.
   MetahandlesIndex metas_bucket;
   DirOpenResult result = store_->Load(&metas_bucket, &info);
   if (OPENED != result)
     return result;
 
-  if (!VerifyReferenceIntegrityUnsafe(metas_bucket))
-    return FAILED_LOGICAL_CORRUPTION;
-
   kernel_ = new Kernel(name, info, delegate, transaction_observer);
   kernel_->metahandles_index->swap(metas_bucket);
   InitializeIndices();
   return OPENED;
 }
 
 void Directory::Close() {
   store_.reset();
   if (kernel_) {
     delete kernel_;
@@ skipping 993 matching lines @@
   // There were no children in the linked list.
   return NULL;
 }
 
 ScopedKernelLock::ScopedKernelLock(const Directory* dir)
   :  scoped_lock_(dir->kernel_->mutex), dir_(const_cast<Directory*>(dir)) {
 }
 
 }  // namespace syncable
 }  // namespace syncer