Media Galleries: Access MTP devices by file ids rather than file paths.

chrome/browser/media_galleries/linux/mtp_device_delegate_impl_linux.h

Index: chrome/browser/media_galleries/linux/mtp_device_delegate_impl_linux.h
diff --git a/chrome/browser/media_galleries/linux/mtp_device_delegate_impl_linux.h b/chrome/browser/media_galleries/linux/mtp_device_delegate_impl_linux.h
index 510f1f0e86aabb4facc757029a36fa8da3cf25c5..d6df68b1db4b4607479378f73416a6debdaea568 100644
--- a/chrome/browser/media_galleries/linux/mtp_device_delegate_impl_linux.h
+++ b/chrome/browser/media_galleries/linux/mtp_device_delegate_impl_linux.h
@@ -5,19 +5,20 @@
 #ifndef CHROME_BROWSER_MEDIA_GALLERIES_LINUX_MTP_DEVICE_DELEGATE_IMPL_LINUX_H_
 #define CHROME_BROWSER_MEDIA_GALLERIES_LINUX_MTP_DEVICE_DELEGATE_IMPL_LINUX_H_
 
-#include <queue>
+#include <deque>
+#include <map>
+#include <string>
 
 #include "base/callback.h"
+#include "base/containers/scoped_ptr_hash_map.h"
+#include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "chrome/browser/media_galleries/fileapi/mtp_device_async_delegate.h"
+#include "content/public/browser/browser_thread.h"
 #include "webkit/browser/fileapi/async_file_util.h"
 
-namespace base {
-class FilePath;
-}
-
 struct SnapshotRequestInfo;
 
 // MTPDeviceDelegateImplLinux communicates with the media transfer protocol
