components: Use stl utilities from the base namespace

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>
@@ skipping 58 matching lines @@
     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() {
-  STLDeleteElements(&dirty_metas);
-  STLDeleteElements(&delete_journals);
+  base::STLDeleteElements(&dirty_metas);
+  base::STLDeleteElements(&delete_journals);
 }
 
 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,
     const WeakHandle<TransactionObserver>& transaction_observer)
     : next_write_transaction_id(0),
       name(name),
       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() {
-  STLDeleteContainerPairSecondPointers(metahandles_map.begin(),
-                                       metahandles_map.end());
+  base::STLDeleteContainerPairSecondPointers(metahandles_map.begin(),
+                                             metahandles_map.end());
 }
 
 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),
@@ skipping 62 matching lines @@
     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.
-  STLValueDeleter<MetahandlesMap> deleter(&tmp_handles_map);
+  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_);
@@ skipping 531 matching lines @@
                                        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;
-    STLElementDeleter<EntryKernelSet> journal_deleter(&entries_to_journal);
+    base::STLElementDeleter<EntryKernelSet> journal_deleter(
+        &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 789 matching lines @@
 Directory::Kernel* Directory::kernel() {
   return kernel_;
 }
 
 const Directory::Kernel* Directory::kernel() const {
   return kernel_;
 }
 
 }  // namespace syncable
 }  // namespace syncer