Remove base::ScopedPtrHashMap from chrome/browser/sync_file_system/drive_backend/.

BUG=579229

Review-Url: https://codereview.chromium.org/2605433002
Cr-Commit-Position: refs/heads/master@{#440938}

chrome/browser/sync_file_system/drive_backend/metadata_database_index.cc

@@ -262,9 +262,10 @@ void MetadataDatabaseIndex::RemoveUnreachableItems() {
 
 bool MetadataDatabaseIndex::GetFileMetadata(
     const std::string& file_id, FileMetadata* metadata) const {
-  FileMetadata* identified = metadata_by_id_.get(file_id);
-  if (!identified)
+  auto it = metadata_by_id_.find(file_id);
+  if (it == metadata_by_id_.end())
     return false;
+  FileMetadata* identified = it->second.get();
   if (metadata)
     metadata->CopyFrom(*identified);
   return true;
@@ -272,9 +273,10 @@ bool MetadataDatabaseIndex::GetFileMetadata(
 
 bool MetadataDatabaseIndex::GetFileTracker(int64_t tracker_id,
                                            FileTracker* tracker) const {
-  FileTracker* identified = tracker_by_id_.get(tracker_id);
-  if (!identified)
+  auto it = tracker_by_id_.find(tracker_id);
+  if (it == tracker_by_id_.end())
     return false;
+  FileTracker* identified = it->second.get();
   if (tracker)
     tracker->CopyFrom(*identified);
   return true;
@@ -289,7 +291,7 @@ void MetadataDatabaseIndex::StoreFileMetadata(
   }
 
   std::string file_id = metadata->file_id();
-  metadata_by_id_.set(file_id, std::move(metadata));
+  metadata_by_id_[file_id] = std::move(metadata);
 }
 
 void MetadataDatabaseIndex::StoreFileTracker(
@@ -301,9 +303,9 @@ void MetadataDatabaseIndex::StoreFileTracker(
   }
 
   int64_t tracker_id = tracker->tracker_id();
-  FileTracker* old_tracker = tracker_by_id_.get(tracker_id);
+  auto old_tracker_it = tracker_by_id_.find(tracker_id);
 
-  if (!old_tracker) {
+  if (old_tracker_it == tracker_by_id_.end()) {
     DVLOG(3) << "Adding new tracker: " << tracker->tracker_id()
              << " " << GetTrackerTitle(*tracker);
 
@@ -315,13 +317,14 @@ void MetadataDatabaseIndex::StoreFileTracker(
     DVLOG(3) << "Updating tracker: " << tracker->tracker_id()
              << " " << GetTrackerTitle(*tracker);
 
+    FileTracker* old_tracker = old_tracker_it->second.get();
     UpdateInAppIDIndex(*old_tracker, *tracker);
     UpdateInPathIndexes(*old_tracker, *tracker);
     UpdateInFileIDIndexes(*old_tracker, *tracker);
     UpdateInDirtyTrackerIndexes(*old_tracker, *tracker);
   }
 
-  tracker_by_id_.set(tracker_id, std::move(tracker));
+  tracker_by_id_[tracker_id] = std::move(tracker);
 }
 
 void MetadataDatabaseIndex::RemoveFileMetadata(const std::string& file_id) {
@@ -332,11 +335,12 @@ void MetadataDatabaseIndex::RemoveFileMetadata(const std::string& file_id) {
 void MetadataDatabaseIndex::RemoveFileTracker(int64_t tracker_id) {
   PutFileTrackerDeletionToDB(tracker_id, db_);
 
-  FileTracker* tracker = tracker_by_id_.get(tracker_id);
-  if (!tracker) {
+  auto tracker_it = tracker_by_id_.find(tracker_id);
+  if (tracker_it == tracker_by_id_.end()) {
     NOTREACHED();
     return;
   }
+  FileTracker* tracker = tracker_it->second.get();
 
   DVLOG(3) << "Removing tracker: "
            << tracker->tracker_id() << " " << GetTrackerTitle(*tracker);
@@ -491,27 +495,22 @@ int64_t MetadataDatabaseIndex::GetNextTrackerID() const {
 std::vector<std::string> MetadataDatabaseIndex::GetRegisteredAppIDs() const {
   std::vector<std::string> result;
   result.reserve(app_root_by_app_id_.size());
-  for (TrackerIDByAppID::const_iterator itr = app_root_by_app_id_.begin();
-       itr != app_root_by_app_id_.end(); ++itr)
-    result.push_back(itr->first);
+  for (const auto& pair : app_root_by_app_id_)
+    result.push_back(pair.first);
   return result;
 }
 
 std::vector<int64_t> MetadataDatabaseIndex::GetAllTrackerIDs() const {
   std::vector<int64_t> result;
-  for (TrackerByID::const_iterator itr = tracker_by_id_.begin();
-       itr != tracker_by_id_.end(); ++itr) {
-    result.push_back(itr->first);
-  }
+  for (const auto& pair : tracker_by_id_)
+    result.push_back(pair.first);
   return result;
 }
 
 std::vector<std::string> MetadataDatabaseIndex::GetAllMetadataIDs() const {
   std::vector<std::string> result;
-  for (MetadataByID::const_iterator itr = metadata_by_id_.begin();
-       itr != metadata_by_id_.end(); ++itr) {
-    result.push_back(itr->first);
-  }
+  for (const auto& pair : metadata_by_id_)
+    result.push_back(pair.first);
   return result;
 }
 

chrome/browser/sync_file_system/drive_backend/metadata_database_index.h

@@ -11,6 +11,7 @@
 #include <map>
 #include <set>
 #include <string>
+#include <unordered_map>
 #include <vector>
 
 #include "base/containers/hash_tables.h"
@@ -104,10 +105,9 @@ class MetadataDatabaseIndex : public MetadataDatabaseIndexInterface {
   std::vector<std::string> GetAllMetadataIDs() const override;
 
  private:
-  typedef base::ScopedPtrHashMap<std::string, std::unique_ptr<FileMetadata>>
+  typedef std::unordered_map<std::string, std::unique_ptr<FileMetadata>>
       MetadataByID;
-  typedef base::ScopedPtrHashMap<int64_t, std::unique_ptr<FileTracker>>
-      TrackerByID;
+  typedef std::unordered_map<int64_t, std::unique_ptr<FileTracker>> TrackerByID;
   typedef base::hash_map<std::string, TrackerIDSet> TrackerIDsByFileID;
   typedef base::hash_map<std::string, TrackerIDSet> TrackerIDsByTitle;
   typedef std::map<int64_t, TrackerIDsByTitle> TrackerIDsByParentAndTitle;

chrome/browser/sync_file_system/drive_backend/metadata_database_unittest.cc

@@ -6,6 +6,7 @@
 
 #include <stdint.h>
 
+#include <unordered_map>
 #include <utility>
 
 #include "base/bind.h"
@@ -105,16 +106,24 @@ void ExpectEquivalent(const std::map<Key, Value>& left,
 template <typename Key, typename Value>
 void ExpectEquivalent(const base::hash_map<Key, Value>& left,
                       const base::hash_map<Key, Value>& right) {
+  // Convert from a hash container to an ordered container for comparison.
   ExpectEquivalentMaps(std::map<Key, Value>(left.begin(), left.end()),
                        std::map<Key, Value>(right.begin(), right.end()));
 }
 
 template <typename Key, typename Value>
 void ExpectEquivalent(
-    const base::ScopedPtrHashMap<Key, std::unique_ptr<Value>>& left,
-    const base::ScopedPtrHashMap<Key, std::unique_ptr<Value>>& right) {
-  ExpectEquivalentMaps(std::map<Key, Value*>(left.begin(), left.end()),
-                       std::map<Key, Value*>(right.begin(), right.end()));
+    const std::unordered_map<Key, std::unique_ptr<Value>>& left,
+    const std::unordered_map<Key, std::unique_ptr<Value>>& right) {
+  // Convert from a hash container to an ordered container for comparison.
+  std::map<Key, Value*> left_ordered;
+  std::map<Key, Value*> right_ordered;
+  for (const auto& item : left)
+    left_ordered[item.first] = item.second.get();
+  for (const auto& item : right)
+    right_ordered[item.first] = item.second.get();
+
+  ExpectEquivalentMaps(left_ordered, right_ordered);
 }
 
 template <typename Container>
@@ -129,6 +138,7 @@ void ExpectEquivalent(const std::set<Value, Comparator>& left,
 template <typename Value>
 void ExpectEquivalent(const base::hash_set<Value>& left,
                       const base::hash_set<Value>& right) {
+  // Convert from a hash container to an ordered container for comparison.
   return ExpectEquivalentSets(std::set<Value>(left.begin(), left.end()),
                               std::set<Value>(right.begin(), right.end()));
 }

chrome/browser/sync_file_system/drive_backend/sync_task_manager.cc

@@ -201,7 +201,8 @@ bool SyncTaskManager::IsRunningTask(int64_t token_id) const {
   if (token_id == SyncTaskToken::kForegroundTaskTokenID)
     return true;
 
-  return ContainsKey(running_background_tasks_, token_id);
+  return running_background_tasks_.find(token_id) !=
+         running_background_tasks_.end();
 }
 
 void SyncTaskManager::DetachFromSequence() {
@@ -240,7 +241,8 @@ void SyncTaskManager::NotifyTaskDoneBody(std::unique_ptr<SyncTaskToken> token,
     token_ = std::move(token);
     task = std::move(running_foreground_task_);
   } else {
-    task = running_background_tasks_.take_and_erase(token->token_id());
+    task = std::move(running_background_tasks_[token->token_id()]);
+    running_background_tasks_.erase(token->token_id());
   }
 
   // Acquire the token to prevent a new task to jump into the queue.
@@ -343,8 +345,8 @@ void SyncTaskManager::UpdateTaskBlockerBody(
         weak_ptr_factory_.GetWeakPtr(), task_runner_.get(), task_token_seq_++,
         std::move(task_blocker));
     background_task_token->UpdateTask(from_here, callback);
-    running_background_tasks_.set(background_task_token->token_id(),
-                                  std::move(running_foreground_task_));
+    running_background_tasks_[background_task_token->token_id()] =
+        std::move(running_foreground_task_);
   }
 
   token_ = std::move(foreground_task_token);

chrome/browser/sync_file_system/drive_backend/sync_task_manager.h

@@ -10,10 +10,10 @@
 
 #include <memory>
 #include <queue>
+#include <unordered_map>
 #include <vector>
 
 #include "base/callback.h"
-#include "base/containers/scoped_ptr_hash_map.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/sequence_checker.h"
@@ -186,7 +186,7 @@ class SyncTaskManager {
 
   // Owns running backgrounded SyncTask to cancel the task on SyncTaskManager
   // deletion.
-  base::ScopedPtrHashMap<int64_t, std::unique_ptr<SyncTask>>
+  std::unordered_map<int64_t, std::unique_ptr<SyncTask>>
       running_background_tasks_;
 
   size_t maximum_background_task_;