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 "content/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 "content/browser/appcache/appcache_service_impl.h" 14 15 using storage::QuotaClient; 16 17 namespace { 18 storage::QuotaStatusCode NetErrorCodeToQuotaStatus(int code) { 19 if (code == net::OK) 20 return storage::kQuotaStatusOk; 21 else if (code == net::ERR_ABORTED) 22 return storage::kQuotaErrorAbort; 23 else 24 return storage::kQuotaStatusUnknown; 25 } 26 27 void RunFront(content::AppCacheQuotaClient::RequestQueue* queue) { 28 base::Closure request = queue->front(); 29 queue->pop_front(); 30 request.Run(); 31 } 32 } // namespace 33 34 namespace content { 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(const GURL& origin, 65 storage::StorageType type, 66 const GetUsageCallback& callback) { 67 DCHECK(!callback.is_null()); 68 DCHECK(!quota_manager_is_destroyed_); 69 70 if (!service_) { 71 callback.Run(0); 72 return; 73 } 74 75 if (!appcache_is_ready_) { 76 pending_batch_requests_.push_back( 77 base::Bind(&AppCacheQuotaClient::GetOriginUsage, 78 base::Unretained(this), origin, type, callback)); 79 return; 80 } 81 82 if (type != storage::kStorageTypeTemporary) { 83 callback.Run(0); 84 return; 85 } 86 87 const AppCacheStorage::UsageMap* map = GetUsageMap(); 88 AppCacheStorage::UsageMap::const_iterator found = map->find(origin); 89 if (found == map->end()) { 90 callback.Run(0); 91 return; 92 } 93 callback.Run(found->second); 94 } 95 96 void AppCacheQuotaClient::GetOriginsForType( 97 storage::StorageType type, 98 const GetOriginsCallback& callback) { 99 GetOriginsHelper(type, std::string(), callback); 100 } 101 102 void AppCacheQuotaClient::GetOriginsForHost( 103 storage::StorageType type, 104 const std::string& host, 105 const GetOriginsCallback& callback) { 106 DCHECK(!callback.is_null()); 107 if (host.empty()) { 108 callback.Run(std::set<GURL>()); 109 return; 110 } 111 GetOriginsHelper(type, host, callback); 112 } 113 114 void AppCacheQuotaClient::DeleteOriginData(const GURL& origin, 115 storage::StorageType type, 116 const DeletionCallback& callback) { 117 DCHECK(!quota_manager_is_destroyed_); 118 119 if (!service_) { 120 callback.Run(storage::kQuotaErrorAbort); 121 return; 122 } 123 124 if (!appcache_is_ready_ || !current_delete_request_callback_.is_null()) { 125 pending_serial_requests_.push_back( 126 base::Bind(&AppCacheQuotaClient::DeleteOriginData, 127 base::Unretained(this), origin, type, callback)); 128 return; 129 } 130 131 current_delete_request_callback_ = callback; 132 if (type != storage::kStorageTypeTemporary) { 133 DidDeleteAppCachesForOrigin(net::OK); 134 return; 135 } 136 137 service_->DeleteAppCachesForOrigin( 138 origin, GetServiceDeleteCallback()->callback()); 139 } 140 141 bool AppCacheQuotaClient::DoesSupport(storage::StorageType type) const { 142 return type == storage::kStorageTypeTemporary; 143 } 144 145 void AppCacheQuotaClient::DidDeleteAppCachesForOrigin(int rv) { 146 DCHECK(service_); 147 if (quota_manager_is_destroyed_) 148 return; 149 150 // Finish the request by calling our callers callback. 151 current_delete_request_callback_.Run(NetErrorCodeToQuotaStatus(rv)); 152 current_delete_request_callback_.Reset(); 153 if (pending_serial_requests_.empty()) 154 return; 155 156 // Start the next in the queue. 157 RunFront(&pending_serial_requests_); 158 } 159 160 void AppCacheQuotaClient::GetOriginsHelper(storage::StorageType type, 161 const std::string& opt_host, 162 const GetOriginsCallback& callback) { 163 DCHECK(!callback.is_null()); 164 DCHECK(!quota_manager_is_destroyed_); 165 166 if (!service_) { 167 callback.Run(std::set<GURL>()); 168 return; 169 } 170 171 if (!appcache_is_ready_) { 172 pending_batch_requests_.push_back( 173 base::Bind(&AppCacheQuotaClient::GetOriginsHelper, 174 base::Unretained(this), type, opt_host, callback)); 175 return; 176 } 177 178 if (type != storage::kStorageTypeTemporary) { 179 callback.Run(std::set<GURL>()); 180 return; 181 } 182 183 const AppCacheStorage::UsageMap* map = GetUsageMap(); 184 std::set<GURL> origins; 185 for (AppCacheStorage::UsageMap::const_iterator iter = map->begin(); 186 iter != map->end(); ++iter) { 187 if (opt_host.empty() || iter->first.host() == opt_host) 188 origins.insert(iter->first); 189 } 190 callback.Run(origins); 191 } 192 193 void AppCacheQuotaClient::ProcessPendingRequests() { 194 DCHECK(appcache_is_ready_); 195 while (!pending_batch_requests_.empty()) 196 RunFront(&pending_batch_requests_); 197 198 if (!pending_serial_requests_.empty()) 199 RunFront(&pending_serial_requests_); 200 } 201 202 void AppCacheQuotaClient::DeletePendingRequests() { 203 pending_batch_requests_.clear(); 204 pending_serial_requests_.clear(); 205 } 206 207 const AppCacheStorage::UsageMap* AppCacheQuotaClient::GetUsageMap() { 208 DCHECK(service_); 209 return service_->storage()->usage_map(); 210 } 211 212 net::CancelableCompletionCallback* 213 AppCacheQuotaClient::GetServiceDeleteCallback() { 214 // Lazily created due to CancelableCompletionCallback's threading 215 // restrictions, there is no way to detach from the thread created on. 216 if (!service_delete_callback_) { 217 service_delete_callback_.reset( 218 new net::CancelableCompletionCallback( 219 base::Bind(&AppCacheQuotaClient::DidDeleteAppCachesForOrigin, 220 base::Unretained(this)))); 221 } 222 return service_delete_callback_.get(); 223 } 224 225 void AppCacheQuotaClient::NotifyAppCacheReady() { 226 // Can reoccur during reinitialization. 227 if (!appcache_is_ready_) { 228 appcache_is_ready_ = true; 229 ProcessPendingRequests(); 230 } 231 } 232 233 void AppCacheQuotaClient::NotifyAppCacheDestroyed() { 234 service_ = NULL; 235 while (!pending_batch_requests_.empty()) 236 RunFront(&pending_batch_requests_); 237 238 while (!pending_serial_requests_.empty()) 239 RunFront(&pending_serial_requests_); 240 241 if (!current_delete_request_callback_.is_null()) { 242 current_delete_request_callback_.Run(storage::kQuotaErrorAbort); 243 current_delete_request_callback_.Reset(); 244 GetServiceDeleteCallback()->Cancel(); 245 } 246 247 if (quota_manager_is_destroyed_) 248 delete this; 249 } 250 251 } // namespace content 252
