Remove stl_util from sync.

components/sync/syncable/directory_backing_store.cc

 // Copyright 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 "components/sync/syncable/directory_backing_store.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <limits>
 #include <unordered_set>
 
 #include "base/base64.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/rand_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "components/sync/base/node_ordinal.h"
 #include "components/sync/base/time.h"
 #include "components/sync/protocol/bookmark_specifics.pb.h"
 #include "components/sync/protocol/sync.pb.h"
-#include "components/sync/syncable/syncable-inl.h"
 #include "components/sync/syncable/syncable_columns.h"
 #include "components/sync/syncable/syncable_util.h"
 #include "sql/connection.h"
 #include "sql/error_delegate_util.h"
 #include "sql/statement.h"
 #include "sql/transaction.h"
 
 using std::string;
 
 namespace syncer {
@@ skipping 284 matching lines @@
       (Directory::KERNEL_SHARE_INFO_DIRTY == snapshot.kernel_info_status);
   if (!snapshot.HasUnsavedMetahandleChanges() && !save_info) {
     return true;
   }
 
   sql::Transaction transaction(db_.get());
   if (!transaction.Begin())
     return false;
 
   PrepareSaveEntryStatement(METAS_TABLE, &save_meta_statement_);
-  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) {
     DCHECK((*i)->is_dirty());
     if (!SaveEntryToDB(&save_meta_statement_, **i))
       return false;
   }
 
   if (!DeleteEntries(METAS_TABLE, snapshot.metahandles_to_purge))
     return false;
 
   PrepareSaveEntryStatement(DELETE_JOURNAL_TABLE,
                             &save_delete_journal_statement_);
-  for (EntryKernelSet::const_iterator i = snapshot.delete_journals.begin();
+  for (auto i = snapshot.delete_journals.begin();
        i != snapshot.delete_journals.end(); ++i) {
     if (!SaveEntryToDB(&save_delete_journal_statement_, **i))
       return false;
   }
 
   if (!DeleteEntries(DELETE_JOURNAL_TABLE, snapshot.delete_journals_to_purge))
     return false;
 
   if (save_info) {
     const Directory::PersistedKernelInfo& info = snapshot.kernel_info;
@@ skipping 337 matching lines @@
     const EntryKernel& entry) const {
   if (entry.ref(IS_DEL)) {
     if (!entry.ref(IS_UNSYNCED) && !entry.ref(IS_UNAPPLIED_UPDATE))
       return true;
     else if (!entry.ref(ID).ServerKnows())
       return true;
   }
   return false;
 }
 
-bool DirectoryBackingStore::LoadDeleteJournals(
-    JournalIndex* delete_journals) {
+bool DirectoryBackingStore::LoadDeleteJournals(JournalIndex* delete_journals) {
   string select;
   select.reserve(kUpdateStatementBufferSize);
   select.append("SELECT ");
   AppendColumnList(&select);
   select.append(" FROM deleted_metas");
 
   sql::Statement s(db_->GetUniqueStatement(select.c_str()));
 
   while (s.Step()) {
     int total_entry_copies;
-    std::unique_ptr<EntryKernel> kernel = UnpackEntry(&s, &total_entry_copies);
+    std::unique_ptr<EntryKernel> kernel_ptr =
+        UnpackEntry(&s, &total_entry_copies);
     // A null kernel is evidence of external data corruption.
-    if (!kernel)
+    if (!kernel_ptr)
       return false;
-    delete_journals->insert(kernel.release());
+    EntryKernel* kernel = kernel_ptr.get();
+    (*delete_journals)[kernel] = std::move(kernel_ptr);
   }
   return s.Succeeded();
 }
 
 bool DirectoryBackingStore::LoadInfo(Directory::KernelLoadInfo* info) {
   {
     sql::Statement s(db_->GetUniqueStatement(
         "SELECT store_birthday, cache_guid, bag_of_chips "
         "FROM share_info"));
     if (!s.Step())
@@ skipping 1028 matching lines @@
   DCHECK(CalledOnValidThread());
   DCHECK(!catastrophic_error_handler.is_null());
   catastrophic_error_handler_ = catastrophic_error_handler;
   sql::Connection::ErrorCallback error_callback =
       base::Bind(&OnSqliteError, catastrophic_error_handler_);
   db_->set_error_callback(error_callback);
 }
 
 }  // namespace syncable
 }  // namespace syncer