Do not call stat() when reading directories via File API.

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 <fcntl.h>
 #include <algorithm>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
-#include "chrome/browser/media_galleries/linux/mtp_device_task_helper.h"
 #include "chrome/browser/media_galleries/linux/mtp_device_task_helper_map_service.h"
 #include "chrome/browser/media_galleries/linux/snapshot_file_details.h"
 #include "net/base/io_buffer.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace {
 
 // File path separator constant.
 const char kRootPath[] = "/";
 
@@ skipping 517 matching lines @@
     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 storage::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);
+    const MTPDeviceTaskHelper::MTPEntry& cached_file_entry = it->second;
+    success_callback.Run(cached_file_entry.file_info);
     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,
@@ skipping 642 matching lines @@
   EnsureInitAndRunTask(PendingTaskInfo(
       base::FilePath(), content::BrowserThread::IO, FROM_HERE, closure));
   PendingRequestDone();
 }
 
 void MTPDeviceDelegateImplLinux::OnDidReadDirectoryToCreateDirectory(
     const std::vector<base::FilePath>& components,
     const bool exclusive,
     const CreateDirectorySuccessCallback& success_callback,
     const ErrorCallback& error_callback,
-    const storage::AsyncFileUtil::EntryList& /* file_list */,
+    const storage::AsyncFileUtil::EntryList& /* entries */,
     const bool has_more) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   if (has_more)
     return;  // Wait until all entries have been read.
 
   const base::Closure closure =
       base::Bind(&MTPDeviceDelegateImplLinux::CreateDirectoryInternal,
                  weak_ptr_factory_.GetWeakPtr(), components, exclusive,
                  success_callback, error_callback);
   EnsureInitAndRunTask(PendingTaskInfo(
       base::FilePath(), content::BrowserThread::IO, FROM_HERE, closure));
 }
 
 void MTPDeviceDelegateImplLinux::OnDidReadDirectoryToDeleteDirectory(
     const base::FilePath& directory_path,
     const uint32 directory_id,
     const DeleteDirectorySuccessCallback& success_callback,
     const ErrorCallback& error_callback,
-    const storage::AsyncFileUtil::EntryList& entries,
+    const MTPDeviceTaskHelper::MTPEntries& entries,
     const bool has_more) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   DCHECK(!has_more);
 
   if (entries.size() > 0) {
     error_callback.Run(base::File::FILE_ERROR_NOT_EMPTY);
   } else {
     RunDeleteObjectOnUIThread(directory_path, directory_id, success_callback,
                               error_callback);
   }
@@ skipping 304 matching lines @@
     const ErrorCallback& callback,
     const base::File::Error error) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   callback.Run(base::File::FILE_ERROR_FAILED);
 }
 
 void MTPDeviceDelegateImplLinux::OnDidReadDirectory(
     uint32 dir_id,
     const ReadDirectorySuccessCallback& success_callback,
-    const storage::AsyncFileUtil::EntryList& file_list,
+    const MTPDeviceTaskHelper::MTPEntries& mtp_entries,
     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]);
 
-  storage::AsyncFileUtil::EntryList normalized_file_list;
-  for (size_t i = 0; i < file_list.size(); ++i) {
-    normalized_file_list.push_back(file_list[i]);
-    storage::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);
+  storage::AsyncFileUtil::EntryList file_list;
+  for (size_t i = 0; i < mtp_entries.size(); ++i) {

[Lei Zhang, 2015/11/12 07:25:16]

for (const auto& mtp_entry : mtp_entries) {
   ...

[mtomasz, 2015/11/12 07:48:24]

Done.

+    storage::DirectoryEntry entry;
+    entry.name = mtp_entries[i].name;
+    entry.is_directory = mtp_entries[i].file_info.is_directory;
+    file_list.push_back(entry);
 
     // Refresh the in memory tree.
-    dir_node->EnsureChildExists(entry.name, file_id);
+    dir_node->EnsureChildExists(entry.name, mtp_entries[i].file_id);
     child_nodes_seen_.insert(entry.name);
 
     // Add to |file_info_cache_|.
-    file_info_cache_[dir_path.Append(entry.name)] = entry;
+    file_info_cache_[dir_path.Append(entry.name)] = mtp_entries[i];
   }
 
-  success_callback.Run(normalized_file_list, has_more);
+  success_callback.Run(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();
 }
@@ skipping 21 matching lines @@
 void MTPDeviceDelegateImplLinux::OnDidReadBytes(
     const ReadBytesSuccessCallback& success_callback,
     const base::File::Info& file_info, int bytes_read) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   success_callback.Run(file_info, bytes_read);
   PendingRequestDone();
 }
 
 void MTPDeviceDelegateImplLinux::OnDidFillFileCache(
     const base::FilePath& path,
-    const storage::AsyncFileUtil::EntryList& /* file_list */,
+    const storage::AsyncFileUtil::EntryList& /* entries */,
     bool has_more) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   DCHECK(path.IsParent(pending_tasks_.front().path));
   if (has_more)
     return;  // Wait until all entries have been read.
   pending_tasks_.front().cached_path = path;
 }
 
 void MTPDeviceDelegateImplLinux::OnFillFileCacheFailed(
     base::File::Error /* error */) {
@@ skipping 238 matching lines @@
   }
 }
 
 void CreateMTPDeviceAsyncDelegate(
     const std::string& device_location,
     const bool read_only,
     const CreateMTPDeviceAsyncDelegateCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   callback.Run(new MTPDeviceDelegateImplLinux(device_location, read_only));
 }