Implement QM::GetOriginsModifiedSince for browser data deleter support

webkit/quota/quota_manager.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_MANAGER_H_
 #define WEBKIT_QUOTA_QUOTA_MANAGER_H_
 #pragma once
 
 #include <deque>
 #include <list>
@@ skipping 128 matching lines @@
   void GetHostUsage(const std::string& host, StorageType type,
                     HostUsageCallback* callback);
 
   void GetStatistics(std::map<std::string, std::string>* statistics);
 
   bool IsStorageUnlimited(const GURL& origin) const {
     return special_storage_policy_.get() &&
            special_storage_policy_->IsStorageUnlimited(origin);
   }
 
+  void GetOriginsModifiedSince(
+      StorageType type,
+      base::Time modified_since,
+      GetOriginsCallback* callback);
+
   // Used to determine the total size of the temp pool.
   static const int64 kTemporaryStorageQuotaDefaultSize;
   static const int64 kTemporaryStorageQuotaMaxSize;
   static const int64 kIncognitoDefaultTemporaryQuota;
 
   // Determines the portion of the temp pool that can be
   // utilized by a single host (ie. 5 for 20%).
   static const int kPerHostTemporaryPortion;
 
   static const char kDatabaseName[];
 
   static const int kThresholdOfErrorsToBeBlacklisted;
 
   static const int kEvictionIntervalInMilliSeconds;
 
  private:
   class DatabaseTaskBase;
   class InitializeTask;
-  class TemporaryGlobalQuotaUpdateTask;
-  class PersistentHostQuotaQueryTask;
-  class PersistentHostQuotaUpdateTask;
+  class UpdateTemporaryGlobalQuotaTask;
+  class GetPersistentHostQuotaTask;
+  class UpdatePersistentHostQuotaTask;
   class GetLRUOriginTask;
-  class OriginDeletionDatabaseTask;
-  class TemporaryOriginsRegistrationTask;
-  class OriginAccessRecordDatabaseTask;
+  class DeleteOriginInfo;
+  class InitializeTemporaryOriginsInfoTask;
+  class UpdateAccesTimeTask;
+  class UpdateModifiedTimeTask;
+  class GetModifiedSinceTask;
 
   class UsageAndQuotaDispatcherTask;
   class UsageAndQuotaDispatcherTaskForTemporary;
   class UsageAndQuotaDispatcherTaskForPersistent;
 
   class OriginDataDeleter;
 
   class AvailableSpaceQueryTask;
   class DumpQuotaTableTask;
-  class DumpLastAccessTimeTableTask;
+  class DumpOriginInfoTableTask;
 
   typedef QuotaDatabase::QuotaTableEntry QuotaTableEntry;
-  typedef QuotaDatabase::LastAccessTimeTableEntry LastAccessTimeTableEntry;
+  typedef QuotaDatabase::OriginInfoTableEntry OriginInfoTableEntry;
   typedef std::vector<QuotaTableEntry> QuotaTableEntries;
-  typedef std::vector<LastAccessTimeTableEntry> LastAccessTimeTableEntries;
+  typedef std::vector<OriginInfoTableEntry> OriginInfoTableEntries;
 
   typedef Callback1<const QuotaTableEntries&>::Type DumpQuotaTableCallback;
-  typedef Callback1<const LastAccessTimeTableEntries&>::Type
-      DumpLastAccessTimeTableCallback;
+  typedef Callback1<const OriginInfoTableEntries&>::Type
+      DumpOriginInfoTableCallback;
 
   struct EvictionContext {
     EvictionContext()
         : evicted_type(kStorageTypeUnknown),
           usage(0),
           unlimited_usage(0),
           quota(0) {}
     virtual ~EvictionContext() {}
 
     GURL evicted_origin;
     StorageType evicted_type;
 
     scoped_ptr<EvictOriginDataCallback> evict_origin_data_callback;
 
     scoped_ptr<GetUsageAndQuotaForEvictionCallback>
         get_usage_and_quota_callback;
     int64 usage;
     int64 unlimited_usage;
     int64 quota;
   };
 
   typedef std::pair<std::string, StorageType> HostAndType;
   typedef std::map<HostAndType, UsageAndQuotaDispatcherTask*>
       UsageAndQuotaDispatcherTaskMap;
 
   friend struct QuotaManagerDeleter;
+  friend class MockStorageClient;
   friend class QuotaManagerProxy;
   friend class QuotaManagerTest;
   friend class QuotaTemporaryStorageEvictor;
 
   // This initialization method is lazily called on the IO thread
   // when the first quota manager API is called.
   // Initialize must be called after all quota clients are added to the
   // manager by RegisterStorage.
   void LazyInitialize();
 
   // Called by clients via proxy.
   // Registers a quota client to the manager.
   // The client must remain valid until OnQuotaManagerDestored is called.
   void RegisterClient(QuotaClient* client);
 
   UsageTracker* GetUsageTracker(StorageType type) const;
 
   // Extract cached origins list from the usage tracker.
   // (Might return empty list if no origin is tracked by the tracker.)
   void GetCachedOrigins(StorageType type, std::set<GURL>* origins);
 
-  // This internal method is separately defined mainly for testing.
+  // These internal methods are separately defined mainly for testing.
   void NotifyStorageAccessedInternal(
       QuotaClient::ID client_id,
       const GURL& origin,
       StorageType type,
       base::Time accessed_time);
+  void NotifyStorageModifiedInternal(
+      QuotaClient::ID client_id,
+      const GURL& origin,
+      StorageType type,
+      int64 delta,
+      base::Time modified_time);
 
   void DumpQuotaTable(DumpQuotaTableCallback* callback);
-  void DumpLastAccessTimeTable(DumpLastAccessTimeTableCallback* callback);
+  void DumpOriginInfoTable(DumpOriginInfoTableCallback* callback);
 
   // Methods for eviction logic.
   void StartEviction();
   void DeleteOriginFromDatabase(const GURL& origin, StorageType type);
 
   void DidOriginDataEvicted(QuotaStatusCode status);
   void DidGetAvailableSpaceForEviction(
       QuotaStatusCode status,
       int64 available_space);
   void DidGetGlobalQuotaForEviction(
@@ skipping 96 matching lines @@
 
   QuotaManager* manager_;  // only accessed on the io thread
   scoped_refptr<base::MessageLoopProxy> io_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(QuotaManagerProxy);
 };
 
 }  // namespace quota
 
 #endif  // WEBKIT_QUOTA_QUOTA_MANAGER_H_