Implement QM::GetOriginsModifiedSince for browser data deleter support

webkit/quota/quota_database_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 <algorithm>
 #include <iterator>
 #include <set>
 
 #include "app/sql/connection.h"
 #include "app/sql/statement.h"
@@ skipping 20 matching lines @@
   }
 };
 }  // namespace
 
 namespace quota {
 
 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(
       QuotaDatabase* quota_database, Iterator itr, Iterator end) {
     if (!quota_database->LazyOpen(true))
       return false;
 
     for (; itr != end; ++itr) {
       const char* kSql =
           "INSERT INTO HostQuotaTable"
@@ skipping 10 matching lines @@
       statement.BindInt64(2, itr->quota);
       if (!statement.Run())
         return false;
     }
 
     quota_database->Commit();
     return true;
   }
 
   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(
               SQL_FROM_HERE, kSql));
       EXPECT_TRUE(statement.is_valid());
 
       statement.BindString(0, itr->origin.spec());
       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;
     }
 
     quota_database->Commit();
     return true;
   }
 
   void LazyOpen(const FilePath& kDbFile) {
     QuotaDatabase db(kDbFile);
@@ skipping 112 matching lines @@
 
     exceptions.insert(kOrigin3);
     EXPECT_TRUE(db.GetLRUOrigin(kStorageTypeTemporary, exceptions,
                                 NULL, &origin));
     EXPECT_TRUE(origin.is_empty());
 
     EXPECT_TRUE(db.SetOriginLastAccessTime(
         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();
     EXPECT_TRUE(db.GetLRUOrigin(kStorageTypeTemporary, exceptions,
                                 NULL, &origin));
     EXPECT_EQ(kOrigin2.spec(), origin.spec());
 
     exceptions.insert(kOrigin1);
     exceptions.insert(kOrigin2);
     EXPECT_TRUE(db.GetLRUOrigin(kStorageTypeTemporary, exceptions,
                                 NULL, &origin));
     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[] = {
       GURL("http://a/"),
       GURL("http://b/"),
       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/"),
                                        kStorageTypeTemporary,
                                        &used_count));
     EXPECT_EQ(0, used_count);
 
     EXPECT_TRUE(db.SetOriginLastAccessTime(
         GURL("http://a/"), kStorageTypeTemporary,
         base::Time::FromDoubleT(1.0)));
     used_count = -1;
     EXPECT_TRUE(db.FindOriginUsedCount(GURL("http://a/"),
                                        kStorageTypeTemporary,
                                        &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/"),
                                        kStorageTypeTemporary,
                                        &used_count));
     EXPECT_EQ(1, used_count);
   }
 
   template <typename EntryType>
   struct EntryVerifier {
@@ skipping 23 matching lines @@
 
     typedef EntryVerifier<QuotaTableEntry> Verifier;
     Verifier verifier(begin, end);
     EXPECT_TRUE(db.DumpQuotaTable(
         new QuotaTableCallback(
             base::Bind(&Verifier::Run,
                        base::Unretained(&verifier)))));
     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());
   }
 };
 
 TEST_F(QuotaDatabaseTest, LazyOpen) {
   ScopedTempDir data_dir;
   ASSERT_TRUE(data_dir.CreateUniqueTempDir());
   const FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db");
@@ skipping 18 matching lines @@
 }
 
 TEST_F(QuotaDatabaseTest, OriginLastAccessTimeLRU) {
   ScopedTempDir data_dir;
   ASSERT_TRUE(data_dir.CreateUniqueTempDir());
   const FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db");
   OriginLastAccessTimeLRU(kDbFile);
   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());
 
   const FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db");
   QuotaDatabase db(kDbFile);
 
   EXPECT_FALSE(db.IsOriginDatabaseBootstrapped());
   EXPECT_TRUE(db.SetOriginDatabaseBootstrapped(true));
   EXPECT_TRUE(db.IsOriginDatabaseBootstrapped());
   EXPECT_TRUE(db.SetOriginDatabaseBootstrapped(false));
   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) {
   ScopedTempDir data_dir;
   ASSERT_TRUE(data_dir.CreateUniqueTempDir());
   const FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db");
   DumpQuotaTable(kDbFile);
   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