Make Platform::queryStorageUsageAndQuota work from worker threads

content/browser/renderer_host/quota_dispatcher_host.cc

 // Copyright (c) 2012 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.
 
 #include "content/browser/renderer_host/quota_dispatcher_host.h"
 
 #include "base/bind.h"
 #include "base/memory/weak_ptr.h"
 #include "content/common/quota_messages.h"
 #include "content/public/browser/quota_permission_context.h"
 #include "net/base/net_util.h"
 #include "url/gurl.h"
 #include "webkit/browser/quota/quota_manager.h"
 
 using quota::QuotaClient;
 using quota::QuotaManager;
 using quota::QuotaStatusCode;
 using quota::StorageType;
 
 namespace content {
 
+namespace {
+const int kDefaultThreadId = 0;
+}
+
 // Created one per request to carry the request's request_id around.
 // Dispatches requests from renderer/worker to the QuotaManager and
 // sends back the response to the renderer/worker.
 class QuotaDispatcherHost::RequestDispatcher {
  public:
   RequestDispatcher(QuotaDispatcherHost* dispatcher_host,
                     int request_id)
       : dispatcher_host_(dispatcher_host),
         request_id_(request_id) {
     dispatcher_host_->outstanding_requests_.AddWithID(this, request_id_);
@@ skipping 19 matching lines @@
  private:
   QuotaDispatcherHost* dispatcher_host_;
   int request_id_;
 };
 
 class QuotaDispatcherHost::QueryUsageAndQuotaDispatcher
     : public RequestDispatcher {
  public:
   QueryUsageAndQuotaDispatcher(
       QuotaDispatcherHost* dispatcher_host,
+      int ipc_thread_id,
       int request_id)
       : RequestDispatcher(dispatcher_host, request_id),
+        ipc_thread_id_(ipc_thread_id),
         weak_factory_(this) {}
   virtual ~QueryUsageAndQuotaDispatcher() {}
 
   void QueryStorageUsageAndQuota(const GURL& origin, StorageType type) {
     quota_manager()->GetUsageAndQuotaForWebApps(
         origin, type,
         base::Bind(&QueryUsageAndQuotaDispatcher::DidQueryStorageUsageAndQuota,
                    weak_factory_.GetWeakPtr()));
   }
 
  private:
   void DidQueryStorageUsageAndQuota(
       QuotaStatusCode status, int64 usage, int64 quota) {
     DCHECK(dispatcher_host());
     if (status != quota::kQuotaStatusOk) {
-      dispatcher_host()->Send(new QuotaMsg_DidFail(request_id(), status));
+      dispatcher_host()->Send(new QuotaMsg_DidFail(
+          ipc_thread_id_, request_id(), status));
     } else {
       dispatcher_host()->Send(new QuotaMsg_DidQueryStorageUsageAndQuota(
-          request_id(), usage, quota));
+          ipc_thread_id_, request_id(), usage, quota));
     }
     Completed();
   }
 
+  int ipc_thread_id_;
   base::WeakPtrFactory<QueryUsageAndQuotaDispatcher> weak_factory_;
 };
 
 class QuotaDispatcherHost::RequestQuotaDispatcher
     : public RequestDispatcher {
  public:
   typedef RequestQuotaDispatcher self_type;
 
   RequestQuotaDispatcher(QuotaDispatcherHost* dispatcher_host,
                          int request_id,
@@ skipping 77 matching lines @@
         base::Bind(&self_type::DidSetHostQuota, weak_factory_.GetWeakPtr()));
   }
 
   void DidSetHostQuota(QuotaStatusCode status, int64 new_quota) {
     DidFinish(status, new_quota);
   }
 
   void DidFinish(QuotaStatusCode status, int64 granted_quota) {
     DCHECK(dispatcher_host());
     if (status != quota::kQuotaStatusOk) {
-      dispatcher_host()->Send(new QuotaMsg_DidFail(request_id(), status));
+      dispatcher_host()->Send(
+          new QuotaMsg_DidFail(kDefaultThreadId, request_id(), status));
     } else {
       dispatcher_host()->Send(new QuotaMsg_DidGrantStorageQuota(
-          request_id(), granted_quota));
+          kDefaultThreadId, request_id(), granted_quota));
     }
     Completed();
   }
 
   const GURL origin_;
   const std::string host_;
   const StorageType type_;
   int64 current_quota_;
   const int64 requested_quota_;
   const int render_view_id_;
@@ skipping 19 matching lines @@
     IPC_MESSAGE_HANDLER(QuotaHostMsg_RequestStorageQuota,
                         OnRequestStorageQuota)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP_EX()
   return handled;
 }
 
 QuotaDispatcherHost::~QuotaDispatcherHost() {}
 
 void QuotaDispatcherHost::OnQueryStorageUsageAndQuota(
+    int ipc_thread_id,
     int request_id,
     const GURL& origin,
     StorageType type) {
   QueryUsageAndQuotaDispatcher* dispatcher = new QueryUsageAndQuotaDispatcher(
-      this, request_id);
+      this, ipc_thread_id, request_id);
   dispatcher->QueryStorageUsageAndQuota(origin, type);
 }
 
 void QuotaDispatcherHost::OnRequestStorageQuota(
     int render_view_id,
     int request_id,
     const GURL& origin,
     StorageType type,
     int64 requested_size) {
   if (quota_manager_->IsStorageUnlimited(origin, type)) {
     // If the origin is marked 'unlimited' we always just return ok.
-    Send(new QuotaMsg_DidGrantStorageQuota(request_id, requested_size));
+    Send(new QuotaMsg_DidGrantStorageQuota(
+        kDefaultThreadId, request_id, requested_size));
     return;
   }
 
   if (type != quota::kStorageTypeTemporary &&
       type != quota::kStorageTypePersistent) {
     // Unsupported storage types.
-    Send(new QuotaMsg_DidFail(request_id, quota::kQuotaErrorNotSupported));
+    Send(new QuotaMsg_DidFail(
+        kDefaultThreadId, request_id, quota::kQuotaErrorNotSupported));
     return;
   }
 
   RequestQuotaDispatcher* dispatcher = new RequestQuotaDispatcher(
       this, request_id, origin, type, requested_size, render_view_id);
   dispatcher->Start();
 }
 
 }  // namespace content