chrome: Use stl utilities from the base namespace

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 152 matching lines @@
 
     AppendContents(
         LookUpMap(trackers_by_parent, tracker_id, std::set<int64_t>()),
         &pending);
   }
 
   // Delete all unreachable trackers.
   ScopedVector<FileTracker> reachable_trackers;
   for (size_t i = 0; i < contents->file_trackers.size(); ++i) {
     FileTracker* tracker = contents->file_trackers[i];
-    if (ContainsKey(visited_trackers, tracker->tracker_id())) {
+    if (base::ContainsKey(visited_trackers, tracker->tracker_id())) {
       reachable_trackers.push_back(tracker);
       contents->file_trackers[i] = nullptr;
     } else {
       PutFileTrackerDeletionToDB(tracker->tracker_id(), db);
     }
   }
   contents->file_trackers = std::move(reachable_trackers);
 
   // List all |file_id| referred by a tracker.
   base::hash_set<std::string> referred_file_ids;
   for (size_t i = 0; i < contents->file_trackers.size(); ++i)
     referred_file_ids.insert(contents->file_trackers[i]->file_id());
 
   // Delete all unreferred metadata.
   ScopedVector<FileMetadata> referred_file_metadata;
   for (size_t i = 0; i < contents->file_metadata.size(); ++i) {
     FileMetadata* metadata = contents->file_metadata[i];
-    if (ContainsKey(referred_file_ids, metadata->file_id())) {
+    if (base::ContainsKey(referred_file_ids, metadata->file_id())) {
       referred_file_metadata.push_back(metadata);
       contents->file_metadata[i] = nullptr;
     } else {
       PutFileMetadataDeletionToDB(metadata->file_id(), db);
     }
   }
   contents->file_metadata = std::move(referred_file_metadata);
 }
 
 }  // namespace
@@ skipping 313 matching lines @@
 }
 
 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();
 
   DCHECK(new_tracker.active());
