Implement QM::GetOriginsModifiedSince for browser data deleter support

webkit/quota/quota_database.h

 // 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.
 
 #ifndef WEBKIT_QUOTA_QUOTA_DATABASE_H_
 #define WEBKIT_QUOTA_QUOTA_DATABASE_H_
 
 #include <set>
 #include <string>
 
@@ skipping 24 matching lines @@
  public:
   // If 'path' is empty, an in memory database will be used.
   explicit QuotaDatabase(const FilePath& path);
   ~QuotaDatabase();
 
   void CloseConnection();
 
   bool GetHostQuota(const std::string& host, StorageType type, int64* quota);
   bool SetHostQuota(const std::string& host, StorageType type, int64 quota);
 
-  bool SetOriginLastAccessTime(const GURL& origin, StorageType type,
+  bool SetOriginLastAccessTime(const GURL& origin,
+                               StorageType type,
                                base::Time last_access_time);
 
+  bool SetOriginLastModifiedTime(const GURL& origin,
+                                 StorageType type,
+                                 base::Time last_modified_time);
+
   // Register |origins| to Database with |used_count| = 0 and
-  // specified |last_access_time|.
+  // specified |last_access_time|.  Last modified time for the
+  // registered origin will be initialized to 0.

[Mike West, 2011/06/16 09:39:33]

Isn't the origin being modified at `base::Time::Now()` if we're registering it?

[kinuko, 2011/06/16 12:09:06]

The naming might be confusing here, this is a one-time method that is to be
called only for the db initialization after the installation or db schema
update.  Renamed this to RegisterInitialOriginInfo() and slightly changed the
signature, hoping it makes more sense.

   bool RegisterOrigins(const std::set<GURL>& origins,
                        StorageType type,
                        base::Time last_access_time);
 
   bool DeleteHostQuota(const std::string& host, StorageType type);

[Mike West, 2011/06/16 09:39:33]

Maybe move this up to live with `GetHostQuota` and `SetHostQuota`, just so
they're all in one place and easy to spot?

[kinuko, 2011/06/16 12:09:06]

Done.

-  bool DeleteOriginLastAccessTime(const GURL& origin, StorageType type);
+  bool DeleteOriginInfo(const GURL& origin, StorageType type);
 
   bool GetGlobalQuota(StorageType type, int64* quota);
   bool SetGlobalQuota(StorageType type, int64 quota);
 
   // Sets |origin| to the least recently used origin of origins not included
   // in |exceptions| and not granted the special unlimited storage right.
   // It returns false when it failed in accessing the database.
   // |origin| is set to empty when there is no matching origin.
   bool GetLRUOrigin(StorageType type,
                     const std::set<GURL>& exceptions,
                     SpecialStoragePolicy* special_storage_policy,
                     GURL* origin);
 
+  // Populates |origins| with the ones that have been modified since
+  // the |modified_since|.
+  bool GetOriginsModifiedSince(StorageType type,
+                               std::set<GURL>* origins,
+                               base::Time modified_since);
+
   // Returns false if SetOriginDatabaseBootstrapped has never
   // been called before, which means existing origins may not have been
   // registered.
   bool IsOriginDatabaseBootstrapped();
   bool SetOriginDatabaseBootstrapped(bool bootstrap_flag);
 
  private:
   struct QuotaTableEntry {
     std::string host;
     StorageType type;
     int64 quota;
   };
   friend bool operator <(const QuotaTableEntry& lhs,
                          const QuotaTableEntry& rhs);
 
-  struct LastAccessTimeTableEntry {
+  struct OriginInfoTableEntry {
     GURL origin;
     StorageType type;
     int used_count;
     base::Time last_access_time;
+    base::Time last_modified_time;
   };
-  friend bool operator <(const LastAccessTimeTableEntry& lhs,
-                         const LastAccessTimeTableEntry& rhs);
+  friend bool operator <(const OriginInfoTableEntry& lhs,
+                         const OriginInfoTableEntry& rhs);
 
   typedef base::Callback<bool (const QuotaTableEntry&)> QuotaTableCallback;
-  typedef base::Callback<bool (const LastAccessTimeTableEntry&)>
-      LastAccessTimeTableCallback;
+  typedef base::Callback<bool (const OriginInfoTableEntry&)>
+      OriginInfoTableCallback;
 
   // For long-running transactions support.  We always keep a transaction open
   // so that multiple transactions can be batched.  They are flushed
   // with a delay after a modification has been made.  We support neither
   // nested transactions nor rollback (as we don't need them for now).
   void Commit();
   void ScheduleCommit();
 
   bool FindOriginUsedCount(const GURL& origin,
                            StorageType type,
                            int* used_count);
 
   bool LazyOpen(bool create_if_needed);
   bool EnsureDatabaseVersion();
   bool CreateSchema();
   bool ResetSchema();
 
-  // |callback| may return false to stop reading data
+  // |callback| may return false to stop reading data.
   bool DumpQuotaTable(QuotaTableCallback* callback);
-  bool DumpLastAccessTimeTable(LastAccessTimeTableCallback* callback);
-
+  bool DumpOriginInfoTable(OriginInfoTableCallback* callback);
 
   FilePath db_file_path_;
 
   scoped_ptr<sql::Connection> db_;
   scoped_ptr<sql::MetaTable> meta_table_;
   bool is_recreating_;
   bool is_disabled_;
 
   base::OneShotTimer<QuotaDatabase> timer_;
 
   friend class QuotaDatabaseTest;
   friend class QuotaManager;
 
   DISALLOW_COPY_AND_ASSIGN(QuotaDatabase);
 };
 
 }  // namespace quota
 
 #endif  // WEBKIT_QUOTA_QUOTA_DATABASE_H_