| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2011 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_request_handler.h" | |
| 6 | |
| 7 #include "net/url_request/url_request.h" | |
| 8 #include "net/url_request/url_request_job.h" | |
| 9 #include "webkit/browser/appcache/appcache.h" | |
| 10 #include "webkit/browser/appcache/appcache_backend_impl.h" | |
| 11 #include "webkit/browser/appcache/appcache_policy.h" | |
| 12 #include "webkit/browser/appcache/appcache_url_request_job.h" | |
| 13 | |
| 14 namespace appcache { | |
| 15 | |
| 16 AppCacheRequestHandler::AppCacheRequestHandler( | |
| 17 AppCacheHost* host, ResourceType::Type resource_type) | |
| 18 : host_(host), resource_type_(resource_type), | |
| 19 is_waiting_for_cache_selection_(false), found_group_id_(0), | |
| 20 found_cache_id_(0), found_network_namespace_(false), | |
| 21 cache_entry_not_found_(false), maybe_load_resource_executed_(false) { | |
| 22 DCHECK(host_); | |
| 23 host_->AddObserver(this); | |
| 24 } | |
| 25 | |
| 26 AppCacheRequestHandler::~AppCacheRequestHandler() { | |
| 27 if (host_) { | |
| 28 storage()->CancelDelegateCallbacks(this); | |
| 29 host_->RemoveObserver(this); | |
| 30 } | |
| 31 } | |
| 32 | |
| 33 AppCacheStorage* AppCacheRequestHandler::storage() const { | |
| 34 DCHECK(host_); | |
| 35 return host_->storage(); | |
| 36 } | |
| 37 | |
| 38 AppCacheURLRequestJob* AppCacheRequestHandler::MaybeLoadResource( | |
| 39 net::URLRequest* request, net::NetworkDelegate* network_delegate) { | |
| 40 maybe_load_resource_executed_ = true; | |
| 41 if (!host_ || !IsSchemeAndMethodSupported(request) || cache_entry_not_found_) | |
| 42 return NULL; | |
| 43 | |
| 44 // This method can get called multiple times over the life | |
| 45 // of a request. The case we detect here is having scheduled | |
| 46 // delivery of a "network response" using a job setup on an | |
| 47 // earlier call thru this method. To send the request thru | |
| 48 // to the network involves restarting the request altogether, | |
| 49 // which will call thru to our interception layer again. | |
| 50 // This time thru, we return NULL so the request hits the wire. | |
| 51 if (job_.get()) { | |
| 52 DCHECK(job_->is_delivering_network_response() || | |
| 53 job_->cache_entry_not_found()); | |
| 54 if (job_->cache_entry_not_found()) | |
| 55 cache_entry_not_found_ = true; | |
| 56 job_ = NULL; | |
| 57 storage()->CancelDelegateCallbacks(this); | |
| 58 return NULL; | |
| 59 } | |
| 60 | |
| 61 // Clear out our 'found' fields since we're starting a request for a | |
| 62 // new resource, any values in those fields are no longer valid. | |
| 63 found_entry_ = AppCacheEntry(); | |
| 64 found_fallback_entry_ = AppCacheEntry(); | |
| 65 found_cache_id_ = kAppCacheNoCacheId; | |
| 66 found_manifest_url_ = GURL(); | |
| 67 found_network_namespace_ = false; | |
| 68 | |
| 69 if (is_main_resource()) | |
| 70 MaybeLoadMainResource(request, network_delegate); | |
| 71 else | |
| 72 MaybeLoadSubResource(request, network_delegate); | |
| 73 | |
| 74 // If its been setup to deliver a network response, we can just delete | |
| 75 // it now and return NULL instead to achieve that since it couldn't | |
| 76 // have been started yet. | |
| 77 if (job_.get() && job_->is_delivering_network_response()) { | |
| 78 DCHECK(!job_->has_been_started()); | |
| 79 job_ = NULL; | |
| 80 } | |
| 81 | |
| 82 return job_.get(); | |
| 83 } | |
| 84 | |
| 85 AppCacheURLRequestJob* AppCacheRequestHandler::MaybeLoadFallbackForRedirect( | |
| 86 net::URLRequest* request, | |
| 87 net::NetworkDelegate* network_delegate, | |
| 88 const GURL& location) { | |
| 89 if (!host_ || !IsSchemeAndMethodSupported(request) || cache_entry_not_found_) | |
| 90 return NULL; | |
| 91 if (is_main_resource()) | |
| 92 return NULL; | |
| 93 // TODO(vabr) This is a temporary fix (see crbug/141114). We should get rid of | |
| 94 // it once a more general solution to crbug/121325 is in place. | |
| 95 if (!maybe_load_resource_executed_) | |
| 96 return NULL; | |
| 97 if (request->url().GetOrigin() == location.GetOrigin()) | |
| 98 return NULL; | |
| 99 | |
| 100 DCHECK(!job_.get()); // our jobs never generate redirects | |
| 101 | |
| 102 if (found_fallback_entry_.has_response_id()) { | |
| 103 // 6.9.6, step 4: If this results in a redirect to another origin, | |
| 104 // get the resource of the fallback entry. | |
| 105 job_ = new AppCacheURLRequestJob(request, network_delegate, | |
| 106 storage(), host_, is_main_resource()); | |
| 107 DeliverAppCachedResponse( | |
| 108 found_fallback_entry_, found_cache_id_, found_group_id_, | |
| 109 found_manifest_url_, true, found_namespace_entry_url_); | |
| 110 } else if (!found_network_namespace_) { | |
| 111 // 6.9.6, step 6: Fail the resource load. | |
| 112 job_ = new AppCacheURLRequestJob(request, network_delegate, | |
| 113 storage(), host_, is_main_resource()); | |
| 114 DeliverErrorResponse(); | |
| 115 } else { | |
| 116 // 6.9.6 step 3 and 5: Fetch the resource normally. | |
| 117 } | |
| 118 | |
| 119 return job_.get(); | |
| 120 } | |
| 121 | |
| 122 AppCacheURLRequestJob* AppCacheRequestHandler::MaybeLoadFallbackForResponse( | |
| 123 net::URLRequest* request, net::NetworkDelegate* network_delegate) { | |
| 124 if (!host_ || !IsSchemeAndMethodSupported(request) || cache_entry_not_found_) | |
| 125 return NULL; | |
| 126 if (!found_fallback_entry_.has_response_id()) | |
| 127 return NULL; | |
| 128 | |
| 129 if (request->status().status() == net::URLRequestStatus::CANCELED) { | |
| 130 // 6.9.6, step 4: But not if the user canceled the download. | |
| 131 return NULL; | |
| 132 } | |
| 133 | |
| 134 // We don't fallback for responses that we delivered. | |
| 135 if (job_.get()) { | |
| 136 DCHECK(!job_->is_delivering_network_response()); | |
| 137 return NULL; | |
| 138 } | |
| 139 | |
| 140 if (request->status().is_success()) { | |
| 141 int code_major = request->GetResponseCode() / 100; | |
| 142 if (code_major !=4 && code_major != 5) | |
| 143 return NULL; | |
| 144 | |
| 145 // Servers can override the fallback behavior with a response header. | |
| 146 const std::string kFallbackOverrideHeader( | |
| 147 "x-chromium-appcache-fallback-override"); | |
| 148 const std::string kFallbackOverrideValue( | |
| 149 "disallow-fallback"); | |
| 150 std::string header_value; | |
| 151 request->GetResponseHeaderByName(kFallbackOverrideHeader, &header_value); | |
| 152 if (header_value == kFallbackOverrideValue) | |
| 153 return NULL; | |
| 154 } | |
| 155 | |
| 156 // 6.9.6, step 4: If this results in a 4xx or 5xx status code | |
| 157 // or there were network errors, get the resource of the fallback entry. | |
| 158 job_ = new AppCacheURLRequestJob(request, network_delegate, | |
| 159 storage(), host_, is_main_resource()); | |
| 160 DeliverAppCachedResponse( | |
| 161 found_fallback_entry_, found_cache_id_, found_group_id_, | |
| 162 found_manifest_url_, true, found_namespace_entry_url_); | |
| 163 return job_.get(); | |
| 164 } | |
| 165 | |
| 166 void AppCacheRequestHandler::GetExtraResponseInfo( | |
| 167 int64* cache_id, GURL* manifest_url) { | |
| 168 if (job_.get() && job_->is_delivering_appcache_response()) { | |
| 169 *cache_id = job_->cache_id(); | |
| 170 *manifest_url = job_->manifest_url(); | |
| 171 } | |
| 172 } | |
| 173 | |
| 174 void AppCacheRequestHandler::PrepareForCrossSiteTransfer(int old_process_id) { | |
| 175 if (!host_) | |
| 176 return; | |
| 177 AppCacheBackendImpl* backend = host_->service()->GetBackend(old_process_id); | |
| 178 host_for_cross_site_transfer_ = backend->TransferHostOut(host_->host_id()); | |
| 179 DCHECK_EQ(host_, host_for_cross_site_transfer_.get()); | |
| 180 } | |
| 181 | |
| 182 void AppCacheRequestHandler::CompleteCrossSiteTransfer( | |
| 183 int new_process_id, int new_host_id) { | |
| 184 if (!host_for_cross_site_transfer_.get()) | |
| 185 return; | |
| 186 DCHECK_EQ(host_, host_for_cross_site_transfer_.get()); | |
| 187 AppCacheBackendImpl* backend = host_->service()->GetBackend(new_process_id); | |
| 188 backend->TransferHostIn(new_host_id, host_for_cross_site_transfer_.Pass()); | |
| 189 } | |
| 190 | |
| 191 void AppCacheRequestHandler::OnDestructionImminent(AppCacheHost* host) { | |
| 192 storage()->CancelDelegateCallbacks(this); | |
| 193 host_ = NULL; // no need to RemoveObserver, the host is being deleted | |
| 194 | |
| 195 // Since the host is being deleted, we don't have to complete any job | |
| 196 // that is current running. It's destined for the bit bucket anyway. | |
| 197 if (job_.get()) { | |
| 198 job_->Kill(); | |
| 199 job_ = NULL; | |
| 200 } | |
| 201 } | |
| 202 | |
| 203 void AppCacheRequestHandler::DeliverAppCachedResponse( | |
| 204 const AppCacheEntry& entry, int64 cache_id, int64 group_id, | |
| 205 const GURL& manifest_url, bool is_fallback, | |
| 206 const GURL& namespace_entry_url) { | |
| 207 DCHECK(host_ && job_.get() && job_->is_waiting()); | |
| 208 DCHECK(entry.has_response_id()); | |
| 209 | |
| 210 if (ResourceType::IsFrame(resource_type_) && !namespace_entry_url.is_empty()) | |
| 211 host_->NotifyMainResourceIsNamespaceEntry(namespace_entry_url); | |
| 212 | |
| 213 job_->DeliverAppCachedResponse(manifest_url, group_id, cache_id, | |
| 214 entry, is_fallback); | |
| 215 } | |
| 216 | |
| 217 void AppCacheRequestHandler::DeliverErrorResponse() { | |
| 218 DCHECK(job_.get() && job_->is_waiting()); | |
| 219 job_->DeliverErrorResponse(); | |
| 220 } | |
| 221 | |
| 222 void AppCacheRequestHandler::DeliverNetworkResponse() { | |
| 223 DCHECK(job_.get() && job_->is_waiting()); | |
| 224 job_->DeliverNetworkResponse(); | |
| 225 } | |
| 226 | |
| 227 // Main-resource handling ---------------------------------------------- | |
| 228 | |
| 229 void AppCacheRequestHandler::MaybeLoadMainResource( | |
| 230 net::URLRequest* request, net::NetworkDelegate* network_delegate) { | |
| 231 DCHECK(!job_.get()); | |
| 232 DCHECK(host_); | |
| 233 | |
| 234 const AppCacheHost* spawning_host = | |
| 235 ResourceType::IsSharedWorker(resource_type_) ? | |
| 236 host_ : host_->GetSpawningHost(); | |
| 237 GURL preferred_manifest_url = spawning_host ? | |
| 238 spawning_host->preferred_manifest_url() : GURL(); | |
| 239 | |
| 240 // We may have to wait for our storage query to complete, but | |
| 241 // this query can also complete syncrhonously. | |
| 242 job_ = new AppCacheURLRequestJob(request, network_delegate, | |
| 243 storage(), host_, is_main_resource()); | |
| 244 storage()->FindResponseForMainRequest( | |
| 245 request->url(), preferred_manifest_url, this); | |
| 246 } | |
| 247 | |
| 248 void AppCacheRequestHandler::OnMainResponseFound( | |
| 249 const GURL& url, const AppCacheEntry& entry, | |
| 250 const GURL& namespace_entry_url, const AppCacheEntry& fallback_entry, | |
| 251 int64 cache_id, int64 group_id, const GURL& manifest_url) { | |
| 252 DCHECK(job_.get()); | |
| 253 DCHECK(host_); | |
| 254 DCHECK(is_main_resource()); | |
| 255 DCHECK(!entry.IsForeign()); | |
| 256 DCHECK(!fallback_entry.IsForeign()); | |
| 257 DCHECK(!(entry.has_response_id() && fallback_entry.has_response_id())); | |
| 258 | |
| 259 if (!job_.get()) | |
| 260 return; | |
| 261 | |
| 262 AppCachePolicy* policy = host_->service()->appcache_policy(); | |
| 263 bool was_blocked_by_policy = !manifest_url.is_empty() && policy && | |
| 264 !policy->CanLoadAppCache(manifest_url, host_->first_party_url()); | |
| 265 | |
| 266 if (was_blocked_by_policy) { | |
| 267 if (ResourceType::IsFrame(resource_type_)) { | |
| 268 host_->NotifyMainResourceBlocked(manifest_url); | |
| 269 } else { | |
| 270 DCHECK(ResourceType::IsSharedWorker(resource_type_)); | |
| 271 host_->frontend()->OnContentBlocked(host_->host_id(), manifest_url); | |
| 272 } | |
| 273 DeliverNetworkResponse(); | |
| 274 return; | |
| 275 } | |
| 276 | |
| 277 if (ResourceType::IsFrame(resource_type_) && cache_id != kAppCacheNoCacheId) { | |
| 278 // AppCacheHost loads and holds a reference to the main resource cache | |
| 279 // for two reasons, firstly to preload the cache into the working set | |
| 280 // in advance of subresource loads happening, secondly to prevent the | |
| 281 // AppCache from falling out of the working set on frame navigations. | |
| 282 host_->LoadMainResourceCache(cache_id); | |
| 283 host_->set_preferred_manifest_url(manifest_url); | |
| 284 } | |
| 285 | |
| 286 // 6.11.1 Navigating across documents, steps 10 and 14. | |
| 287 | |
| 288 found_entry_ = entry; | |
| 289 found_namespace_entry_url_ = namespace_entry_url; | |
| 290 found_fallback_entry_ = fallback_entry; | |
| 291 found_cache_id_ = cache_id; | |
| 292 found_group_id_ = group_id; | |
| 293 found_manifest_url_ = manifest_url; | |
| 294 found_network_namespace_ = false; // not applicable to main requests | |
| 295 | |
| 296 if (found_entry_.has_response_id()) { | |
| 297 DCHECK(!found_fallback_entry_.has_response_id()); | |
| 298 DeliverAppCachedResponse( | |
| 299 found_entry_, found_cache_id_, found_group_id_, found_manifest_url_, | |
| 300 false, found_namespace_entry_url_); | |
| 301 } else { | |
| 302 DeliverNetworkResponse(); | |
| 303 } | |
| 304 } | |
| 305 | |
| 306 // Sub-resource handling ---------------------------------------------- | |
| 307 | |
| 308 void AppCacheRequestHandler::MaybeLoadSubResource( | |
| 309 net::URLRequest* request, net::NetworkDelegate* network_delegate) { | |
| 310 DCHECK(!job_.get()); | |
| 311 | |
| 312 if (host_->is_selection_pending()) { | |
| 313 // We have to wait until cache selection is complete and the | |
| 314 // selected cache is loaded. | |
| 315 is_waiting_for_cache_selection_ = true; | |
| 316 job_ = new AppCacheURLRequestJob(request, network_delegate, | |
| 317 storage(), host_, is_main_resource()); | |
| 318 return; | |
| 319 } | |
| 320 | |
| 321 if (!host_->associated_cache() || | |
| 322 !host_->associated_cache()->is_complete() || | |
| 323 host_->associated_cache()->owning_group()->is_being_deleted()) { | |
| 324 return; | |
| 325 } | |
| 326 | |
| 327 job_ = new AppCacheURLRequestJob(request, network_delegate, | |
| 328 storage(), host_, is_main_resource()); | |
| 329 ContinueMaybeLoadSubResource(); | |
| 330 } | |
| 331 | |
| 332 void AppCacheRequestHandler::ContinueMaybeLoadSubResource() { | |
| 333 // 6.9.6 Changes to the networking model | |
| 334 // If the resource is not to be fetched using the HTTP GET mechanism or | |
| 335 // equivalent ... then fetch the resource normally. | |
| 336 DCHECK(job_.get()); | |
| 337 DCHECK(host_->associated_cache() && host_->associated_cache()->is_complete()); | |
| 338 | |
| 339 const GURL& url = job_->request()->url(); | |
| 340 AppCache* cache = host_->associated_cache(); | |
| 341 storage()->FindResponseForSubRequest( | |
| 342 host_->associated_cache(), url, | |
| 343 &found_entry_, &found_fallback_entry_, &found_network_namespace_); | |
| 344 | |
| 345 if (found_entry_.has_response_id()) { | |
| 346 // Step 2: If there's an entry, get it instead. | |
| 347 DCHECK(!found_network_namespace_ && | |
| 348 !found_fallback_entry_.has_response_id()); | |
| 349 found_cache_id_ = cache->cache_id(); | |
| 350 found_group_id_ = cache->owning_group()->group_id(); | |
| 351 found_manifest_url_ = cache->owning_group()->manifest_url(); | |
| 352 DeliverAppCachedResponse( | |
| 353 found_entry_, found_cache_id_, found_group_id_, found_manifest_url_, | |
| 354 false, GURL()); | |
| 355 return; | |
| 356 } | |
| 357 | |
| 358 if (found_fallback_entry_.has_response_id()) { | |
| 359 // Step 4: Fetch the resource normally, if this results | |
| 360 // in certain conditions, then use the fallback. | |
| 361 DCHECK(!found_network_namespace_ && | |
| 362 !found_entry_.has_response_id()); | |
| 363 found_cache_id_ = cache->cache_id(); | |
| 364 found_manifest_url_ = cache->owning_group()->manifest_url(); | |
| 365 DeliverNetworkResponse(); | |
| 366 return; | |
| 367 } | |
| 368 | |
| 369 if (found_network_namespace_) { | |
| 370 // Step 3 and 5: Fetch the resource normally. | |
| 371 DCHECK(!found_entry_.has_response_id() && | |
| 372 !found_fallback_entry_.has_response_id()); | |
| 373 DeliverNetworkResponse(); | |
| 374 return; | |
| 375 } | |
| 376 | |
| 377 // Step 6: Fail the resource load. | |
| 378 DeliverErrorResponse(); | |
| 379 } | |
| 380 | |
| 381 void AppCacheRequestHandler::OnCacheSelectionComplete(AppCacheHost* host) { | |
| 382 DCHECK(host == host_); | |
| 383 if (is_main_resource()) | |
| 384 return; | |
| 385 if (!is_waiting_for_cache_selection_) | |
| 386 return; | |
| 387 | |
| 388 is_waiting_for_cache_selection_ = false; | |
| 389 | |
| 390 if (!host_->associated_cache() || | |
| 391 !host_->associated_cache()->is_complete()) { | |
| 392 DeliverNetworkResponse(); | |
| 393 return; | |
| 394 } | |
| 395 | |
| 396 ContinueMaybeLoadSubResource(); | |
| 397 } | |
| 398 | |
| 399 } // 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