Implement EvictOriginData 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 11 matching lines @@
 #include "webkit/quota/quota_types.h"
 
 namespace base {
 class MessageLoopProxy;
 }
 class FilePath;
 
 namespace quota {
 
 class QuotaDatabase;
+class QuotaTemporaryStorageEvictor;
 class UsageTracker;
 
 struct QuotaManagerDeleter;
 class QuotaManagerProxy;
 
 // An interface called by QuotaTemporaryStorageEvictor.
 class QuotaEvictionHandler {
  public:
   typedef Callback1<GURL>::Type GetLRUOriginCallback;
   typedef Callback4<QuotaStatusCode,
                     int64 /* usage */,
                     int64 /* quota */,
                     int64 /* physical_avail */ >::Type DeleteOriginDataCallback;
 
   virtual void GetUsageAndQuotaForEviction(
       DeleteOriginDataCallback* callback) = 0;
 
   virtual void DeleteOriginData(

[michaeln, 2011/05/17 00:19:45]

Delete sounds more generic than this really is given the signature of the
callback, maybe EvictOriginData(...)

[Dai Mikurube (NOT FULLTIME), 2011/05/17 09:18:40]

Done.

       const GURL& origin,
       StorageType type,
       DeleteOriginDataCallback* callback) = 0;
 
   virtual void GetLRUOrigin(
       StorageType type,
       GetLRUOriginCallback* callback) = 0;
 };
 
 // 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:
   typedef Callback3<QuotaStatusCode,
                     int64 /* usage */,
                     int64 /* quota */>::Type GetUsageAndQuotaCallback;
   typedef Callback2<QuotaStatusCode,
                     int64 /* granted_quota */>::Type RequestQuotaCallback;
-  typedef Callback1<GURL>::Type GetLRUOriginCallback;
 
   QuotaManager(bool is_incognito,
                const FilePath& profile_path,
                base::MessageLoopProxy* io_thread,
                base::MessageLoopProxy* db_thread);
 
   virtual ~QuotaManager();
 
   // Returns a proxy object that can be used on any thread.
   QuotaManagerProxy* proxy() { return proxy_.get(); }
@@ skipping 40 matching lines @@
   void GetPersistentHostQuota(const std::string& host,
                               HostQuotaCallback* callback);
   void SetPersistentHostQuota(const std::string& host,
                               int64 new_quota,
                               HostQuotaCallback* callback);
 
   void GetGlobalUsage(StorageType type, UsageCallback* callback);
   void GetHostUsage(const std::string& host, StorageType type,
                     HostUsageCallback* callback);
 
+  // TODO(dmikurube): Make it a friend?
+  void RegisterTemporaryStorageEvictor(
+      scoped_refptr<QuotaTemporaryStorageEvictor> temporary_storage_evictor);
+
   static const int64 kTemporaryStorageQuotaDefaultSize;
   static const int64 kTemporaryStorageQuotaMaxSize;
   static const char kDatabaseName[];
 
   static const int64 kIncognitoDefaultTemporaryQuota;
 
  private:
   class InitializeTask;
   class TemporaryGlobalQuotaUpdateTask;
   class PersistentHostQuotaUpdateTask;
   class PersistentHostQuotaQueryTask;
   class GetLRUOriginTask;
 
   class UsageAndQuotaDispatcherTask;
   class UsageAndQuotaDispatcherTaskForTemporary;
   class UsageAndQuotaDispatcherTaskForPersistent;
 
   typedef std::pair<std::string, StorageType> HostAndType;
   typedef std::map<HostAndType, UsageAndQuotaDispatcherTask*>
       UsageAndQuotaDispatcherTaskMap;
 
   friend struct QuotaManagerDeleter;
   friend class QuotaManagerProxy;
+  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);
 
-  // TODO(dmikurube): Add a test for this method.
   virtual void GetLRUOrigin(
       StorageType type,
-      GetLRUOriginCallback* callback);
+      GetLRUOriginCallback* callback) OVERRIDE;
+
+  void StartEviction();
+
+  virtual void GetUsageAndQuotaForEviction(
+      DeleteOriginDataCallback* callback) OVERRIDE;
+
+  void OnOriginDataDeleted(
+      QuotaStatusCode status,
+      DeleteOriginDataCallback* callback);
+
+  virtual void DeleteOriginData(
+      const GURL& origin,
+      StorageType type,
+      DeleteOriginDataCallback* callback) OVERRIDE;

[kinuko, 2011/05/16 13:48:01]

style-nit: Can you put derived methods together without empty lines?

http://dev.chromium.org/developers/coding-style says:
"When you implement an interface, group those functions in your header file in
one section, clearly labeled as implementing that interface. Be sure to preserve
the order of the virtual base class, and do not add comments or whitespace
between them, as the reader can refer to the virtual base class for more
information."

[Dai Mikurube (NOT FULLTIME), 2011/05/17 09:18:40]

Done.

 
   UsageTracker* GetUsageTracker(StorageType type) const;
 
   void DidGetTemporaryGlobalQuota(int64 quota);
 
   void DeleteOnCorrectThread() const;
 
   const bool is_incognito_;
   const FilePath profile_path_;
 
   scoped_refptr<QuotaManagerProxy> proxy_;
   bool db_initialized_;
   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_;
+  scoped_refptr<QuotaTemporaryStorageEvictor> temporary_storage_evictor_;
 
   UsageAndQuotaDispatcherTaskMap usage_and_quota_dispatchers_;
 
+  int num_deletion_requested_clients_;
+  int num_deleted_clients_;
+
   int64 temporary_global_quota_;
   QuotaCallbackQueue temporary_global_quota_callbacks_;
 
   // Map from origin to count.
   std::map<GURL, int> origins_in_use_;
 
   DISALLOW_COPY_AND_ASSIGN(QuotaManager);
 };
 
 struct QuotaManagerDeleter {
@@ skipping 31 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_