Media Galleries: Cache file info during a directory read to service incoming requests to get file i…

chrome/browser/media_galleries/linux/mtp_device_delegate_impl_linux.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 "chrome/browser/media_galleries/linux/mtp_device_delegate_impl_linux.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 189 matching lines @@
 }
 
 MTPDeviceDelegateImplLinux::PendingTaskInfo::~PendingTaskInfo() {
 }
 
 // Represents a file on the MTP device.
 // Lives on the IO thread.
 class MTPDeviceDelegateImplLinux::MTPFileNode {
  public:
   MTPFileNode(uint32 file_id,
+              const std::string& file_name,
               MTPFileNode* parent,
               FileIdToMTPFileNodeMap* file_id_to_node_map);
   ~MTPFileNode();
 
   const MTPFileNode* GetChild(const std::string& name) const;
 
   void EnsureChildExists(const std::string& name, uint32 id);
 
   // Clears all the children, except those in |children_to_keep|.
   void ClearNonexistentChildren(
       const std::set<std::string>& children_to_keep);
 
   bool DeleteChild(uint32 file_id);
 
   uint32 file_id() const { return file_id_; }
+  const std::string& file_name() const { return file_name_; }
   MTPFileNode* parent() { return parent_; }
 
  private:
   // Container for holding a node's children.
   typedef base::ScopedPtrHashMap<std::string, MTPFileNode> ChildNodes;
 
   const uint32 file_id_;
+  const std::string file_name_;
+
   ChildNodes children_;
   MTPFileNode* const parent_;
   FileIdToMTPFileNodeMap* file_id_to_node_map_;
 
   DISALLOW_COPY_AND_ASSIGN(MTPFileNode);
 };
 
 MTPDeviceDelegateImplLinux::MTPFileNode::MTPFileNode(
     uint32 file_id,
+    const std::string& file_name,
     MTPFileNode* parent,
     FileIdToMTPFileNodeMap* file_id_to_node_map)
     : file_id_(file_id),
+      file_name_(file_name),
       parent_(parent),
       file_id_to_node_map_(file_id_to_node_map) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   DCHECK(file_id_to_node_map_);
   DCHECK(!ContainsKey(*file_id_to_node_map_, file_id_));
   (*file_id_to_node_map_)[file_id_] = this;
 }
 
 MTPDeviceDelegateImplLinux::MTPFileNode::~MTPFileNode() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
@@ skipping 11 matching lines @@
 void MTPDeviceDelegateImplLinux::MTPFileNode::EnsureChildExists(
     const std::string& name,
     uint32 id) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   const MTPFileNode* child = GetChild(name);
   if (child && child->file_id() == id)
     return;
 
   children_.set(
       name,
-      make_scoped_ptr(new MTPFileNode(id, this, file_id_to_node_map_)));
+      make_scoped_ptr(new MTPFileNode(id, name, this, file_id_to_node_map_)));
 }
 
 void MTPDeviceDelegateImplLinux::MTPFileNode::ClearNonexistentChildren(
     const std::set<std::string>& children_to_keep) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   std::set<std::string> children_to_erase;
   for (ChildNodes::const_iterator it = children_.begin();
        it != children_.end(); ++it) {
     if (ContainsKey(children_to_keep, it->first))
       continue;
@@ skipping 16 matching lines @@
   }
   return false;
 }
 
 MTPDeviceDelegateImplLinux::MTPDeviceDelegateImplLinux(
     const std::string& device_location)
     : init_state_(UNINITIALIZED),
       task_in_progress_(false),
       device_path_(device_location),
       root_node_(new MTPFileNode(mtpd::kRootFileId,
-                                 NULL,
+                                 "",    // Root node has no name.
+                                 NULL,  // And no parent node.
                                  &file_id_to_node_map_)),
       weak_ptr_factory_(this) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   DCHECK(!device_path_.empty());
   base::RemoveChars(device_location, kRootPath, &storage_name_);
   DCHECK(!storage_name_.empty());
 }
 
 MTPDeviceDelegateImplLinux::~MTPDeviceDelegateImplLinux() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 }
 
 void MTPDeviceDelegateImplLinux::GetFileInfo(
     const base::FilePath& file_path,
     const GetFileInfoSuccessCallback& success_callback,
     const ErrorCallback& error_callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   DCHECK(!file_path.empty());
+
+  // If a ReadDirectory operation is in progress, the file info may already be
+  // cached.
+  FileInfoCache::const_iterator it = file_info_cache_.find(file_path);
+  if (it != file_info_cache_.end()) {
+    // TODO(thestig): This code is repeated in several places. Combine them.
+    // e.g. c/b/media_galleries/win/mtp_device_operations_util.cc
+    const fileapi::DirectoryEntry& cached_file_entry = it->second;
+    base::File::Info info;
+    info.size = cached_file_entry.size;
+    info.is_directory = cached_file_entry.is_directory;
+    info.is_symbolic_link = false;
+    info.last_modified = cached_file_entry.last_modified_time;
+    info.creation_time = base::Time();
+
+    success_callback.Run(info);

[kinaba, 2014/08/20 23:10:05]

Just a comment.

Ah, I didn't fully understand the consequence of this change until I read your
comment in the Bug. So it not just reuse caches but also avoids the task queue
in this cached case. Great. Thanks!

+    return;
+  }
   base::Closure closure =
       base::Bind(&MTPDeviceDelegateImplLinux::GetFileInfoInternal,
                  weak_ptr_factory_.GetWeakPtr(),
                  file_path,
                  success_callback,
                  error_callback);
   EnsureInitAndRunTask(PendingTaskInfo(file_path,
                                        content::BrowserThread::IO,
                                        FROM_HERE,
                                        closure));
@@ skipping 385 matching lines @@
     uint32 dir_id,
     const ReadDirectorySuccessCallback& success_callback,
     const fileapi::AsyncFileUtil::EntryList& file_list,
     bool has_more) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   FileIdToMTPFileNodeMap::iterator it = file_id_to_node_map_.find(dir_id);
   DCHECK(it != file_id_to_node_map_.end());
   MTPFileNode* dir_node = it->second;
 
