chrome: Use stl utilities from the base namespace

chrome/browser/sync_file_system/drive_backend/drive_backend_sync_unittest.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 <stddef.h>
 #include <stdint.h>
 #include <algorithm>
 #include <stack>
 #include <utility>
 
@@ skipping 214 matching lines @@
         base::Bind(
             &SetValueAndCallClosure<bool>, run_loop.QuitClosure(), &success));
     run_loop.Run();
     EXPECT_TRUE(success);
     EXPECT_EQ(normalized_path, result_path);
     return tracker.file_id();
   }
 
   SyncStatusCode RegisterApp(const std::string& app_id) {
     GURL origin = extensions::Extension::GetBaseURLFromExtensionId(app_id);
-    if (!ContainsKey(file_systems_, app_id)) {
+    if (!base::ContainsKey(file_systems_, app_id)) {
       CannedSyncableFileSystem* file_system = new CannedSyncableFileSystem(
           origin, in_memory_env_.get(),
           io_task_runner_.get(), file_task_runner_.get());
       file_system->SetUp(CannedSyncableFileSystem::QUOTA_DISABLED);
 
       SyncStatusCode status = SYNC_STATUS_UNKNOWN;
       base::RunLoop run_loop;
       local_sync_service_->MaybeInitializeFileSystemContext(
           origin, file_system->file_system_context(),
           base::Bind(&SetValueAndCallClosure<SyncStatusCode>,
@@ skipping 13 matching lines @@
     remote_sync_service_->RegisterOrigin(
         origin,
         base::Bind(&SetValueAndCallClosure<SyncStatusCode>,
                    run_loop.QuitClosure(), &status));
     run_loop.Run();
     return status;
   }
 
   void AddLocalFolder(const std::string& app_id,
                       const base::FilePath::StringType& path) {
-    ASSERT_TRUE(ContainsKey(file_systems_, app_id));
+    ASSERT_TRUE(base::ContainsKey(file_systems_, app_id));
     EXPECT_EQ(base::File::FILE_OK,
               file_systems_[app_id]->CreateDirectory(
                   CreateURL(app_id, path)));
   }
 
   void AddOrUpdateLocalFile(const std::string& app_id,
                             const base::FilePath::StringType& path,
                             const std::string& content) {
     storage::FileSystemURL url(CreateURL(app_id, path));
-    ASSERT_TRUE(ContainsKey(file_systems_, app_id));
+    ASSERT_TRUE(base::ContainsKey(file_systems_, app_id));
     EXPECT_EQ(base::File::FILE_OK, file_systems_[app_id]->CreateFile(url));
     int64_t bytes_written = file_systems_[app_id]->WriteString(url, content);
     EXPECT_EQ(static_cast<int64_t>(content.size()), bytes_written);
     base::RunLoop().RunUntilIdle();
   }
 
   void UpdateLocalFile(const std::string& app_id,
                        const base::FilePath::StringType& path,
                        const std::string& content) {
-    ASSERT_TRUE(ContainsKey(file_systems_, app_id));
+    ASSERT_TRUE(base::ContainsKey(file_systems_, app_id));
     int64_t bytes_written =
         file_systems_[app_id]->WriteString(CreateURL(app_id, path), content);
     EXPECT_EQ(static_cast<int64_t>(content.size()), bytes_written);
     base::RunLoop().RunUntilIdle();
   }
 
   void RemoveLocal(const std::string& app_id,
                    const base::FilePath::StringType& path) {
-    ASSERT_TRUE(ContainsKey(file_systems_, app_id));
+    ASSERT_TRUE(base::ContainsKey(file_systems_, app_id));
     EXPECT_EQ(base::File::FILE_OK,
               file_systems_[app_id]->Remove(
                   CreateURL(app_id, path),
                   true /* recursive */));
     base::RunLoop().RunUntilIdle();
   }
 
   SyncStatusCode ProcessLocalChange() {
     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
     storage::FileSystemURL url;
@@ skipping 108 matching lines @@
     ScopedVector<google_apis::FileResource> remote_entries;
     EXPECT_EQ(google_apis::HTTP_SUCCESS,
               fake_drive_service_helper_->ListFilesInFolder(
                   sync_root_folder_id, &remote_entries));
     std::map<std::string, const google_apis::FileResource*> app_root_by_title;
     for (ScopedVector<google_apis::FileResource>::iterator itr =
              remote_entries.begin();
          itr != remote_entries.end();
          ++itr) {
       const google_apis::FileResource& remote_entry = **itr;
-      EXPECT_FALSE(ContainsKey(app_root_by_title, remote_entry.title()));
+      EXPECT_FALSE(base::ContainsKey(app_root_by_title, remote_entry.title()));
       app_root_by_title[remote_entry.title()] = *itr;
     }
 
     for (std::map<std::string, CannedSyncableFileSystem*>::const_iterator itr =
              file_systems_.begin();
          itr != file_systems_.end(); ++itr) {
       const std::string& app_id = itr->first;
       SCOPED_TRACE(testing::Message() << "Verifying app: " << app_id);
       CannedSyncableFileSystem* file_system = itr->second;
-      ASSERT_TRUE(ContainsKey(app_root_by_title, app_id));
+      ASSERT_TRUE(base::ContainsKey(app_root_by_title, app_id));
       VerifyConsistencyForFolder(
           app_id, base::FilePath(),
           app_root_by_title[app_id]->file_id(),
           file_system);
     }
   }
 
   void VerifyConsistencyForFolder(const std::string& app_id,
                                   const base::FilePath& path,
                                   const std::string& folder_id,
                                   CannedSyncableFileSystem* file_system) {
     SCOPED_TRACE(testing::Message() << "Verifying folder: " << path.value());
 
     ScopedVector<google_apis::FileResource> remote_entries;
     EXPECT_EQ(google_apis::HTTP_SUCCESS,
               fake_drive_service_helper_->ListFilesInFolder(
                   folder_id, &remote_entries));
     std::map<std::string, const google_apis::FileResource*>
         remote_entry_by_title;
     for (size_t i = 0; i < remote_entries.size(); ++i) {
       google_apis::FileResource* remote_entry = remote_entries[i];
-      EXPECT_FALSE(ContainsKey(remote_entry_by_title, remote_entry->title()))
+      EXPECT_FALSE(
+          base::ContainsKey(remote_entry_by_title, remote_entry->title()))
           << "title: " << remote_entry->title();
       remote_entry_by_title[remote_entry->title()] = remote_entry;
     }
 
     storage::FileSystemURL url(CreateURL(app_id, path));
     FileEntryList local_entries;
     EXPECT_EQ(base::File::FILE_OK,
               file_system->ReadDirectory(url, &local_entries));
     for (FileEntryList::iterator itr = local_entries.begin();
          itr != local_entries.end();
          ++itr) {
       const storage::DirectoryEntry& local_entry = *itr;
       storage::FileSystemURL entry_url(
           CreateURL(app_id, path.Append(local_entry.name)));
       std::string title =
           storage::VirtualPath::BaseName(entry_url.path()).AsUTF8Unsafe();
       SCOPED_TRACE(testing::Message() << "Verifying entry: " << title);
 
-      ASSERT_TRUE(ContainsKey(remote_entry_by_title, title));
+      ASSERT_TRUE(base::ContainsKey(remote_entry_by_title, title));
       const google_apis::FileResource& remote_entry =
           *remote_entry_by_title[title];
       if (local_entry.is_directory) {
         ASSERT_TRUE(remote_entry.IsDirectory());
         VerifyConsistencyForFolder(app_id, entry_url.path(),
                                    remote_entry.file_id(),
                                    file_system);
       } else {
         ASSERT_FALSE(remote_entry.IsDirectory());
         VerifyConsistencyForFile(app_id, entry_url.path(),
@@ skipping 16 matching lines @@
               fake_drive_service_helper_->ReadFile(file_id, &file_content));
     EXPECT_EQ(base::File::FILE_OK,
               file_system->VerifyFile(url, file_content));
   }
 
   size_t CountApp() {
     return file_systems_.size();
   }
 
   size_t CountLocalFile(const std::string& app_id) {
-    if (!ContainsKey(file_systems_, app_id))
+    if (!base::ContainsKey(file_systems_, app_id))
       return 0;
 
     CannedSyncableFileSystem* file_system = file_systems_[app_id];
     std::stack<base::FilePath> folders;
     folders.push(base::FilePath());  // root folder
 
     size_t result = 1;
     while (!folders.empty()) {
       storage::FileSystemURL url(CreateURL(app_id, folders.top()));
       folders.pop();
@@ skipping 11 matching lines @@
 
     return result;
   }
 
   void VerifyLocalFile(const std::string& app_id,
                        const base::FilePath::StringType& path,
                        const std::string& content) {
     SCOPED_TRACE(testing::Message() << "Verifying local file: "
                                     << "app_id = " << app_id
                                     << ", path = " << path);
-    ASSERT_TRUE(ContainsKey(file_systems_, app_id));
+    ASSERT_TRUE(base::ContainsKey(file_systems_, app_id));
     EXPECT_EQ(base::File::FILE_OK,
               file_systems_[app_id]->VerifyFile(
                   CreateURL(app_id, path), content));
   }
 
   void VerifyLocalFolder(const std::string& app_id,
                          const base::FilePath::StringType& path) {
     SCOPED_TRACE(testing::Message() << "Verifying local file: "
                                     << "app_id = " << app_id
                                     << ", path = " << path);
-    ASSERT_TRUE(ContainsKey(file_systems_, app_id));
+    ASSERT_TRUE(base::ContainsKey(file_systems_, app_id));
     EXPECT_EQ(base::File::FILE_OK,
               file_systems_[app_id]->DirectoryExists(CreateURL(app_id, path)));
   }
 
   size_t CountMetadata() {
     size_t count = 0;
     base::RunLoop run_loop;
     PostTaskAndReplyWithResult(
         worker_task_runner_.get(),
         FROM_HERE,
@@ skipping 1154 matching lines @@
 
   EXPECT_EQ(1u, CountApp());
   EXPECT_EQ(1u, CountLocalFile(app_id));
 
   EXPECT_EQ(2u, CountMetadata());
   EXPECT_EQ(2u, CountTracker());
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system