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"};
 
+// Longer is better. But at the same time, this value should be short enough as
+// drive::internal::kMinFreeSpaceInBytes is not used up by file download in this
+// interval.
+const base::TimeDelta kFreeDiskSpaceDelay = base::TimeDelta::FromSeconds(3);
+
 // 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) {
-}
+      has_pending_free_disk_space_(false),
+      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;
+}
+
+int64 DownloadHandler::CalculateRequestSpace(
+    const DownloadManager::DownloadVector& downloads) {
+  int64 request_space = 0;
+
+  for (const auto* download : downloads) {
+    if (download->IsDone())
+      continue;
+
+    const int64 total_bytes = download->GetTotalBytes();
+    // Skip unknown size download. Since drive cache tries to keep
+    // drive::internal::kMinFreeSpaceInBytes, we can continue download with
+    // using the space temporally.
+    if (total_bytes == 0)
+      continue;
+
+    request_space += total_bytes - download->GetReceivedBytes();
+  }
+
+  return request_space;
+}
+
+void DownloadHandler::FreeDiskSpaceIfNeeded() {
+  if (has_pending_free_disk_space_)
+    return;
+
+  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+      FROM_HERE, base::Bind(&DownloadHandler::FreeDiskSpaceIfNeededImmediately,
+                            weak_ptr_factory_.GetWeakPtr()),
+      free_disk_space_delay_);
+
+  has_pending_free_disk_space_ = true;
+}
+
+void DownloadHandler::FreeDiskSpaceIfNeededImmediately() {
+  DownloadManager::DownloadVector downloads;
+
+  // Get all downloads of current profile and its off-the-record profile.
+  // TODO(yawano): support multi profiles.
+  if (notifier_ && notifier_->GetManager()) {
+    notifier_->GetManager()->GetAllDownloads(&downloads);
+  }
+  if (notifier_incognito_ && notifier_incognito_->GetManager()) {
+    notifier_incognito_->GetManager()->GetAllDownloads(&downloads);
+  }
+
+  // Free disk space even if request size is 0 byte in order to make drive cache
+  // keep drive::internal::kMinFreeSpaceInBytes.
+  file_system_->FreeDiskSpaceIfNeededFor(
+      CalculateRequestSpace(downloads),
+      base::Bind(&IgnoreFreeDiskSpaceIfNeededForCallback));
+
+  has_pending_free_disk_space_ = false;
+}
+
 void DownloadHandler::OnDownloadCreated(DownloadManager* manager,
                                         DownloadItem* download) {
+  FreeDiskSpaceIfNeededImmediately();
+
   // 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();
+
   // 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 69 matching lines @@
 
 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