Remove stl_util from sync.

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"
 #include "components/sync/syncable/model_neutral_mutable_entry.h"
 #include "components/sync/syncable/on_disk_directory_backing_store.h"
 #include "components/sync/syncable/scoped_kernel_lock.h"
 #include "components/sync/syncable/scoped_parent_child_index_updater.h"
-#include "components/sync/syncable/syncable-inl.h"
 #include "components/sync/syncable/syncable_base_transaction.h"
 #include "components/sync/syncable/syncable_changes_version.h"
 #include "components/sync/syncable/syncable_read_transaction.h"
 #include "components/sync/syncable/syncable_util.h"
 #include "components/sync/syncable/syncable_write_transaction.h"
 
 using std::string;
 
 namespace syncer {
 namespace syncable {
@@ skipping 27 matching lines @@
 bool Directory::PersistedKernelInfo::HasEmptyDownloadProgress(
     ModelType model_type) {
   const sync_pb::DataTypeProgressMarker& progress_marker =
       download_progress[model_type];
   return progress_marker.token().empty();
 }
 
 Directory::SaveChangesSnapshot::SaveChangesSnapshot()
     : kernel_info_status(KERNEL_SHARE_INFO_INVALID) {}
 
-Directory::SaveChangesSnapshot::~SaveChangesSnapshot() {
-  base::STLDeleteElements(&dirty_metas);
-  base::STLDeleteElements(&delete_journals);
-}
+Directory::SaveChangesSnapshot::~SaveChangesSnapshot() {}
 
 bool Directory::SaveChangesSnapshot::HasUnsavedMetahandleChanges() const {
   return !dirty_metas.empty() || !metahandles_to_purge.empty() ||
          !delete_journals.empty() || !delete_journals_to_purge.empty();
 }
 
 Directory::Kernel::Kernel(
     const std::string& name,
     const KernelLoadInfo& info,
     DirectoryChangeDelegate* delegate,
@@ skipping 83 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;
 
-  JournalIndex delete_journals;
+  std::unique_ptr<JournalIndex> delete_journals =
+      base::MakeUnique<JournalIndex>();
   MetahandleSet metahandles_to_purge;
 
-  DirOpenResult result = store_->Load(&tmp_handles_map, &delete_journals,
+  DirOpenResult result = store_->Load(&tmp_handles_map, delete_journals.get(),
                                       &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));
+  delete_journal_ = base::MakeUnique<DeleteJournal>(std::move(delete_journals));

[maxbogue, 2016/09/01 21:10:22]

I don't think you need the MakeUnique here, do you? This should be fine:

delete_journal_ = std::move(delete_journals);

[maxbogue, 2016/09/01 21:13:17]

Never mind, Pavel pointed out that these are different types, sorry!

   InitializeIndices(&tmp_handles_map);
 
   // 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(
@@ skipping 326 matching lines @@
   // clear dirty flags.
   for (MetahandleSet::const_iterator i = kernel_->dirty_metahandles.begin();
        i != kernel_->dirty_metahandles.end(); ++i) {
     EntryKernel* entry = GetEntryByHandle(lock, *i);
     if (!entry)
       continue;
     // Skip over false positives; it happens relatively infrequently.
     if (!entry->is_dirty())
       continue;
     snapshot->dirty_metas.insert(snapshot->dirty_metas.end(),
-                                 new EntryKernel(*entry));
+                                 base::MakeUnique<EntryKernel>(*entry));
     DCHECK_EQ(1U, kernel_->dirty_metahandles.count(*i));
     // We don't bother removing from the index here as we blow the entire thing
     // in a moment, and it unnecessarily complicates iteration.
     entry->clear_dirty(NULL);
   }
   ClearDirtyMetahandles(lock);
 
   // Set purged handles.
   DCHECK(snapshot->metahandles_to_purge.empty());
   snapshot->metahandles_to_purge.swap(kernel_->metahandles_to_purge);
@@ skipping 27 matching lines @@
 }
 
 bool Directory::VacuumAfterSaveChanges(const SaveChangesSnapshot& snapshot) {
   if (snapshot.dirty_metas.empty())
     return true;
 
   // 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) {
+  for (auto 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.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;
@@ skipping 75 matching lines @@
 
   // At this point locally created items that aren't synced will become locally
   // deleted items, and purged on the next snapshot. All other items will match
   // the state they would have had if they were just created via a server
   // update. See MutableEntry::MutableEntry(.., CreateNewUpdateItem, ..).
 }
 
 void Directory::DeleteEntry(const ScopedKernelLock& lock,
                             bool save_to_journal,
                             EntryKernel* entry,
-                            EntryKernelSet* entries_to_journal) {
+                            OwnedEntryKernelSet* 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;
@@ skipping 12 matching lines @@
     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_ptr.release());
+    entries_to_journal->insert(std::move(entry_ptr));
   }
 }
 
 bool Directory::PurgeEntriesWithTypeIn(ModelTypeSet disabled_types,
                                        ModelTypeSet types_to_journal,
                                        ModelTypeSet types_to_unapply) {
   disabled_types.RemoveAll(ProxyTypes());
 
   if (disabled_types.Empty())
     return true;
 
   {
     WriteTransaction trans(FROM_HERE, PURGE_ENTRIES, this);
 
-    EntryKernelSet entries_to_journal;
-    base::STLElementDeleter<EntryKernelSet> journal_deleter(
-        &entries_to_journal);
+    OwnedEntryKernelSet entries_to_journal;
 
     {
       ScopedKernelLock lock(this);
 
       bool found_progress = false;
       for (ModelTypeSet::Iterator iter = disabled_types.First(); iter.Good();
            iter.Inc()) {
         if (!kernel_->persisted_info.HasEmptyDownloadProgress(iter.Get()))
           found_progress = true;
       }
@@ skipping 100 matching lines @@
 void Directory::HandleSaveChangesFailure(const SaveChangesSnapshot& snapshot) {
   WriteTransaction trans(FROM_HERE, HANDLE_SAVE_FAILURE, this);
   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
   // that SaveChanges will at least try again later.
-  for (EntryKernelSet::const_iterator i = snapshot.dirty_metas.begin();
-       i != snapshot.dirty_metas.end(); ++i) {
+  for (auto i = snapshot.dirty_metas.begin(); i != snapshot.dirty_metas.end();
+       ++i) {
     MetahandlesMap::iterator found =
         kernel_->metahandles_map.find((*i)->ref(META_HANDLE));
     if (found != kernel_->metahandles_map.end()) {
       found->second->mark_dirty(&kernel_->dirty_metahandles);
     }
   }
 
   kernel_->metahandles_to_purge.insert(snapshot.metahandles_to_purge.begin(),
                                        snapshot.metahandles_to_purge.end());
 
@@ skipping 667 matching lines @@
 Directory::Kernel* Directory::kernel() {
   return kernel_;
 }
 
 const Directory::Kernel* Directory::kernel() const {
   return kernel_;
 }
 
 }  // namespace syncable
 }  // namespace syncer