1 // Copyright (c) 2012 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.
5 #include "content/browser/appcache/appcache_quota_client.h"
11 #include "base/bind.h"
12 #include "base/bind_helpers.h"
13 #include "content/browser/appcache/appcache_service_impl.h"
15 using quota::QuotaClient;
18 quota::QuotaStatusCode NetErrorCodeToQuotaStatus(int code) {
20 return quota::kQuotaStatusOk;
21 else if (code == net::ERR_ABORTED)
22 return quota::kQuotaErrorAbort;
24 return quota::kQuotaStatusUnknown;
27 void RunFront(content::AppCacheQuotaClient::RequestQueue* queue) {
28 base::Closure request = queue->front();
36 AppCacheQuotaClient::AppCacheQuotaClient(AppCacheServiceImpl* service)
38 appcache_is_ready_(false),
39 quota_manager_is_destroyed_(false) {
42 AppCacheQuotaClient::~AppCacheQuotaClient() {
43 DCHECK(pending_batch_requests_.empty());
44 DCHECK(pending_serial_requests_.empty());
45 DCHECK(current_delete_request_callback_.is_null());
48 QuotaClient::ID AppCacheQuotaClient::id() const {
52 void AppCacheQuotaClient::OnQuotaManagerDestroyed() {
53 DeletePendingRequests();
54 if (!current_delete_request_callback_.is_null()) {
55 current_delete_request_callback_.Reset();
56 GetServiceDeleteCallback()->Cancel();
59 quota_manager_is_destroyed_ = true;
64 void AppCacheQuotaClient::GetOriginUsage(
66 quota::StorageType type,
67 const GetUsageCallback& callback) {
68 DCHECK(!callback.is_null());
69 DCHECK(!quota_manager_is_destroyed_);
76 if (!appcache_is_ready_) {
77 pending_batch_requests_.push_back(
78 base::Bind(&AppCacheQuotaClient::GetOriginUsage,
79 base::Unretained(this), origin, type, callback));
83 if (type != quota::kStorageTypeTemporary) {
88 const AppCacheStorage::UsageMap* map = GetUsageMap();
89 AppCacheStorage::UsageMap::const_iterator found = map->find(origin);
90 if (found == map->end()) {
94 callback.Run(found->second);
97 void AppCacheQuotaClient::GetOriginsForType(
98 quota::StorageType type,
99 const GetOriginsCallback& callback) {
100 GetOriginsHelper(type, std::string(), callback);
103 void AppCacheQuotaClient::GetOriginsForHost(
104 quota::StorageType type,
105 const std::string& host,
106 const GetOriginsCallback& callback) {
107 DCHECK(!callback.is_null());
109 callback.Run(std::set<GURL>());
112 GetOriginsHelper(type, host, callback);
115 void AppCacheQuotaClient::DeleteOriginData(const GURL& origin,
116 quota::StorageType type,
117 const DeletionCallback& callback) {
118 DCHECK(!quota_manager_is_destroyed_);
121 callback.Run(quota::kQuotaErrorAbort);
125 if (!appcache_is_ready_ || !current_delete_request_callback_.is_null()) {
126 pending_serial_requests_.push_back(
127 base::Bind(&AppCacheQuotaClient::DeleteOriginData,
128 base::Unretained(this), origin, type, callback));
132 current_delete_request_callback_ = callback;
133 if (type != quota::kStorageTypeTemporary) {
134 DidDeleteAppCachesForOrigin(net::OK);
138 service_->DeleteAppCachesForOrigin(
139 origin, GetServiceDeleteCallback()->callback());
142 bool AppCacheQuotaClient::DoesSupport(quota::StorageType type) const {
143 return type == quota::kStorageTypeTemporary;
146 void AppCacheQuotaClient::DidDeleteAppCachesForOrigin(int rv) {
148 if (quota_manager_is_destroyed_)
151 // Finish the request by calling our callers callback.
152 current_delete_request_callback_.Run(NetErrorCodeToQuotaStatus(rv));
153 current_delete_request_callback_.Reset();
154 if (pending_serial_requests_.empty())
157 // Start the next in the queue.
158 RunFront(&pending_serial_requests_);
161 void AppCacheQuotaClient::GetOriginsHelper(
162 quota::StorageType type,
163 const std::string& opt_host,
164 const GetOriginsCallback& callback) {
165 DCHECK(!callback.is_null());
166 DCHECK(!quota_manager_is_destroyed_);
169 callback.Run(std::set<GURL>());
173 if (!appcache_is_ready_) {
174 pending_batch_requests_.push_back(
175 base::Bind(&AppCacheQuotaClient::GetOriginsHelper,
176 base::Unretained(this), type, opt_host, callback));
180 if (type != quota::kStorageTypeTemporary) {
181 callback.Run(std::set<GURL>());
185 const AppCacheStorage::UsageMap* map = GetUsageMap();
186 std::set<GURL> origins;
187 for (AppCacheStorage::UsageMap::const_iterator iter = map->begin();
188 iter != map->end(); ++iter) {
189 if (opt_host.empty() || iter->first.host() == opt_host)
190 origins.insert(iter->first);
192 callback.Run(origins);
195 void AppCacheQuotaClient::ProcessPendingRequests() {
196 DCHECK(appcache_is_ready_);
197 while (!pending_batch_requests_.empty())
198 RunFront(&pending_batch_requests_);
200 if (!pending_serial_requests_.empty())
201 RunFront(&pending_serial_requests_);
204 void AppCacheQuotaClient::DeletePendingRequests() {
205 pending_batch_requests_.clear();
206 pending_serial_requests_.clear();
209 const AppCacheStorage::UsageMap* AppCacheQuotaClient::GetUsageMap() {
211 return service_->storage()->usage_map();
214 net::CancelableCompletionCallback*
215 AppCacheQuotaClient::GetServiceDeleteCallback() {
216 // Lazily created due to CancelableCompletionCallback's threading
217 // restrictions, there is no way to detach from the thread created on.
218 if (!service_delete_callback_) {
219 service_delete_callback_.reset(
220 new net::CancelableCompletionCallback(
221 base::Bind(&AppCacheQuotaClient::DidDeleteAppCachesForOrigin,
222 base::Unretained(this))));
224 return service_delete_callback_.get();
227 void AppCacheQuotaClient::NotifyAppCacheReady() {
228 // Can reoccur during reinitialization.
229 if (!appcache_is_ready_) {
230 appcache_is_ready_ = true;
231 ProcessPendingRequests();
235 void AppCacheQuotaClient::NotifyAppCacheDestroyed() {
237 while (!pending_batch_requests_.empty())
238 RunFront(&pending_batch_requests_);
240 while (!pending_serial_requests_.empty())
241 RunFront(&pending_serial_requests_);
243 if (!current_delete_request_callback_.is_null()) {
244 current_delete_request_callback_.Run(quota::kQuotaErrorAbort);
245 current_delete_request_callback_.Reset();
246 GetServiceDeleteCallback()->Cancel();
249 if (quota_manager_is_destroyed_)
253 } // namespace content