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

chrome/browser/sync_file_system/drive_backend/metadata_database_index.cc

 // Copyright 2014 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 "chrome/browser/sync_file_system/drive_backend/metadata_database_index.h"
 
 #include <tuple>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
@@ skipping 244 matching lines @@
 MetadataDatabaseIndex::~MetadataDatabaseIndex() {}
 
 void MetadataDatabaseIndex::RemoveUnreachableItems() {
   // Do nothing. MetadataDatabaseIndex is behind a private flag and will be
   // removed soon.
   // TODO(crbug.com/568008): Remove MetadataDatabaseIndex.
 }
 
 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;
 }
 
 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;
 }
 
 void MetadataDatabaseIndex::StoreFileMetadata(
     std::unique_ptr<FileMetadata> metadata) {
   PutFileMetadataToDB(*metadata.get(), db_);
   if (!metadata) {
     NOTREACHED();
     return;
   }
 
   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(
     std::unique_ptr<FileTracker> tracker) {
   PutFileTrackerToDB(*tracker.get(), db_);
   if (!tracker) {
     NOTREACHED();
     return;
   }
 
   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);
 
     AddToAppIDIndex(*tracker);
     AddToPathIndexes(*tracker);
     AddToFileIDIndexes(*tracker);
     AddToDirtyTrackerIndexes(*tracker);
   } else {
     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) {
   PutFileMetadataDeletionToDB(file_id, db_);
   metadata_by_id_.erase(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);
 
   RemoveFromAppIDIndex(*tracker);
   RemoveFromPathIndexes(*tracker);
   RemoveFromFileIDIndexes(*tracker);
   RemoveFromDirtyTrackerIndexes(*tracker);
 
   tracker_by_id_.erase(tracker_id);
@@ skipping 134 matching lines @@
   if (!service_metadata_->has_next_tracker_id()) {
     NOTREACHED();
     return kInvalidTrackerID;
   }
   return service_metadata_->next_tracker_id();
 }
 
 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;
 }
 
 void MetadataDatabaseIndex::AddToAppIDIndex(
     const FileTracker& new_tracker) {
   if (!IsAppRoot(new_tracker))
     return;
 
   DVLOG(3) << "  Add to app_root_by_app_id_: " << new_tracker.app_id();
 
@@ skipping 242 matching lines @@
 
     DVLOG(3) << "  Remove from dirty_trackers_: " << tracker_id;
     dirty_trackers_.erase(tracker_id);
 
     demoted_dirty_trackers_.erase(tracker_id);
   }
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system