Implement GetUsageAndQuotaForEviction in QuotaManager.

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 38 matching lines @@
       StorageType type,
       GetLRUOriginCallback* callback) = 0;
 
   virtual void EvictOriginData(
       const GURL& origin,
       StorageType type,
       EvictOriginDataCallback* callback) = 0;
 
   virtual void GetUsageAndQuotaForEviction(
       GetUsageAndQuotaForEvictionCallback* callback) = 0;
+
+ protected:
+  virtual ~QuotaEvictionHandler() {}
 };
 
 // The quota manager class.  This class is instantiated per profile and
 // held by the profile.  With the exception of the constructor and the
 // proxy() method, all methods should only be called on the IO thread.
 class QuotaManager : public QuotaTaskObserver,
                      public QuotaEvictionHandler,
                      public base::RefCountedThreadSafe<
                          QuotaManager, QuotaManagerDeleter> {
  public:
@@ skipping 78 matching lines @@
   class PersistentHostQuotaQueryTask;
   class GetLRUOriginTask;
   class OriginDeletionDatabaseTask;
 
   class UsageAndQuotaDispatcherTask;
   class UsageAndQuotaDispatcherTaskForTemporary;
   class UsageAndQuotaDispatcherTaskForPersistent;
 
   class AvailableSpaceQueryTask;
 
+  struct EvictionContext {
+    EvictionContext()
+        : num_eviction_requested_clients(0),
+          num_evicted_clients(0),
+          num_eviction_error(0),
+          usage(0),
+          quota(0) {}
+    virtual ~EvictionContext() {}
+
+    scoped_ptr<EvictOriginDataCallback> evict_origin_data_callback;
+    int num_eviction_requested_clients;
+    int num_evicted_clients;
+    int num_eviction_error;
+
+    scoped_ptr<GetUsageAndQuotaForEvictionCallback>
+        get_usage_and_quota_callback;
+    int64 usage;
+    int64 quota;
+  };
+
   typedef std::pair<std::string, StorageType> HostAndType;
   typedef std::map<HostAndType, UsageAndQuotaDispatcherTask*>
       UsageAndQuotaDispatcherTaskMap;
 
   friend struct QuotaManagerDeleter;
   friend class QuotaManagerProxy;
   friend class QuotaManagerTest;
 
   // 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;
 
   void DidGetTemporaryGlobalQuota(int64 quota);
 
   // Methods for eviction logic.
   void DeleteOriginFromDatabase(const GURL& origin, StorageType type);
 
   void DidOriginDataEvicted(QuotaStatusCode status);
+  void DidGetAvailableSpaceForEviction(
+      QuotaStatusCode status,
+      int64 available_space);
+  void DidGetGlobalQuotaForEviction(
+      QuotaStatusCode status,
+      int64 quota);
+  void DidGetGlobalUsageForEviction(int64 usage);
 
   virtual void GetLRUOrigin(
       StorageType type,
       GetLRUOriginCallback* callback) OVERRIDE;
   virtual void EvictOriginData(
       const GURL& origin,
       StorageType type,
       EvictOriginDataCallback* callback) OVERRIDE;
   virtual void GetUsageAndQuotaForEviction(
       GetUsageAndQuotaForEvictionCallback* callback) OVERRIDE;
 
   void DeleteOnCorrectThread() const;
 
   const bool is_incognito_;
   const FilePath profile_path_;
 
   scoped_refptr<QuotaManagerProxy> proxy_;
   bool db_disabled_;
   scoped_refptr<base::MessageLoopProxy> io_thread_;
   scoped_refptr<base::MessageLoopProxy> db_thread_;
   mutable scoped_ptr<QuotaDatabase> database_;
 
   QuotaClientList clients_;
 
   scoped_ptr<UsageTracker> temporary_usage_tracker_;
   scoped_ptr<UsageTracker> persistent_usage_tracker_;
 
+  EvictionContext eviction_context_;
+
   UsageAndQuotaDispatcherTaskMap usage_and_quota_dispatchers_;
 
-  scoped_ptr<EvictOriginDataCallback> evict_origin_data_callback_;
-  int num_eviction_requested_clients_;
-  int num_evicted_clients_;
-
   int64 temporary_global_quota_;
   QuotaCallbackQueue temporary_global_quota_callbacks_;
 
   // Map from origin to count.
   std::map<GURL, int> origins_in_use_;
 
   base::ScopedCallbackFactory<QuotaManager> callback_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(QuotaManager);
 };
@@ skipping 33 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_