Make chrome.fileManagerPrivate.getSizeStat return actual available space for Downloads.

chrome/browser/chromeos/extensions/file_manager/private_api_file_system.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/extensions/file_manager/private_api_file_system.h"
 
 #include <sys/statvfs.h>
 
 #include <algorithm>
 #include <set>
@@ skipping 65 matching lines @@
                                 uint64_t* total_size,
                                 uint64_t* remaining_size) {
   int64_t size = base::SysInfo::AmountOfTotalDiskSpace(mount_path);
   if (size >= 0)
     *total_size = size;
   size = base::SysInfo::AmountOfFreeDiskSpace(mount_path);
   if (size >= 0)
     *remaining_size = size;
 }
 
-// Used for OnCalculateEvictableCacheSize.
-using GetSizeStatsCallback =
-    base::Callback<void(const uint64_t* total_size,
-                        const uint64_t* remaining_space)>;
-
-// Calculates the real remaining size of Download volume and pass it to
-// GetSizeStatsCallback.
-void OnCalculateEvictableCacheSize(const GetSizeStatsCallback& callback,
-                                   uint64_t total_size,
-                                   uint64_t remaining_size,
-                                   int64_t evictable_cache_size) {
-  // For calculating real remaining size of Download volume
-  // - Adds evictable cache size since the space is available if they are
-  //   evicted.
-  // - Subtracts minimum free space of cryptohome since the space is not
-  //   available for file manager.
-  const uint64_t real_remaining_size =
-      std::max(static_cast<int64_t>(remaining_size + evictable_cache_size) -
-                   cryptohome::kMinFreeSpaceInBytes,
-               int64_t(0));
-  callback.Run(&total_size, &real_remaining_size);
-}
-
 // Retrieves the maximum file name length of the file system of |path|.
 // Returns 0 if it could not be queried.
 size_t GetFileNameMaxLengthOnBlockingPool(const std::string& path) {
   struct statvfs stat = {};
   if (HANDLE_EINTR(statvfs(path.c_str(), &stat)) != 0) {
     // The filesystem seems not supporting statvfs(). Assume it to be a commonly
     // used bound 255, and log the failure.
     LOG(ERROR) << "Cannot statvfs() the name length limit for: " << path;
     return 255;
   }
@@ skipping 346 matching lines @@
         storage_name,
         base::Bind(
             &FileManagerPrivateGetSizeStatsFunction::OnGetMtpAvailableSpace,
             this));
   } else {
     uint64_t* total_size = new uint64_t(0);
     uint64_t* remaining_size = new uint64_t(0);
     BrowserThread::PostBlockingPoolTaskAndReply(
         FROM_HERE, base::Bind(&GetSizeStatsOnBlockingPool, volume->mount_path(),
                               total_size, remaining_size),
-        base::Bind(
-            &FileManagerPrivateGetSizeStatsFunction::OnGetLocalSpace, this,
-            base::Owned(total_size), base::Owned(remaining_size),
-            volume->type() == file_manager::VOLUME_TYPE_DOWNLOADS_DIRECTORY));
+        base::Bind(&FileManagerPrivateGetSizeStatsFunction::OnGetSizeStats,
+                   this, base::Owned(total_size), base::Owned(remaining_size)));
   }
   return true;
 }
 
-void FileManagerPrivateGetSizeStatsFunction::OnGetLocalSpace(
-    uint64_t* total_size,
-    uint64_t* remaining_size,
-    bool is_download) {
-  drive::FileSystemInterface* const file_system =
-      drive::util::GetFileSystemByProfile(GetProfile());
-
-  if (!is_download || !file_system) {
-    OnGetSizeStats(total_size, remaining_size);
-    return;
-  }
-
-  // We need to add evictable cache size to the remaining size of Downloads
-  // volume if drive is available.
-  file_system->CalculateEvictableCacheSize(base::Bind(
-      &OnCalculateEvictableCacheSize,
-      base::Bind(&FileManagerPrivateGetSizeStatsFunction::OnGetSizeStats, this),
-      *total_size, *remaining_size));
-}
-
 void FileManagerPrivateGetSizeStatsFunction::OnGetDriveAvailableSpace(
     drive::FileError error,
     int64_t bytes_total,
     int64_t bytes_used) {
   if (error == drive::FILE_ERROR_OK) {
     const uint64_t bytes_total_unsigned = bytes_total;
     // bytes_used can be larger than bytes_total (over quota).
     const uint64_t bytes_remaining_unsigned =
         std::max(bytes_total - bytes_used, int64_t(0));
     OnGetSizeStats(&bytes_total_unsigned, &bytes_remaining_unsigned);
@@ skipping 481 matching lines @@
   return RespondLater();
 }
 
 void FileManagerPrivateInternalSetEntryTagFunction::OnSetEntryPropertyCompleted(
     drive::FileError result) {
   Respond(result == drive::FILE_ERROR_OK ? NoArguments()
                                          : Error("Failed to set a tag."));
 }
 
 }  // namespace extensions