-  DCHECK(!ContainsKey(app_root_by_app_id_, new_tracker.app_id()));
+  DCHECK(!base::ContainsKey(app_root_by_app_id_, new_tracker.app_id()));
   app_root_by_app_id_[new_tracker.app_id()] = new_tracker.tracker_id();
 }
 
 void MetadataDatabaseIndex::UpdateInAppIDIndex(
     const FileTracker& old_tracker,
     const FileTracker& new_tracker) {
   DCHECK_EQ(old_tracker.tracker_id(), new_tracker.tracker_id());
 
   if (IsAppRoot(old_tracker) && !IsAppRoot(new_tracker)) {
     DCHECK(old_tracker.active());
     DCHECK(!new_tracker.active());
-    DCHECK(ContainsKey(app_root_by_app_id_, old_tracker.app_id()));
+    DCHECK(base::ContainsKey(app_root_by_app_id_, old_tracker.app_id()));
 
     DVLOG(3) << "  Remove from app_root_by_app_id_: " << old_tracker.app_id();
 
     app_root_by_app_id_.erase(old_tracker.app_id());
   } else if (!IsAppRoot(old_tracker) && IsAppRoot(new_tracker)) {
     DCHECK(!old_tracker.active());
     DCHECK(new_tracker.active());
-    DCHECK(!ContainsKey(app_root_by_app_id_, new_tracker.app_id()));
+    DCHECK(!base::ContainsKey(app_root_by_app_id_, new_tracker.app_id()));
 
     DVLOG(3) << "  Add to app_root_by_app_id_: " << new_tracker.app_id();
 
     app_root_by_app_id_[new_tracker.app_id()] = new_tracker.tracker_id();
   }
 }
 
 void MetadataDatabaseIndex::RemoveFromAppIDIndex(
     const FileTracker& tracker) {
   if (IsAppRoot(tracker)) {
     DCHECK(tracker.active());
-    DCHECK(ContainsKey(app_root_by_app_id_, tracker.app_id()));
+    DCHECK(base::ContainsKey(app_root_by_app_id_, tracker.app_id()));
 
     DVLOG(3) << "  Remove from app_root_by_app_id_: " << tracker.app_id();
 
     app_root_by_app_id_.erase(tracker.app_id());
   }
 }
 
 void MetadataDatabaseIndex::AddToFileIDIndexes(
     const FileTracker& new_tracker) {
   DVLOG(3) << "  Add to trackers_by_file_id_: " << new_tracker.file_id();
 
   trackers_by_file_id_[new_tracker.file_id()].Insert(new_tracker);
 
   if (trackers_by_file_id_[new_tracker.file_id()].size() > 1) {
-    DVLOG_IF(3, !ContainsKey(multi_tracker_file_ids_, new_tracker.file_id()))
+    DVLOG_IF(3,
+             !base::ContainsKey(multi_tracker_file_ids_, new_tracker.file_id()))
         << "  Add to multi_tracker_file_ids_: " << new_tracker.file_id();
     multi_tracker_file_ids_.insert(new_tracker.file_id());
   }
 }
 
 void MetadataDatabaseIndex::UpdateInFileIDIndexes(
     const FileTracker& old_tracker,
     const FileTracker& new_tracker) {
   DCHECK_EQ(old_tracker.tracker_id(), new_tracker.tracker_id());
   DCHECK_EQ(old_tracker.file_id(), new_tracker.file_id());
 
   std::string file_id = new_tracker.file_id();
-  DCHECK(ContainsKey(trackers_by_file_id_, file_id));
+  DCHECK(base::ContainsKey(trackers_by_file_id_, file_id));
 
   if (old_tracker.active() && !new_tracker.active())
     trackers_by_file_id_[file_id].Deactivate(new_tracker.tracker_id());
   else if (!old_tracker.active() && new_tracker.active())
     trackers_by_file_id_[file_id].Activate(new_tracker.tracker_id());
 }
 
 void MetadataDatabaseIndex::RemoveFromFileIDIndexes(
     const FileTracker& tracker) {
   TrackerIDsByFileID::iterator found =
       trackers_by_file_id_.find(tracker.file_id());
   if (found == trackers_by_file_id_.end()) {
     NOTREACHED();
     return;
   }
 
   DVLOG(3) << "  Remove from trackers_by_file_id_: "
            << tracker.tracker_id();
   found->second.Erase(tracker.tracker_id());
 
   if (trackers_by_file_id_[tracker.file_id()].size() <= 1) {
-    DVLOG_IF(3, ContainsKey(multi_tracker_file_ids_, tracker.file_id()))
+    DVLOG_IF(3, base::ContainsKey(multi_tracker_file_ids_, tracker.file_id()))
         << "  Remove from multi_tracker_file_ids_: " << tracker.file_id();
     multi_tracker_file_ids_.erase(tracker.file_id());
   }
 
   if (found->second.empty())
     trackers_by_file_id_.erase(found);
 }
 
 void MetadataDatabaseIndex::AddToPathIndexes(
     const FileTracker& new_tracker) {
   int64_t parent = new_tracker.parent_tracker_id();
   std::string title = GetTrackerTitle(new_tracker);
 
   DVLOG(3) << "  Add to trackers_by_parent_and_title_: "
            << parent << " " << title;
 
   trackers_by_parent_and_title_[parent][title].Insert(new_tracker);
 
   if (trackers_by_parent_and_title_[parent][title].size() > 1 &&
       !title.empty()) {
-    DVLOG_IF(3, !ContainsKey(multi_backing_file_paths_,
-                             ParentIDAndTitle(parent, title)))
+    DVLOG_IF(3, !base::ContainsKey(multi_backing_file_paths_,
+                                   ParentIDAndTitle(parent, title)))
         << "  Add to multi_backing_file_paths_: " << parent << " " << title;
     multi_backing_file_paths_.insert(ParentIDAndTitle(parent, title));
   }
 }
 
 void MetadataDatabaseIndex::UpdateInPathIndexes(
     const FileTracker& old_tracker,
     const FileTracker& new_tracker) {
   DCHECK_EQ(old_tracker.tracker_id(), new_tracker.tracker_id());
   DCHECK_EQ(old_tracker.parent_tracker_id(), new_tracker.parent_tracker_id());
@@ skipping 20 matching lines @@
       NOTREACHED();
     }
 
     DVLOG(3) << "  Add to trackers_by_parent_and_title_: "
              << parent << " " << title;
 
     (*trackers_by_title)[title].Insert(new_tracker);
 
     if (trackers_by_parent_and_title_[parent][old_title].size() <= 1 &&
         !old_title.empty()) {
-      DVLOG_IF(3, ContainsKey(multi_backing_file_paths_,
-                              ParentIDAndTitle(parent, old_title)))
-          << "  Remove from multi_backing_file_paths_: "
-          << parent << " " << old_title;
+      DVLOG_IF(3, base::ContainsKey(multi_backing_file_paths_,
+                                    ParentIDAndTitle(parent, old_title)))
+          << "  Remove from multi_backing_file_paths_: " << parent << " "
+          << old_title;
       multi_backing_file_paths_.erase(ParentIDAndTitle(parent, old_title));
     }
 
     if (trackers_by_parent_and_title_[parent][title].size() > 1 &&
         !title.empty()) {
-      DVLOG_IF(3, !ContainsKey(multi_backing_file_paths_,
-                               ParentIDAndTitle(parent, title)))
+      DVLOG_IF(3, !base::ContainsKey(multi_backing_file_paths_,
+                                     ParentIDAndTitle(parent, title)))
           << "  Add to multi_backing_file_paths_: " << parent << " " << title;
       multi_backing_file_paths_.insert(ParentIDAndTitle(parent, title));
     }
 
     return;
   }
 
   if (old_tracker.active() && !new_tracker.active())
     trackers_by_parent_and_title_[parent][title].Deactivate(tracker_id);
   else if (!old_tracker.active() && new_tracker.active())
     trackers_by_parent_and_title_[parent][title].Activate(tracker_id);
 }
 
 void MetadataDatabaseIndex::RemoveFromPathIndexes(
     const FileTracker& tracker) {
   int64_t tracker_id = tracker.tracker_id();
   int64_t parent = tracker.parent_tracker_id();
   std::string title = GetTrackerTitle(tracker);
 
-  DCHECK(ContainsKey(trackers_by_parent_and_title_, parent));
-  DCHECK(ContainsKey(trackers_by_parent_and_title_[parent], title));
+  DCHECK(base::ContainsKey(trackers_by_parent_and_title_, parent));
+  DCHECK(base::ContainsKey(trackers_by_parent_and_title_[parent], title));
 
   DVLOG(3) << "  Remove from trackers_by_parent_and_title_: "
            << parent << " " << title;
 
   trackers_by_parent_and_title_[parent][title].Erase(tracker_id);
 
   if (trackers_by_parent_and_title_[parent][title].size() <= 1 &&
       !title.empty()) {
-    DVLOG_IF(3, ContainsKey(multi_backing_file_paths_,
-                            ParentIDAndTitle(parent, title)))
-        << "  Remove from multi_backing_file_paths_: "
-        << parent << " " << title;
+    DVLOG_IF(3, base::ContainsKey(multi_backing_file_paths_,
+                                  ParentIDAndTitle(parent, title)))
+        << "  Remove from multi_backing_file_paths_: " << parent << " "
+        << title;
     multi_backing_file_paths_.erase(ParentIDAndTitle(parent, title));
   }
 
   if (trackers_by_parent_and_title_[parent][title].empty()) {
     trackers_by_parent_and_title_[parent].erase(title);
     if (trackers_by_parent_and_title_[parent].empty())
       trackers_by_parent_and_title_.erase(parent);
   }
 }
 
 void MetadataDatabaseIndex::AddToDirtyTrackerIndexes(
     const FileTracker& new_tracker) {
-  DCHECK(!ContainsKey(dirty_trackers_, new_tracker.tracker_id()));
-  DCHECK(!ContainsKey(demoted_dirty_trackers_, new_tracker.tracker_id()));
+  DCHECK(!base::ContainsKey(dirty_trackers_, new_tracker.tracker_id()));
+  DCHECK(!base::ContainsKey(demoted_dirty_trackers_, new_tracker.tracker_id()));
 
   if (new_tracker.dirty()) {
     DVLOG(3) << "  Add to dirty_trackers_: " << new_tracker.tracker_id();
     dirty_trackers_.insert(new_tracker.tracker_id());
   }
 }
 
 void MetadataDatabaseIndex::UpdateInDirtyTrackerIndexes(
     const FileTracker& old_tracker,
     const FileTracker& new_tracker) {
   DCHECK_EQ(old_tracker.tracker_id(), new_tracker.tracker_id());
 
   int64_t tracker_id = new_tracker.tracker_id();
   if (old_tracker.dirty() && !new_tracker.dirty()) {
-    DCHECK(ContainsKey(dirty_trackers_, tracker_id) ||
-           ContainsKey(demoted_dirty_trackers_, tracker_id));
+    DCHECK(base::ContainsKey(dirty_trackers_, tracker_id) ||
+           base::ContainsKey(demoted_dirty_trackers_, tracker_id));
 
     DVLOG(3) << "  Remove from dirty_trackers_: " << tracker_id;
 
     dirty_trackers_.erase(tracker_id);
     demoted_dirty_trackers_.erase(tracker_id);
   } else if (!old_tracker.dirty() && new_tracker.dirty()) {
-    DCHECK(!ContainsKey(dirty_trackers_, tracker_id));
-    DCHECK(!ContainsKey(demoted_dirty_trackers_, tracker_id));
+    DCHECK(!base::ContainsKey(dirty_trackers_, tracker_id));
+    DCHECK(!base::ContainsKey(demoted_dirty_trackers_, tracker_id));
 
     DVLOG(3) << "  Add to dirty_trackers_: " << tracker_id;
 
     dirty_trackers_.insert(tracker_id);
   }
 }
 
 void MetadataDatabaseIndex::RemoveFromDirtyTrackerIndexes(
     const FileTracker& tracker) {
   if (tracker.dirty()) {
     int64_t tracker_id = tracker.tracker_id();
-    DCHECK(ContainsKey(dirty_trackers_, tracker_id) ||
-           ContainsKey(demoted_dirty_trackers_, tracker_id));
+    DCHECK(base::ContainsKey(dirty_trackers_, tracker_id) ||
+           base::ContainsKey(demoted_dirty_trackers_, tracker_id));
 
     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