Add an option to specify requested fields for fetching metadata.

chrome/browser/chromeos/file_manager/fileapi_util.cc

 // Copyright 2013 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/chromeos/file_manager/fileapi_util.h"
 
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/chromeos/file_manager/app_id.h"
@@ skipping 331 matching lines @@
       return;
     }
 
     if (!it->file_system_url.is_valid()) {
       FillMetadataOnIOThread(lifetime.Pass(), it + 1);
       return;
     }
 
     context_->operation_runner()->GetMetadata(
         context_->CrackURL(it->file_system_url),
+        storage::FileSystemOperation::GET_METADATA_FIELD_IS_DIRECTORY |
+            storage::FileSystemOperation::GET_METADATA_FIELD_SIZE |
+            storage::FileSystemOperation::GET_METADATA_FIELD_LAST_MODIFIED,
         base::Bind(&ConvertSelectedFileInfoListToFileChooserFileInfoListImpl::
                        OnGotMetadataOnIOThread,
-                   base::Unretained(this),
-                   base::Passed(&lifetime),
-                   it));
+                   base::Unretained(this), base::Passed(&lifetime), it));
   }
 
   // Callback invoked after GetMetadata.
   void OnGotMetadataOnIOThread(Lifetime lifetime,
                                const FileChooserFileInfoList::iterator& it,
                                base::File::Error result,
                                const base::File::Info& file_info) {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
     if (result != base::File::FILE_OK) {
@@ skipping 180 matching lines @@
       BrowserThread::IO, FROM_HERE,
       base::Bind(base::IgnoreResult(
                      &storage::FileSystemOperationRunner::DirectoryExists),
                  file_system_context->operation_runner()->AsWeakPtr(),
                  internal_url, google_apis::CreateRelayCallback(callback)));
 }
 
 void GetMetadataForPath(
     scoped_refptr<storage::FileSystemContext> file_system_context,
     const base::FilePath& entry_path,
+    int fields,
     const storage::FileSystemOperationRunner::GetMetadataCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   storage::ExternalFileSystemBackend* const backend =
       file_system_context->external_backend();
   DCHECK(backend);
   const storage::FileSystemURL internal_url =
       backend->CreateInternalURL(file_system_context.get(), entry_path);
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(
           base::IgnoreResult(&storage::FileSystemOperationRunner::GetMetadata),
           file_system_context->operation_runner()->AsWeakPtr(), internal_url,
-          google_apis::CreateRelayCallback(callback)));
+          fields, google_apis::CreateRelayCallback(callback)));
 }
 
 storage::FileSystemURL CreateIsolatedURLFromVirtualPath(
     const storage::FileSystemContext& context,
     const GURL& origin,
     const base::FilePath& virtual_path) {
   const storage::FileSystemURL original_url =
       context.CreateCrackedFileSystemURL(
           origin, storage::kFileSystemTypeExternal, virtual_path);
 
   std::string register_name;
   const std::string isolated_file_system_id =
       storage::IsolatedContext::GetInstance()->RegisterFileSystemForPath(
           original_url.type(),
           original_url.filesystem_id(),
           original_url.path(),
           &register_name);
   const storage::FileSystemURL isolated_url =
       context.CreateCrackedFileSystemURL(
           origin,
           storage::kFileSystemTypeIsolated,
           base::FilePath(isolated_file_system_id).Append(register_name));
   return isolated_url;
 }
 
 }  // namespace util
 }  // namespace file_manager