@@ -40,14 +41,24 @@ class MTPDeviceDelegateImplLinux : public MTPDeviceAsyncDelegate {
 
   // Used to represent pending task details.
   struct PendingTaskInfo {
-    PendingTaskInfo(const tracked_objects::Location& location,
+    PendingTaskInfo(const base::FilePath& path,
+                    content::BrowserThread::ID thread_id,
+                    const tracked_objects::Location& location,
                     const base::Closure& task);
     ~PendingTaskInfo();
 
+    base::FilePath path;
+    base::FilePath cached_path;
+    const content::BrowserThread::ID thread_id;
     const tracked_objects::Location location;
     const base::Closure task;
   };
 
+  class MTPFileNode;
+
+  // Maps file ids to file nodes.
+  typedef std::map<uint32, MTPFileNode*> FileIdToMTPFileNodeMap;
+
   // Should only be called by CreateMTPDeviceAsyncDelegate() factory call.
   // Defer the device initializations until the first file operation request.
   // Do all the initializations in EnsureInitAndRunTask() function.
@@ -77,17 +88,41 @@ class MTPDeviceDelegateImplLinux : public MTPDeviceAsyncDelegate {
       const ErrorCallback& error_callback) OVERRIDE;
   virtual void CancelPendingTasksAndDeleteDelegate() OVERRIDE;
 
-  // Ensures the device is initialized for communication by doing a
-  // call-and-reply to the UI thread. |task_info.task| runs on the UI thread.
-  //
-  // If the device is already initialized, post the |task_info.task| immediately
-  // on the UI thread.
+  // The internal methods correspond to the similarly named methods above.
+  // The |root_node_| cache should be filled at this point.
+  virtual void GetFileInfoInternal(
+      const base::FilePath& file_path,
+      const GetFileInfoSuccessCallback& success_callback,
+      const ErrorCallback& error_callback);
+  virtual void ReadDirectoryInternal(
+      const base::FilePath& root,
+      const ReadDirectorySuccessCallback& success_callback,
+      const ErrorCallback& error_callback);
+  virtual void CreateSnapshotFileInternal(
+      const base::FilePath& device_file_path,
+      const base::FilePath& local_path,
+      const CreateSnapshotFileSuccessCallback& success_callback,
+      const ErrorCallback& error_callback);
+  virtual void ReadBytesInternal(
+      const base::FilePath& device_file_path,
+      net::IOBuffer* buf, int64 offset, int buf_len,
+      const ReadBytesSuccessCallback& success_callback,
+      const ErrorCallback& error_callback);
+
+  // Ensures the device is initialized for communication.
+  // If the device is already initialized, call RunTask().
   //
   // If the device is uninitialized, store the |task_info| in a pending task
-  // list and runs all the pending tasks once the device is successfully
-  // initialized.
+  // queue and runs the pending tasks in the queue once the device is
+  // successfully initialized.
   void EnsureInitAndRunTask(const PendingTaskInfo& task_info);
 
+  // Runs a task. If |task_info.path| is empty, or if the path is cached, runs
+  // the task immediately.
+  // Otherwise, fills the cache first before running the task.
+  // |task_info.task| runs on the UI thread.
+  void RunTask(const PendingTaskInfo& task_info);
+
   // Writes data from the device to the snapshot file path based on the
   // parameters in |current_snapshot_request_info_| by doing a call-and-reply to
   // the UI thread.
@@ -114,16 +149,16 @@ class MTPDeviceDelegateImplLinux : public MTPDeviceAsyncDelegate {
                         const base::File::Info& file_info);
 
   // Called when GetFileInfo() succeeds. GetFileInfo() is invoked to
-  // get the |root| directory metadata details. |file_info| specifies the |root|
-  // directory details.
+  // get the |dir_id| directory metadata details. |file_info| specifies the
+  // |dir_id| directory details.
   //
-  // If |root| is a directory, post a task on the UI thread to read the |root|
-  // directory file entries.
+  // If |dir_id| is a directory, post a task on the UI thread to read the
+  // |dir_id| directory file entries.
   //
-  // If |root| is not a directory, |error_callback| is invoked to notify the
+  // If |dir_id| is not a directory, |error_callback| is invoked to notify the
   // caller about the file error and process the next pending request.
   void OnDidGetFileInfoToReadDirectory(
-      const std::string& root,
+      uint32 dir_id,
       const ReadDirectorySuccessCallback& success_callback,
       const ErrorCallback& error_callback,
       const base::File::Info& file_info);
@@ -140,10 +175,12 @@ class MTPDeviceDelegateImplLinux : public MTPDeviceAsyncDelegate {
 
   // Called when ReadDirectory() succeeds.
   //
-  // |file_list| contains the directory file entries.
+  // |dir_id| is the directory read.
+  // |file_list| contains the directory file entries with their file ids.
   // |success_callback| is invoked to notify the caller about the directory
   // file entries.
-  void OnDidReadDirectory(const ReadDirectorySuccessCallback& success_callback,
+  void OnDidReadDirectory(uint32 dir_id,
+                          const ReadDirectorySuccessCallback& success_callback,
                           const fileapi::AsyncFileUtil::EntryList& file_list);
 
   // Called when WriteDataIntoSnapshotFile() succeeds.
@@ -171,11 +208,34 @@ class MTPDeviceDelegateImplLinux : public MTPDeviceAsyncDelegate {
   void OnDidReadBytes(const ReadBytesSuccessCallback& success_callback,
                       const base::File::Info& file_info, int bytes_read);
 
-  // Handles the device file |error|. |error_callback| is invoked to notify the
-  // caller about the file error.
+  // Called when FillFileCache() succeeds.
+  void OnDidFillFileCache(const base::FilePath& path,
+                          const fileapi::AsyncFileUtil::EntryList& file_list,
+                          bool has_more);
+
+  // Called when FillFileCache() fails.
+  void OnFillFileCacheFailed(base::File::Error error);
+
+  // Handles the device file |error| while operating on |file_id|.
+  // |error_callback| is invoked to notify the caller about the file error.
   void HandleDeviceFileError(const ErrorCallback& error_callback,
+                             uint32 file_id,
                              base::File::Error error);
 
+  // Given a full path, returns a non-empty sub-path that needs to be read into
+  // the cache if such a uncached path exists.
+  // |cached_path| is the portion of |path| that has had cache lookup attempts.
+  base::FilePath NextUncachedPathComponent(
+      const base::FilePath& path,
+      const base::FilePath& cached_path) const;
+
+  // Fills the file cache using the results from NextUncachedPathComponent().
+  void FillFileCache(const base::FilePath& uncached_path);
+
+  // Given a full path, if it exists in the cache, writes the file's id to |id|
+  // and return true.
+  bool CachedPathToId(const base::FilePath& path, uint32* id) const;
+
   // MTP device initialization state.
   InitializationState init_state_;
 
@@ -193,7 +253,7 @@ class MTPDeviceDelegateImplLinux : public MTPDeviceAsyncDelegate {
 
   // A list of pending tasks that needs to be run when the device is
   // initialized or when the current task in progress is complete.
-  std::queue<PendingTaskInfo> pending_tasks_;
+  std::deque<PendingTaskInfo> pending_tasks_;
 
   // Used to track the current snapshot file request. A snapshot file is created
   // incrementally. CreateSnapshotFile request reads the device file and writes
@@ -202,6 +262,15 @@ class MTPDeviceDelegateImplLinux : public MTPDeviceAsyncDelegate {
   // request at any time.
   scoped_ptr<SnapshotRequestInfo> current_snapshot_request_info_;
 
+  // A mapping for quick lookups into the |root_node_| tree structure. Since
+  // |root_node_| contains pointers to this map, it must be declared after this
+  // so destruction happens in the right order.
+  FileIdToMTPFileNodeMap file_id_to_node_map_;
+
+  // The root node of a tree-structure that caches the directory structure of
+  // the MTP device.
+  scoped_ptr<MTPFileNode> root_node_;
+
   // For callbacks that may run after destruction.
   base::WeakPtrFactory<MTPDeviceDelegateImplLinux> weak_ptr_factory_;