chromeos: Stop directly downloading files to the cache directory from DriveFileSystem::GetResolvedF…

chrome/browser/chromeos/drive/drive_file_system.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/chromeos/drive/drive_file_system.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/message_loop_proxy.h"
@@ skipping 163 matching lines @@
     if (entry_proto->file_specific_info().is_hosted_document()) {
       get_file_callback.Run(
           DRIVE_FILE_OK, local_file_path, kMimeTypeJson, HOSTED_DOCUMENT);
     } else {
       get_file_callback.Run(
           DRIVE_FILE_OK, local_file_path,
           entry_proto->file_specific_info().content_mime_type(), REGULAR_FILE);
     }
   }
 
-  void OnDownloadFileCompleted(const base::FilePath& downloaded_file_path) {
+  void OnStoreCompleted(const base::FilePath& local_file_path) {
     get_file_callback.Run(
-        DRIVE_FILE_OK, downloaded_file_path,
+        DRIVE_FILE_OK, local_file_path,
         entry_proto->file_specific_info().content_mime_type(), REGULAR_FILE);
   }
 
   const base::FilePath drive_file_path;
   const DriveClientContext context;
   scoped_ptr<DriveEntryProto> entry_proto;
   const GetFileCallback get_file_callback;
   const google_apis::GetContentCallback get_content_callback;
 };
 
@@ skipping 726 matching lines @@
 
   if (error != DRIVE_FILE_OK) {
     params->OnError(error);
     return;
   }
 
   int64 file_size = entry_proto->file_info().size();
   params->entry_proto = entry_proto.Pass();  // Update the entry in |params|.
   cache_->FreeDiskSpaceIfNeededFor(
       file_size,
-      base::Bind(
-          &DriveFileSystem
-              ::GetResolvedFileByPathAfterFreeDiskSpacePreliminarily,
-          weak_ptr_factory_.GetWeakPtr(),
-          base::Passed(&params),
-          download_url));
+      base::Bind(&DriveFileSystem::GetResolvedFileByPathAfterFreeDiskSpace,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 base::Passed(&params),
+                 download_url));
 }
 
-void DriveFileSystem::GetResolvedFileByPathAfterFreeDiskSpacePreliminarily(
+void DriveFileSystem::GetResolvedFileByPathAfterFreeDiskSpace(
     scoped_ptr<GetResolvedFileParams> params,
     const GURL& download_url,
     bool has_enough_space) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(params);
 
   if (!has_enough_space) {
     // If no enough space, return DRIVE_FILE_ERROR_NO_SPACE.
     params->OnError(DRIVE_FILE_ERROR_NO_SPACE);
     return;
   }
 
-  // We have enough disk space. Start downloading the file.
-  base::FilePath local_tmp_path = cache_->GetCacheFilePath(
-      params->entry_proto->resource_id(),
-      params->entry_proto->file_specific_info().file_md5(),
-      DriveCache::CACHE_TYPE_TMP,
-      DriveCache::CACHED_FILE_FROM_SERVER);
+  // We have enough disk space. Create download destination file.
+  const base::FilePath temp_download_directory =
+      cache_->GetCacheDirectoryPath(DriveCache::CACHE_TYPE_TMP_DOWNLOADS);
+  base::FilePath* file_path = new base::FilePath;
+  base::PostTaskAndReplyWithResult(
+      blocking_task_runner_,
+      FROM_HERE,
+      base::Bind(&file_util::CreateTemporaryFileInDir,
+                 temp_download_directory,
+                 file_path),
+      base::Bind(&DriveFileSystem::GetResolveFileByPathAfterCreateTemporaryFile,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 base::Passed(&params),
+                 download_url,
+                 base::Owned(file_path)));
+}
+
+void DriveFileSystem::GetResolveFileByPathAfterCreateTemporaryFile(
+    scoped_ptr<GetResolvedFileParams> params,
+    const GURL& download_url,
+    base::FilePath* temp_file,
+    bool success) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(params);
+
+  if (!success) {
+    params->OnError(DRIVE_FILE_ERROR_FAILED);
+    return;
+  }
+
   GetResolvedFileParams* params_ptr = params.get();
   scheduler_->DownloadFile(
       params_ptr->drive_file_path,
-      local_tmp_path,
+      *temp_file,
       download_url,
       params_ptr->context,
       base::Bind(&DriveFileSystem::GetResolvedFileByPathAfterDownloadFile,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(&params)),
       params_ptr->get_content_callback);
 }
 
 void DriveFileSystem::GetResolvedFileByPathAfterDownloadFile(
     scoped_ptr<GetResolvedFileParams> params,
@@ skipping 14 matching lines @@
             params->entry_proto->resource_id(),
             params->entry_proto->file_specific_info().file_md5()));
   }
 
   DriveFileError error = util::GDataToDriveFileError(status);
   if (error != DRIVE_FILE_OK) {
     params->OnError(error);
     return;
   }
 
