Quota: Add proxy for QuotaManager::GetUsageAndQuota

webkit/browser/quota/quota_manager.cc

 // Copyright 2013 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 "webkit/browser/quota/quota_manager.h"
 
 #include <algorithm>
 #include <deque>
 #include <functional>
 #include <set>
@@ skipping 25 matching lines @@
 namespace quota {
 
 namespace {
 
 const int64 kMBytes = 1024 * 1024;
 const int kMinutesInMilliSeconds = 60 * 1000;
 
 const int64 kReportHistogramInterval = 60 * 60 * 1000;  // 1 hour
 const double kTemporaryQuotaRatioToAvail = 1.0 / 3.0;  // 33%
 
+void DidGetUsageAndQuota(
+    base::SingleThreadTaskRunner* original_task_runner,
+    const QuotaManagerProxy::GetUsageAndQuotaCallback& callback,
+    QuotaStatusCode status, int64 usage, int64 quota) {
+  if (!original_task_runner->BelongsToCurrentThread()) {
+    original_task_runner->PostTask(
+        FROM_HERE,
+        base::Bind(&DidGetUsageAndQuota,
+                   make_scoped_refptr(original_task_runner),
+                   callback, status, usage, quota));
+    return;
+  }
+  callback.Run(status, usage, quota);
+}
+
 }  // namespace
 
 // Arbitrary for now, but must be reasonably small so that
 // in-memory databases can fit.
 // TODO(kinuko): Refer SysInfo::AmountOfPhysicalMemory() to determine this.
 const int64 QuotaManager::kIncognitoDefaultQuotaLimit = 100 * kMBytes;
 
 const int64 QuotaManager::kNoLimit = kint64max;
 
 const int QuotaManager::kPerHostTemporaryPortion = 5;  // 20%
@@ skipping 1617 matching lines @@
     io_thread_->PostTask(
         FROM_HERE,
         base::Bind(&QuotaManagerProxy::SetUsageCacheEnabled, this,
                    client_id, origin, type, enabled));
     return;
   }
   if (manager_)
     manager_->SetUsageCacheEnabled(client_id, origin, type, enabled);
 }
 
+void QuotaManagerProxy::GetUsageAndQuota(
+    base::SingleThreadTaskRunner* original_task_runner,
+    const GURL& origin,
+    StorageType type,
+    const GetUsageAndQuotaCallback& callback) {
+  if (!io_thread_->BelongsToCurrentThread()) {
+    io_thread_->PostTask(
+        FROM_HERE,
+        base::Bind(&QuotaManagerProxy::GetUsageAndQuota, this,
+                   make_scoped_refptr(original_task_runner),
+                   origin, type, callback));
+    return;
+  }
+  if (!manager_) {
+    DidGetUsageAndQuota(original_task_runner, callback, kQuotaErrorAbort, 0, 0);
+    return;
+  }
+  manager_->GetUsageAndQuota(
+      origin, type,
+      base::Bind(&DidGetUsageAndQuota,
+                 make_scoped_refptr(original_task_runner), callback));
+}
+
 QuotaManager* QuotaManagerProxy::quota_manager() const {
   DCHECK(!io_thread_.get() || io_thread_->BelongsToCurrentThread());
   return manager_;
 }
 
 QuotaManagerProxy::QuotaManagerProxy(
     QuotaManager* manager, base::SingleThreadTaskRunner* io_thread)
     : manager_(manager), io_thread_(io_thread) {
 }
 
 QuotaManagerProxy::~QuotaManagerProxy() {
 }
 
 }  // namespace quota