[BlobStorage] Enabling disk paging and direct storage.

storage/browser/blob/blob_memory_controller.h

 // Copyright 2016 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.
 
 #ifndef STORAGE_BROWSER_BLOB_BLOB_MEMORY_CONTROLLER_H_
 #define STORAGE_BROWSER_BLOB_BLOB_MEMORY_CONTROLLER_H_
 
 #include <stdint.h>
 
 #include <list>
 #include <map>
 #include <memory>
 #include <string>
 #include <unordered_map>
 #include <unordered_set>
 #include <utility>
 #include <vector>
 
-#include "base/callback.h"
+#include "base/callback_forward.h"
 #include "base/callback_helpers.h"
 #include "base/containers/mru_cache.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/optional.h"
 #include "base/time/time.h"
 #include "storage/browser/storage_browser_export.h"
 #include "storage/common/blob_storage/blob_storage_constants.h"
 
 namespace base {
 class TaskRunner;
 }
 
+namespace content {
+class ChromeBlobStorageContext;
+}
+
 namespace storage {
 class ShareableBlobDataItem;
 class ShareableFileReference;
 
 // This class's main responsibility is deciding how blob data gets stored.
 // This encompasses:
 // * Keeping track of memory & file quota,
 // * How to transport the blob data from the renderer (DetermineStrategy),
 // * Allocating memory & file quota (ReserveMemoryQuota, ReserveFileQuota)
 // * Paging memory quota to disk when we're nearing our memory limit, and
@@ skipping 103 matching lines @@
       std::vector<scoped_refptr<ShareableBlobDataItem>> unreserved_file_items,
       const FileQuotaRequestCallback& done_callback);
 
   // Called when initially populated or upon later access.
   void NotifyMemoryItemsUsed(
       const std::vector<scoped_refptr<ShareableBlobDataItem>>& items);
 
   size_t memory_usage() const { return blob_memory_used_; }
   uint64_t disk_usage() const { return disk_used_; }
 
+  base::WeakPtr<BlobMemoryController> GetWeakPtr();
+
   const BlobStorageLimits& limits() const { return limits_; }
   void set_limits_for_testing(const BlobStorageLimits& limits) {
+    manual_limits_set_ = true;
     limits_ = limits;
   }
 
+  using DiskSpaceFuncPtr = int64_t (*)(const base::FilePath&);
+
+  void set_testing_disk_space(DiskSpaceFuncPtr disk_space_function) {
+    disk_space_function_ = disk_space_function;
+  }
+
  private:
   class FileQuotaAllocationTask;
   class MemoryQuotaAllocationTask;
 
+  // So this (and only this) class can call CalculateBlobStorageLimits().
+  friend class content::ChromeBlobStorageContext;
+
+  // Schedules a task on the file runner to calculate blob storage quota limits.
+  // This should only be called once per storage partition initialization as we
+  // emit UMA stats with that expectation.
+  void CalculateBlobStorageLimits();
+
   using PendingMemoryQuotaTaskList =
       std::list<std::unique_ptr<MemoryQuotaAllocationTask>>;
   using PendingFileQuotaTaskList =
       std::list<std::unique_ptr<FileQuotaAllocationTask>>;
 
+  void OnStorageLimitsCalculated(BlobStorageLimits limits);
+
+  // Adjusts the effective disk usage based on the available space. We try to
+  // keep at least BlobSorageLimits::min_available_disk_space() free.
+  void AdjustDiskUsage(uint64_t avail_disk_space);
+
   base::WeakPtr<QuotaAllocationTask> AppendMemoryTask(
       uint64_t total_bytes_needed,
       std::vector<scoped_refptr<ShareableBlobDataItem>> unreserved_memory_items,
       const MemoryQuotaRequestCallback& done_callback);
 
   void MaybeGrantPendingMemoryRequests();
 
   size_t CollectItemsForEviction(
       std::vector<scoped_refptr<ShareableBlobDataItem>>* output);
 
   // Schedule paging until our memory usage is below our memory limit.
   void MaybeScheduleEvictionUntilSystemHealthy();
 
   // Called when we've completed evicting a list of items to disk. This is where
   // we swap the bytes items for file items, and update our bookkeeping.
   void OnEvictionComplete(
       scoped_refptr<ShareableFileReference> file_reference,
       std::vector<scoped_refptr<ShareableBlobDataItem>> items,
       size_t total_items_size,
-      FileCreationInfo result);
+      std::pair<FileCreationInfo, int64_t /* disk_avail */> result);
 
   size_t GetAvailableMemoryForBlobs() const;
   uint64_t GetAvailableFileSpaceForBlobs() const;
 
   void GrantMemoryAllocations(
       std::vector<scoped_refptr<ShareableBlobDataItem>>* items,
       size_t total_bytes);
   void RevokeMemoryAllocation(uint64_t item_id, size_t length);
 
   // This is registered as a callback for file deletions on the file reference
   // of our paging files. We decrement the disk space used.
   void OnBlobFileDelete(uint64_t size, const base::FilePath& path);
 
   base::FilePath GenerateNextPageFileName();
 
   // This records diagnostic counters of our memory quotas. Called when usage
   // changes.
   void RecordTracingCounters() const;
 
+  // Store that we set manual limits so we don't accidentally override them with
+  // our configuration task.
+  bool manual_limits_set_ = false;
   BlobStorageLimits limits_;
 
   // Memory bookkeeping. These numbers are all disjoint.
   // This is the amount of memory we're using for blobs in RAM, including the
   // in_flight_memory_used_.
   size_t blob_memory_used_ = 0;
   // This is memory we're temporarily using while we try to write blob items to
   // disk.
   size_t in_flight_memory_used_ = 0;
   // This is the amount of memory we're using on disk.
   uint64_t disk_used_ = 0;
 
   // State for GenerateNextPageFileName.
   uint64_t current_file_num_ = 0;
 
   size_t pending_memory_quota_total_size_ = 0;
   PendingMemoryQuotaTaskList pending_memory_quota_tasks_;
   PendingFileQuotaTaskList pending_file_quota_tasks_;
 
   int pending_evictions_ = 0;
 
   bool file_paging_enabled_ = false;
   base::FilePath blob_storage_dir_;
   scoped_refptr<base::TaskRunner> file_runner_;
+  // This defaults to calling base::SysInfo::AmountOfFreeDiskSpace.
+  DiskSpaceFuncPtr disk_space_function_;
 
   // Lifetime of the ShareableBlobDataItem objects is handled externally in the
   // BlobStorageContext class.
   base::MRUCache<uint64_t, ShareableBlobDataItem*> populated_memory_items_;
   size_t populated_memory_items_bytes_ = 0;
   // We need to keep track of items currently being paged to disk so that if
   // another blob successfully grabs a ref, we can prevent it from adding the
   // item to the recent_item_cache_ above.
   std::unordered_set<uint64_t> items_paging_to_file_;
 
   base::WeakPtrFactory<BlobMemoryController> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(BlobMemoryController);
 };
 }  // namespace storage
 #endif  // STORAGE_BROWSER_BLOB_BLOB_MEMORY_CONTROLLER_H_