Finish commit 146665.

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 559 matching lines @@
                       (&trans)))
         return false;
       delete entry;
     }
     if (trans.unrecoverable_error_set())
       return false;
   }
   return true;
 }
 
-void Directory::PurgeEntriesWithTypeIn(ModelTypeSet types) {
+bool Directory::PurgeEntriesWithTypeIn(ModelTypeSet types) {
   if (types.Empty())
-    return;
+    return true;
 
   {
     WriteTransaction trans(FROM_HERE, PURGE_ENTRIES, this);
     {
       ScopedKernelLock lock(this);
       MetahandlesIndex::iterator it = kernel_->metahandles_index->begin();
       while (it != kernel_->metahandles_index->end()) {
         const sync_pb::EntitySpecifics& local_specifics = (*it)->ref(SPECIFICS);
         const sync_pb::EntitySpecifics& server_specifics =
             (*it)->ref(SERVER_SPECIFICS);
         ModelType local_type = GetModelTypeFromSpecifics(local_specifics);
         ModelType server_type = GetModelTypeFromSpecifics(server_specifics);
 
         // Note the dance around incrementing |it|, since we sometimes erase().
         if ((IsRealDataType(local_type) && types.Has(local_type)) ||
             (IsRealDataType(server_type) && types.Has(server_type))) {
           if (!UnlinkEntryFromOrder(*it, &trans, &lock, DATA_TYPE_PURGE))
-            return;
+            return false;
 
           int64 handle = (*it)->ref(META_HANDLE);
           kernel_->metahandles_to_purge->insert(handle);
 
           size_t num_erased = 0;
           EntryKernel* entry = *it;
           num_erased = kernel_->ids_index->erase(entry);
           DCHECK_EQ(1u, num_erased);
           num_erased = kernel_->client_tag_index->erase(entry);
           DCHECK_EQ(entry->ref(UNIQUE_CLIENT_TAG).empty(), !num_erased);
@@ skipping 12 matching lines @@
       }
 
       // Ensure meta tracking for these data types reflects the deleted state.
       for (syncer::ModelTypeSet::Iterator it = types.First();
            it.Good(); it.Inc()) {
         set_initial_sync_ended_for_type_unsafe(it.Get(), false);
         kernel_->persisted_info.reset_download_progress(it.Get());
       }
     }
   }
+  return true;
 }
 
 void Directory::HandleSaveChangesFailure(const SaveChangesSnapshot& snapshot) {
   ScopedKernelLock lock(this);
   kernel_->info_status = KERNEL_SHARE_INFO_DIRTY;
 
   // Because we optimistically cleared the dirty bit on the real entries when
   // taking the snapshot, we must restore it on failure.  Not doing this could
   // cause lost data, if no other changes are made to the in-memory entries
   // that would cause the dirty bit to get set again. Setting the bit ensures
@@ skipping 605 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