| OLD | NEW |
|---|
| (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 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 344493002:
Move all remaining appcache-related code to content namespace (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src