webkit/appcache/appcache_quota_client.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef WEBKIT_APPCACHE_APPCACHE_QUOTA_CLIENT_H_
   6 #define WEBKIT_APPCACHE_APPCACHE_QUOTA_CLIENT_H_
   7
   8 #include <deque>
   9 #include <map>
  10 #include <string>
  11
  12 #include "base/gtest_prod_util.h"
  13 #include "base/memory/ref_counted.h"
  14 #include "base/memory/scoped_ptr.h"
  15 #include "net/base/completion_callback.h"
  16 #include "webkit/appcache/appcache_storage.h"
  17 #include "webkit/quota/quota_client.h"
  18 #include "webkit/quota/quota_task.h"
  19 #include "webkit/quota/quota_types.h"
  20 #include "webkit/storage/webkit_storage_export.h"
  21
  22 namespace appcache {
  23
  24 class AppCacheService;
  25 class AppCacheStorageImpl;
  26 class AppCacheQuotaClientTest;
  27
  28 // A QuotaClient implementation to integrate the appcache service
  29 // with the quota management system. The QuotaClient interface is
  30 // used on the IO thread by the quota manager. This class deletes
  31 // itself when both the quota manager and the appcache service have
  32 // been destroyed.
  33 class AppCacheQuotaClient : public quota::QuotaClient {
  34  public:
  35   typedef std::deque<base::Closure> RequestQueue;
  36
  37   virtual ~AppCacheQuotaClient();
  38
  39   // QuotaClient method overrides
  40   virtual ID id() const OVERRIDE;
  41   virtual void OnQuotaManagerDestroyed() OVERRIDE;
  42   virtual void GetOriginUsage(const GURL& origin,
  43                               quota::StorageType type,
  44                               const GetUsageCallback& callback) OVERRIDE;
  45   virtual void GetOriginsForType(quota::StorageType type,
  46                                  const GetOriginsCallback& callback) OVERRIDE;
  47   virtual void GetOriginsForHost(quota::StorageType type,
  48                                  const std::string& host,
  49                                  const GetOriginsCallback& callback) OVERRIDE;
  50   virtual void DeleteOriginData(const GURL& origin,
  51                                 quota::StorageType type,
  52                                 const DeletionCallback& callback) OVERRIDE;
  53
  54  private:
  55   friend class AppCacheService;  // for NotifyAppCacheIsDestroyed
  56   friend class AppCacheStorageImpl;  // for NotifyAppCacheIsReady
  57   friend class AppCacheQuotaClientTest;
  58
  59   WEBKIT_STORAGE_EXPORT explicit AppCacheQuotaClient(AppCacheService* service);
  60
  61   void DidDeleteAppCachesForOrigin(int rv);
  62   void GetOriginsHelper(quota::StorageType type,
  63                         const std::string& opt_host,
  64                         const GetOriginsCallback& callback);
  65   void ProcessPendingRequests();
  66   void DeletePendingRequests();
  67   const AppCacheStorage::UsageMap* GetUsageMap();
  68   net::CancelableCompletionCallback* GetServiceDeleteCallback();
  69
  70   // For use by appcache internals during initialization and shutdown.
  71   WEBKIT_STORAGE_EXPORT void NotifyAppCacheReady();
  72   WEBKIT_STORAGE_EXPORT void NotifyAppCacheDestroyed();
  73
  74   // Prior to appcache service being ready, we have to queue
  75   // up reqeusts and defer acting on them until we're ready.
  76   RequestQueue pending_batch_requests_;
  77   RequestQueue pending_serial_requests_;
  78
  79   // And once it's ready, we can only handle one delete request at a time,
  80   // so we queue up additional requests while one is in already in progress.
  81   DeletionCallback current_delete_request_callback_;
  82   scoped_ptr<net::CancelableCompletionCallback> service_delete_callback_;
  83
  84   AppCacheService* service_;
  85   bool appcache_is_ready_;
  86   bool quota_manager_is_destroyed_;
  87
  88   DISALLOW_COPY_AND_ASSIGN(AppCacheQuotaClient);
  89 };
  90
  91 }  // namespace appcache
  92
  93 #endif  // WEBKIT_APPCACHE_APPCACHE_QUOTA_CLIENT_H_