Time-based removal of temporary file systems via BrowsingDataRemover

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>
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_callback_factory.h"
 #include "base/memory/scoped_ptr.h"
 #include "webkit/quota/quota_database.h"
 #include "webkit/quota/quota_client.h"
 #include "webkit/quota/quota_task.h"
 #include "webkit/quota/quota_types.h"
 #include "webkit/quota/special_storage_policy.h"
 
+class FilePath;
+
 namespace base {
 class MessageLoopProxy;
 }
-class FilePath;
 
 namespace quota_internals {
 class QuotaInternalsProxy;
 }
 
 namespace quota {
 
 struct QuotaManagerDeleter;
 
 class QuotaDatabase;
 class QuotaManagerProxy;
 class QuotaTemporaryStorageEvictor;
 class UsageTracker;
+class MockQuotaManager;
 
 // An interface called by QuotaTemporaryStorageEvictor.
 class QuotaEvictionHandler {
  public:
   virtual ~QuotaEvictionHandler() {}
 
   typedef Callback1<const GURL&>::Type GetLRUOriginCallback;
   typedef StatusCallback EvictOriginDataCallback;
   typedef Callback5<QuotaStatusCode,
                     int64 /* usage */,
@@ skipping 64 matching lines @@
   // Used to avoid evicting origins with open pages.
   // A call to NotifyOriginInUse must be balanced by a later call
   // to NotifyOriginNoLongerInUse.
   void NotifyOriginInUse(const GURL& origin);
   void NotifyOriginNoLongerInUse(const GURL& origin);
   bool IsOriginInUse(const GURL& origin) const {
     return origins_in_use_.find(origin) != origins_in_use_.end();
   }
 
   // Called by UI.
-  void DeleteOriginData(const GURL& origin,
-                        StorageType type,
-                        StatusCallback* callback);
+  virtual void DeleteOriginData(const GURL& origin,
+                                StorageType type,
+                                StatusCallback* callback);
 
   // Called by UI and internal modules.
   void GetAvailableSpace(AvailableSpaceCallback* callback);
   void GetTemporaryGlobalQuota(QuotaCallback* callback);
   void SetTemporaryGlobalQuota(int64 new_quota, QuotaCallback* callback);
   void GetPersistentHostQuota(const std::string& host,
                               HostQuotaCallback* callback);
   void SetPersistentHostQuota(const std::string& host,
                               int64 new_quota,
                               HostQuotaCallback* callback);
   void GetGlobalUsage(StorageType type, GlobalUsageCallback* callback);
   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);
+  virtual void GetOriginsModifiedSince(StorageType type,
+                                       base::Time modified_since,
+                                       GetOriginsCallback* callback);
 
   bool ResetUsageTracker(StorageType type);
 
   // 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%).
@@ skipping 61 matching lines @@
   typedef std::pair<std::string, StorageType> HostAndType;
   typedef std::map<HostAndType, UsageAndQuotaDispatcherTask*>
       UsageAndQuotaDispatcherTaskMap;
 
   friend class quota_internals::QuotaInternalsProxy;
   friend struct QuotaManagerDeleter;
   friend class MockStorageClient;
   friend class QuotaManagerProxy;
   friend class QuotaManagerTest;
   friend class QuotaTemporaryStorageEvictor;
+  friend class MockQuotaManager;
 
   // 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.
@@ skipping 139 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_