Remove base::ScopedPtrHashMap from apps/.

apps/saved_files_service.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 "apps/saved_files_service.h"
 
 #include <stdint.h>
+
 #include <algorithm>
 #include <map>
+#include <unordered_map>
 #include <utility>
 
 #include "apps/saved_files_service_factory.h"
-#include "base/containers/scoped_ptr_hash_map.h"
 #include "base/memory/ptr_util.h"
 #include "base/value_conversions.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/profiles/profile.h"
 #include "content/public/browser/notification_service.h"
 #include "extensions/browser/extension_host.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/notification_types.h"
 #include "extensions/common/permissions/api_permission.h"
@@ skipping 148 matching lines @@
   // Compacts sequence numbers if the largest sequence number is
   // g_max_sequence_number. Outside of testing, it is set to kint32max, so this
   // will almost never do any real work.
   void MaybeCompactSequenceNumbers();
 
   void LoadSavedFileEntriesFromPreferences();
 
   Profile* profile_;
   const std::string extension_id_;
 
-  // Contains all file entries that have been registered, keyed by ID. Owns
-  // values.
-  base::ScopedPtrHashMap<std::string, std::unique_ptr<SavedFileEntry>>
+  // Contains all file entries that have been registered, keyed by ID.
+  std::unordered_map<std::string, std::unique_ptr<SavedFileEntry>>
       registered_file_entries_;
 
   // The queue of file entries that have been retained, keyed by
   // sequence_number. Values are a subset of values in registered_file_entries_.
   // This should be kept in sync with file entries stored in extension prefs.
   std::map<int, SavedFileEntry*> saved_file_lru_;
 
   DISALLOW_COPY_AND_ASSIGN(SavedFiles);
 };
 
@@ skipping 112 matching lines @@
     : profile_(profile), extension_id_(extension_id) {
   LoadSavedFileEntriesFromPreferences();
 }
 
 SavedFilesService::SavedFiles::~SavedFiles() {}
 
 void SavedFilesService::SavedFiles::RegisterFileEntry(
     const std::string& id,
     const base::FilePath& file_path,
     bool is_directory) {
-  if (ContainsKey(registered_file_entries_, id))
+  auto it = registered_file_entries_.find(id);
+  if (it != registered_file_entries_.end())
     return;
 
-  registered_file_entries_.add(
-      id, base::MakeUnique<SavedFileEntry>(id, file_path, is_directory, 0));
+  registered_file_entries_[id] =
+      base::MakeUnique<SavedFileEntry>(id, file_path, is_directory, 0);
 }
 
 void SavedFilesService::SavedFiles::EnqueueFileEntry(const std::string& id) {
   auto it = registered_file_entries_.find(id);
   DCHECK(it != registered_file_entries_.end());
 
-  SavedFileEntry* file_entry = it->second;
+  SavedFileEntry* file_entry = it->second.get();
   int old_sequence_number = file_entry->sequence_number;
   if (!saved_file_lru_.empty()) {
     // Get the sequence number after the last file entry in the LRU.
     std::map<int, SavedFileEntry*>::reverse_iterator it =
         saved_file_lru_.rbegin();
     if (it->second == file_entry)
       return;
 
     file_entry->sequence_number = it->first + 1;
   } else {
@@ skipping 12 matching lines @@
       std::map<int, SavedFileEntry*>::iterator it = saved_file_lru_.begin();
       it->second->sequence_number = 0;
       RemoveSavedFileEntry(prefs, extension_id_, it->second->id);
       saved_file_lru_.erase(it);
     }
   }
   MaybeCompactSequenceNumbers();
 }
 
 bool SavedFilesService::SavedFiles::IsRegistered(const std::string& id) const {
-  return ContainsKey(registered_file_entries_, id);
+  auto it = registered_file_entries_.find(id);
+  return it != registered_file_entries_.end();
 }
 
 const SavedFileEntry* SavedFilesService::SavedFiles::GetFileEntry(
     const std::string& id) const {
   auto it = registered_file_entries_.find(id);
   if (it == registered_file_entries_.end())
     return NULL;
 
-  return it->second;
+  return it->second.get();
 }
 
 std::vector<SavedFileEntry> SavedFilesService::SavedFiles::GetAllFileEntries()
     const {
   std::vector<SavedFileEntry> result;
   for (auto it = registered_file_entries_.begin();
        it != registered_file_entries_.end(); ++it) {
-    result.push_back(*it->second);
+    result.push_back(*it->second.get());
   }
   return result;
 }
 
 void SavedFilesService::SavedFiles::MaybeCompactSequenceNumbers() {
   DCHECK_GE(g_max_sequence_number, 0);
   DCHECK_GE(static_cast<size_t>(g_max_sequence_number),
             g_max_saved_file_entries);
   std::map<int, SavedFileEntry*>::reverse_iterator it =
       saved_file_lru_.rbegin();
@@ skipping 30 matching lines @@
   ExtensionPrefs* prefs = ExtensionPrefs::Get(profile_);
   std::vector<SavedFileEntry> saved_entries =
       GetSavedFileEntries(prefs, extension_id_);
   for (std::vector<SavedFileEntry>::iterator it = saved_entries.begin();
        it != saved_entries.end();
        ++it) {
     std::unique_ptr<SavedFileEntry> file_entry(new SavedFileEntry(*it));
     const std::string& id = file_entry->id;
     saved_file_lru_.insert(
         std::make_pair(file_entry->sequence_number, file_entry.get()));
-    registered_file_entries_.add(id, std::move(file_entry));
+    registered_file_entries_[id] = std::move(file_entry);
   }
 }
 
 // static
 void SavedFilesService::SetMaxSequenceNumberForTest(int max_value) {
   g_max_sequence_number = max_value;
 }
 
 // static
 void SavedFilesService::ClearMaxSequenceNumberForTest() {
   g_max_sequence_number = kMaxSequenceNumber;
 }
 
 // static
 void SavedFilesService::SetLruSizeForTest(int size) {
   g_max_saved_file_entries = size;
 }
 
 // static
 void SavedFilesService::ClearLruSizeForTest() {
   g_max_saved_file_entries = kMaxSavedFileEntries;
 }
 
 }  // namespace apps