content/browser/appcache/appcache_request_handler.cc

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