Remove stl_util's STLValueDeleter.

components/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 "components/sync/syncable/directory.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <iterator>
 #include <utility>
 
 #include "base/base64.h"
 #include "base/guid.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "components/sync/base/attachment_id_proto.h"
 #include "components/sync/base/unique_position.h"
 #include "components/sync/base/unrecoverable_error_handler.h"
 #include "components/sync/syncable/entry.h"
 #include "components/sync/syncable/entry_kernel.h"
 #include "components/sync/syncable/in_memory_directory_backing_store.h"
@@ skipping 69 matching lines @@
       info_status(Directory::KERNEL_SHARE_INFO_VALID),
       persisted_info(info.kernel_info),
       cache_guid(info.cache_guid),
       next_metahandle(info.max_metahandle + 1),
       delegate(delegate),
       transaction_observer(transaction_observer) {
   DCHECK(delegate);
   DCHECK(transaction_observer.IsInitialized());
 }
 
-Directory::Kernel::~Kernel() {
-  base::STLDeleteContainerPairSecondPointers(metahandles_map.begin(),
-                                             metahandles_map.end());
-}
+Directory::Kernel::~Kernel() {}
 
 Directory::Directory(
     DirectoryBackingStore* store,
     const WeakHandle<UnrecoverableErrorHandler>& unrecoverable_error_handler,
     const base::Closure& report_unrecoverable_error_function,
     NigoriHandler* nigori_handler,
     Cryptographer* cryptographer)
     : kernel_(NULL),
       store_(store),
       unrecoverable_error_handler_(unrecoverable_error_handler),
