Add memory pressure listener to Blob storage

storage/browser/blob/blob_memory_controller_unittest.cc

 // 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.
 
 #include "storage/browser/blob/blob_memory_controller.h"
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 15 matching lines @@
 using base::TestSimpleTaskRunner;
 using ItemState = ShareableBlobDataItem::State;
 using QuotaAllocationTask = BlobMemoryController::QuotaAllocationTask;
 
 const std::string kBlobStorageDirectory = "blob_storage";
 const size_t kTestBlobStorageIPCThresholdBytes = 20;
 const size_t kTestBlobStorageMaxSharedMemoryBytes = 50;
 const size_t kTestBlobStorageMaxBlobMemorySize = 500;
 const uint64_t kTestBlobStorageMaxDiskSpace = 1000;
 const uint64_t kTestBlobStorageMinFileSizeBytes = 10;
+const float kTestBlobStorageMinFileSizeBytesUnderPressure = 0.004;
 const uint64_t kTestBlobStorageMaxFileSizeBytes = 100;
 
 const uint64_t kTestSmallBlobStorageMaxDiskSpace = 100;
 
 static int64_t sFakeDiskSpace = 0;
 static bool sFakeDiskSpaceCalled = true;
 
 int64_t FakeDiskSpaceMethod(const base::FilePath& path) {
   EXPECT_FALSE(sFakeDiskSpaceCalled);
   sFakeDiskSpaceCalled = true;
@@ skipping 38 matching lines @@
   }
 
   void SetTestMemoryLimits(BlobMemoryController* controller) {
     BlobStorageLimits limits;
     limits.max_ipc_memory_size = kTestBlobStorageIPCThresholdBytes;
     limits.max_shared_memory_size = kTestBlobStorageMaxSharedMemoryBytes;
     limits.max_blob_in_memory_space = kTestBlobStorageMaxBlobMemorySize;
     limits.desired_max_disk_space = kTestBlobStorageMaxDiskSpace;
     limits.effective_max_disk_space = kTestBlobStorageMaxDiskSpace;
     limits.min_page_file_size = kTestBlobStorageMinFileSizeBytes;
+    limits.min_page_file_size_ratio_under_pressure =
+        kTestBlobStorageMinFileSizeBytesUnderPressure;
     limits.max_file_size = kTestBlobStorageMaxFileSizeBytes;
     controller->set_limits_for_testing(limits);
   }
 
   void SetSmallDiskTestMemoryLimits(BlobMemoryController* controller) {
     BlobStorageLimits limits;
     limits.max_ipc_memory_size = kTestBlobStorageIPCThresholdBytes;
     limits.max_shared_memory_size = kTestBlobStorageMaxSharedMemoryBytes;
     limits.max_blob_in_memory_space = kTestBlobStorageMaxBlobMemorySize;
     limits.desired_max_disk_space = kTestSmallBlobStorageMaxDiskSpace;
     limits.effective_max_disk_space = kTestSmallBlobStorageMaxDiskSpace;
     limits.min_page_file_size = kTestBlobStorageMinFileSizeBytes;
+    limits.min_page_file_size_ratio_under_pressure =
+        kTestBlobStorageMinFileSizeBytesUnderPressure;
     limits.max_file_size = kTestBlobStorageMaxFileSizeBytes;
     controller->set_limits_for_testing(limits);
   }
 
   void SaveFileCreationInfo(std::vector<FileCreationInfo> info, bool success) {
     file_quota_result_ = success;
     if (success) {
       files_created_.swap(info);
     }
   }
@@ skipping 997 matching lines @@
   set_disk_space(-1ll);
 
   RunFileThreadTasks();
   ExpectDiskSpaceCalled();
   base::RunLoop().RunUntilIdle();
 
   // Check the effective limit is constrained.
   EXPECT_FALSE(controller.limits().IsDiskSpaceConstrained());
 }
 
+TEST_F(BlobMemoryControllerTest, OnMemoryPressure) {
+  BlobMemoryController controller(temp_dir_.GetPath(), file_runner_);
+  SetTestMemoryLimits(&controller);
+  AssertEnoughDiskSpace();
+
+  char kData[1];
+  kData[0] = 'e';
+
+  std::vector<scoped_refptr<ShareableBlobDataItem>> small_items;
+  size_t size_to_load = 2 * kTestBlobStorageMaxBlobMemorySize *
+                            kTestBlobStorageMinFileSizeBytesUnderPressure +
+                        1;
+  // 2 * kTestBlobStorageMinFileSizeBytesUnderPressure is less than
+  // 2 * kTestBlobStorageMinFileSizeBytes.
+  for (size_t i = 0; i < size_to_load; i++) {
+    BlobDataBuilder builder("fake");
+    builder.AppendData(kData, 1);
+    std::vector<scoped_refptr<ShareableBlobDataItem>> items =
+        CreateSharedDataItems(builder);
+    base::WeakPtr<QuotaAllocationTask> memory_task =
+        controller.ReserveMemoryQuota(items, GetMemoryRequestCallback());
+    EXPECT_FALSE(memory_task);
+    items[0]->set_state(ItemState::POPULATED_WITH_QUOTA);
+    small_items.insert(small_items.end(), items.begin(), items.end());
+  }
+  controller.NotifyMemoryItemsUsed(small_items);
+  EXPECT_FALSE(file_runner_->HasPendingTask());
+  EXPECT_EQ(size_to_load, controller.memory_usage());
+
+  controller.OnMemoryPressure(
+      base::MemoryPressureListener::MemoryPressureLevel::
+          MEMORY_PRESSURE_LEVEL_CRITICAL);
+
+  EXPECT_TRUE(file_runner_->HasPendingTask());
+  RunFileThreadTasks();
+
+  base::RunLoop().RunUntilIdle();
+
+  EXPECT_EQ(1u, controller.memory_usage());
+  EXPECT_EQ(size_to_load - 1, controller.disk_usage());
+  return;
+}
+
 }  // namespace storage