Implement QuotaTemporaryStorageEvictor.

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 "base/basictypes.h"
 #include "base/callback.h"
 #include "base/file_path.h"
 #include "base/memory/scoped_callback_factory.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "webkit/quota/quota_client.h"
 #include "webkit/quota/quota_task.h"
 #include "webkit/quota/quota_types.h"
 
 class FilePath;
 
 namespace quota {
 
 class QuotaDatabase;
+class QuotaTemporaryStorageEvictor;
 class UsageTracker;
 
 struct QuotaManagerDeleter;
 class QuotaManagerProxy;
 
 // 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 base::RefCountedThreadSafe<
                          QuotaManager, QuotaManagerDeleter> {
  public:
   typedef Callback3<QuotaStatusCode,
                     int64 /* usage */,
                     int64 /* quota */>::Type GetUsageAndQuotaCallback;
   typedef Callback2<QuotaStatusCode,
                     int64 /* granted_quota */>::Type RequestQuotaCallback;
+  typedef Callback1<QuotaStatusCode>::Type DeleteOriginDataCallback;
 
   QuotaManager(bool is_incognito,
                const FilePath& profile_path,
                scoped_refptr<base::MessageLoopProxy> io_thread,
                scoped_refptr<base::MessageLoopProxy> db_thread);
 
   virtual ~QuotaManager();
 
   // Returns a proxy object that can be used on any thread.
   QuotaManagerProxy* proxy() { return proxy_.get(); }
@@ skipping 41 matching lines @@
 
   class GlobalUsageQueryTask;
   class HostUsageQueryTask;
 
   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);
 
   // Called by clients via proxy.
   // QuotaClients must call this method whenever they have made any
   // modifications that change the amount of data stored in their storage.
   void NotifyStorageModified(QuotaClient::ID client_id,
                              const GURL& origin,
                              StorageType type,
                              int64 delta);
 
+  // It must be called on the io_thread.
+  // It is called from QuotaTemporaryStorageEvictor.
+  virtual void DeleteOriginDataOnIOThread(

[kinuko, 2011/05/13 05:49:04]

nit: for now all the methods of QuotaManager need to be called on io thread
(it's noted in the comment at the top of this file), so maybe you can drop
OnIOThread from the method name.

[Dai Mikurube (NOT FULLTIME), 2011/05/13 07:52:40]

Done.

+      const GURL& origin,
+      StorageType type,
+      DeleteOriginDataCallback* callback);
+
   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_;
 
   int64 temporary_global_quota_;
   QuotaCallbackQueue temporary_global_quota_callbacks_;
 
   DISALLOW_COPY_AND_ASSIGN(QuotaManager);
 };
 
 struct QuotaManagerDeleter {
@@ skipping 23 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_