Lazily prune the multibuffer block cache.

media/blink/multibuffer_unittest.cc

 // Copyright 2015 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 <stddef.h>
 #include <stdint.h>
 
 #include <deque>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/message_loop/message_loop.h"
+#include "base/test/simple_test_tick_clock.h"
+#include "media/base/fake_single_thread_task_runner.h"
 #include "media/base/test_random.h"
 #include "media/blink/multibuffer.h"
 #include "media/blink/multibuffer_reader.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 const int kBlockSizeShift = 8;
 const size_t kBlockSize = 1UL << kBlockSizeShift;
 
 namespace media {
 
@@ skipping 188 matching lines @@
   int32_t max_blocks_after_defer_;
   bool must_read_whole_file_;
   int32_t writers_created_;
   TestRandom* rnd_;
 };
 
 class MultiBufferTest : public testing::Test {
  public:
   MultiBufferTest()
       : rnd_(42),
-        lru_(new MultiBuffer::GlobalLRU()),
+        task_runner_(new FakeSingleThreadTaskRunner(&clock_)),
+        lru_(new MultiBuffer::GlobalLRU(task_runner_)),
         multibuffer_(kBlockSizeShift, lru_, &rnd_) {}
 
+  void TearDown() override {
+    // Make sure we have nothing left to prune.
+    lru_->Prune(1000000);
+    // Run the outstanding callback to make sure everything is freed.
+    task_runner_->Sleep(base::TimeDelta::FromSeconds(30));
+  }
+
   void Advance() {
     CHECK(writers.size());
     writers[rnd_.Rand() % writers.size()]->Advance();
   }
 
   bool AdvanceAll() {
     bool advanced = false;
     for (size_t i = 0; i < writers.size(); i++) {
       advanced |= writers[i]->Advance();
     }
     multibuffer_.CheckLRUState();
     return advanced;
   }
 
  protected:
   TestRandom rnd_;
+  base::SimpleTestTickClock clock_;
+  scoped_refptr<FakeSingleThreadTaskRunner> task_runner_;
   scoped_refptr<MultiBuffer::GlobalLRU> lru_;
   TestMultiBuffer multibuffer_;
+
+  // TODO(hubbe): Make MultiBufferReader take a task_runner_
   base::MessageLoop message_loop_;
 };
 
 TEST_F(MultiBufferTest, ReadAll) {
   multibuffer_.SetMaxWriters(1);
   size_t pos = 0;
   size_t end = 10000;
   multibuffer_.SetFileSize(10000);
   multibuffer_.SetMustReadWholeFile(true);
   MultiBufferReader reader(&multibuffer_, pos, end,
@@ skipping 128 matching lines @@
   lru_->Prune(3);
   current_size -= 3;
   EXPECT_EQ(current_size, lru_->Size());
   lru_->Prune(3);
   current_size -= 3;
   EXPECT_EQ(current_size, lru_->Size());
   lru_->Prune(1000);
   EXPECT_EQ(0, lru_->Size());
 }
 
+TEST_F(MultiBufferTest, LRUTestExpirationTest) {
+  int64_t max_size = 17;
+  int64_t current_size = 0;
+  lru_->IncrementMaxSize(max_size);
+
+  multibuffer_.SetMaxWriters(1);
+  size_t pos = 0;
+  size_t end = 10000;
+  multibuffer_.SetFileSize(10000);
+  MultiBufferReader reader(&multibuffer_, pos, end,
+                           base::Callback<void(int64_t, int64_t)>());
+  reader.SetPreload(10000, 10000);
+  // Note, no pinning, all data should end up in LRU.
+  EXPECT_EQ(current_size, lru_->Size());
+  current_size += max_size;
+  while (AdvanceAll()) {
+  }
+  EXPECT_EQ(current_size, lru_->Size());
+  EXPECT_FALSE(lru_->Pruneable());
+
+  // Make 3 packets pruneable.
+  lru_->IncrementMaxSize(-3);
+  max_size -= 3;
+
+  // There should be no change after 29 seconds.
+  task_runner_->Sleep(base::TimeDelta::FromSeconds(29));
+  EXPECT_EQ(current_size, lru_->Size());
+  EXPECT_TRUE(lru_->Pruneable());
+
+  // After 30 seconds, pruning should have happened.
+  task_runner_->Sleep(base::TimeDelta::FromSeconds(30));
+  current_size -= 3;
+  EXPECT_EQ(current_size, lru_->Size());
+  EXPECT_FALSE(lru_->Pruneable());
+
+  // Make the rest of the packets pruneable.
+  lru_->IncrementMaxSize(-max_size);
+
+  // After another 30 seconds, everything should be pruned.
+  task_runner_->Sleep(base::TimeDelta::FromSeconds(30));
+  EXPECT_EQ(0, lru_->Size());
+  EXPECT_FALSE(lru_->Pruneable());
+}
+
 class ReadHelper {
  public:
   ReadHelper(size_t end,
              size_t max_read_size,
              MultiBuffer* multibuffer,
              TestRandom* rnd)
       : pos_(0),
         end_(end),
         max_read_size_(max_read_size),
         read_size_(0),
@@ skipping 106 matching lines @@
     multibuffer_.CheckLRUState();
   }
   multibuffer_.CheckPresentState();
   while (!read_helpers.empty()) {
     delete read_helpers.back();
     read_helpers.pop_back();
   }
 }
 
 }  // namespace media