Add memory pressure listener to Blob 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_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/gtest_prod_util.h"
 #include "base/macros.h"
+#include "base/memory/memory_pressure_listener.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;
 }
@@ skipping 136 matching lines @@
   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;
 
+  FRIEND_TEST_ALL_PREFIXES(BlobMemoryControllerTest, OnMemoryPressure);
   // 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);
+      std::vector<scoped_refptr<ShareableBlobDataItem>>* output,
+      uint64_t min_page_file_size);
 
   // Schedule paging until our memory usage is below our memory limit.
-  void MaybeScheduleEvictionUntilSystemHealthy();
+  void MaybeScheduleEvictionUntilSystemHealthy(bool on_memory_pressure);

[dmurph, 2017/05/09 21:57:33]

Please make the argument MemoryPressureLevel instead of a bool.

[ssid, 2017/05/10 00:21:38]

Done.

 
   // 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,
-      std::pair<FileCreationInfo, int64_t /* disk_avail */> result);
+      const char* evict_reason,
+      size_t memory_usage_before_eviction,
+      std::pair<FileCreationInfo, int64_t /* avail_disk */> result);
+
+  void OnMemoryPressure(
+      base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level);
 
   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
@@ skipping 28 matching lines @@
   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_;
+  base::TimeTicks last_eviction_time_;
 
   // 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::MemoryPressureListener memory_pressure_listener_;
+
   base::WeakPtrFactory<BlobMemoryController> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(BlobMemoryController);
 };
 }  // namespace storage
 #endif  // STORAGE_BROWSER_BLOB_BLOB_MEMORY_CONTROLLER_H_