device: Use stl utilities from the base namespace

device/media_transfer_protocol/media_transfer_protocol_manager.cc

 // Copyright (c) 2012 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 "device/media_transfer_protocol/media_transfer_protocol_manager.h"
 
 #include <algorithm>
 #include <map>
 #include <memory>
 #include <queue>
@@ skipping 113 matching lines @@
     DCHECK(thread_checker_.CalledOnValidThread());
     StorageInfoMap::const_iterator it = storage_info_map_.find(storage_name);
     return it != storage_info_map_.end() ? &it->second : NULL;
   }
 
   // MediaTransferProtocolManager override.
   void GetStorageInfoFromDevice(
       const std::string& storage_name,
       const GetStorageInfoFromDeviceCallback& callback) override {
     DCHECK(thread_checker_.CalledOnValidThread());
-    if (!ContainsKey(storage_info_map_, storage_name) || !mtp_client_) {
+    if (!base::ContainsKey(storage_info_map_, storage_name) || !mtp_client_) {
       MtpStorageInfo info;
       callback.Run(info, true /* error */);
       return;
     }
     get_storage_info_from_device_callbacks_.push(callback);
     mtp_client_->GetStorageInfoFromDevice(
         storage_name,
         base::Bind(
             &MediaTransferProtocolManagerImpl::OnGetStorageInfoFromDevice,
             weak_ptr_factory_.GetWeakPtr()),
         base::Bind(
             &MediaTransferProtocolManagerImpl::OnGetStorageInfoFromDeviceError,
             weak_ptr_factory_.GetWeakPtr()));
   }
 
   // MediaTransferProtocolManager override.
   void OpenStorage(const std::string& storage_name,
                    const std::string& mode,
                    const OpenStorageCallback& callback) override {
     DCHECK(thread_checker_.CalledOnValidThread());
-    if (!ContainsKey(storage_info_map_, storage_name) || !mtp_client_) {
+    if (!base::ContainsKey(storage_info_map_, storage_name) || !mtp_client_) {
       callback.Run(std::string(), true);
       return;
     }
     open_storage_callbacks_.push(callback);
     mtp_client_->OpenStorage(
         storage_name,
         mode,
         base::Bind(&MediaTransferProtocolManagerImpl::OnOpenStorage,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&MediaTransferProtocolManagerImpl::OnOpenStorageError,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   // MediaTransferProtocolManager override.
   void CloseStorage(const std::string& storage_handle,
                     const CloseStorageCallback& callback) override {
     DCHECK(thread_checker_.CalledOnValidThread());
-    if (!ContainsKey(handles_, storage_handle) || !mtp_client_) {
+    if (!base::ContainsKey(handles_, storage_handle) || !mtp_client_) {
       callback.Run(true);
       return;
     }
     close_storage_callbacks_.push(std::make_pair(callback, storage_handle));
     mtp_client_->CloseStorage(
         storage_handle,
         base::Bind(&MediaTransferProtocolManagerImpl::OnCloseStorage,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&MediaTransferProtocolManagerImpl::OnCloseStorageError,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   void CreateDirectory(const std::string& storage_handle,
                        const uint32_t parent_id,
                        const std::string& directory_name,
                        const CreateDirectoryCallback& callback) override {
     DCHECK(thread_checker_.CalledOnValidThread());
-    if (!ContainsKey(handles_, storage_handle) || !mtp_client_) {
+    if (!base::ContainsKey(handles_, storage_handle) || !mtp_client_) {
       callback.Run(true /* error */);
       return;
     }
     create_directory_callbacks_.push(callback);
     mtp_client_->CreateDirectory(
         storage_handle, parent_id, directory_name,
         base::Bind(&MediaTransferProtocolManagerImpl::OnCreateDirectory,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&MediaTransferProtocolManagerImpl::OnCreateDirectoryError,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   // MediaTransferProtocolManager override.
   void ReadDirectory(const std::string& storage_handle,
                      const uint32_t file_id,
                      const size_t max_size,
                      const ReadDirectoryCallback& callback) override {
     DCHECK(thread_checker_.CalledOnValidThread());
-    if (!ContainsKey(handles_, storage_handle) || !mtp_client_) {
+    if (!base::ContainsKey(handles_, storage_handle) || !mtp_client_) {
       callback.Run(std::vector<MtpFileEntry>(),
                    false /* no more entries */,
                    true /* error */);
       return;
     }
     read_directory_callbacks_.push(callback);
     mtp_client_->ReadDirectoryEntryIds(
         storage_handle, file_id,
         base::Bind(&MediaTransferProtocolManagerImpl::
                        OnReadDirectoryEntryIdsToReadDirectory,
                    weak_ptr_factory_.GetWeakPtr(), storage_handle, max_size),
         base::Bind(&MediaTransferProtocolManagerImpl::OnReadDirectoryError,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   // MediaTransferProtocolManager override.
   void ReadFileChunk(const std::string& storage_handle,
                      uint32_t file_id,
                      uint32_t offset,
                      uint32_t count,
                      const ReadFileCallback& callback) override {
     DCHECK(thread_checker_.CalledOnValidThread());
-    if (!ContainsKey(handles_, storage_handle) || !mtp_client_) {
+    if (!base::ContainsKey(handles_, storage_handle) || !mtp_client_) {
       callback.Run(std::string(), true);
       return;
     }
     read_file_callbacks_.push(callback);
     mtp_client_->ReadFileChunk(
         storage_handle, file_id, offset, count,
         base::Bind(&MediaTransferProtocolManagerImpl::OnReadFile,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&MediaTransferProtocolManagerImpl::OnReadFileError,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   void GetFileInfo(const std::string& storage_handle,
                    uint32_t file_id,
                    const GetFileInfoCallback& callback) override {
     DCHECK(thread_checker_.CalledOnValidThread());
-    if (!ContainsKey(handles_, storage_handle) || !mtp_client_) {
+    if (!base::ContainsKey(handles_, storage_handle) || !mtp_client_) {
       callback.Run(MtpFileEntry(), true);
       return;
     }
     std::vector<uint32_t> file_ids;
     file_ids.push_back(file_id);
     get_file_info_callbacks_.push(callback);
     mtp_client_->GetFileInfo(
         storage_handle,
         file_ids,
         kInitialOffset,
         file_ids.size(),
         base::Bind(&MediaTransferProtocolManagerImpl::OnGetFileInfo,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&MediaTransferProtocolManagerImpl::OnGetFileInfoError,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   void RenameObject(const std::string& storage_handle,
                     const uint32_t object_id,
                     const std::string& new_name,
                     const RenameObjectCallback& callback) override {
     DCHECK(thread_checker_.CalledOnValidThread());
-    if (!ContainsKey(handles_, storage_handle) || !mtp_client_) {
+    if (!base::ContainsKey(handles_, storage_handle) || !mtp_client_) {
       callback.Run(true /* error */);
       return;
     }
     rename_object_callbacks_.push(callback);
     mtp_client_->RenameObject(
         storage_handle, object_id, new_name,
         base::Bind(&MediaTransferProtocolManagerImpl::OnRenameObject,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&MediaTransferProtocolManagerImpl::OnRenameObjectError,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   void CopyFileFromLocal(const std::string& storage_handle,
                          const int source_file_descriptor,
                          const uint32_t parent_id,
                          const std::string& file_name,
                          const CopyFileFromLocalCallback& callback) override {
     DCHECK(thread_checker_.CalledOnValidThread());
-    if (!ContainsKey(handles_, storage_handle) || !mtp_client_) {
+    if (!base::ContainsKey(handles_, storage_handle) || !mtp_client_) {
       callback.Run(true /* error */);
       return;
     }
     copy_file_from_local_callbacks_.push(callback);
     mtp_client_->CopyFileFromLocal(
         storage_handle, source_file_descriptor, parent_id, file_name,
         base::Bind(&MediaTransferProtocolManagerImpl::OnCopyFileFromLocal,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&MediaTransferProtocolManagerImpl::OnCopyFileFromLocalError,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   void DeleteObject(const std::string& storage_handle,
                     const uint32_t object_id,
                     const DeleteObjectCallback& callback) override {
     DCHECK(thread_checker_.CalledOnValidThread());
-    if (!ContainsKey(handles_, storage_handle) || !mtp_client_) {
+    if (!base::ContainsKey(handles_, storage_handle) || !mtp_client_) {
       callback.Run(true /* error */);
       return;
     }
     delete_object_callbacks_.push(callback);
     mtp_client_->DeleteObject(
         storage_handle, object_id,
         base::Bind(&MediaTransferProtocolManagerImpl::OnDeleteObject,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&MediaTransferProtocolManagerImpl::OnDeleteObjectError,
                    weak_ptr_factory_.GetWeakPtr()));
@@ skipping 46 matching lines @@
     if (is_attach)
       OnStorageAttached(storage_name);
     else
       OnStorageDetached(storage_name);
   }
 
   void OnEnumerateStorages(const std::vector<std::string>& storage_names) {
     DCHECK(thread_checker_.CalledOnValidThread());
     DCHECK(mtp_client_);
     for (size_t i = 0; i < storage_names.size(); ++i) {
-      if (ContainsKey(storage_info_map_, storage_names[i])) {
+      if (base::ContainsKey(storage_info_map_, storage_names[i])) {
         // OnStorageChanged() might have gotten called first.
         continue;
       }
       OnStorageAttached(storage_names[i]);
     }
   }
 
   void OnGetStorageInfo(const MtpStorageInfo& storage_info) {
     DCHECK(thread_checker_.CalledOnValidThread());
     const std::string& storage_name = storage_info.storage_name();
-    if (ContainsKey(storage_info_map_, storage_name)) {
+    if (base::ContainsKey(storage_info_map_, storage_name)) {
       // This should not happen, since MediaTransferProtocolManagerImpl should
       // only call EnumerateStorages() once, which populates |storage_info_map_|
       // with the already-attached devices.
       // After that, all incoming signals are either for new storage
       // attachments, which should not be in |storage_info_map_|, or for
       // storage detachments, which do not add to |storage_info_map_|.
       // Return to avoid giving observers phantom detach events.
       NOTREACHED();
       return;
     }
@@ skipping 12 matching lines @@
   }
 
   void OnGetStorageInfoFromDeviceError() {
     MtpStorageInfo info;
     get_storage_info_from_device_callbacks_.front().Run(info, true /* error */);
     get_storage_info_from_device_callbacks_.pop();
   }
 
   void OnOpenStorage(const std::string& handle) {
     DCHECK(thread_checker_.CalledOnValidThread());
-    if (!ContainsKey(handles_, handle)) {
+    if (!base::ContainsKey(handles_, handle)) {
       handles_.insert(handle);
       open_storage_callbacks_.front().Run(handle, false);
     } else {
       NOTREACHED();
       open_storage_callbacks_.front().Run(std::string(), true);
     }
     open_storage_callbacks_.pop();
   }
 
   void OnOpenStorageError() {
     open_storage_callbacks_.front().Run(std::string(), true);
     open_storage_callbacks_.pop();
   }
 
   void OnCloseStorage() {
     DCHECK(thread_checker_.CalledOnValidThread());
     const std::string& handle = close_storage_callbacks_.front().second;
-    if (ContainsKey(handles_, handle)) {
+    if (base::ContainsKey(handles_, handle)) {
       handles_.erase(handle);
       close_storage_callbacks_.front().first.Run(false);
     } else {
       NOTREACHED();
       close_storage_callbacks_.front().first.Run(true);
     }
     close_storage_callbacks_.pop();
   }
 
   void OnCloseStorageError() {
@@ skipping 263 matching lines @@
   DCHECK(!g_media_transfer_protocol_manager);
 
   g_media_transfer_protocol_manager =
       new MediaTransferProtocolManagerImpl(task_runner);
   VLOG(1) << "MediaTransferProtocolManager initialized";
 
   return g_media_transfer_protocol_manager;
 }
 
 }  // namespace device