Replace MtpManager's ReadDirectory() with ReadDirectoryEntryIds().

MediaTransferProtocolDaemonClient currently provides a low-level
ReadDirectoryEntryIds() method, and MtpManager does the translation to
the high-level ReadDirectory() method that MTPDeviceTaskHelper
understands.

Change MtpManager's ReadDirectory() method to ReadDirectoryEntryIds(),
so it acts more like a pass-through. Make MTPDeviceTaskHelper handle the
translation.

BUG=769630

Change-Id: I5154bd4beac0b6ab15579f166cdf8b8add6a7dac
Reviewed-on: https://chromium-review.googlesource.com/1080214
Commit-Queue: Lei Zhang <thestig@chromium.org>
Reviewed-by: Colin Blundell <blundell@chromium.org>
Reviewed-by: Tom Sepez <tsepez@chromium.org>
Cr-Commit-Position: refs/heads/master@{#565441}

chrome/browser/media_galleries/chromeos/mtp_device_task_helper.cc

@@ -24,6 +24,13 @@ using storage_monitor::StorageMonitor;
 
 namespace {
 
+// When reading directory entries, this is the number of entries for
+// GetFileInfo() to read in one operation. If set too low, efficiency goes down
+// slightly due to the overhead of D-Bus calls. If set too high, then slow
+// devices may trigger a D-Bus timeout.
+// The value below is a good initial estimate.
+const size_t kFileInfoToFetchChunkSize = 25;
+
 // When calling GetFileInfo() with only a single file ID, the offset into the
 // file IDs vector should be 0.
 constexpr size_t kSingleFileIdOffset = 0;
@@ -118,11 +125,12 @@ void MTPDeviceTaskHelper::ReadDirectory(
   if (device_handle_.empty())
     return HandleDeviceError(error_callback, base::File::FILE_ERROR_FAILED);
 
-  GetMediaTransferProtocolManager()->ReadDirectory(
-      device_handle_, directory_id, max_size,
-      base::Bind(&MTPDeviceTaskHelper::OnDidReadDirectory,
-                 weak_ptr_factory_.GetWeakPtr(), success_callback,
-                 error_callback));
+  GetMediaTransferProtocolManager()->ReadDirectoryEntryIds(
+      device_handle_, directory_id,
+      base::BindOnce(
+          &MTPDeviceTaskHelper::OnReadDirectoryEntryIdsToReadDirectory,
+          weak_ptr_factory_.GetWeakPtr(), success_callback, error_callback,
+          max_size));
 }
 
 void MTPDeviceTaskHelper::WriteDataIntoSnapshotFile(
@@ -253,16 +261,67 @@ void MTPDeviceTaskHelper::OnCreateDirectory(
                                    success_callback);
 }
 
-void MTPDeviceTaskHelper::OnDidReadDirectory(
+void MTPDeviceTaskHelper::OnReadDirectoryEntryIdsToReadDirectory(
     const ReadDirectorySuccessCallback& success_callback,
     const ErrorCallback& error_callback,
+    size_t max_size,
+    const std::vector<uint32_t>& file_ids,
+    bool error) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+
+  if (error)
+    return HandleDeviceError(error_callback, base::File::FILE_ERROR_FAILED);
+
+  if (file_ids.empty()) {
+    content::BrowserThread::PostTask(
+        content::BrowserThread::IO, FROM_HERE,
+        base::BindOnce(success_callback, MTPEntries(), /*has_more=*/false));
+    return;
+  }
+
+  std::vector<uint32_t> sorted_file_ids = file_ids;
+  std::sort(sorted_file_ids.begin(), sorted_file_ids.end());
+  const size_t chunk_size = max_size == 0
+                                ? kFileInfoToFetchChunkSize
+                                : std::min(max_size, kFileInfoToFetchChunkSize);
+
+  // This is the first GetFileInfo() call for a read directory operation. Start
+  // at offset 0.
+  static constexpr size_t kInitialOffset = 0;
+
+  GetMediaTransferProtocolManager()->GetFileInfo(
+      device_handle_, file_ids, kInitialOffset, chunk_size,
+      base::BindOnce(&MTPDeviceTaskHelper::OnGotDirectoryEntries,
+                     weak_ptr_factory_.GetWeakPtr(), success_callback,
+                     error_callback, file_ids, kInitialOffset, max_size,
+                     sorted_file_ids));
+}
+
+void MTPDeviceTaskHelper::OnGotDirectoryEntries(
+    const ReadDirectorySuccessCallback& success_callback,
+    const ErrorCallback& error_callback,
+    const std::vector<uint32_t>& file_ids,
+    size_t offset,
+    size_t max_size,
+    const std::vector<uint32_t>& sorted_file_ids,
     std::vector<device::mojom::MtpFileEntryPtr> file_entries,
-    bool has_more,
-    bool error) const {
+    bool error) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  DCHECK_EQ(file_ids.size(), sorted_file_ids.size());
+
   if (error)
     return HandleDeviceError(error_callback, base::File::FILE_ERROR_FAILED);
 
+  // Use |sorted_file_ids| to sanity check and make sure the results are a
+  // subset of the requested file ids.
+  for (const auto& entry : file_entries) {
+    std::vector<uint32_t>::const_iterator it = std::lower_bound(
+        sorted_file_ids.begin(), sorted_file_ids.end(), entry->item_id);
+    if (it == sorted_file_ids.end()) {
+      return HandleDeviceError(error_callback, base::File::FILE_ERROR_FAILED);
+    }
+  }
+
   MTPEntries entries;
   base::FilePath current;
   MTPDeviceObjectEnumerator file_enum(std::move(file_entries));
@@ -276,10 +335,29 @@ void MTPDeviceTaskHelper::OnDidReadDirectory(
     entry.file_info.last_modified = file_enum.LastModifiedTime();
     entries.push_back(entry);
   }
+
+  const size_t directory_size =
+      max_size == 0 ? file_ids.size() : std::min(file_ids.size(), max_size);
+  size_t next_offset = directory_size;
+  if (offset < SIZE_MAX - kFileInfoToFetchChunkSize)
+    next_offset = std::min(next_offset, offset + kFileInfoToFetchChunkSize);
+  bool has_more = next_offset < directory_size;
+
   content::BrowserThread::PostTask(
-      content::BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(success_callback, entries, has_more));
+      content::BrowserThread::IO, FROM_HERE,
+      base::BindOnce(success_callback, entries, has_more));
+
+  if (!has_more)
+    return;
+
+  const size_t chunk_size =
+      std::min(directory_size - next_offset, kFileInfoToFetchChunkSize);
+  GetMediaTransferProtocolManager()->GetFileInfo(
+      device_handle_, file_ids, next_offset, chunk_size,
+      base::BindOnce(&MTPDeviceTaskHelper::OnGotDirectoryEntries,
+                     weak_ptr_factory_.GetWeakPtr(), success_callback,
+                     error_callback, file_ids, next_offset, max_size,
+                     sorted_file_ids));
 }
 
 void MTPDeviceTaskHelper::OnGetFileInfoToReadBytes(

chrome/browser/media_galleries/chromeos/mtp_device_task_helper.h

@@ -177,20 +177,44 @@ class MTPDeviceTaskHelper {
                          const ErrorCallback& error_callback,
                          const bool error) const;
 
-  // Query callback for ReadDirectory().
+  // Query callback for ReadDirectoryEntryIds().
   //
-  // If there is no error, |error| is set to false, |file_entries| has the
-  // directory file entries and |success_callback| is invoked on the IO thread
-  // to notify the caller.
+  // |max_size| specifies the number of entries to read. If it is zero, then
+  // read all the entries.
   //
-  // If there is an error, |error| is set to true, |file_entries| is empty
-  // and |error_callback| is invoked on the IO thread to notify the caller.
-  void OnDidReadDirectory(
+  // If there is no error, |error| is set to false, and |file_ids| has the IDs
+  // of the directory file entries. If |file_ids| is empty, then just run
+  // |success_callback|. Otherwise, get the directories entries from |file_ids|
+  // in chunks via OnGotDirectoryEntries().
+  //
+  // If there is an error, then |error| is set to true, and |error_callback| is
+  // invoked on the IO thread to notify the caller.
+  void OnReadDirectoryEntryIdsToReadDirectory(
       const ReadDirectorySuccessCallback& success_callback,
       const ErrorCallback& error_callback,
+      size_t max_size,
+      const std::vector<uint32_t>& file_ids,
+      bool error);
+
+  // Query callback for GetFileInfo() when called by
+  // OnReadDirectoryEntryIdsToReadDirectory().
+  //
+  // Many of the parameters are shared with
+  // OnReadDirectoryEntryIdsToReadDirectory() and are exactly the same.
+  //
+  // |offset| is the offset into |file_ids| to read from.
+  // |sorted_file_ids| is a sorted copy of |file_ids|.
+  // |file_entries| contains the results of the GetFileInfo() call.
+  // |error| indicates if the GetFileInfo() call succeeded or failed.
+  void OnGotDirectoryEntries(
+      const ReadDirectorySuccessCallback& success_callback,
+      const ErrorCallback& error_callback,
+      const std::vector<uint32_t>& file_ids,
+      size_t offset,
+      size_t max_size,
+      const std::vector<uint32_t>& sorted_file_ids,
       std::vector<device::mojom::MtpFileEntryPtr> file_entries,
-      bool has_more,
-      bool error) const;
+      bool error);
 
   // Intermediate step to finish a ReadBytes request.
   void OnGetFileInfoToReadBytes(

components/storage_monitor/test_media_transfer_protocol_manager_chromeos.cc

@@ -71,13 +71,11 @@ void TestMediaTransferProtocolManagerChromeOS::CreateDirectory(
   std::move(callback).Run(true /* error */);
 }
 
-void TestMediaTransferProtocolManagerChromeOS::ReadDirectory(
+void TestMediaTransferProtocolManagerChromeOS::ReadDirectoryEntryIds(
     const std::string& storage_handle,
     uint32_t file_id,
-    uint64_t max_size,
-    ReadDirectoryCallback callback) {
-  std::move(callback).Run(std::vector<device::mojom::MtpFileEntryPtr>(),
-                          false /* no more entries*/, true /* error */);
+    ReadDirectoryEntryIdsCallback callback) {
+  std::move(callback).Run(std::vector<uint32_t>(), /*error=*/true);
 }
 
 void TestMediaTransferProtocolManagerChromeOS::ReadFileChunk(

components/storage_monitor/test_media_transfer_protocol_manager_chromeos.h

@@ -45,10 +45,9 @@ class TestMediaTransferProtocolManagerChromeOS
                        uint32_t parent_id,
                        const std::string& directory_name,
                        CreateDirectoryCallback callback) override;
-  void ReadDirectory(const std::string& storage_handle,
-                     uint32_t file_id,
-                     uint64_t max_size,
-                     ReadDirectoryCallback callback) override;
+  void ReadDirectoryEntryIds(const std::string& storage_handle,
+                             uint32_t file_id,
+                             ReadDirectoryEntryIdsCallback callback) override;
   void ReadFileChunk(const std::string& storage_handle,
                      uint32_t file_id,
                      uint32_t offset,

services/device/media_transfer_protocol/media_transfer_protocol_manager.cc

@@ -34,16 +34,6 @@ namespace {
 MediaTransferProtocolManager* g_media_transfer_protocol_manager = nullptr;
 #endif
 
-// When reading directory entries, this is the number of entries for
-// GetFileInfo() to read in one operation. If set too low, efficiency goes down
-// slightly due to the overhead of D-Bus calls. If set too high, then slow
-// devices may trigger a D-Bus timeout.
-// The value below is a good initial estimate.
-const size_t kFileInfoToFetchChunkSize = 25;
-
-// On the first call to GetFileInfo, the offset to use is 0.
-const size_t kInitialOffset = 0;
-
 // The MediaTransferProtocolManager implementation.
 class MediaTransferProtocolManagerImpl : public MediaTransferProtocolManager {
  public:
@@ -177,7 +167,7 @@ class MediaTransferProtocolManagerImpl : public MediaTransferProtocolManager {
   }
 
   void CreateDirectory(const std::string& storage_handle,
-                       const uint32_t parent_id,
+                       uint32_t parent_id,
                        const std::string& directory_name,
                        const CreateDirectoryCallback& callback) override {
     DCHECK(thread_checker_.CalledOnValidThread());
@@ -195,23 +185,20 @@ class MediaTransferProtocolManagerImpl : public MediaTransferProtocolManager {
   }
 
   // MediaTransferProtocolManager override.
-  void ReadDirectory(const std::string& storage_handle,
-                     const uint32_t file_id,
-                     const size_t max_size,
-                     const ReadDirectoryCallback& callback) override {
+  void ReadDirectoryEntryIds(
+      const std::string& storage_handle,
+      uint32_t file_id,
+      mojom::MtpManager::ReadDirectoryEntryIdsCallback callback) override {
     DCHECK(thread_checker_.CalledOnValidThread());
     if (!base::ContainsKey(handles_, storage_handle) || !mtp_client_) {
-      callback.Run(std::vector<mojom::MtpFileEntry>(),
-                   false /* no more entries */,
-                   true /* error */);
+      std::move(callback).Run(std::vector<uint32_t>(), /*error=*/true);
       return;
     }
-    read_directory_callbacks_.push(callback);
+    read_directory_callbacks_.push(std::move(callback));
     mtp_client_->ReadDirectoryEntryIds(
         storage_handle, file_id,
-        base::Bind(&MediaTransferProtocolManagerImpl::
-                       OnReadDirectoryEntryIdsToReadDirectory,
-                   weak_ptr_factory_.GetWeakPtr(), storage_handle, max_size),
+        base::Bind(&MediaTransferProtocolManagerImpl::OnReadDirectoryEntryIds,
+                   weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&MediaTransferProtocolManagerImpl::OnReadDirectoryError,
                    weak_ptr_factory_.GetWeakPtr()));
   }
@@ -257,7 +244,7 @@ class MediaTransferProtocolManagerImpl : public MediaTransferProtocolManager {
   }
 
   void RenameObject(const std::string& storage_handle,
-                    const uint32_t object_id,
+                    uint32_t object_id,
                     const std::string& new_name,
                     const RenameObjectCallback& callback) override {
     DCHECK(thread_checker_.CalledOnValidThread());
@@ -276,7 +263,7 @@ class MediaTransferProtocolManagerImpl : public MediaTransferProtocolManager {
 
   void CopyFileFromLocal(const std::string& storage_handle,
                          const int source_file_descriptor,
-                         const uint32_t parent_id,
+                         uint32_t parent_id,
                          const std::string& file_name,
                          const CopyFileFromLocalCallback& callback) override {
     DCHECK(thread_checker_.CalledOnValidThread());
@@ -294,7 +281,7 @@ class MediaTransferProtocolManagerImpl : public MediaTransferProtocolManager {
   }
 
   void DeleteObject(const std::string& storage_handle,
-                    const uint32_t object_id,
+                    uint32_t object_id,
                     const DeleteObjectCallback& callback) override {
     DCHECK(thread_checker_.CalledOnValidThread());
     if (!base::ContainsKey(handles_, storage_handle) || !mtp_client_) {
@@ -321,7 +308,8 @@ class MediaTransferProtocolManagerImpl : public MediaTransferProtocolManager {
   using CloseStorageCallbackQueue =
       base::queue<std::pair<CloseStorageCallback, std::string>>;
   using CreateDirectoryCallbackQueue = base::queue<CreateDirectoryCallback>;
-  using ReadDirectoryCallbackQueue = base::queue<ReadDirectoryCallback>;
+  using ReadDirectoryCallbackQueue =
+      base::queue<mojom::MtpManager::ReadDirectoryEntryIdsCallback>;
   using ReadFileCallbackQueue = base::queue<ReadFileCallback>;
   using GetFileInfoCallbackQueue =
       base::queue<mojom::MtpManager::GetFileInfoCallback>;
@@ -453,86 +441,16 @@ class MediaTransferProtocolManagerImpl : public MediaTransferProtocolManager {
     create_directory_callbacks_.pop();
   }
 
-  void OnReadDirectoryEntryIdsToReadDirectory(
-      const std::string& storage_handle,
-      const size_t max_size,
-      const std::vector<uint32_t>& file_ids) {
+  void OnReadDirectoryEntryIds(const std::vector<uint32_t>& file_ids) {
     DCHECK(thread_checker_.CalledOnValidThread());
-
-    if (file_ids.empty()) {
-      OnGotDirectoryEntries(storage_handle, file_ids, kInitialOffset, max_size,
-                            file_ids, std::vector<mojom::MtpFileEntry>());
-      return;
-    }
-
-    std::vector<uint32_t> sorted_file_ids = file_ids;
-    std::sort(sorted_file_ids.begin(), sorted_file_ids.end());
-
-    const size_t chunk_size =
-        max_size == 0 ? kFileInfoToFetchChunkSize
-                      : std::min(max_size, kFileInfoToFetchChunkSize);
-
-    mtp_client_->GetFileInfo(
-        storage_handle, file_ids, kInitialOffset, chunk_size,
-        base::Bind(&MediaTransferProtocolManagerImpl::OnGotDirectoryEntries,
-                   weak_ptr_factory_.GetWeakPtr(), storage_handle, file_ids,
-                   kInitialOffset, max_size, sorted_file_ids),
-        base::Bind(&MediaTransferProtocolManagerImpl::OnReadDirectoryError,
-                   weak_ptr_factory_.GetWeakPtr()));
-  }
-
-  void OnGotDirectoryEntries(
-      const std::string& storage_handle,
-      const std::vector<uint32_t>& file_ids,
-      const size_t offset,
-      const size_t max_size,
-      const std::vector<uint32_t>& sorted_file_ids,
-      const std::vector<mojom::MtpFileEntry>& file_entries) {
-    DCHECK(thread_checker_.CalledOnValidThread());
-    DCHECK_EQ(file_ids.size(), sorted_file_ids.size());
-
-    // Use |sorted_file_ids| to sanity check and make sure the results are a
-    // subset of the requested file ids.
-    for (const auto& entry : file_entries) {
-      std::vector<uint32_t>::const_iterator it = std::lower_bound(
-          sorted_file_ids.begin(), sorted_file_ids.end(), entry.item_id);
-      if (it == sorted_file_ids.end()) {
-        OnReadDirectoryError();
-        return;
-      }
-    }
-
-    const size_t directory_size =
-        max_size == 0 ? file_ids.size() : std::min(file_ids.size(), max_size);
-    size_t next_offset = directory_size;
-    if (offset < SIZE_MAX - kFileInfoToFetchChunkSize)
-      next_offset = std::min(next_offset, offset + kFileInfoToFetchChunkSize);
-    bool has_more = next_offset < directory_size;
-    read_directory_callbacks_.front().Run(file_entries,
-                                          has_more,
-                                          false /* no error */);
-
-    if (has_more) {
-      const size_t chunk_size =
-          std::min(directory_size - next_offset, kFileInfoToFetchChunkSize);
-
-      mtp_client_->GetFileInfo(
-          storage_handle, file_ids, next_offset, chunk_size,
-          base::Bind(&MediaTransferProtocolManagerImpl::OnGotDirectoryEntries,
-                     weak_ptr_factory_.GetWeakPtr(), storage_handle, file_ids,
-                     next_offset, max_size, sorted_file_ids),
-          base::Bind(&MediaTransferProtocolManagerImpl::OnReadDirectoryError,
-                     weak_ptr_factory_.GetWeakPtr()));
-      return;
-    }
+    std::move(read_directory_callbacks_.front()).Run(file_ids, /*error=*/false);
     read_directory_callbacks_.pop();
   }
 
   void OnReadDirectoryError() {
     DCHECK(thread_checker_.CalledOnValidThread());
-    read_directory_callbacks_.front().Run(std::vector<mojom::MtpFileEntry>(),
-                                          false /* no more entries */,
-                                          true /* error */);
+    std::move(read_directory_callbacks_.front())
+        .Run(std::vector<uint32_t>(), /*error=*/true);
     read_directory_callbacks_.pop();
   }
 

services/device/media_transfer_protocol/media_transfer_protocol_manager.h

@@ -54,15 +54,6 @@ class MediaTransferProtocolManager {
   // The first argument is true if there was an error.
   using CreateDirectoryCallback = base::Callback<void(bool error)>;
 
-  // A callback to handle the result of ReadDirectory.
-  // The first argument is a vector of file entries.
-  // The second argument is true if there are more file entries.
-  // The third argument is true if there was an error.
-  using ReadDirectoryCallback =
-      base::Callback<void(const std::vector<mojom::MtpFileEntry>& file_entries,
-                          bool has_more,
-                          bool error)>;
-
   // A callback to handle the result of ReadFileChunk.
   // The first argument is a string containing the file data.
   // The second argument is true if there was an error.
@@ -127,16 +118,16 @@ class MediaTransferProtocolManager {
 
   // Creates |directory_name| in |parent_id|.
   virtual void CreateDirectory(const std::string& storage_handle,
-                               const uint32_t parent_id,
+                               uint32_t parent_id,
                                const std::string& directory_name,
                                const CreateDirectoryCallback& callback) = 0;
 
-  // Reads directory entries from |file_id| on |storage_handle| and runs
-  // |callback|. |max_size| is a maximum number of files to be read.
-  virtual void ReadDirectory(const std::string& storage_handle,
-                             const uint32_t file_id,
-                             const size_t max_size,
-                             const ReadDirectoryCallback& callback) = 0;
+  // Reads IDs of directory entries from |file_id| on |storage_handle| and runs
+  // |callback|.
+  virtual void ReadDirectoryEntryIds(
+      const std::string& storage_handle,
+      uint32_t file_id,
+      mojom::MtpManager::ReadDirectoryEntryIdsCallback callback) = 0;
 
   // Reads file data from |file_id| on |storage_handle| and runs |callback|.
   // Reads |count| bytes of data starting at |offset|.
@@ -159,7 +150,7 @@ class MediaTransferProtocolManager {
 
   // Renames |object_id| to |new_name|.
   virtual void RenameObject(const std::string& storage_handle,
-                            const uint32_t object_id,
+                            uint32_t object_id,
                             const std::string& new_name,
                             const RenameObjectCallback& callback) = 0;
 
@@ -167,13 +158,13 @@ class MediaTransferProtocolManager {
   // |parent_id|.
   virtual void CopyFileFromLocal(const std::string& storage_handle,
                                  const int source_file_descriptor,
-                                 const uint32_t parent_id,
+                                 uint32_t parent_id,
                                  const std::string& file_name,
                                  const CopyFileFromLocalCallback& callback) = 0;
 
   // Deletes |object_id|.
   virtual void DeleteObject(const std::string& storage_handle,
-                            const uint32_t object_id,
+                            uint32_t object_id,
                             const DeleteObjectCallback& callback) = 0;
 
   // Creates and returns the global MediaTransferProtocolManager instance.

services/device/media_transfer_protocol/mtp_device_manager.cc

@@ -41,17 +41,6 @@ void EnumerateStorageCallbackWrapper(
   std::move(callback).Run(std::move(storage_info_ptr_list));
 }
 
-void ReadDirectoryCallbackWrapper(
-    mojom::MtpManager::ReadDirectoryCallback callback,
-    const std::vector<mojom::MtpFileEntry>& file_entries,
-    bool has_more,
-    bool error) {
-  std::vector<mojom::MtpFileEntryPtr> files(file_entries.size());
-  for (size_t i = 0; i < file_entries.size(); ++i)
-    files[i] = file_entries[i].Clone();
-  std::move(callback).Run(std::move(files), has_more, error);
-}
-
 }  // namespace
 
 MtpDeviceManager::MtpDeviceManager()
@@ -115,14 +104,12 @@ void MtpDeviceManager::CreateDirectory(const std::string& storage_handle,
       base::AdaptCallbackForRepeating(std::move(callback)));
 }
 
-void MtpDeviceManager::ReadDirectory(const std::string& storage_handle,
-                                     uint32_t file_id,
-                                     uint64_t max_size,
-                                     ReadDirectoryCallback callback) {
-  media_transfer_protocol_manager_->ReadDirectory(
-      storage_handle, file_id, max_size,
-      base::Bind(ReadDirectoryCallbackWrapper,
-                 base::AdaptCallbackForRepeating(std::move(callback))));
+void MtpDeviceManager::ReadDirectoryEntryIds(
+    const std::string& storage_handle,
+    uint32_t file_id,
+    ReadDirectoryEntryIdsCallback callback) {
+  media_transfer_protocol_manager_->ReadDirectoryEntryIds(
+      storage_handle, file_id, std::move(callback));
 }
 
 void MtpDeviceManager::ReadFileChunk(const std::string& storage_handle,

services/device/media_transfer_protocol/mtp_device_manager.h

@@ -46,10 +46,9 @@ class MtpDeviceManager : public mojom::MtpManager {
                        uint32_t parent_id,
                        const std::string& directory_name,
                        CreateDirectoryCallback callback) override;
-  void ReadDirectory(const std::string& storage_handle,
-                     uint32_t file_id,
-                     uint64_t max_size,
-                     ReadDirectoryCallback callback) override;
+  void ReadDirectoryEntryIds(const std::string& storage_handle,
+                             uint32_t file_id,
+                             ReadDirectoryEntryIdsCallback callback) override;
   void ReadFileChunk(const std::string& storage_handle,
                      uint32_t file_id,
                      uint32_t offset,

services/device/public/mojom/mtp_manager.mojom

@@ -42,11 +42,9 @@ interface MtpManager {
   CreateDirectory(string storage_handle, uint32 parent_id,
       string directory_name) => (bool error);
 
-  // Reads directory entries from |file_id| on |storage_handle|.
-  // |max_size| is a maximum number of files to be read.
-  ReadDirectory(string storage_handle,
-      uint32 file_id, uint64 max_size) =>
-    (array<MtpFileEntry> file_entries, bool has_more, bool error);
+  // Reads the directory listing for |file_id| and returns the list of file ids.
+  ReadDirectoryEntryIds(string storage_handle,
+      uint32 file_id) => (array<uint32> file_ids, bool error);
 
   // Reads file data from |file_id| on |storage_handle|.
   // Reads |count| bytes of data starting at |offset|.