+  // Traverse the MTPFileNode tree to reconstuct the full path for |dir_id|.
+  std::deque<std::string> dir_path_parts;
+  MTPFileNode* parent_node = dir_node;
+  while (parent_node->parent()) {
+    dir_path_parts.push_front(parent_node->file_name());
+    parent_node = parent_node->parent();
+  }
+  base::FilePath dir_path = device_path_;
+  for (size_t i = 0; i < dir_path_parts.size(); ++i)
+    dir_path = dir_path.Append(dir_path_parts[i]);
+
   fileapi::AsyncFileUtil::EntryList normalized_file_list;
   for (size_t i = 0; i < file_list.size(); ++i) {
     normalized_file_list.push_back(file_list[i]);
     fileapi::DirectoryEntry& entry = normalized_file_list.back();
 
     // |entry.name| has the file id encoded in it. Decode here.
     size_t separator_idx = entry.name.find_last_of(',');
     DCHECK_NE(std::string::npos, separator_idx);
     std::string file_id_str = entry.name.substr(separator_idx);
     file_id_str = file_id_str.substr(1);  // Get rid of the comma.
     uint32 file_id = 0;
     bool ret = base::StringToUint(file_id_str, &file_id);
     DCHECK(ret);
     entry.name = entry.name.substr(0, separator_idx);
 
     // Refresh the in memory tree.
     dir_node->EnsureChildExists(entry.name, file_id);
     child_nodes_seen_.insert(entry.name);
+
+    // Add to |file_info_cache_|.
+    file_info_cache_[dir_path.Append(entry.name)] = entry;
   }
 
   success_callback.Run(normalized_file_list, has_more);
   if (has_more)
     return;  // Wait to be called again.
 
   // Last call, finish book keeping and continue with the next request.
   dir_node->ClearNonexistentChildren(child_nodes_seen_);
   child_nodes_seen_.clear();
+  file_info_cache_.clear();
 
   PendingRequestDone();
 }
 
 void MTPDeviceDelegateImplLinux::OnDidWriteDataIntoSnapshotFile(
     const base::File::Info& file_info,
     const base::FilePath& snapshot_file_path) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   DCHECK(current_snapshot_request_info_.get());
   current_snapshot_request_info_->success_callback.Run(
@@ skipping 125 matching lines @@
   *id = current_node->file_id();
   return true;
 }
 
 void CreateMTPDeviceAsyncDelegate(
     const std::string& device_location,
     const CreateMTPDeviceAsyncDelegateCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   callback.Run(new MTPDeviceDelegateImplLinux(device_location));
 }