Implement QM::GetOriginsModifiedSince for browser data deleter support

webkit/quota/quota_database_unittest.cc

Index: webkit/quota/quota_database_unittest.cc
diff --git a/webkit/quota/quota_database_unittest.cc b/webkit/quota/quota_database_unittest.cc
index f126f31dda0ad4bc8beb2fc679c9e95ae76db2e6..4e9df563456e91c993a2947387b880e604db7aae 100644
--- a/webkit/quota/quota_database_unittest.cc
+++ b/webkit/quota/quota_database_unittest.cc
@@ -38,9 +38,9 @@ class QuotaDatabaseTest : public testing::Test {
  protected:
   typedef QuotaDatabase::QuotaTableEntry QuotaTableEntry;
   typedef QuotaDatabase::QuotaTableCallback QuotaTableCallback;
-  typedef QuotaDatabase::LastAccessTimeTableEntry LastAccessTimeTableEntry;
-  typedef QuotaDatabase::LastAccessTimeTableCallback
-      LastAccessTimeTableCallback;
+  typedef QuotaDatabase::OriginInfoTableEntry OriginInfoTableEntry;
+  typedef QuotaDatabase::OriginInfoTableCallback
+      OriginInfoTableCallback;
 
   template <typename Iterator>
   bool AssignQuotaTable(
@@ -71,16 +71,16 @@ class QuotaDatabaseTest : public testing::Test {
   }
 
   template <typename Iterator>
-  bool AssignLastAccessTimeTable(
+  bool AssignOriginInfoTable(
       QuotaDatabase* quota_database, Iterator itr, Iterator end) {
     if (!quota_database->LazyOpen(true))
       return false;
 
     for (; itr != end; ++itr) {
       const char* kSql =
-          "INSERT INTO OriginLastAccessTable"
-          " (origin, type, used_count, last_access_time)"
-          " VALUES (?, ?, ?, ?)";
+          "INSERT INTO OriginInfoTable"
+          " (origin, type, used_count, last_access_time, last_modified_time)"
+          " VALUES (?, ?, ?, ?, ?)";
       sql::Statement statement;
       statement.Assign(
           quota_database->db_->GetCachedStatement(
@@ -91,6 +91,7 @@ class QuotaDatabaseTest : public testing::Test {
       statement.BindInt(1, static_cast<int>(itr->type));
       statement.BindInt(2, itr->used_count);
       statement.BindInt64(3, itr->last_access_time.ToInternalValue());
+      statement.BindInt64(4, itr->last_modified_time.ToInternalValue());
       if (!statement.Run())
         return false;
     }
@@ -223,7 +224,7 @@ class QuotaDatabaseTest : public testing::Test {
         kOrigin1, kStorageTypeTemporary, base::Time::Now()));
 
     // Delete origin/type last access time information.
-    EXPECT_TRUE(db.DeleteOriginLastAccessTime(kOrigin3, kStorageTypeTemporary));
+    EXPECT_TRUE(db.DeleteOriginInfo(kOrigin3, kStorageTypeTemporary));
 
     // Querying again to see if the deletion has worked.
     exceptions.clear();
@@ -238,7 +239,77 @@ class QuotaDatabaseTest : public testing::Test {
     EXPECT_TRUE(origin.is_empty());
   }
 
-  void RegisterOrigins(const FilePath& kDbFile) {
+  void OriginLastModifiedSince(const FilePath& kDbFile) {
+    QuotaDatabase db(kDbFile);
+    ASSERT_TRUE(db.LazyOpen(true));
+
+    std::set<GURL> origins;
+    EXPECT_TRUE(db.GetOriginsModifiedSince(
+        kStorageTypeTemporary, &origins, base::Time()));
+    EXPECT_TRUE(origins.empty());
+
+    const GURL kOrigin1("http://a/");
+    const GURL kOrigin2("http://b/");
+    const GURL kOrigin3("http://c/");
+
+    // Report last mod time for the test origins.
+    EXPECT_TRUE(db.SetOriginLastModifiedTime(
+        kOrigin1, kStorageTypeTemporary, base::Time::FromInternalValue(10)));
+    EXPECT_TRUE(db.SetOriginLastModifiedTime(
+        kOrigin2, kStorageTypeTemporary, base::Time::FromInternalValue(20)));
+    EXPECT_TRUE(db.SetOriginLastModifiedTime(
+        kOrigin3, kStorageTypeTemporary, base::Time::FromInternalValue(30)));
+
+    EXPECT_TRUE(db.GetOriginsModifiedSince(
+        kStorageTypeTemporary, &origins, base::Time::FromInternalValue(15)));
+    EXPECT_EQ(2U, origins.size());
+    EXPECT_EQ(0U, origins.count(kOrigin1));
+    EXPECT_EQ(1U, origins.count(kOrigin2));
+    EXPECT_EQ(1U, origins.count(kOrigin3));
+
+    EXPECT_TRUE(db.GetOriginsModifiedSince(
+        kStorageTypeTemporary, &origins, base::Time::FromInternalValue(25)));
+    EXPECT_EQ(1U, origins.size());
+    EXPECT_EQ(0U, origins.count(kOrigin1));
+    EXPECT_EQ(0U, origins.count(kOrigin2));
+    EXPECT_EQ(1U, origins.count(kOrigin3));
+
+    EXPECT_TRUE(db.GetOriginsModifiedSince(
+        kStorageTypeTemporary, &origins, base::Time::FromInternalValue(35)));
+    EXPECT_TRUE(origins.empty());
+
+    // Update origin1's mod time but for persistent storage.
+    EXPECT_TRUE(db.SetOriginLastModifiedTime(
+        kOrigin1, kStorageTypePersistent, base::Time::FromInternalValue(40)));
+
+    // Must have no effects on temporary origins info.
+    EXPECT_TRUE(db.GetOriginsModifiedSince(
+        kStorageTypeTemporary, &origins, base::Time::FromInternalValue(15)));
+    EXPECT_EQ(2U, origins.size());
+    EXPECT_EQ(0U, origins.count(kOrigin1));
+    EXPECT_EQ(1U, origins.count(kOrigin2));
+    EXPECT_EQ(1U, origins.count(kOrigin3));
+
+    // One more update for persistent origin2.
+    EXPECT_TRUE(db.SetOriginLastModifiedTime(
+        kOrigin2, kStorageTypePersistent, base::Time::FromInternalValue(50)));
+
+    EXPECT_TRUE(db.GetOriginsModifiedSince(
+        kStorageTypePersistent, &origins, base::Time::FromInternalValue(35)));
+    EXPECT_EQ(2U, origins.size());
+    EXPECT_EQ(1U, origins.count(kOrigin1));
+    EXPECT_EQ(1U, origins.count(kOrigin2));
+    EXPECT_EQ(0U, origins.count(kOrigin3));
+
+    EXPECT_TRUE(db.GetOriginsModifiedSince(
+        kStorageTypePersistent, &origins, base::Time::FromInternalValue(45)));
+    EXPECT_EQ(1U, origins.size());
+    EXPECT_EQ(0U, origins.count(kOrigin1));
+    EXPECT_EQ(1U, origins.count(kOrigin2));
+    EXPECT_EQ(0U, origins.count(kOrigin3));
+  }
+
+  void RegisterInitialOriginInfo(const FilePath& kDbFile) {
     QuotaDatabase db(kDbFile);
 
     const GURL kOrigins[] = {
@@ -247,9 +318,7 @@ class QuotaDatabaseTest : public testing::Test {
       GURL("http://c/") };
     std::set<GURL> origins(kOrigins, kOrigins + ARRAYSIZE_UNSAFE(kOrigins));
 
-    EXPECT_TRUE(db.RegisterOrigins(origins,
-                                   kStorageTypeTemporary,
-                                   base::Time()));
+    EXPECT_TRUE(db.RegisterInitialOriginInfo(origins, kStorageTypeTemporary));
 
     int used_count = -1;
     EXPECT_TRUE(db.FindOriginUsedCount(GURL("http://a/"),
@@ -266,9 +335,7 @@ class QuotaDatabaseTest : public testing::Test {
                                        &used_count));
     EXPECT_EQ(1, used_count);
 
-    EXPECT_TRUE(db.RegisterOrigins(origins,
-                                   kStorageTypeTemporary,
-                                   base::Time()));
+    EXPECT_TRUE(db.RegisterInitialOriginInfo(origins, kStorageTypeTemporary));
 
     used_count = -1;
     EXPECT_TRUE(db.FindOriginUsedCount(GURL("http://a/"),
@@ -312,24 +379,23 @@ class QuotaDatabaseTest : public testing::Test {
     EXPECT_TRUE(verifier.table.empty());
   }
 
-  void DumpLastAccessTimeTable(const FilePath& kDbFile) {
+  void DumpOriginInfoTable(const FilePath& kDbFile) {
     base::Time now(base::Time::Now());
-    LastAccessTimeTableEntry kTableEntries[] = {
-      {GURL("http://go/"), kStorageTypeTemporary, 2147483647, now},
-      {GURL("http://oo/"), kStorageTypeTemporary, 0, now},
-      {GURL("http://gle/"), kStorageTypeTemporary, 1, now},
+    OriginInfoTableEntry kTableEntries[] = {
+      {GURL("http://go/"), kStorageTypeTemporary, 2147483647, now, now},
+      {GURL("http://oo/"), kStorageTypeTemporary, 0, now, now},
+      {GURL("http://gle/"), kStorageTypeTemporary, 1, now, now},
     };
-    LastAccessTimeTableEntry* begin = kTableEntries;
-    LastAccessTimeTableEntry* end = kTableEntries +
-        ARRAYSIZE_UNSAFE(kTableEntries);
+    OriginInfoTableEntry* begin = kTableEntries;
+    OriginInfoTableEntry* end = kTableEntries + ARRAYSIZE_UNSAFE(kTableEntries);
 
     QuotaDatabase db(kDbFile);
-    EXPECT_TRUE(AssignLastAccessTimeTable(&db, begin, end));
+    EXPECT_TRUE(AssignOriginInfoTable(&db, begin, end));
 
-    typedef EntryVerifier<LastAccessTimeTableEntry> Verifier;
+    typedef EntryVerifier<OriginInfoTableEntry> Verifier;
     Verifier verifier(begin, end);
-    EXPECT_TRUE(db.DumpLastAccessTimeTable(
-        new LastAccessTimeTableCallback(
+    EXPECT_TRUE(db.DumpOriginInfoTable(
+        new OriginInfoTableCallback(
             base::Bind(&Verifier::Run,
                        base::Unretained(&verifier)))));
     EXPECT_TRUE(verifier.table.empty());
@@ -368,6 +434,14 @@ TEST_F(QuotaDatabaseTest, OriginLastAccessTimeLRU) {
   OriginLastAccessTimeLRU(FilePath());
 }
 
+TEST_F(QuotaDatabaseTest, OriginLastModifiedSince) {
+  ScopedTempDir data_dir;
+  ASSERT_TRUE(data_dir.CreateUniqueTempDir());
+  const FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db");
+  OriginLastModifiedSince(kDbFile);
+  OriginLastModifiedSince(FilePath());
+}
+
 TEST_F(QuotaDatabaseTest, BootstrapFlag) {
   ScopedTempDir data_dir;
   ASSERT_TRUE(data_dir.CreateUniqueTempDir());
@@ -382,12 +456,12 @@ TEST_F(QuotaDatabaseTest, BootstrapFlag) {
   EXPECT_FALSE(db.IsOriginDatabaseBootstrapped());
 }
 
-TEST_F(QuotaDatabaseTest, RegisterOrigins) {
+TEST_F(QuotaDatabaseTest, RegisterInitialOriginInfo) {
   ScopedTempDir data_dir;
   ASSERT_TRUE(data_dir.CreateUniqueTempDir());
   const FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db");
-  RegisterOrigins(kDbFile);
-  RegisterOrigins(FilePath());
+  RegisterInitialOriginInfo(kDbFile);
+  RegisterInitialOriginInfo(FilePath());
 }
 
 TEST_F(QuotaDatabaseTest, DumpQuotaTable) {
@@ -398,11 +472,11 @@ TEST_F(QuotaDatabaseTest, DumpQuotaTable) {
   DumpQuotaTable(FilePath());
 }
 
-TEST_F(QuotaDatabaseTest, DumpLastAccessTimeTable) {
+TEST_F(QuotaDatabaseTest, DumpOriginInfoTable) {
   ScopedTempDir data_dir;
   ASSERT_TRUE(data_dir.CreateUniqueTempDir());
   const FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db");
-  DumpLastAccessTimeTable(kDbFile);
-  DumpLastAccessTimeTable(FilePath());
+  DumpOriginInfoTable(kDbFile);
+  DumpOriginInfoTable(FilePath());
 }
 }  // namespace quota