Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(121)

Side by Side Diff: webkit/browser/appcache/appcache_quota_client.cc

Issue 344493002: Move all remaining appcache-related code to content namespace (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: rebase Created 6 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
(Empty)
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.
4
5 #include "webkit/browser/appcache/appcache_quota_client.h"
6
7 #include <algorithm>
8 #include <map>
9 #include <set>
10
11 #include "base/bind.h"
12 #include "base/bind_helpers.h"
13 #include "webkit/browser/appcache/appcache_service_impl.h"
14
15 using quota::QuotaClient;
16
17 namespace {
18 quota::QuotaStatusCode NetErrorCodeToQuotaStatus(int code) {
19 if (code == net::OK)
20 return quota::kQuotaStatusOk;
21 else if (code == net::ERR_ABORTED)
22 return quota::kQuotaErrorAbort;
23 else
24 return quota::kQuotaStatusUnknown;
25 }
26
27 void RunFront(appcache::AppCacheQuotaClient::RequestQueue* queue) {
28 base::Closure request = queue->front();
29 queue->pop_front();
30 request.Run();
31 }
32 } // namespace
33
34 namespace appcache {
35
36 AppCacheQuotaClient::AppCacheQuotaClient(AppCacheServiceImpl* service)
37 : service_(service),
38 appcache_is_ready_(false),
39 quota_manager_is_destroyed_(false) {
40 }
41
42 AppCacheQuotaClient::~AppCacheQuotaClient() {
43 DCHECK(pending_batch_requests_.empty());
44 DCHECK(pending_serial_requests_.empty());
45 DCHECK(current_delete_request_callback_.is_null());
46 }
47
48 QuotaClient::ID AppCacheQuotaClient::id() const {
49 return kAppcache;
50 }
51
52 void AppCacheQuotaClient::OnQuotaManagerDestroyed() {
53 DeletePendingRequests();
54 if (!current_delete_request_callback_.is_null()) {
55 current_delete_request_callback_.Reset();
56 GetServiceDeleteCallback()->Cancel();
57 }
58
59 quota_manager_is_destroyed_ = true;
60 if (!service_)
61 delete this;
62 }
63
64 void AppCacheQuotaClient::GetOriginUsage(
65 const GURL& origin,
66 quota::StorageType type,
67 const GetUsageCallback& callback) {
68 DCHECK(!callback.is_null());
69 DCHECK(!quota_manager_is_destroyed_);
70
71 if (!service_) {
72 callback.Run(0);
73 return;
74 }
75
76 if (!appcache_is_ready_) {
77 pending_batch_requests_.push_back(
78 base::Bind(&AppCacheQuotaClient::GetOriginUsage,
79 base::Unretained(this), origin, type, callback));
80 return;
81 }
82
83 if (type != quota::kStorageTypeTemporary) {
84 callback.Run(0);
85 return;
86 }
87
88 const AppCacheStorage::UsageMap* map = GetUsageMap();
89 AppCacheStorage::UsageMap::const_iterator found = map->find(origin);
90 if (found == map->end()) {
91 callback.Run(0);
92 return;
93 }
94 callback.Run(found->second);
95 }
96
97 void AppCacheQuotaClient::GetOriginsForType(
98 quota::StorageType type,
99 const GetOriginsCallback& callback) {
100 GetOriginsHelper(type, std::string(), callback);
101 }
102
103 void AppCacheQuotaClient::GetOriginsForHost(
104 quota::StorageType type,
105 const std::string& host,
106 const GetOriginsCallback& callback) {
107 DCHECK(!callback.is_null());
108 if (host.empty()) {
109 callback.Run(std::set<GURL>());
110 return;
111 }
112 GetOriginsHelper(type, host, callback);
113 }
114
115 void AppCacheQuotaClient::DeleteOriginData(const GURL& origin,
116 quota::StorageType type,
117 const DeletionCallback& callback) {
118 DCHECK(!quota_manager_is_destroyed_);
119
120 if (!service_) {
121 callback.Run(quota::kQuotaErrorAbort);
122 return;
123 }
124
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));
129 return;
130 }
131
132 current_delete_request_callback_ = callback;
133 if (type != quota::kStorageTypeTemporary) {
134 DidDeleteAppCachesForOrigin(net::OK);
135 return;
136 }
137
138 service_->DeleteAppCachesForOrigin(
139 origin, GetServiceDeleteCallback()->callback());
140 }
141
142 bool AppCacheQuotaClient::DoesSupport(quota::StorageType type) const {
143 return type == quota::kStorageTypeTemporary;
144 }
145
146 void AppCacheQuotaClient::DidDeleteAppCachesForOrigin(int rv) {
147 DCHECK(service_);
148 if (quota_manager_is_destroyed_)
149 return;
150
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())
155 return;
156
157 // Start the next in the queue.
158 RunFront(&pending_serial_requests_);
159 }
160
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_);
167
168 if (!service_) {
169 callback.Run(std::set<GURL>());
170 return;
171 }
172
173 if (!appcache_is_ready_) {
174 pending_batch_requests_.push_back(
175 base::Bind(&AppCacheQuotaClient::GetOriginsHelper,
176 base::Unretained(this), type, opt_host, callback));
177 return;
178 }
179
180 if (type != quota::kStorageTypeTemporary) {
181 callback.Run(std::set<GURL>());
182 return;
183 }
184
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);
191 }
192 callback.Run(origins);
193 }
194
195 void AppCacheQuotaClient::ProcessPendingRequests() {
196 DCHECK(appcache_is_ready_);
197 while (!pending_batch_requests_.empty())
198 RunFront(&pending_batch_requests_);
199
200 if (!pending_serial_requests_.empty())
201 RunFront(&pending_serial_requests_);
202 }
203
204 void AppCacheQuotaClient::DeletePendingRequests() {
205 pending_batch_requests_.clear();
206 pending_serial_requests_.clear();
207 }
208
209 const AppCacheStorage::UsageMap* AppCacheQuotaClient::GetUsageMap() {
210 DCHECK(service_);
211 return service_->storage()->usage_map();
212 }
213
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))));
223 }
224 return service_delete_callback_.get();
225 }
226
227 void AppCacheQuotaClient::NotifyAppCacheReady() {
228 // Can reoccur during reinitialization.
229 if (!appcache_is_ready_) {
230 appcache_is_ready_ = true;
231 ProcessPendingRequests();
232 }
233 }
234
235 void AppCacheQuotaClient::NotifyAppCacheDestroyed() {
236 service_ = NULL;
237 while (!pending_batch_requests_.empty())
238 RunFront(&pending_batch_requests_);
239
240 while (!pending_serial_requests_.empty())
241 RunFront(&pending_serial_requests_);
242
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();
247 }
248
249 if (quota_manager_is_destroyed_)
250 delete this;
251 }
252
253 } // namespace appcache
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698