Evict drive cache with file download from website if necessary.

chrome/browser/chromeos/drive/download_handler.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/download_handler.h"
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/strings/string_util.h"
 #include "base/supports_user_data.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/chromeos/drive/drive_integration_service.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/chromeos/drive/write_on_cache_file.h"
 #include "chrome/browser/download/download_history.h"
 #include "chrome/browser/download/download_service.h"
 #include "chrome/browser/download/download_service_factory.h"
 #include "components/drive/drive.pb.h"
 #include "components/drive/file_system_interface.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 using content::DownloadManager;
 using content::DownloadItem;
 
 namespace drive {
 namespace {
 
 // Key for base::SupportsUserData::Data.
 const char kDrivePathKey[] = "DrivePath";
 
 // Mime types that we better not trust. If the file was downloade with these
 // mime types, while uploading to Drive we ignore it at guess by our own logic.
 const char* kGenericMimeTypes[] = {"text/html", "text/plain",
                                    "application/octet-stream"};
 
+const int64 kDefaultRequestSpace = 512 * (1 << 20);  // 512MB

[hashimoto, 2015/10/28 09:06:15]

How was this value chosen? (based on some statistics?)

[yawano, 2015/10/28 09:29:44]

No, this is not based on some statistics.

This value should be
- small as possible since we don't want to evict Drive cache unnecessary.
- large enough as not to be used up until the next FreeDiskSpace (5 secs).

+
+const base::TimeDelta kFreeDiskSpaceDelay = base::TimeDelta::FromSeconds(5);
+
 // User Data stored in DownloadItem for drive path.
 class DriveUserData : public base::SupportsUserData::Data {
  public:
   explicit DriveUserData(const base::FilePath& path) : file_path_(path),
                                                        is_complete_(false) {}
   ~DriveUserData() override {}
 
   const base::FilePath& file_path() const { return file_path_; }
   const base::FilePath& cache_file_path() const { return cache_file_path_; }
   void set_cache_file_path(const base::FilePath& path) {
@@ skipping 71 matching lines @@
 // 'default' fallback choice on the HTTP server. In such a case, we ignore the
 // type so that our logic can guess by its own while uploading to Drive.
 std::string FilterOutGenericMimeType(const std::string& mime_type) {
   for (size_t i = 0; i < arraysize(kGenericMimeTypes); ++i) {
     if (base::LowerCaseEqualsASCII(mime_type, kGenericMimeTypes[i]))
       return std::string();
   }
   return mime_type;
 }
 
+void IgnoreFreeDiskSpaceIfNeededForCallback(bool /*result*/) {}
+
 }  // namespace
 
 DownloadHandler::DownloadHandler(FileSystemInterface* file_system)
     : file_system_(file_system),
-      weak_ptr_factory_(this) {
-}
+      pending_request_space_(0),
+      free_disk_space_delay_(kFreeDiskSpaceDelay),
+      weak_ptr_factory_(this) {}
 
 DownloadHandler::~DownloadHandler() {
 }
 
 // static
 DownloadHandler* DownloadHandler::GetForProfile(Profile* profile) {
   DriveIntegrationService* service =
       DriveIntegrationServiceFactory::FindForProfile(profile);
   if (!service || !service->IsMounted())
     return NULL;
@@ skipping 86 matching lines @@
 
 void DownloadHandler::CheckForFileExistence(
     const DownloadItem* download,
     const content::CheckForFileExistenceCallback& callback) {
   file_system_->GetResourceEntry(
       util::ExtractDrivePath(GetTargetPath(download)),
       base::Bind(&ContinueCheckingForFileExistence,
                  callback));
 }
 
+void DownloadHandler::SetFreeDiskSpaceDelayForTesting(
+    const base::TimeDelta& delay) {
+  free_disk_space_delay_ = delay;
+}
+
+// TODO(yawano): support multiple in-progress downloads.

[hashimoto, 2015/10/28 09:06:15]

Why don't you support multiple downloads now?

[yawano, 2015/10/28 09:29:44]

I thought it will make this CL larger. But I think this will be the best timing
to support it. I'll try to implement it in this CL.

+void DownloadHandler::FreeDiskSpaceIfNeeded(const DownloadItem* download,
+                                            bool immediate) {
+  if (download->IsDone())
+    return;
+
+  const int64 total_bytes = download->GetTotalBytes();
+  const int64 request_space = total_bytes == 0

[hashimoto, 2015/10/28 09:06:15]

Please add a comment why we need to handle total_bytes==0 case.

[yawano, 2015/10/29 02:52:43]

Done.

+                                  ? kDefaultRequestSpace

[hashimoto, 2015/10/28 09:06:15]

IIUC, when the download is 99% complete, this can result in requesting needed
bytes + 512MB
Is this really what we want?

[yawano, 2015/10/28 09:29:44]

This value is used when we don't know total bytes of Download. When
content_length is not available, total bytes become 0.

https://code.google.com/p/chromium/codesearch#chromium/src/content/browser/do...

+                                  : total_bytes - download->GetReceivedBytes();
+
+  if (immediate) {
+    file_system_->FreeDiskSpaceIfNeededFor(
+        request_space, base::Bind(&IgnoreFreeDiskSpaceIfNeededForCallback));
+
+    return;
+  }
+
+  const bool post_task = pending_request_space_ == 0;
+  pending_request_space_ = request_space;
+
+  if (post_task) {
+    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+        FROM_HERE, base::Bind(&DownloadHandler::ExecuteFreeDiskSpaceIfNeededFor,
+                              weak_ptr_factory_.GetWeakPtr()),
+        free_disk_space_delay_);
+  }
+}
+
 void DownloadHandler::OnDownloadCreated(DownloadManager* manager,
                                         DownloadItem* download) {
+  FreeDiskSpaceIfNeeded(download, true /* immediate */);
+
   // Remove any persisted Drive DownloadItem. crbug.com/171384
   if (IsPersistedDriveDownload(drive_tmp_download_path_, download)) {
     // Remove download later, since doing it here results in a crash.
     BrowserThread::PostTask(BrowserThread::UI,
                             FROM_HERE,
                             base::Bind(&DownloadHandler::RemoveDownload,
                                        weak_ptr_factory_.GetWeakPtr(),
                                        static_cast<void*>(manager),
                                        download->GetId()));
   }
 }
 
 void DownloadHandler::RemoveDownload(void* manager_id, int id) {
   DownloadManager* manager = GetDownloadManager(manager_id);
   if (!manager)
     return;
   DownloadItem* download = manager->GetDownload(id);
   if (!download)
     return;
   download->Remove();
 }
 
 void DownloadHandler::OnDownloadUpdated(
     DownloadManager* manager, DownloadItem* download) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
+  FreeDiskSpaceIfNeeded(download, false /* not immediate */);
+
   // Only accept downloads that have the Drive meta data associated with them.
   DriveUserData* data = GetDriveUserData(download);
   if (!drive_tmp_download_path_.IsParent(download->GetTargetFilePath()) ||
       !data ||
       data->is_complete())
     return;
 
   switch (download->GetState()) {
     case DownloadItem::IN_PROGRESS:
       break;
@@ skipping 60 matching lines @@
     return;
   DownloadItem* download = manager->GetDownload(id);
   if (!download)
     return;
   DriveUserData* data = GetDriveUserData(download);
   if (!data)
     return;
   data->set_cache_file_path(*cache_file_path);
 }
 
+void DownloadHandler::ExecuteFreeDiskSpaceIfNeededFor() {
+  file_system_->FreeDiskSpaceIfNeededFor(
+      pending_request_space_,
+      base::Bind(&IgnoreFreeDiskSpaceIfNeededForCallback));
+
+  pending_request_space_ = 0;
+}
+
 DownloadManager* DownloadHandler::GetDownloadManager(void* manager_id) {
   if (manager_id == notifier_->GetManager())
     return notifier_->GetManager();
   if (notifier_incognito_ && manager_id == notifier_incognito_->GetManager())
     return notifier_incognito_->GetManager();
   return NULL;
 }
 
 }  // namespace drive