In DownloadOperation use locally modified file info if dirty Drive cache exists.

chrome/browser/chromeos/drive/file_system/download_operation.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/drive/file_system/download_operation.h"
 
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/task_runner_util.h"
@@ skipping 19 matching lines @@
 // the path to the JSON file.
 // If the resource is a regular file and its local cache is available,
 // returns FILE_ERROR_OK with |cache_file_path| storing the path to the
 // cache file.
 // If the resource is a regular file but its local cache is NOT available,
 // returns FILE_ERROR_OK, but |cache_file_path| is kept empty.
 // Otherwise returns error code.
 FileError CheckPreConditionForEnsureFileDownloaded(
     internal::ResourceMetadata* metadata,
     internal::FileCache* cache,
-    const ResourceEntry& entry,
+    ResourceEntry* entry,
     base::FilePath* cache_file_path) {
   DCHECK(metadata);
   DCHECK(cache);
   DCHECK(cache_file_path);
 
-  if (entry.file_info().is_directory())
+  if (entry->file_info().is_directory())
     return FILE_ERROR_NOT_A_FILE;
 
   // The file's entry should have its file specific info.
-  DCHECK(entry.has_file_specific_info());
+  DCHECK(entry->has_file_specific_info());
 
   // For a hosted document, we create a special JSON file to represent the
   // document instead of fetching the document content in one of the exported
   // formats. The JSON file contains the edit URL and resource ID of the
   // document.
-  if (entry.file_specific_info().is_hosted_document()) {
+  if (entry->file_specific_info().is_hosted_document()) {
     base::FilePath gdoc_file_path;
     if (!file_util::CreateTemporaryFileInDir(
             cache->GetCacheDirectoryPath(
                 internal::FileCache::CACHE_TYPE_TMP_DOCUMENTS),
             &gdoc_file_path) ||
         !util::CreateGDocFile(gdoc_file_path,
-                              GURL(entry.file_specific_info().alternate_url()),
-                              entry.resource_id()))
+                              GURL(entry->file_specific_info().alternate_url()),
+                              entry->resource_id()))
       return FILE_ERROR_FAILED;
 
     *cache_file_path = gdoc_file_path;
     return FILE_ERROR_OK;
   }
 
   // Get the cache file path if available.
-  cache->GetFile(entry.resource_id(),
-                 entry.file_specific_info().file_md5(),
+  cache->GetFile(entry->resource_id(),
+                 entry->file_specific_info().file_md5(),
                  cache_file_path);
+
+  // If the cache file is available and dirty, the modified file info needs to
+  // be stored in |entry|.
+  // TODO(kinaba): crbug.com/246469. The logic below is a duplicate of that in
+  // drive::FileSystem::CheckLocalModificationAndRun. We should merge them once
+  // the drive::FS side is also converted to run fully on blocking pool.
+  if (!cache_file_path->empty()) {
+    FileCacheEntry cache_entry;
+    if (cache->GetCacheEntry(entry->resource_id(),
+                             entry->file_specific_info().file_md5(),
+                             &cache_entry) &&
+        cache_entry.is_dirty()) {
+      base::PlatformFileInfo file_info;
+      if (file_util::GetFileInfo(*cache_file_path, &file_info)) {
+        PlatformFileInfoProto entry_file_info;
+        util::ConvertPlatformFileInfoToResourceEntry(file_info,
+                                                     &entry_file_info);
+        *entry->mutable_file_info() = entry_file_info;
+      }
+    }
+  }
+
   return FILE_ERROR_OK;
 }
 
 // Calls CheckPreConditionForEnsureFileDownloaded() with the entry specified by
 // the given ID.
 FileError CheckPreConditionForEnsureFileDownloadedByResourceId(
     internal::ResourceMetadata* metadata,
     internal::FileCache* cache,
     const std::string& resource_id,
     base::FilePath* cache_file_path,
     ResourceEntry* entry) {
   FileError error = metadata->GetResourceEntryById(resource_id, entry);
   if (error != FILE_ERROR_OK)
     return error;
   return CheckPreConditionForEnsureFileDownloaded(
-      metadata, cache, *entry, cache_file_path);
+      metadata, cache, entry, cache_file_path);
 }
 
 // Calls CheckPreConditionForEnsureFileDownloaded() with the entry specified by
 // the given file path.
 FileError CheckPreConditionForEnsureFileDownloadedByPath(
     internal::ResourceMetadata* metadata,
     internal::FileCache* cache,
     const base::FilePath& file_path,
     base::FilePath* cache_file_path,
     ResourceEntry* entry) {
   FileError error = metadata->GetResourceEntryByPath(file_path, entry);
   if (error != FILE_ERROR_OK)
     return error;
   return CheckPreConditionForEnsureFileDownloaded(
-      metadata, cache, *entry, cache_file_path);
+      metadata, cache, entry, cache_file_path);
 }
 
 // Creates a file with unique name in |dir| and stores the path to |temp_file|.
 // Additionally, sets the permission of the file to allow read access from
 // others and group member users (i.e, "-rw-r--r--").
 // We need this wrapper because Drive cache files may be read from other
 // processes (e.g., cros_disks for mounting zip files).
 bool CreateTemporaryReadableFileInDir(const base::FilePath& dir,
                                       base::FilePath* temp_file) {
   if (!file_util::CreateTemporaryFileInDir(dir, temp_file))
@@ skipping 409 matching lines @@
   observer_->OnDirectoryChangedByOperation(file_path.DirName());
   callback.OnComplete(*cache_file_path, entry.Pass());
 }
 
 void DownloadOperation::CancelJob(JobID job_id) {
   scheduler_->CancelJob(job_id);
 }
 
 }  // namespace file_system
 }  // namespace drive