Devices: Remove MTP functions that use file paths.

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 <map>
 #include <queue>
 #include <set>
 #include <utility>
@@ skipping 131 matching lines @@
     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()));
   }
 
   // MediaTransferProtocolManager override.
-  virtual void ReadDirectoryByPath(
-      const std::string& storage_handle,
-      const std::string& path,
-      const ReadDirectoryCallback& callback) OVERRIDE {
-    DCHECK(thread_checker_.CalledOnValidThread());
-    if (!ContainsKey(handles_, storage_handle) || !mtp_client_) {
-      callback.Run(std::vector<MtpFileEntry>(), true);
-      return;
-    }
-    read_directory_callbacks_.push(callback);
-    mtp_client_->ReadDirectoryByPath(
-        storage_handle,
-        path,
-        base::Bind(&MediaTransferProtocolManagerImpl::OnReadDirectory,
-                   weak_ptr_factory_.GetWeakPtr()),
-        base::Bind(&MediaTransferProtocolManagerImpl::OnReadDirectoryError,
-                   weak_ptr_factory_.GetWeakPtr()));
-  }
-
-  // MediaTransferProtocolManager override.
   virtual void ReadDirectoryById(
       const std::string& storage_handle,
       uint32 file_id,
       const ReadDirectoryCallback& callback) OVERRIDE {
     DCHECK(thread_checker_.CalledOnValidThread());
     if (!ContainsKey(handles_, storage_handle) || !mtp_client_) {
       callback.Run(std::vector<MtpFileEntry>(), true);
       return;
     }
     read_directory_callbacks_.push(callback);
     mtp_client_->ReadDirectoryById(
         storage_handle,
         file_id,
         base::Bind(&MediaTransferProtocolManagerImpl::OnReadDirectory,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&MediaTransferProtocolManagerImpl::OnReadDirectoryError,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   // MediaTransferProtocolManager override.
-  virtual void ReadFileChunkByPath(const std::string& storage_handle,
-                                   const std::string& path,
-                                   uint32 offset,
-                                   uint32 count,
-                                   const ReadFileCallback& callback) OVERRIDE {
-    DCHECK(thread_checker_.CalledOnValidThread());
-    if (!ContainsKey(handles_, storage_handle) || !mtp_client_) {
-      callback.Run(std::string(), true);
-      return;
-    }
-    read_file_callbacks_.push(callback);
-    mtp_client_->ReadFileChunkByPath(
-        storage_handle, path, offset, count,
-        base::Bind(&MediaTransferProtocolManagerImpl::OnReadFile,
-                   weak_ptr_factory_.GetWeakPtr()),
-        base::Bind(&MediaTransferProtocolManagerImpl::OnReadFileError,
-                   weak_ptr_factory_.GetWeakPtr()));
-  }
-
-  // MediaTransferProtocolManager override.
   virtual void ReadFileChunkById(const std::string& storage_handle,
                                  uint32 file_id,
                                  uint32 offset,
                                  uint32 count,
                                  const ReadFileCallback& callback) OVERRIDE {
     DCHECK(thread_checker_.CalledOnValidThread());
     if (!ContainsKey(handles_, storage_handle) || !mtp_client_) {
       callback.Run(std::string(), true);
       return;
     }
     read_file_callbacks_.push(callback);
     mtp_client_->ReadFileChunkById(
         storage_handle, file_id, offset, count,
         base::Bind(&MediaTransferProtocolManagerImpl::OnReadFile,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&MediaTransferProtocolManagerImpl::OnReadFileError,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
-  virtual void GetFileInfoByPath(const std::string& storage_handle,
-                                 const std::string& path,
-                                 const GetFileInfoCallback& callback) OVERRIDE {
-    DCHECK(thread_checker_.CalledOnValidThread());
-    if (!ContainsKey(handles_, storage_handle) || !mtp_client_) {
-      callback.Run(MtpFileEntry(), true);
-      return;
-    }
-    get_file_info_callbacks_.push(callback);
-    mtp_client_->GetFileInfoByPath(
-        storage_handle,
-        path,
-        base::Bind(&MediaTransferProtocolManagerImpl::OnGetFileInfo,
-                   weak_ptr_factory_.GetWeakPtr()),
-        base::Bind(&MediaTransferProtocolManagerImpl::OnGetFileInfoError,
-                   weak_ptr_factory_.GetWeakPtr()));
-  }
-
   virtual void GetFileInfoById(const std::string& storage_handle,
                                uint32 file_id,
                                const GetFileInfoCallback& callback) OVERRIDE {
     DCHECK(thread_checker_.CalledOnValidThread());
     if (!ContainsKey(handles_, storage_handle) || !mtp_client_) {
       callback.Run(MtpFileEntry(), true);
       return;
     }
     get_file_info_callbacks_.push(callback);
     mtp_client_->GetFileInfoById(
@@ skipping 252 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