Lazily prune the multibuffer block cache.

media/blink/multibuffer.cc

Index: media/blink/multibuffer.cc
diff --git a/media/blink/multibuffer.cc b/media/blink/multibuffer.cc
index cc15b23cd591521774c1dfc722669a79aa3ea1b8..74bf40bce6043a46b8f4f5348ba0d07be17489cc 100644
--- a/media/blink/multibuffer.cc
+++ b/media/blink/multibuffer.cc
@@ -7,9 +7,17 @@
 #include "media/blink/multibuffer.h"
 
 #include "base/bind.h"
+#include "base/message_loop/message_loop.h"
 
 namespace media {
 
+// Prune 80 blocks per 30 seconds.
+// This means a full cache will go away in ~5 minutes.
+enum {
+  kBlockPruneInterval = 30,
+  kBlocksPrunedPerInterval = 80,
+};
+
 // Returns the block ID closest to (but less or equal than) |pos| from |index|.
 template <class T>
 static MultiBuffer::BlockId ClosestPreviousEntry(
@@ -42,7 +50,8 @@ static MultiBuffer::BlockId ClosestNextEntry(
 //
 // MultiBuffer::GlobalLRU
 //
-MultiBuffer::GlobalLRU::GlobalLRU() : max_size_(0), data_size_(0) {}
+MultiBuffer::GlobalLRU::GlobalLRU()
+    : max_size_(0), data_size_(0), background_pruning_active_(false) {}
 
 MultiBuffer::GlobalLRU::~GlobalLRU() {
   // By the time we're freed, all blocks should have been removed,
@@ -56,12 +65,14 @@ void MultiBuffer::GlobalLRU::Use(MultiBuffer* multibuffer,
                                  MultiBufferBlockId block_id) {
   GlobalBlockId id(multibuffer, block_id);
   lru_.Use(id);
+  SchedulePrune();
 }
 
 void MultiBuffer::GlobalLRU::Insert(MultiBuffer* multibuffer,
                                     MultiBufferBlockId block_id) {
   GlobalBlockId id(multibuffer, block_id);
   lru_.Insert(id);
+  SchedulePrune();
 }
 
 void MultiBuffer::GlobalLRU::Remove(MultiBuffer* multibuffer,
@@ -84,6 +95,26 @@ void MultiBuffer::GlobalLRU::IncrementDataSize(int64_t blocks) {
 void MultiBuffer::GlobalLRU::IncrementMaxSize(int64_t blocks) {
   max_size_ += blocks;
   DCHECK_GE(max_size_, 0);
+  SchedulePrune();
+}
+
+bool MultiBuffer::GlobalLRU::Pruneable() const {
+  return data_size_ > max_size_ && !lru_.Empty();
+}
+
+void MultiBuffer::GlobalLRU::SchedulePrune() {
+  if (Pruneable() && !background_pruning_active_) {
+    base::MessageLoop::current()->PostDelayedTask(
+        FROM_HERE, base::Bind(&MultiBuffer::GlobalLRU::PruneTask, this),
+        base::TimeDelta::FromSeconds(kBlockPruneInterval));
+    background_pruning_active_ = true;
+  }
+}
+
+void MultiBuffer::GlobalLRU::PruneTask() {
+  background_pruning_active_ = false;

[DaleCurtis, 2016/03/24 19:12:24]

This disables pruning on the first scheduled one and will stop if Use/Insert is
not called. That doesn't seem like it will continue to run pruning if insert/use
is not called.

[hubbe, 2016/03/24 20:57:40]

I renamed background_pruning_active_ to backround_pruning_pending_.
This doesn't disable background pruning, it just means that there no pending
call to this function anymore, which means that SchedulePrune() can schedule
another one.

+  Prune(kBlocksPrunedPerInterval);
+  SchedulePrune();
 }
 
 void MultiBuffer::GlobalLRU::Prune(int64_t max_to_free) {