Move implementation of QuotaManager.getVolumeInfo to base::SysInfo.

storage/browser/quota/quota_manager.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 "storage/browser/quota/quota_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 18 matching lines @@
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "net/base/url_util.h"
 #include "storage/browser/quota/client_usage_tracker.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
 #include "storage/browser/quota/quota_temporary_storage_evictor.h"
 #include "storage/browser/quota/storage_monitor.h"
 #include "storage/browser/quota/usage_tracker.h"
 #include "storage/common/quota/quota_types.h"
 
-// Platform specific includes for GetVolumeInfo().
-#if defined(OS_WIN)
-#include <windows.h>
-#elif defined(OS_POSIX)
-#if defined(OS_ANDROID)
-#include <sys/vfs.h>
-#define statvfs statfs  // Android uses a statvfs-like statfs struct and call.
-#else
-#include <sys/statvfs.h>
-#endif
-#endif
-
 #define UMA_HISTOGRAM_MBYTES(name, sample)          \
   UMA_HISTOGRAM_CUSTOM_COUNTS(                      \
       (name), static_cast<int>((sample) / kMBytes), \
       1, 10 * 1024 * 1024 /* 10TB */, 100)
 
 namespace storage {
 
 namespace {
 
 const int64_t kMBytes = 1024 * 1024;
@@ skipping 822 matching lines @@
       profile_path_(profile_path),
       proxy_(new QuotaManagerProxy(this, io_thread)),
       db_disabled_(false),
       eviction_disabled_(false),
       io_thread_(io_thread),
       db_thread_(db_thread),
       is_getting_eviction_origin_(false),
       temporary_quota_initialized_(false),
       temporary_quota_override_(-1),
       special_storage_policy_(special_storage_policy),
-      get_volume_info_fn_(&QuotaManager::GetVolumeInfo),
+      get_volume_info_fn_(&base::SysInfo::GetDiskSpaceInfo),
       storage_monitor_(new StorageMonitor(this)),
       weak_factory_(this) {}
 
 void QuotaManager::GetUsageInfo(const GetUsageInfoCallback& callback) {
   LazyInitialize();
   GetUsageInfoTask* get_usage_info = new GetUsageInfoTask(this, callback);
   get_usage_info->Start();
 }
 
 void QuotaManager::GetUsageAndQuotaForWebApps(
@@ skipping 755 matching lines @@
   GetUsageTracker(kStorageTypeTemporary)
       ->GetGlobalLimitedUsage(dispatcher->GetGlobalLimitedUsageCallback());
   GetTemporaryGlobalQuota(dispatcher->GetQuotaCallback());
   GetAvailableSpace(dispatcher->GetAvailableSpaceCallback());
   dispatcher->WaitForResults(callback);
 }
 
 void QuotaManager::AsyncGetVolumeInfo(
     const VolumeInfoCallback& callback) {
   DCHECK(io_thread_->BelongsToCurrentThread());
-  uint64_t* available_space = new uint64_t(0);
-  uint64_t* total_space = new uint64_t(0);
+  int64_t* available_space = new int64_t(0);
+  int64_t* total_space = new int64_t(0);
   PostTaskAndReplyWithResult(
       db_thread_.get(),
       FROM_HERE,
       base::Bind(get_volume_info_fn_,
                  profile_path_,
                  base::Unretained(available_space),
                  base::Unretained(total_space)),
       base::Bind(&QuotaManager::DidGetVolumeInfo,
                  weak_factory_.GetWeakPtr(),
                  callback,
                  base::Owned(available_space),
                  base::Owned(total_space)));
 }
 
 void QuotaManager::DidGetVolumeInfo(
     const VolumeInfoCallback& callback,
-    uint64_t* available_space, uint64_t* total_space, bool success) {
+    int64_t* available_space, int64_t* total_space, bool success) {
   DCHECK(io_thread_->BelongsToCurrentThread());
   callback.Run(success, *available_space, *total_space);
 }
 
 void QuotaManager::GetLRUOrigin(StorageType type,
                                 const GetOriginCallback& callback) {
   LazyInitialize();
   // This must not be called while there's an in-flight task.
   DCHECK(lru_origin_callback_.is_null());
   lru_origin_callback_ = callback;
@@ skipping 140 matching lines @@
 // static
 int64_t QuotaManager::CallGetAmountOfFreeDiskSpace(
     GetVolumeInfoFn get_volume_info_fn,
     const base::FilePath& profile_path) {
   // crbug.com/349708
   TRACE_EVENT0("io", "CallSystemGetAmountOfFreeDiskSpace");
   if (!base::CreateDirectory(profile_path)) {
     LOG(WARNING) << "Create directory failed for path" << profile_path.value();
     return 0;
   }
-  uint64_t available, total;
+  int64_t available, total;
   if (!get_volume_info_fn(profile_path, &available, &total)) {
     return 0;
   }
   UMA_HISTOGRAM_MBYTES("Quota.AvailableDiskSpace", available);
   UMA_HISTOGRAM_MBYTES("Quota.TotalDiskSpace", total);
   return static_cast<int64_t>(available);
 }
 
-//static
-bool QuotaManager::GetVolumeInfo(const base::FilePath& path,
-                                 uint64_t* available_space,
-                                 uint64_t* total_size) {
-  // Inspired by similar code in the base::SysInfo class.
-  base::ThreadRestrictions::AssertIOAllowed();
-#if defined(OS_WIN)
-  ULARGE_INTEGER available, total, free;
-  if (!GetDiskFreeSpaceExW(path.value().c_str(), &available, &total, &free))
-    return false;
-  *available_space = static_cast<uint64_t>(available.QuadPart);
-  *total_size = static_cast<uint64_t>(total.QuadPart);
-#elif defined(OS_POSIX)
-  struct statvfs stats;
-  if (HANDLE_EINTR(statvfs(path.value().c_str(), &stats)) != 0)
-    return false;
-  *available_space = static_cast<uint64_t>(stats.f_bavail) * stats.f_frsize;
-  *total_size = static_cast<uint64_t>(stats.f_blocks) * stats.f_frsize;
-#else
-#error Not implemented
-#endif
-  return true;
-}
-
 }  // namespace storage