storage/browser/quota/quota_manager_proxy.cc

   1 // Copyright 2014 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 "storage/browser/quota/quota_manager_proxy.h"
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/callback.h"
  10 #include "base/sequenced_task_runner.h"
  11 #include "base/single_thread_task_runner.h"
  12 #include "base/strings/string_number_conversions.h"
  13 #include "base/task_runner_util.h"
  14
  15 namespace storage {
  16
  17 namespace {
  18
  19 void DidGetUsageAndQuota(
  20     base::SequencedTaskRunner* original_task_runner,
  21     const QuotaManagerProxy::GetUsageAndQuotaCallback& callback,
  22     QuotaStatusCode status, int64 usage, int64 quota) {
  23   if (!original_task_runner->RunsTasksOnCurrentThread()) {
  24     original_task_runner->PostTask(
  25         FROM_HERE,
  26         base::Bind(&DidGetUsageAndQuota,
  27                    make_scoped_refptr(original_task_runner),
  28                    callback, status, usage, quota));
  29     return;
  30   }
  31   callback.Run(status, usage, quota);
  32 }
  33
  34 }  // namespace
  35
  36 void QuotaManagerProxy::RegisterClient(QuotaClient* client) {
  37   if (!io_thread_->BelongsToCurrentThread() &&
  38       io_thread_->PostTask(
  39           FROM_HERE,
  40           base::Bind(&QuotaManagerProxy::RegisterClient, this, client))) {
  41     return;
  42   }
  43
  44   if (manager_)
  45     manager_->RegisterClient(client);
  46   else
  47     client->OnQuotaManagerDestroyed();
  48 }
  49
  50 void QuotaManagerProxy::NotifyStorageAccessed(
  51     QuotaClient::ID client_id,
  52     const GURL& origin,
  53     StorageType type) {
  54   if (!io_thread_->BelongsToCurrentThread()) {
  55     io_thread_->PostTask(
  56         FROM_HERE,
  57         base::Bind(&QuotaManagerProxy::NotifyStorageAccessed, this, client_id,
  58                    origin, type));
  59     return;
  60   }
  61
  62   if (manager_)
  63     manager_->NotifyStorageAccessed(client_id, origin, type);
  64 }
  65
  66 void QuotaManagerProxy::NotifyStorageModified(
  67     QuotaClient::ID client_id,
  68     const GURL& origin,
  69     StorageType type,
  70     int64 delta) {
  71   if (!io_thread_->BelongsToCurrentThread()) {
  72     io_thread_->PostTask(
  73         FROM_HERE,
  74         base::Bind(&QuotaManagerProxy::NotifyStorageModified, this, client_id,
  75                    origin, type, delta));
  76     return;
  77   }
  78
  79   if (manager_)
  80     manager_->NotifyStorageModified(client_id, origin, type, delta);
  81 }
  82
  83 void QuotaManagerProxy::NotifyOriginInUse(
  84     const GURL& origin) {
  85   if (!io_thread_->BelongsToCurrentThread()) {
  86     io_thread_->PostTask(
  87         FROM_HERE,
  88         base::Bind(&QuotaManagerProxy::NotifyOriginInUse, this, origin));
  89     return;
  90   }
  91
  92   if (manager_)
  93     manager_->NotifyOriginInUse(origin);
  94 }
  95
  96 void QuotaManagerProxy::NotifyOriginNoLongerInUse(
  97     const GURL& origin) {
  98   if (!io_thread_->BelongsToCurrentThread()) {
  99     io_thread_->PostTask(
 100         FROM_HERE,
 101         base::Bind(&QuotaManagerProxy::NotifyOriginNoLongerInUse, this,
 102                    origin));
 103     return;
 104   }
 105   if (manager_)
 106     manager_->NotifyOriginNoLongerInUse(origin);
 107 }
 108
 109 void QuotaManagerProxy::SetUsageCacheEnabled(QuotaClient::ID client_id,
 110                                              const GURL& origin,
 111                                              StorageType type,
 112                                              bool enabled) {
 113   if (!io_thread_->BelongsToCurrentThread()) {
 114     io_thread_->PostTask(
 115         FROM_HERE,
 116         base::Bind(&QuotaManagerProxy::SetUsageCacheEnabled, this,
 117                    client_id, origin, type, enabled));
 118     return;
 119   }
 120   if (manager_)
 121     manager_->SetUsageCacheEnabled(client_id, origin, type, enabled);
 122 }
 123
 124 void QuotaManagerProxy::GetUsageAndQuota(
 125     base::SequencedTaskRunner* original_task_runner,
 126     const GURL& origin,
 127     StorageType type,
 128     const GetUsageAndQuotaCallback& callback) {
 129   if (!io_thread_->BelongsToCurrentThread()) {
 130     io_thread_->PostTask(
 131         FROM_HERE,
 132         base::Bind(&QuotaManagerProxy::GetUsageAndQuota, this,
 133                    make_scoped_refptr(original_task_runner),
 134                    origin, type, callback));
 135     return;
 136   }
 137   if (!manager_) {
 138     DidGetUsageAndQuota(original_task_runner, callback, kQuotaErrorAbort, 0, 0);
 139     return;
 140   }
 141   manager_->GetUsageAndQuota(
 142       origin, type,
 143       base::Bind(&DidGetUsageAndQuota,
 144                  make_scoped_refptr(original_task_runner), callback));
 145 }
 146
 147 QuotaManager* QuotaManagerProxy::quota_manager() const {
 148   DCHECK(!io_thread_.get() || io_thread_->BelongsToCurrentThread());
 149   return manager_;
 150 }
 151
 152 QuotaManagerProxy::QuotaManagerProxy(
 153     QuotaManager* manager,
 154     const scoped_refptr<base::SingleThreadTaskRunner>& io_thread)
 155     : manager_(manager), io_thread_(io_thread) {
 156 }
 157
 158 QuotaManagerProxy::~QuotaManagerProxy() {
 159 }
 160
 161 }  // namespace storage