@@ skipping 17 matching lines @@
   const DirOpenResult result = OpenImpl(name, delegate, transaction_observer);
 
   if (OPENED != result)
     Close();
   return result;
 }
 
 void Directory::InitializeIndices(MetahandlesMap* handles_map) {
   ScopedKernelLock lock(this);
   kernel_->metahandles_map.swap(*handles_map);
-  for (MetahandlesMap::const_iterator it = kernel_->metahandles_map.begin();
+  for (auto it = kernel_->metahandles_map.begin();
        it != kernel_->metahandles_map.end(); ++it) {
-    EntryKernel* entry = it->second;
+    EntryKernel* entry = it->second.get();
     if (ParentChildIndex::ShouldInclude(entry))
       kernel_->parent_child_index.Insert(entry);
     const int64_t metahandle = entry->ref(META_HANDLE);
     if (entry->ref(IS_UNSYNCED))
       kernel_->unsynced_metahandles.insert(metahandle);
     if (entry->ref(IS_UNAPPLIED_UPDATE)) {
       const ModelType type = entry->GetServerModelType();
       kernel_->unapplied_update_metahandles[type].insert(metahandle);
     }
     if (!entry->ref(UNIQUE_SERVER_TAG).empty()) {
@@ skipping 19 matching lines @@
 
 DirOpenResult Directory::OpenImpl(
     const string& name,
     DirectoryChangeDelegate* delegate,
     const WeakHandle<TransactionObserver>& transaction_observer) {
   KernelLoadInfo info;
   // Temporary indices before kernel_ initialized in case Load fails. We 0(1)
   // swap these later.
   Directory::MetahandlesMap tmp_handles_map;
 
-  // Avoids mem leaks on failure.  Harmlessly deletes the empty hash map after
-  // the swap in the success case.
-  base::STLValueDeleter<MetahandlesMap> deleter(&tmp_handles_map);
-
   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);
@@ skipping 78 matching lines @@
   ScopedKernelLock lock(this);
   return GetEntryByHandle(lock, metahandle);
 }
 
 EntryKernel* Directory::GetEntryByHandle(const ScopedKernelLock& lock,
                                          int64_t metahandle) {
   // Look up in memory
   MetahandlesMap::iterator found = kernel_->metahandles_map.find(metahandle);
   if (found != kernel_->metahandles_map.end()) {
     // Found it in memory.  Easy.
-    return found->second;
+    return found->second.get();
   }
   return NULL;
 }
 
 bool Directory::GetChildHandlesById(BaseTransaction* trans,
                                     const Id& parent_id,
                                     Directory::Metahandles* result) {
   if (!SyncAssert(this == trans->directory(), FROM_HERE,
                   "Directories don't match", trans))
     return false;
@@ skipping 59 matching lines @@
 
 bool Directory::InsertEntry(const ScopedKernelLock& lock,
                             BaseWriteTransaction* trans,
                             EntryKernel* entry) {
   if (!SyncAssert(NULL != entry, FROM_HERE, "Entry is null", trans))
     return false;
 
   static const char error[] = "Entry already in memory index.";
 
   if (!SyncAssert(kernel_->metahandles_map
-                      .insert(std::make_pair(entry->ref(META_HANDLE), entry))
+                      .insert(std::make_pair(entry->ref(META_HANDLE),
+                                             base::WrapUnique(entry)))
                       .second,
                   FROM_HERE, error, trans)) {
     return false;
   }
   if (!SyncAssert(
           kernel_->ids_map.insert(std::make_pair(entry->ref(ID).value(), entry))
               .second,
           FROM_HERE, error, trans)) {
     return false;
   }
@@ skipping 211 matching lines @@
 
   // Need a write transaction as we are about to permanently purge entries.
   WriteTransaction trans(FROM_HERE, VACUUM_AFTER_SAVE, this);
   ScopedKernelLock lock(this);
   // Now drop everything we can out of memory.
   for (EntryKernelSet::const_iterator i = snapshot.dirty_metas.begin();
        i != snapshot.dirty_metas.end(); ++i) {
     MetahandlesMap::iterator found =
         kernel_->metahandles_map.find((*i)->ref(META_HANDLE));
     EntryKernel* entry =
-        (found == kernel_->metahandles_map.end() ? NULL : found->second);
+        (found == kernel_->metahandles_map.end() ? NULL : found->second.get());
     if (entry && SafeToPurgeFromMemory(&trans, entry)) {
       // We now drop deleted metahandles that are up to date on both the client
       // and the server.
+      std::unique_ptr<EntryKernel> unique_entry = std::move(found->second);
+
       size_t num_erased = 0;
       num_erased = kernel_->metahandles_map.erase(entry->ref(META_HANDLE));
       DCHECK_EQ(1u, num_erased);
       num_erased = kernel_->ids_map.erase(entry->ref(ID).value());
       DCHECK_EQ(1u, num_erased);
       if (!entry->ref(UNIQUE_SERVER_TAG).empty()) {
         num_erased =
             kernel_->server_tags_map.erase(entry->ref(UNIQUE_SERVER_TAG));
         DCHECK_EQ(1u, num_erased);
       }
       if (!entry->ref(UNIQUE_CLIENT_TAG).empty()) {
         num_erased =
             kernel_->client_tags_map.erase(entry->ref(UNIQUE_CLIENT_TAG));
         DCHECK_EQ(1u, num_erased);
       }
       if (!SyncAssert(!kernel_->parent_child_index.Contains(entry), FROM_HERE,
                       "Deleted entry still present", (&trans)))
         return false;
       RemoveFromAttachmentIndex(lock, entry->ref(META_HANDLE),
                                 entry->ref(ATTACHMENT_METADATA));
-
-      delete entry;
     }
     if (trans.unrecoverable_error_set())
       return false;
   }
   return true;
 }
 
 void Directory::UnapplyEntry(EntryKernel* entry) {
   int64_t handle = entry->ref(META_HANDLE);
   ModelType server_type =
@@ skipping 53 matching lines @@
 void Directory::DeleteEntry(const ScopedKernelLock& lock,
                             bool save_to_journal,
                             EntryKernel* entry,
                             EntryKernelSet* entries_to_journal) {
   int64_t handle = entry->ref(META_HANDLE);
   ModelType server_type =
       GetModelTypeFromSpecifics(entry->ref(SERVER_SPECIFICS));
 
   kernel_->metahandles_to_purge.insert(handle);
 
+  std::unique_ptr<EntryKernel> entry_ptr =
+      std::move(kernel_->metahandles_map[handle]);
+
   size_t num_erased = 0;
-  num_erased = kernel_->metahandles_map.erase(entry->ref(META_HANDLE));
+  num_erased = kernel_->metahandles_map.erase(handle);
   DCHECK_EQ(1u, num_erased);
   num_erased = kernel_->ids_map.erase(entry->ref(ID).value());
   DCHECK_EQ(1u, num_erased);
   num_erased = kernel_->unsynced_metahandles.erase(handle);
   DCHECK_EQ(entry->ref(IS_UNSYNCED), num_erased > 0);
   num_erased = kernel_->unapplied_update_metahandles[server_type].erase(handle);
   DCHECK_EQ(entry->ref(IS_UNAPPLIED_UPDATE), num_erased > 0);
   if (kernel_->parent_child_index.Contains(entry))
     kernel_->parent_child_index.Remove(entry);
 
   if (!entry->ref(UNIQUE_CLIENT_TAG).empty()) {
     num_erased = kernel_->client_tags_map.erase(entry->ref(UNIQUE_CLIENT_TAG));
     DCHECK_EQ(1u, num_erased);
   }
   if (!entry->ref(UNIQUE_SERVER_TAG).empty()) {
     num_erased = kernel_->server_tags_map.erase(entry->ref(UNIQUE_SERVER_TAG));
     DCHECK_EQ(1u, num_erased);
   }
   RemoveFromAttachmentIndex(lock, handle, entry->ref(ATTACHMENT_METADATA));
 
   if (save_to_journal) {
-    entries_to_journal->insert(entry);
-  } else {
-    delete entry;
+    entries_to_journal->insert(entry_ptr.release());
   }
 }
 
 bool Directory::PurgeEntriesWithTypeIn(ModelTypeSet disabled_types,
                                        ModelTypeSet types_to_journal,
                                        ModelTypeSet types_to_unapply) {
   disabled_types.RemoveAll(ProxyTypes());
 
   if (disabled_types.Empty())
     return true;
@@ skipping 15 matching lines @@
           found_progress = true;
       }
 
       // If none of the disabled types have progress markers, there's nothing to
       // purge.
       if (!found_progress)
         return true;
 
       for (MetahandlesMap::iterator it = kernel_->metahandles_map.begin();
            it != kernel_->metahandles_map.end();) {
-        EntryKernel* entry = it->second;
+        EntryKernel* entry = it->second.get();
         const sync_pb::EntitySpecifics& local_specifics = entry->ref(SPECIFICS);
         const sync_pb::EntitySpecifics& server_specifics =
             entry->ref(SERVER_SPECIFICS);
         ModelType local_type = GetModelTypeFromSpecifics(local_specifics);
         ModelType server_type = GetModelTypeFromSpecifics(server_specifics);
 
         // Increment the iterator before (potentially) calling DeleteEntry,
         // otherwise our iterator may be invalidated.
         ++it;
 
@@ skipping 308 matching lines @@
   GetMetaHandlesOfType(lock, trans, type, result);
 }
 
 void Directory::GetMetaHandlesOfType(const ScopedKernelLock& lock,
                                      BaseTransaction* trans,
                                      ModelType type,
                                      std::vector<int64_t>* result) {
   result->clear();
   for (MetahandlesMap::iterator it = kernel_->metahandles_map.begin();
        it != kernel_->metahandles_map.end(); ++it) {
-    EntryKernel* entry = it->second;
+    EntryKernel* entry = it->second.get();
     const ModelType entry_type =
         GetModelTypeFromSpecifics(entry->ref(SPECIFICS));
     if (entry_type == type)
       result->push_back(it->first);
   }
 }
 
 void Directory::CollectMetaHandleCounts(
     std::vector<int>* num_entries_by_type,
     std::vector<int>* num_to_delete_entries_by_type) {
   syncable::ReadTransaction trans(FROM_HERE, this);
   ScopedKernelLock lock(this);
 
   for (MetahandlesMap::iterator it = kernel_->metahandles_map.begin();
        it != kernel_->metahandles_map.end(); ++it) {
-    EntryKernel* entry = it->second;
+    EntryKernel* entry = it->second.get();
     const ModelType type = GetModelTypeFromSpecifics(entry->ref(SPECIFICS));
     (*num_entries_by_type)[type]++;
     if (entry->ref(IS_DEL))
       (*num_to_delete_entries_by_type)[type]++;
   }
 }
 
 std::unique_ptr<base::ListValue> Directory::GetNodeDetailsForType(
     BaseTransaction* trans,
     ModelType type) {
   std::unique_ptr<base::ListValue> nodes(new base::ListValue());
 
   ScopedKernelLock lock(this);
   for (MetahandlesMap::iterator it = kernel_->metahandles_map.begin();
        it != kernel_->metahandles_map.end(); ++it) {
     if (GetModelTypeFromSpecifics(it->second->ref(SPECIFICS)) != type) {
       continue;
     }
 
-    EntryKernel* kernel = it->second;
+    EntryKernel* kernel = it->second.get();
     std::unique_ptr<base::DictionaryValue> node(
         kernel->ToValue(GetCryptographer(trans)));
 
     // Add the position index if appropriate.  This must be done here (and not
     // in EntryKernel) because the EntryKernel does not have access to its
     // siblings.
     if (kernel->ShouldMaintainPosition() && !kernel->ref(IS_DEL)) {
       node->SetInteger("positionIndex", GetPositionIndex(trans, kernel));
     }
 
@@ skipping 405 matching lines @@
 Directory::Kernel* Directory::kernel() {
   return kernel_;
 }
 
 const Directory::Kernel* Directory::kernel() const {
   return kernel_;
 }
 
 }  // namespace syncable
 }  // namespace syncer