Home | History | Annotate | Download | only in child 
      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/child/worker_task_runner.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 WorkerTaskRunner::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   virtual ~QuotaDispatcher();
     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   // WorkerTaskRunner::Observer implementation.
     57   virtual void OnWorkerRunLoopStopped() 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_
     95