Media Galleries: Omit ById in various method names, since all operations are now by id.

chrome/browser/media_galleries/linux/mtp_device_task_helper.cc

 // Copyright 2013 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/media_galleries/linux/mtp_device_task_helper.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
@@ skipping 57 matching lines @@
                                      base::Bind(callback, true));
     return;
   }
   GetMediaTransferProtocolManager()->OpenStorage(
       storage_name, mtpd::kReadOnlyMode,
       base::Bind(&MTPDeviceTaskHelper::OnDidOpenStorage,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback));
 }
 
-void MTPDeviceTaskHelper::GetFileInfoById(
+void MTPDeviceTaskHelper::GetFileInfo(
     uint32 file_id,
     const GetFileInfoSuccessCallback& success_callback,
     const ErrorCallback& error_callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (device_handle_.empty())
     return HandleDeviceError(error_callback, base::File::FILE_ERROR_FAILED);
 
-  GetMediaTransferProtocolManager()->GetFileInfoById(
+  GetMediaTransferProtocolManager()->GetFileInfo(
       device_handle_, file_id,
       base::Bind(&MTPDeviceTaskHelper::OnGetFileInfo,
                  weak_ptr_factory_.GetWeakPtr(),
                  success_callback,
                  error_callback));
 }
 
-void MTPDeviceTaskHelper::ReadDirectoryById(
+void MTPDeviceTaskHelper::ReadDirectory(
     uint32 dir_id,
     const ReadDirectorySuccessCallback& success_callback,
     const ErrorCallback& error_callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (device_handle_.empty())
     return HandleDeviceError(error_callback, base::File::FILE_ERROR_FAILED);
 
-  GetMediaTransferProtocolManager()->ReadDirectoryById(
+  GetMediaTransferProtocolManager()->ReadDirectory(
       device_handle_, dir_id,
-      base::Bind(&MTPDeviceTaskHelper::OnDidReadDirectoryById,
+      base::Bind(&MTPDeviceTaskHelper::OnDidReadDirectory,
                  weak_ptr_factory_.GetWeakPtr(),
                  success_callback,
                  error_callback));
 }
 
 void MTPDeviceTaskHelper::WriteDataIntoSnapshotFile(
     const SnapshotRequestInfo& request_info,
     const base::File::Info& snapshot_file_info) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (device_handle_.empty()) {
     return HandleDeviceError(request_info.error_callback,
                              base::File::FILE_ERROR_FAILED);
   }
 
   if (!read_file_worker_)
     read_file_worker_.reset(new MTPReadFileWorker(device_handle_));
   read_file_worker_->WriteDataIntoSnapshotFile(request_info,
                                                snapshot_file_info);
 }
 
 void MTPDeviceTaskHelper::ReadBytes(
     const MTPDeviceAsyncDelegate::ReadBytesRequest& request) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (device_handle_.empty()) {
     return HandleDeviceError(request.error_callback,
                              base::File::FILE_ERROR_FAILED);
   }
 
-  GetMediaTransferProtocolManager()->GetFileInfoById(
+  GetMediaTransferProtocolManager()->GetFileInfo(
       device_handle_, request.file_id,
       base::Bind(&MTPDeviceTaskHelper::OnGetFileInfoToReadBytes,
                  weak_ptr_factory_.GetWeakPtr(), request));
 }
 
 void MTPDeviceTaskHelper::CloseStorage() const {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (device_handle_.empty())
     return;
   GetMediaTransferProtocolManager()->CloseStorage(device_handle_,
@@ skipping 21 matching lines @@
     return HandleDeviceError(error_callback,
                              base::File::FILE_ERROR_NOT_FOUND);
   }
 
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(success_callback, FileInfoFromMTPFileEntry(file_entry)));
 }
 
-void MTPDeviceTaskHelper::OnDidReadDirectoryById(
+void MTPDeviceTaskHelper::OnDidReadDirectory(
     const ReadDirectorySuccessCallback& success_callback,
     const ErrorCallback& error_callback,
     const std::vector<MtpFileEntry>& file_entries,
     bool has_more,
     bool error) const {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (error)
     return HandleDeviceError(error_callback, base::File::FILE_ERROR_FAILED);
 
   fileapi::AsyncFileUtil::EntryList entries;
@@ skipping 44 matching lines @@
                                      FROM_HERE,
                                      base::Bind(request.success_callback,
                                                 file_info, 0u));
     return;
   }
 
   uint32 bytes_to_read = std::min(
       base::checked_cast<uint32>(request.buf_len),
       base::saturated_cast<uint32>(file_info.size - request.offset));
 
-  GetMediaTransferProtocolManager()->ReadFileChunkById(
+  GetMediaTransferProtocolManager()->ReadFileChunk(
       device_handle_,
       request.file_id,
       base::checked_cast<uint32>(request.offset),
       bytes_to_read,
       base::Bind(&MTPDeviceTaskHelper::OnDidReadBytes,
                  weak_ptr_factory_.GetWeakPtr(), request, file_info));
 }
 
 void MTPDeviceTaskHelper::OnDidReadBytes(
     const MTPDeviceAsyncDelegate::ReadBytesRequest& request,
@@ skipping 16 matching lines @@
 }
 
 void MTPDeviceTaskHelper::HandleDeviceError(
     const ErrorCallback& error_callback,
     base::File::Error error) const {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   content::BrowserThread::PostTask(content::BrowserThread::IO,
                                    FROM_HERE,
                                    base::Bind(error_callback, error));
 }