Fix EntryKernel leak if sync database load fails

chrome/browser/sync/syncable/syncable.cc

 // Copyright (c) 2010 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 "chrome/browser/sync/syncable/syncable.h"
 
 #include "build/build_config.h"
 
 #include <sys/stat.h>
 #if defined(OS_POSIX)
@@ skipping 14 matching lines @@
 #include <limits>
 #include <set>
 #include <string>
 
 #include "base/hash_tables.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/perftimer.h"
 #include "base/scoped_ptr.h"
 #include "base/string_util.h"
+#include "base/stl_util-inl.h"
 #include "base/time.h"
 #include "chrome/browser/sync/engine/syncer.h"
 #include "chrome/browser/sync/engine/syncer_util.h"
 #include "chrome/browser/sync/protocol/autofill_specifics.pb.h"
 #include "chrome/browser/sync/protocol/bookmark_specifics.pb.h"
 #include "chrome/browser/sync/protocol/password_specifics.pb.h"
 #include "chrome/browser/sync/protocol/preference_specifics.pb.h"
 #include "chrome/browser/sync/protocol/service_constants.h"
 #include "chrome/browser/sync/protocol/theme_specifics.pb.h"
 #include "chrome/browser/sync/protocol/typed_url_specifics.pb.h"
@@ skipping 131 matching lines @@
       unsynced_metahandles(new MetahandleSet),
       dirty_metahandles(new MetahandleSet),
       metahandles_to_purge(new MetahandleSet),
       channel(new Directory::Channel(syncable::DIRECTORY_DESTROYED)),
       info_status(Directory::KERNEL_SHARE_INFO_VALID),
       persisted_info(info.kernel_info),
       cache_guid(info.cache_guid),
       next_metahandle(info.max_metahandle + 1) {
 }
 
-inline void DeleteEntry(EntryKernel* kernel) {
-  delete kernel;
-}
-
 void Directory::Kernel::AddRef() {
   base::subtle::NoBarrier_AtomicIncrement(&refcount, 1);
 }
 
 void Directory::Kernel::Release() {
   if (!base::subtle::NoBarrier_AtomicIncrement(&refcount, -1))
     delete this;
 }
 
 Directory::Kernel::~Kernel() {
   CHECK(0 == refcount);
   delete channel;
   changes_channel.Notify(kShutdownChangesEvent);
   delete unsynced_metahandles;
   delete unapplied_update_metahandles;
   delete dirty_metahandles;
   delete metahandles_to_purge;
   delete parent_id_child_index;
   delete client_tag_index;
   delete ids_index;
-  for_each(metahandles_index->begin(), metahandles_index->end(), DeleteEntry);
+  STLDeleteElements(metahandles_index);
   delete metahandles_index;
 }
 
 Directory::Directory() : kernel_(NULL), store_(NULL) {
 }
 
 Directory::~Directory() {
   Close();
 }
 
@@ skipping 111 matching lines @@
 EntryKernel* Directory::GetEntryByHandle(const int64 metahandle) {
   ScopedKernelLock lock(this);
   return GetEntryByHandle(metahandle, &lock);
 }
 
 EntryKernel* Directory::GetEntryByHandle(const int64 metahandle,
                                          ScopedKernelLock* lock) {
   // Look up in memory
   kernel_->needle.put(META_HANDLE, metahandle);
   MetahandlesIndex::iterator found =
-    kernel_->metahandles_index->find(&kernel_->needle);
+      kernel_->metahandles_index->find(&kernel_->needle);
   if (found != kernel_->metahandles_index->end()) {
     // Found it in memory.  Easy.
     return *found;
   }
   return NULL;
 }
 
 // An interface to specify the details of which children
 // GetChildHandles() is looking for.
 // TODO(chron): Clean this up into one function to get child handles
@@ skipping 270 matching lines @@
         ModelType local_type = GetModelTypeFromSpecifics(local_specifics);
         ModelType server_type = GetModelTypeFromSpecifics(server_specifics);
 
         // Note the dance around incrementing |it|, since we sometimes erase().
         if (types.count(local_type) > 0 || types.count(server_type) > 0) {
           UnlinkEntryFromOrder(*it, NULL, &lock);
           int64 handle = (*it)->ref(META_HANDLE);
           kernel_->metahandles_to_purge->insert(handle);
 
           size_t num_erased = 0;
-          num_erased = kernel_->ids_index->erase(*it);
+          EntryKernel* entry = *it;
+          num_erased = kernel_->ids_index->erase(entry);
           DCHECK_EQ(1u, num_erased);
-          num_erased = kernel_->client_tag_index->erase(*it);
-          DCHECK_EQ((*it)->ref(UNIQUE_CLIENT_TAG).empty(), !num_erased);
+          num_erased = kernel_->client_tag_index->erase(entry);
+          DCHECK_EQ(entry->ref(UNIQUE_CLIENT_TAG).empty(), !num_erased);
           num_erased = kernel_->unsynced_metahandles->erase(handle);
-          DCHECK_EQ((*it)->ref(IS_UNSYNCED), num_erased > 0);
+          DCHECK_EQ(entry->ref(IS_UNSYNCED), num_erased > 0);
           num_erased = kernel_->unapplied_update_metahandles->erase(handle);
-          DCHECK_EQ((*it)->ref(IS_UNAPPLIED_UPDATE), num_erased > 0);
-          num_erased = kernel_->parent_id_child_index->erase(*it);
-          DCHECK_EQ((*it)->ref(IS_DEL), !num_erased);
+          DCHECK_EQ(entry->ref(IS_UNAPPLIED_UPDATE), num_erased > 0);
+          num_erased = kernel_->parent_id_child_index->erase(entry);
+          DCHECK_EQ(entry->ref(IS_DEL), !num_erased);
           kernel_->metahandles_index->erase(it++);
+          delete entry;
         } else {
           ++it;
         }
       }
 
       // Ensure meta tracking for these data types reflects the deleted state.
       for (std::set<ModelType>::const_iterator it = types.begin();
            it != types.end(); ++it) {
         set_initial_sync_ended_for_type_unsafe(*it, false);
         set_last_download_timestamp_unsafe(*it, 0);
@@ skipping 925 matching lines @@
   return s << std::dec;
 }
 
 FastDump& operator<<(FastDump& dump, const syncable::Blob& blob) {
   if (blob.empty())
     return dump;
   string buffer(HexEncode(&blob[0], blob.size()));
   dump.out_->sputn(buffer.c_str(), buffer.size());
   return dump;
 }