2nd try: Implement QM::GetOriginsModifiedSince for browser data deleter support

webkit/quota/quota_manager_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 <set>
 #include <sstream>
 #include <vector>
 
 #include "base/file_util.h"
 #include "base/memory/scoped_callback_factory.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/scoped_temp_dir.h"
 #include "base/stl_util-inl.h"
@@ skipping 15 matching lines @@
 namespace quota {
 
 // For shorter names.
 const StorageType kTemp = kStorageTypeTemporary;
 const StorageType kPerm = kStorageTypePersistent;
 
 class QuotaManagerTest : public testing::Test {
  protected:
   typedef QuotaManager::QuotaTableEntry QuotaTableEntry;
   typedef QuotaManager::QuotaTableEntries QuotaTableEntries;
-  typedef QuotaManager::LastAccessTimeTableEntry LastAccessTimeTableEntry;
-  typedef QuotaManager::LastAccessTimeTableEntries LastAccessTimeTableEntries;
+  typedef QuotaManager::OriginInfoTableEntries OriginInfoTableEntries;
 
  public:
   QuotaManagerTest()
       : callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
-        virtual_time_counter_(0) {
+        mock_time_counter_(0) {
   }
 
   void SetUp() {
     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
     mock_special_storage_policy_ = new MockSpecialStoragePolicy;
     quota_manager_ = new QuotaManager(
         false /* is_incognito */,
         data_dir_.path(),
         MessageLoopProxy::CreateForCurrentThread(),
         MessageLoopProxy::CreateForCurrentThread(),
@@ skipping 138 matching lines @@
     ASSERT_TRUE(origins != NULL);
     origins->clear();
     quota_manager_->GetCachedOrigins(type, origins);
   }
 
   void NotifyStorageAccessed(QuotaClient* client,
                              const GURL& origin,
                              StorageType type) {
     DCHECK(client);
     quota_manager_->NotifyStorageAccessedInternal(
-        client->id(), origin, type, GetCurrentMockTime());
+        client->id(), origin, type, IncrementMockTime());
   }
 
   void DeleteOriginFromDatabase(const GURL& origin, StorageType type) {
     quota_manager_->DeleteOriginFromDatabase(origin, type);
   }
 
   void GetLRUOrigin(StorageType type) {
     lru_origin_ = GURL();
     quota_manager_->GetLRUOrigin(type,
         callback_factory_.NewCallback(&QuotaManagerTest::DidGetLRUOrigin));
   }
 
   void NotifyOriginInUse(const GURL& origin) {
     quota_manager_->NotifyOriginInUse(origin);
   }
 
   void NotifyOriginNoLongerInUse(const GURL& origin) {
     quota_manager_->NotifyOriginNoLongerInUse(origin);
   }
 
+  void GetOriginsModifiedSince(StorageType type, base::Time modified_since) {
+    modified_origins_.clear();
+    quota_manager_->GetOriginsModifiedSince(type, modified_since,
+        callback_factory_.NewCallback(
+            &QuotaManagerTest::DidGetModifiedOrigins));
+  }
+
   void DumpQuotaTable() {
-    quota_table_.clear();
+    quota_entries_.clear();
     quota_manager_->DumpQuotaTable(
         callback_factory_.NewCallback(
             &QuotaManagerTest::DidDumpQuotaTable));
   }
 
-  void DumpLastAccessTimeTable() {
-    last_access_time_table_.clear();
-    quota_manager_->DumpLastAccessTimeTable(
+  void DumpOriginInfoTable() {
+    origin_info_entries_.clear();
+    quota_manager_->DumpOriginInfoTable(
         callback_factory_.NewCallback(
-            &QuotaManagerTest::DidDumpLastAccessTimeTable));
+            &QuotaManagerTest::DidDumpOriginInfoTable));
   }
 
   void DidGetUsageAndQuota(QuotaStatusCode status, int64 usage, int64 quota) {
     quota_status_ = status;
     usage_ = usage;
     quota_ = quota;
   }
 
   void DidGetQuota(QuotaStatusCode status,
                    StorageType type,
@@ skipping 44 matching lines @@
     usage_ = usage;
     unlimited_usage_ = unlimited_usage;
     quota_ = quota;
     available_space_ = available_space;
   }
 
   void DidGetLRUOrigin(const GURL& origin) {
     lru_origin_ = origin;
   }
 
-  void DidDumpQuotaTable(const QuotaTableEntries& entries) {
-    quota_table_ = entries;
+  void DidGetModifiedOrigins(const std::set<GURL>& origins) {
+    modified_origins_ = origins;
   }
 
-  void DidDumpLastAccessTimeTable(const LastAccessTimeTableEntries& entries) {
-    last_access_time_table_ = entries;
+  void DidDumpQuotaTable(const QuotaTableEntries& entries) {
+    quota_entries_ = entries;
+  }
+
+  void DidDumpOriginInfoTable(const OriginInfoTableEntries& entries) {
+    origin_info_entries_ = entries;
   }
 
   void GetUsage_WithModifyTestBody(const StorageType type);
 
   void set_additional_callback_count(int c) { additional_callback_count_ = c; }
   int additional_callback_count() const { return additional_callback_count_; }
   void DidGetUsageAndQuotaAdditional(
       QuotaStatusCode status, int64 usage, int64 quota) {
     ++additional_callback_count_;
   }
 
   QuotaManager* quota_manager() const { return quota_manager_.get(); }
   void set_quota_manager(QuotaManager* quota_manager) {
     quota_manager_ = quota_manager;
   }
 
   MockSpecialStoragePolicy* mock_special_storage_policy() const {
     return mock_special_storage_policy_.get();
   }
 
   QuotaStatusCode status() const { return quota_status_; }
   const std::string& host() const { return host_; }
   StorageType type() const { return type_; }
   int64 usage() const { return usage_; }
   int64 unlimited_usage() const { return unlimited_usage_; }
   int64 quota() const { return quota_; }
   int64 available_space() const { return available_space_; }
   const GURL& lru_origin() const { return lru_origin_; }
-  const QuotaTableEntries& quota_table() const { return quota_table_; }
-  const LastAccessTimeTableEntries& last_access_time_table() const {
-    return last_access_time_table_;
+  const std::set<GURL>& modified_origins() const { return modified_origins_; }
+  const QuotaTableEntries& quota_entries() const { return quota_entries_; }
+  const OriginInfoTableEntries& origin_info_entries() const {
+    return origin_info_entries_;
   }
   FilePath profile_path() const { return data_dir_.path(); }
   int status_callback_count() const { return status_callback_count_; }
   void reset_status_callback_count() { status_callback_count_ = 0; }
 
  private:
-  base::Time GetCurrentMockTime() {
-    ++virtual_time_counter_;
-    return base::Time::FromDoubleT(virtual_time_counter_ * 10.0);
+  base::Time IncrementMockTime() {
+    ++mock_time_counter_;
+    return base::Time::FromDoubleT(mock_time_counter_ * 10.0);
   }
 
   ScopedTempDir data_dir_;
   base::ScopedCallbackFactory<QuotaManagerTest> callback_factory_;
 
   scoped_refptr<QuotaManager> quota_manager_;
   scoped_refptr<MockSpecialStoragePolicy> mock_special_storage_policy_;
 
   QuotaStatusCode quota_status_;
   std::string host_;
   StorageType type_;
   int64 usage_;
   int64 unlimited_usage_;
   int64 quota_;
   int64 available_space_;
   GURL lru_origin_;
-  QuotaTableEntries quota_table_;
-  LastAccessTimeTableEntries last_access_time_table_;
+  std::set<GURL> modified_origins_;
+  QuotaTableEntries quota_entries_;
+  OriginInfoTableEntries origin_info_entries_;
   int status_callback_count_;
 
   int additional_callback_count_;
 
-  int virtual_time_counter_;
+  int mock_time_counter_;
 
   DISALLOW_COPY_AND_ASSIGN(QuotaManagerTest);
 };
 
 TEST_F(QuotaManagerTest, GetUsageAndQuota_Simple) {
   static const MockOriginData kData[] = {
     { "http://foo.com/", kTemp,  10 },
     { "http://foo.com/", kPerm, 80 },
   };
   RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData)));
@@ skipping 663 matching lines @@
     quota_manager()->NotifyStorageAccessed(QuotaClient::kMockStart,
         GURL(kData1[i].origin), kData1[i].type);
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kData2); ++i)
     quota_manager()->NotifyStorageAccessed(QuotaClient::kMockStart,
         GURL(kData2[i].origin), kData2[i].type);
   MessageLoop::current()->RunAllPending();
 
   EvictOriginData(GURL("http://foo.com/"), kTemp);
   MessageLoop::current()->RunAllPending();
 
-  DumpLastAccessTimeTable();
+  DumpOriginInfoTable();
   MessageLoop::current()->RunAllPending();
 
-  typedef LastAccessTimeTableEntries::const_iterator iterator;
-  for (iterator itr(last_access_time_table().begin()),
-                end(last_access_time_table().end());
+  typedef OriginInfoTableEntries::const_iterator iterator;
+  for (iterator itr(origin_info_entries().begin()),
+                end(origin_info_entries().end());
        itr != end; ++itr) {
     if (itr->type == kTemp)
       EXPECT_NE(std::string("http://foo.com/"), itr->origin.spec());
   }
 
   GetGlobalUsage(kTemp);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(predelete_global_tmp - (1 + 50000), usage());
 
   GetHostUsage("foo.com", kTemp);
@@ skipping 35 matching lines @@
   client->AddOriginToErrorSet(GURL("http://foo.com/"), kTemp);
 
   for (int i = 0;
        i < QuotaManager::kThresholdOfErrorsToBeBlacklisted + 1;
        ++i) {
     EvictOriginData(GURL("http://foo.com/"), kTemp);
     MessageLoop::current()->RunAllPending();
     EXPECT_EQ(kQuotaErrorInvalidModification, status());
   }
 
-  DumpLastAccessTimeTable();
+  DumpOriginInfoTable();
   MessageLoop::current()->RunAllPending();
 
   bool found_origin_in_database = false;
-  typedef LastAccessTimeTableEntries::const_iterator iterator;
-  for (iterator itr(last_access_time_table().begin()),
-                end(last_access_time_table().end());
+  typedef OriginInfoTableEntries::const_iterator iterator;
+  for (iterator itr(origin_info_entries().begin()),
+                end(origin_info_entries().end());
        itr != end; ++itr) {
     if (itr->type == kTemp &&
         GURL("http://foo.com/") == itr->origin) {
       found_origin_in_database = true;
       break;
     }
   }
   // The origin "http://foo.com/" should be in the database.
   EXPECT_TRUE(found_origin_in_database);
 
@@ skipping 101 matching lines @@
   MessageLoop::current()->RunAllPending();
 
   reset_status_callback_count();
   DeleteOriginData(GURL("http://foo.com/"), kTemp);
   DeleteOriginData(GURL("http://bar.com/"), kTemp);
   DeleteOriginData(GURL("http://foo.com/"), kTemp);
   MessageLoop::current()->RunAllPending();
 
   EXPECT_EQ(3, status_callback_count());
 
-  DumpLastAccessTimeTable();
+  DumpOriginInfoTable();
   MessageLoop::current()->RunAllPending();
 
-  typedef LastAccessTimeTableEntries::const_iterator iterator;
-  for (iterator itr(last_access_time_table().begin()),
-                end(last_access_time_table().end());
+  typedef OriginInfoTableEntries::const_iterator iterator;
+  for (iterator itr(origin_info_entries().begin()),
+                end(origin_info_entries().end());
        itr != end; ++itr) {
     if (itr->type == kTemp) {
       EXPECT_NE(std::string("http://foo.com/"), itr->origin.spec());
       EXPECT_NE(std::string("http://bar.com/"), itr->origin.spec());
     }
   }
 
   GetGlobalUsage(kTemp);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(predelete_global_tmp - (1 + 4000 + 50000 + 9), usage());
@@ skipping 142 matching lines @@
   // see empty result here.
   EXPECT_TRUE(lru_origin().is_empty());
 
   NotifyOriginNoLongerInUse(GURL("http://a.com/"));
   NotifyOriginNoLongerInUse(GURL("https://a.com/"));
   GetLRUOrigin(kTemp);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ("http://a.com/", lru_origin().spec());
 }
 
+TEST_F(QuotaManagerTest, GetOriginsModifiedSince) {
+  static const MockOriginData kData[] = {
+    { "http://a.com/",   kTemp,  0 },
+    { "http://a.com:1/", kTemp,  0 },
+    { "https://a.com/",  kTemp,  0 },
+    { "http://b.com/",   kPerm,  0 },  // persistent
+    { "http://c.com/",   kTemp,  0 },
+  };
+  MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData));
+  RegisterClient(client);
+
+  GetOriginsModifiedSince(kTemp, base::Time());
+  MessageLoop::current()->RunAllPending();
+  EXPECT_TRUE(modified_origins().empty());
+
+  base::Time time1 = client->IncrementMockTime();
+  client->ModifyOriginAndNotify(GURL("http://a.com/"), kTemp, 10);
+  client->ModifyOriginAndNotify(GURL("http://a.com:1/"), kTemp, 10);
+  client->ModifyOriginAndNotify(GURL("http://b.com/"), kPerm, 10);
+  base::Time time2 = client->IncrementMockTime();
+  client->ModifyOriginAndNotify(GURL("https://a.com/"), kTemp, 10);
+  client->ModifyOriginAndNotify(GURL("http://c.com/"), kTemp, 10);
+  base::Time time3 = client->IncrementMockTime();
+
+  GetOriginsModifiedSince(kTemp, time1);
+  MessageLoop::current()->RunAllPending();
+  EXPECT_EQ(4U, modified_origins().size());
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kData); ++i) {
+    if (kData[i].type == kTemp)
+      EXPECT_EQ(1U, modified_origins().count(GURL(kData[i].origin)));
+  }
+
+  GetOriginsModifiedSince(kTemp, time2);
+  MessageLoop::current()->RunAllPending();
+  EXPECT_EQ(2U, modified_origins().size());
+
+  GetOriginsModifiedSince(kTemp, time3);
+  MessageLoop::current()->RunAllPending();
+  EXPECT_TRUE(modified_origins().empty());
+
+  client->ModifyOriginAndNotify(GURL("http://a.com/"), kTemp, 10);
+
+  GetOriginsModifiedSince(kTemp, time3);
+  MessageLoop::current()->RunAllPending();
+  EXPECT_EQ(1U, modified_origins().size());
+  EXPECT_EQ(1U, modified_origins().count(GURL("http://a.com/")));
+}
+
 TEST_F(QuotaManagerTest, DumpQuotaTable) {
   SetPersistentHostQuota("example1.com", 1);
   SetPersistentHostQuota("example2.com", 20);
   SetPersistentHostQuota("example3.com", 300);
   MessageLoop::current()->RunAllPending();
 
   DumpQuotaTable();
   MessageLoop::current()->RunAllPending();
 
   const QuotaTableEntry kEntries[] = {
-    {"example1.com", kPerm, 1},
-    {"example2.com", kPerm, 20},
-    {"example3.com", kPerm, 300},
+    QuotaTableEntry("example1.com", kPerm, 1),
+    QuotaTableEntry("example2.com", kPerm, 20),
+    QuotaTableEntry("example3.com", kPerm, 300),
   };
   std::set<QuotaTableEntry> entries
       (kEntries, kEntries + ARRAYSIZE_UNSAFE(kEntries));
 
   typedef QuotaTableEntries::const_iterator iterator;
-  for (iterator itr(quota_table().begin()), end(quota_table().end());
+  for (iterator itr(quota_entries().begin()), end(quota_entries().end());
        itr != end; ++itr) {
     SCOPED_TRACE(testing::Message()
                  << "host = " << itr->host << ", "
                  << "quota = " << itr->quota);
     EXPECT_EQ(1u, entries.erase(*itr));
   }
   EXPECT_TRUE(entries.empty());
 }
 
-TEST_F(QuotaManagerTest, DumpLastAccessTimeTable) {
+TEST_F(QuotaManagerTest, DumpOriginInfoTable) {
   using std::make_pair;
 
   quota_manager()->NotifyStorageAccessed(
       QuotaClient::kMockStart,
       GURL("http://example.com/"),
       kTemp);
   quota_manager()->NotifyStorageAccessed(
       QuotaClient::kMockStart,
       GURL("http://example.com/"),
       kPerm);
   quota_manager()->NotifyStorageAccessed(
       QuotaClient::kMockStart,
       GURL("http://example.com/"),
       kPerm);
   MessageLoop::current()->RunAllPending();
 
-  DumpLastAccessTimeTable();
+  DumpOriginInfoTable();
   MessageLoop::current()->RunAllPending();
 
   typedef std::pair<GURL, StorageType> TypedOrigin;
   typedef std::pair<TypedOrigin, int> Entry;
   const Entry kEntries[] = {
     make_pair(make_pair(GURL("http://example.com/"), kTemp), 1),
     make_pair(make_pair(GURL("http://example.com/"), kPerm), 2),
   };
   std::set<Entry> entries
       (kEntries, kEntries + ARRAYSIZE_UNSAFE(kEntries));
 
-  typedef LastAccessTimeTableEntries::const_iterator iterator;
-  for (iterator itr(last_access_time_table().begin()),
-                end(last_access_time_table().end());
+  typedef OriginInfoTableEntries::const_iterator iterator;
+  for (iterator itr(origin_info_entries().begin()),
+                end(origin_info_entries().end());
        itr != end; ++itr) {
     SCOPED_TRACE(testing::Message()
                  << "host = " << itr->origin << ", "
                  << "type = " << itr->type << ", "
                  << "used_count = " << itr->used_count);
     EXPECT_EQ(1u, entries.erase(
         make_pair(make_pair(itr->origin, itr->type),
                   itr->used_count)));
   }
   EXPECT_TRUE(entries.empty());
 }
 
 TEST_F(QuotaManagerTest, QuotaForEmptyHost) {
   GetPersistentHostQuota(std::string());
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(0, quota());
 
   SetPersistentHostQuota(std::string(), 10);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaErrorNotSupported, status());
 }
 }  // namespace quota