-  // At this point, the disk can be full or nearly full for several reasons:
-  // - The expected file size was incorrect and the file was larger
-  // - There was an in-flight download operation and it used up space
-  // - The disk became full for some user actions we cannot control
-  //   (ex. the user might have downloaded a large file from a regular web site)
-  //
-  // If we don't have enough space, we return PLATFORM_FILE_ERROR_NO_SPACE,
-  // and try to free up space, even if the file was downloaded successfully.
-  cache_->FreeDiskSpaceIfNeededFor(
-      0,
-      base::Bind(&DriveFileSystem::GetResolvedFileByPathAfterFreeDiskSpace,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 base::Passed(&params),
-                 downloaded_file_path));
+  DriveEntryProto* entry = params->entry_proto.get();
+  cache_->Store(entry->resource_id(),
+                entry->file_specific_info().file_md5(),
+                downloaded_file_path,
+                DriveCache::FILE_OPERATION_MOVE,
+                base::Bind(&DriveFileSystem::GetResolvedFileByPathAfterStore,
+                           weak_ptr_factory_.GetWeakPtr(),
+                           base::Passed(&params),
+                           downloaded_file_path));
 }
 
 void DriveFileSystem::GetResolvedFileByPathAfterGetCacheEntryForCancel(
     const std::string& resource_id,
     const std::string& md5,
     bool success,
     const DriveCacheEntry& cache_entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // TODO(hshi): http://crbug.com/127138 notify when file properties change.
   // This allows file manager to clear the "Available offline" checkbox.
   if (success && cache_entry.is_pinned()) {
     cache_->Unpin(resource_id,
                   md5,
                   base::Bind(&util::EmptyFileOperationCallback));
   }
 }
 
-void DriveFileSystem::GetResolvedFileByPathAfterFreeDiskSpace(
+void DriveFileSystem::GetResolvedFileByPathAfterStore(
     scoped_ptr<GetResolvedFileParams> params,
     const base::FilePath& downloaded_file_path,
-    bool has_enough_space) {
+    DriveFileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(params);
 
-  // If we don't have enough space, remove the downloaded file, and
-  // report "no space" error.
-  if (!has_enough_space) {
+  if (error != DRIVE_FILE_OK) {
     blocking_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(base::IgnoreResult(&file_util::Delete),
                    downloaded_file_path,
                    false /* recursive*/));
-    params->OnError(DRIVE_FILE_ERROR_NO_SPACE);
+    params->OnError(error);
     return;
   }
-
-  // Make sure that downloaded file is properly stored in cache. We don't have
-  // to wait for this operation to finish since the user can already use the
-  // downloaded file.
-  cache_->Store(params->entry_proto->resource_id(),
-                params->entry_proto->file_specific_info().file_md5(),
-                downloaded_file_path,
-                DriveCache::FILE_OPERATION_MOVE,
-                base::Bind(&util::EmptyFileOperationCallback));
   // Storing to cache changes the "offline available" status, hence notify.
   OnDirectoryChanged(params->drive_file_path.DirName());
 
-  params->OnDownloadFileCompleted(downloaded_file_path);
+  DriveEntryProto* entry = params->entry_proto.get();
+  cache_->GetFile(
+      entry->resource_id(),
+      entry->file_specific_info().file_md5(),
+      base::Bind(&DriveFileSystem::GetResolvedFileByPathAfterGetFile,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 base::Passed(&params)));
+}
+
+void DriveFileSystem::GetResolvedFileByPathAfterGetFile(
+    scoped_ptr<GetResolvedFileParams> params,
+    DriveFileError error,
+    const base::FilePath& cache_file) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(params);
+
+  if (error != DRIVE_FILE_OK) {
+    params->OnError(error);
+    return;
+  }
+  params->OnStoreCompleted(cache_file);
 }
 
 void DriveFileSystem::RefreshDirectory(
     const base::FilePath& directory_path,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   // Make sure the destination directory exists.
   resource_metadata_->GetEntryInfoByPath(
@@ skipping 620 matching lines @@
     return;
   }
 
   PlatformFileInfoProto entry_file_info;
   util::ConvertPlatformFileInfoToProto(*file_info, &entry_file_info);
   *entry_proto->mutable_file_info() = entry_file_info;
   callback.Run(DRIVE_FILE_OK, entry_proto.Pass());
 }
 
 }  // namespace drive