Implement QuotaTemporaryStorageEvictor.

webkit/quota/quota_temporary_storage_evictor_unittest.cc

+// Copyright (c) 2011 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 "testing/gtest/include/gtest/gtest.h"
+
+#include <list>
+#include <map>
+
+#include "base/memory/scoped_ptr.h"
+#include "base/message_loop.h"
+#include "base/task.h"
+#include "webkit/quota/mock_storage_client.h"
+#include "webkit/quota/quota_temporary_storage_evictor.h"
+
+namespace quota {
+
+class QuotaTemporaryStorageEvictorTest;
+
+namespace {
+
+class MockQuotaEvictionHandler : public quota::QuotaEvictionHandler {
+ public:
+  MockQuotaEvictionHandler(QuotaTemporaryStorageEvictorTest *test)
+      : quota_(0),
+        available_space_(0),
+        test_(test) {}
+
+  virtual void EvictOriginData(
+      const GURL& origin,
+      StorageType type,
+      EvictOriginDataCallback* callback) OVERRIDE {
+    int64 origin_usage = EnsureOriginRemoved(origin);
+    if (origin_usage >= 0)
+      available_space_ += origin_usage;
+    callback->Run(quota::kQuotaStatusOk);
+    delete callback;
+  }
+
+  virtual void GetUsageAndQuotaForEviction(
+      GetUsageAndQuotaForEvictionCallback* callback) OVERRIDE {
+    if (task_for_get_usage_and_quota_.get())
+      task_for_get_usage_and_quota_->Run();
+    callback->Run(quota::kQuotaStatusOk, GetUsage(), quota_, available_space_);
+    delete callback;
+  }
+
+  virtual void GetLRUOrigin(
+      StorageType type,
+      GetLRUOriginCallback* callback) OVERRIDE {
+    if (origin_order_.empty())
+      callback->Run(GURL());
+    else
+      callback->Run(origin_order_.front());
+    delete callback;
+  }
+
+  int64 GetUsage() const {
+    int64 total_usage = 0;
+    for (std::map<GURL, int64>::const_iterator p = origins_.begin();
+         p != origins_.end();
+         ++p)
+      total_usage += p->second;
+    return total_usage;
+  }
+
+  void set_quota(int64 quota) {
+    quota_ = quota;
+  }
+  void set_available_space(int64 available_space) {
+    available_space_ = available_space;
+  }
+  void set_task_for_get_usage_and_quota(CancelableTask* task) {
+    task_for_get_usage_and_quota_.reset(task);
+  }
+
+  // Simulates an access to |origin|.  It reorders the internal LRU list.
+  // It internally uses AddOrigin().
+  void AccessOrigin(const GURL& origin) {
+    std::map<GURL, int64>::iterator found = origins_.find(origin);
+    EXPECT_NE(origins_.end(), found);
+    AddOrigin(origin, found->second);
+  }
+
+  // Simulates adding or overwriting the |origin| to the internal origin set
+  // with the |usage|.  It also adds or moves the |origin| to the end of the
+  // LRU list.
+  void AddOrigin(const GURL& origin, int64 usage) {
+    EnsureOriginRemoved(origin);
+    origin_order_.push_back(origin);
+    origins_[origin] = usage;
+  }
+
+ private:
+  int64 EnsureOriginRemoved(const GURL& origin) {
+    int64 origin_usage;
+    if (origins_.find(origin) == origins_.end())
+      return -1;
+    else
+      origin_usage = origins_[origin];
+
+    origins_.erase(origin);
+    origin_order_.remove(origin);
+    return origin_usage;
+  }
+
+  int64 quota_;
+  int64 available_space_;
+  std::list<GURL> origin_order_;
+  std::map<GURL, int64> origins_;
+
+  QuotaTemporaryStorageEvictorTest *test_;
+  scoped_ptr<CancelableTask> task_for_get_usage_and_quota_;
+};
+
+}  // anonymous namespace
+
+class QuotaTemporaryStorageEvictorTest : public testing::Test {
+ public:
+  QuotaTemporaryStorageEvictorTest()
+      : num_get_usage_and_quota_for_eviction_(0),
+        runnable_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {}
+
+  void SetUp() {
+    quota_eviction_handler_.reset(new MockQuotaEvictionHandler(this));
+
+    // Run repeatedly in the single RunAllPending() when interval_ms == 0

[kinuko, 2011/05/24 09:20:53]

nit: in the single -> in a single
nit: Run repeatedly -> Run multiple evictions ?

[Dai Mikurube (NOT FULLTIME), 2011/05/24 11:30:52]

Done.

+    temporary_storage_evictor_.reset(new QuotaTemporaryStorageEvictor(
+        quota_eviction_handler_.get(),
+        0, base::MessageLoopProxy::CreateForCurrentThread()));
+  }
+
+  void TearDown() {
+    temporary_storage_evictor_.reset();
+    quota_eviction_handler_.reset();
+    MessageLoop::current()->RunAllPending();
+  }
+
+  void TaskForRepeatTestAfterGetUsageAndQuota(
+      int e_size,

[kinuko, 2011/05/24 09:20:53]

Thanks for parameterizing the expected values.

The argument name 'e_size' won't have any meaningful indication to the readers. 
I think it'd look clearer if we do either: 
1. rename this variable to 'size_to_add_between_eviction' or something, or 
2. parameterize both of the origin name and size to be added and name it
'origin_to_be_added' or something meaningful  (e.g. replace 'int e_size' with
'const std::pair<GURL, int64>& origin_to_be_added').
I slightly prefer option 2.  Wdyt?

[Dai Mikurube (NOT FULLTIME), 2011/05/24 11:30:52]

Make sense.  Done 2.

+      int expected_usage_after_first,
+      int expected_usage_after_second) {
+    switch (num_get_usage_and_quota_for_eviction_) {
+    case 1:
+      EXPECT_EQ(expected_usage_after_first,
+                quota_eviction_handler()->GetUsage());
+      quota_eviction_handler()->AddOrigin(GURL("http://www.e.com"), e_size);
+      quota_eviction_handler()->AccessOrigin(GURL("http://www.c.com"));

[kinuko, 2011/05/24 09:20:53]

Here I'd wonder why we need to mix 'eviction-with-access-origin' and
'repeated-eviction' in a single test case?   Is this 'accessing origin' a
necessary part of the RepeatedEvictionTest?  (I might be missing something)

I'd imagine if we separate this into two tests like:

TEST_F(..., RepeatedEvictionTest)
TEST_F(..., EvictionWithAccessOrigin)   // (A)

We'd be able to easily know something has screwed up around AccessOrigin or
GetLRUOrigin if test (B) fails, while we may need to diagnose what part of the
test code went wrong when the current version of RepeatedEvictionTest fails.

[Dai Mikurube (NOT FULLTIME), 2011/05/24 11:30:52]

Ah, I understand.

1) I've tried separating them.  Such an 'eviction-with-access-origin' test looks
meaningful, however, only in repeated evictions.  AccessOrigin before the first
eviction results in a completely identical case with SimpleEvictionTest.

2) I tried separating them into the following two test cases :
* RepeatedEvictionWithAddOriginTest
* RepeatedEvictionWithAccessOriginTest.

The second test 'RepeatedEvictionWithAccessOriginTest' had no meaning since no
second eviction occurs without AddOrigin.

Finally, I found it is required to do AddOrigin and AccessOrigin in the same
case in order to test changing the order in the LRU list (AccessOrigin).


My final decision is :
* RepeatedEvictionTest : does only AddOrigin().
* RepeatedEvictionWithAccessOriginTest : does AddOrigin() and AccessOrigin().

What do you think?

[kinuko, 2011/05/24 12:46:48]

I imagined a separate test doing AccessOrigin between two manually-kicked
eviction (without setting repeated_eviction true) but your current approach
would work too.

+      break;
+    case 2:
+      EXPECT_EQ(expected_usage_after_second,
+                quota_eviction_handler()->GetUsage());
+      temporary_storage_evictor()->set_repeated_eviction(false);
+      break;
+    }
+    ++num_get_usage_and_quota_for_eviction_;
+  }
+
+ protected:
+  MockQuotaEvictionHandler* quota_eviction_handler() const {
+    return static_cast<MockQuotaEvictionHandler*>(
+        quota_eviction_handler_.get());
+  }
+
+  QuotaTemporaryStorageEvictor* temporary_storage_evictor() const {
+    return temporary_storage_evictor_.get();
+  }
+
+  int num_get_usage_and_quota_for_eviction() const {
+    return num_get_usage_and_quota_for_eviction_;
+  }
+
+  int64 default_min_available_disk_space_to_start_eviction() const {
+    return QuotaTemporaryStorageEvictor::
+        kDefaultMinAvailableDiskSpaceToStartEviction;
+  }
+
+  scoped_ptr<QuotaEvictionHandler> quota_eviction_handler_;
+  scoped_ptr<QuotaTemporaryStorageEvictor> temporary_storage_evictor_;
+
+  int num_get_usage_and_quota_for_eviction_;
+
+  ScopedRunnableMethodFactory<QuotaTemporaryStorageEvictorTest>
+      runnable_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(QuotaTemporaryStorageEvictorTest);
+};
+
+TEST_F(QuotaTemporaryStorageEvictorTest, SimpleEvictionTest) {
+  quota_eviction_handler()->AddOrigin(GURL("http://www.z.com"), 3000);
+  quota_eviction_handler()->AddOrigin(GURL("http://www.y.com"), 200);
+  quota_eviction_handler()->AddOrigin(GURL("http://www.x.com"), 500);
+  quota_eviction_handler()->set_quota(4000);
+  quota_eviction_handler()->set_available_space(1000000000);
+  EXPECT_EQ(3700, quota_eviction_handler()->GetUsage());
+  temporary_storage_evictor()->Start();
+  MessageLoop::current()->RunAllPending();
+  EXPECT_EQ(700, quota_eviction_handler()->GetUsage());
+}
+
+TEST_F(QuotaTemporaryStorageEvictorTest, MultipleEvictionTest) {
+  quota_eviction_handler()->AddOrigin(GURL("http://www.z.com"), 20);
+  quota_eviction_handler()->AddOrigin(GURL("http://www.y.com"), 2900);
+  quota_eviction_handler()->AddOrigin(GURL("http://www.x.com"), 450);
+  quota_eviction_handler()->AddOrigin(GURL("http://www.w.com"), 400);
+  quota_eviction_handler()->set_quota(4000);
+  quota_eviction_handler()->set_available_space(1000000000);
+  EXPECT_EQ(3770, quota_eviction_handler()->GetUsage());
+  temporary_storage_evictor()->Start();
+  MessageLoop::current()->RunAllPending();
+  EXPECT_EQ(850, quota_eviction_handler()->GetUsage());
+}
+
+TEST_F(QuotaTemporaryStorageEvictorTest, RepeatedEvictionTest) {
+  const int64 a_size = 400;
+  const int64 b_size = 150;
+  const int64 c_size = 120;
+  const int64 d_size = 292;
+  const int64 initial_total_size = a_size + b_size + c_size + d_size;
+  const int64 e_size = 275;
+
+  quota_eviction_handler()->AddOrigin(GURL("http://www.d.com"), d_size);
+  quota_eviction_handler()->AddOrigin(GURL("http://www.c.com"), c_size);
+  quota_eviction_handler()->AddOrigin(GURL("http://www.b.com"), b_size);
+  quota_eviction_handler()->AddOrigin(GURL("http://www.a.com"), a_size);
+  quota_eviction_handler()->set_quota(1000);
+  quota_eviction_handler()->set_available_space(1000000000);
+  quota_eviction_handler()->set_task_for_get_usage_and_quota(
+      runnable_factory_.NewRunnableMethod(&QuotaTemporaryStorageEvictorTest::
+          TaskForRepeatTestAfterGetUsageAndQuota,
+          e_size,
+          initial_total_size - d_size,
+          initial_total_size - d_size + e_size - b_size));
+  EXPECT_EQ(initial_total_size, quota_eviction_handler()->GetUsage());
+  temporary_storage_evictor()->set_repeated_eviction(true);
+  temporary_storage_evictor()->Start();
+  MessageLoop::current()->RunAllPending();
+  EXPECT_EQ(initial_total_size - d_size + e_size - b_size - a_size,
+            quota_eviction_handler()->GetUsage());
+  EXPECT_EQ(4, num_get_usage_and_quota_for_eviction());
+}
+
+TEST_F(QuotaTemporaryStorageEvictorTest, DiskSpaceEvictionTest) {
+  quota_eviction_handler()->AddOrigin(GURL("http://www.z.com"), 294);
+  quota_eviction_handler()->AddOrigin(GURL("http://www.y.com"), 120);
+  quota_eviction_handler()->AddOrigin(GURL("http://www.x.com"), 150);
+  quota_eviction_handler()->AddOrigin(GURL("http://www.w.com"), 300);
+  quota_eviction_handler()->set_quota(10000);
+  quota_eviction_handler()->set_available_space(
+      default_min_available_disk_space_to_start_eviction() - 350);
+  EXPECT_EQ(864, quota_eviction_handler()->GetUsage());
+  temporary_storage_evictor()->Start();
+  MessageLoop::current()->RunAllPending();
+  EXPECT_EQ(450, quota_eviction_handler()->GetUsage());
+}
+
+}  // namespace quota