content/child/quota_dispatcher.h

   1 // Copyright (c) 2011 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 CONTENT_CHILD_QUOTA_DISPATCHER_H_
   6 #define CONTENT_CHILD_QUOTA_DISPATCHER_H_
   7
   8 #include <map>
   9 #include <set>
  10
  11 #include "base/basictypes.h"
  12 #include "base/id_map.h"
  13 #include "base/memory/ref_counted.h"
  14 #include "content/public/child/worker_thread.h"
  15 #include "storage/common/quota/quota_types.h"
  16
  17 class GURL;
  18
  19 namespace IPC {
  20 class Message;
  21 }
  22
  23 namespace blink {
  24 class WebStorageQuotaCallbacks;
  25 }
  26
  27 namespace content {
  28
  29 class ThreadSafeSender;
  30 class QuotaMessageFilter;
  31
  32 // Dispatches and sends quota related messages sent to/from a child
  33 // process from/to the main browser process.  There is one instance
  34 // per each thread.  Thread-specific instance can be obtained by
  35 // ThreadSpecificInstance().
  36 class QuotaDispatcher : public WorkerThread::Observer {
  37  public:
  38   class Callback {
  39    public:
  40     virtual ~Callback() {}
  41     virtual void DidQueryStorageUsageAndQuota(int64 usage, int64 quota) = 0;
  42     virtual void DidGrantStorageQuota(int64 usage, int64 granted_quota) = 0;
  43     virtual void DidFail(storage::QuotaStatusCode status) = 0;
  44   };
  45
  46   QuotaDispatcher(ThreadSafeSender* thread_safe_sender,
  47                   QuotaMessageFilter* quota_message_filter);
  48   ~QuotaDispatcher() override;
  49
  50   // |thread_safe_sender| and |quota_message_filter| are used if
  51   // calling this leads to construction.
  52   static QuotaDispatcher* ThreadSpecificInstance(
  53       ThreadSafeSender* thread_safe_sender,
  54       QuotaMessageFilter* quota_message_filter);
  55
  56   // WorkerThread::Observer implementation.
  57   void WillStopCurrentWorkerThread() override;
  58
  59   void OnMessageReceived(const IPC::Message& msg);
  60
  61   void QueryStorageUsageAndQuota(const GURL& gurl,
  62                                  storage::StorageType type,
  63                                  Callback* callback);
  64   void RequestStorageQuota(int render_view_id,
  65                            const GURL& gurl,
  66                            storage::StorageType type,
  67                            uint64 requested_size,
  68                            Callback* callback);
  69
  70   // Creates a new Callback instance for WebStorageQuotaCallbacks.
  71   static Callback* CreateWebStorageQuotaCallbacksWrapper(
  72       blink::WebStorageQuotaCallbacks callbacks);
  73
  74  private:
  75   // Message handlers.
  76   void DidQueryStorageUsageAndQuota(int request_id,
  77                                     int64 current_usage,
  78                                     int64 current_quota);
  79   void DidGrantStorageQuota(int request_id,
  80                             int64 current_usage,
  81                             int64 granted_quota);
  82   void DidFail(int request_id, storage::QuotaStatusCode error);
  83
  84   IDMap<Callback, IDMapOwnPointer> pending_quota_callbacks_;
  85
  86   scoped_refptr<ThreadSafeSender> thread_safe_sender_;
  87   scoped_refptr<QuotaMessageFilter> quota_message_filter_;
  88
  89   DISALLOW_COPY_AND_ASSIGN(QuotaDispatcher);
  90 };
  91
  92 }  // namespace content
  93
  94 #endif  // CONTENT_CHILD_QUOTA_DISPATCHER_H_