content/child/quota_dispatcher.cc

   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 #include "content/child/quota_dispatcher.h"
   6
   7 #include "base/basictypes.h"
   8 #include "base/lazy_instance.h"
   9 #include "base/threading/thread_local.h"
  10 #include "content/child/child_thread.h"
  11 #include "content/child/quota_message_filter.h"
  12 #include "content/child/thread_safe_sender.h"
  13 #include "content/common/quota_messages.h"
  14 #include "third_party/WebKit/public/platform/WebStorageQuotaCallbacks.h"
  15 #include "third_party/WebKit/public/platform/WebStorageQuotaType.h"
  16 #include "third_party/WebKit/public/web/WebUserGestureIndicator.h"
  17 #include "url/gurl.h"
  18
  19 using blink::WebStorageQuotaCallbacks;
  20 using blink::WebStorageQuotaError;
  21 using blink::WebStorageQuotaType;
  22 using storage::QuotaStatusCode;
  23 using storage::StorageType;
  24
  25 namespace content {
  26
  27 static base::LazyInstance<base::ThreadLocalPointer<QuotaDispatcher> >::Leaky
  28     g_quota_dispatcher_tls = LAZY_INSTANCE_INITIALIZER;
  29
  30 namespace {
  31
  32 // QuotaDispatcher::Callback implementation for WebStorageQuotaCallbacks.
  33 class WebStorageQuotaDispatcherCallback : public QuotaDispatcher::Callback {
  34  public:
  35   explicit WebStorageQuotaDispatcherCallback(
  36       blink::WebStorageQuotaCallbacks callback)
  37       : callbacks_(callback) {}
  38   virtual ~WebStorageQuotaDispatcherCallback() {}
  39
  40   virtual void DidQueryStorageUsageAndQuota(int64 usage, int64 quota) OVERRIDE {
  41     callbacks_.didQueryStorageUsageAndQuota(usage, quota);
  42   }
  43   virtual void DidGrantStorageQuota(int64 usage, int64 granted_quota) OVERRIDE {
  44     callbacks_.didGrantStorageQuota(usage, granted_quota);
  45   }
  46   virtual void DidFail(storage::QuotaStatusCode error) OVERRIDE {
  47     callbacks_.didFail(static_cast<WebStorageQuotaError>(error));
  48   }
  49
  50  private:
  51   blink::WebStorageQuotaCallbacks callbacks_;
  52
  53   DISALLOW_COPY_AND_ASSIGN(WebStorageQuotaDispatcherCallback);
  54 };
  55
  56 int CurrentWorkerId() {
  57   return WorkerTaskRunner::Instance()->CurrentWorkerId();
  58 }
  59
  60 }  // namespace
  61
  62 QuotaDispatcher::QuotaDispatcher(ThreadSafeSender* thread_safe_sender,
  63                                  QuotaMessageFilter* quota_message_filter)
  64     : thread_safe_sender_(thread_safe_sender),
  65       quota_message_filter_(quota_message_filter) {
  66   g_quota_dispatcher_tls.Pointer()->Set(this);
  67 }
  68
  69 QuotaDispatcher::~QuotaDispatcher() {
  70   IDMap<Callback, IDMapOwnPointer>::iterator iter(&pending_quota_callbacks_);
  71   while (!iter.IsAtEnd()) {
  72     iter.GetCurrentValue()->DidFail(storage::kQuotaErrorAbort);
  73     iter.Advance();
  74   }
  75
  76   g_quota_dispatcher_tls.Pointer()->Set(NULL);
  77 }
  78
  79 QuotaDispatcher* QuotaDispatcher::ThreadSpecificInstance(
  80     ThreadSafeSender* thread_safe_sender,
  81     QuotaMessageFilter* quota_message_filter) {
  82   if (g_quota_dispatcher_tls.Pointer()->Get())
  83     return g_quota_dispatcher_tls.Pointer()->Get();
  84
  85   QuotaDispatcher* dispatcher = new QuotaDispatcher(
  86       thread_safe_sender, quota_message_filter);
  87   if (WorkerTaskRunner::Instance()->CurrentWorkerId())
  88     WorkerTaskRunner::Instance()->AddStopObserver(dispatcher);
  89   return dispatcher;
  90 }
  91
  92 void QuotaDispatcher::OnWorkerRunLoopStopped() {
  93   delete this;
  94 }
  95
  96 void QuotaDispatcher::OnMessageReceived(const IPC::Message& msg) {
  97   bool handled = true;
  98   IPC_BEGIN_MESSAGE_MAP(QuotaDispatcher, msg)
  99     IPC_MESSAGE_HANDLER(QuotaMsg_DidGrantStorageQuota,
 100                         DidGrantStorageQuota)
 101     IPC_MESSAGE_HANDLER(QuotaMsg_DidQueryStorageUsageAndQuota,
 102                         DidQueryStorageUsageAndQuota);
 103     IPC_MESSAGE_HANDLER(QuotaMsg_DidFail, DidFail);
 104     IPC_MESSAGE_UNHANDLED(handled = false)
 105   IPC_END_MESSAGE_MAP()
 106   DCHECK(handled) << "Unhandled message:" << msg.type();
 107 }
 108
 109 void QuotaDispatcher::QueryStorageUsageAndQuota(
 110     const GURL& origin_url,
 111     StorageType type,
 112     Callback* callback) {
 113   DCHECK(callback);
 114   int request_id = quota_message_filter_->GenerateRequestID(CurrentWorkerId());
 115   pending_quota_callbacks_.AddWithID(callback, request_id);
 116   thread_safe_sender_->Send(new QuotaHostMsg_QueryStorageUsageAndQuota(
 117       request_id, origin_url, type));
 118 }
 119
 120 void QuotaDispatcher::RequestStorageQuota(
 121     int render_view_id,
 122     const GURL& origin_url,
 123     StorageType type,
 124     uint64 requested_size,
 125     Callback* callback) {
 126   DCHECK(callback);
 127   DCHECK(CurrentWorkerId() == 0);
 128   int request_id = quota_message_filter_->GenerateRequestID(CurrentWorkerId());
 129   pending_quota_callbacks_.AddWithID(callback, request_id);
 130
 131   StorageQuotaParams params;
 132   params.render_view_id = render_view_id;
 133   params.request_id = request_id;
 134   params.origin_url = origin_url;
 135   params.storage_type = type;
 136   params.requested_size = requested_size;
 137   params.user_gesture =
 138       blink::WebUserGestureIndicator::isProcessingUserGesture();
 139   thread_safe_sender_->Send(new QuotaHostMsg_RequestStorageQuota(params));
 140 }
 141
 142 // static
 143 QuotaDispatcher::Callback*
 144 QuotaDispatcher::CreateWebStorageQuotaCallbacksWrapper(
 145     blink::WebStorageQuotaCallbacks callbacks) {
 146   return new WebStorageQuotaDispatcherCallback(callbacks);
 147 }
 148
 149 void QuotaDispatcher::DidGrantStorageQuota(
 150     int request_id,
 151     int64 current_usage,
 152     int64 granted_quota) {
 153   Callback* callback = pending_quota_callbacks_.Lookup(request_id);
 154   DCHECK(callback);
 155   callback->DidGrantStorageQuota(current_usage, granted_quota);
 156   pending_quota_callbacks_.Remove(request_id);
 157 }
 158
 159 void QuotaDispatcher::DidQueryStorageUsageAndQuota(
 160     int request_id,
 161     int64 current_usage,
 162     int64 current_quota) {
 163   Callback* callback = pending_quota_callbacks_.Lookup(request_id);
 164   DCHECK(callback);
 165   callback->DidQueryStorageUsageAndQuota(current_usage, current_quota);
 166   pending_quota_callbacks_.Remove(request_id);
 167 }
 168
 169 void QuotaDispatcher::DidFail(
 170     int request_id,
 171     QuotaStatusCode error) {
 172   Callback* callback = pending_quota_callbacks_.Lookup(request_id);
 173   DCHECK(callback);
 174   callback->DidFail(error);
 175   pending_quota_callbacks_.Remove(request_id);
 176 }
 177
 178 COMPILE_ASSERT(int(blink::WebStorageQuotaTypeTemporary) ==
 179                    int(storage::kStorageTypeTemporary),
 180                mismatching_enums);
 181 COMPILE_ASSERT(int(blink::WebStorageQuotaTypePersistent) ==
 182                    int(storage::kStorageTypePersistent),
 183                mismatching_enums);
 184
 185 COMPILE_ASSERT(int(blink::WebStorageQuotaErrorNotSupported) ==
 186                    int(storage::kQuotaErrorNotSupported),
 187                mismatching_enums);
 188 COMPILE_ASSERT(int(blink::WebStorageQuotaErrorAbort) ==
 189                    int(storage::kQuotaErrorAbort),
 190                mismatching_enums);
 191
 192 }  // namespace content