quota_manager_proxy.cc revision 1320f92c476a1ad9d19dba2a48c72b75566198e9 
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
15namespace storage {
16
17namespace {
18
19void 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
36void 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
50void 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
66void 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
83void 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
96void 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
109void 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
124void 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
147QuotaManager* QuotaManagerProxy::quota_manager() const {
148  DCHECK(!io_thread_.get() || io_thread_->BelongsToCurrentThread());
149  return manager_;
150}
151
152QuotaManagerProxy::QuotaManagerProxy(
153    QuotaManager* manager,
154    const scoped_refptr<base::SingleThreadTaskRunner>& io_thread)
155    : manager_(manager), io_thread_(io_thread) {
156}
157
158QuotaManagerProxy::~QuotaManagerProxy() {
159}
160
161}  // namespace storage
162