content/browser/appcache/appcache_url_request_job.cc

   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_url_request_job.h"
   6
   7 #include <vector>
   8
   9 #include "base/bind.h"
  10 #include "base/bind_helpers.h"
  11 #include "base/command_line.h"
  12 #include "base/compiler_specific.h"
  13 #include "base/location.h"
  14 #include "base/single_thread_task_runner.h"
  15 #include "base/strings/string_util.h"
  16 #include "base/strings/stringprintf.h"
  17 #include "base/thread_task_runner_handle.h"
  18 #include "content/browser/appcache/appcache.h"
  19 #include "content/browser/appcache/appcache_group.h"
  20 #include "content/browser/appcache/appcache_histograms.h"
  21 #include "content/browser/appcache/appcache_host.h"
  22 #include "content/browser/appcache/appcache_service_impl.h"
  23 #include "net/base/io_buffer.h"
  24 #include "net/base/net_errors.h"
  25 #include "net/http/http_request_headers.h"
  26 #include "net/http/http_response_headers.h"
  27 #include "net/http/http_util.h"
  28 #include "net/log/net_log.h"
  29 #include "net/url_request/url_request.h"
  30 #include "net/url_request/url_request_status.h"
  31
  32 namespace content {
  33
  34 AppCacheURLRequestJob::AppCacheURLRequestJob(
  35     net::URLRequest* request,
  36     net::NetworkDelegate* network_delegate,
  37     AppCacheStorage* storage,
  38     AppCacheHost* host,
  39     bool is_main_resource)
  40     : net::URLRequestJob(request, network_delegate),
  41       host_(host),
  42       storage_(storage),
  43       has_been_started_(false), has_been_killed_(false),
  44       delivery_type_(AWAITING_DELIVERY_ORDERS),
  45       group_id_(0), cache_id_(kAppCacheNoCacheId), is_fallback_(false),
  46       is_main_resource_(is_main_resource),
  47       cache_entry_not_found_(false),
  48       weak_factory_(this) {
  49   DCHECK(storage_);
  50 }
  51
  52 void AppCacheURLRequestJob::DeliverAppCachedResponse(
  53     const GURL& manifest_url, int64 group_id, int64 cache_id,
  54     const AppCacheEntry& entry, bool is_fallback) {
  55   DCHECK(!has_delivery_orders());
  56   DCHECK(entry.has_response_id());
  57   delivery_type_ = APPCACHED_DELIVERY;
  58   manifest_url_ = manifest_url;
  59   group_id_ = group_id;
  60   cache_id_ = cache_id;
  61   entry_ = entry;
  62   is_fallback_ = is_fallback;
  63   MaybeBeginDelivery();
  64 }
  65
  66 void AppCacheURLRequestJob::DeliverNetworkResponse() {
  67   DCHECK(!has_delivery_orders());
  68   delivery_type_ = NETWORK_DELIVERY;
  69   storage_ = NULL;  // not needed
  70   MaybeBeginDelivery();
  71 }
  72
  73 void AppCacheURLRequestJob::DeliverErrorResponse() {
  74   DCHECK(!has_delivery_orders());
  75   delivery_type_ = ERROR_DELIVERY;
  76   storage_ = NULL;  // not needed
  77   MaybeBeginDelivery();
  78 }
  79
  80 void AppCacheURLRequestJob::MaybeBeginDelivery() {
  81   if (has_been_started() && has_delivery_orders()) {
  82     // Start asynchronously so that all error reporting and data
  83     // callbacks happen as they would for network requests.
  84     base::ThreadTaskRunnerHandle::Get()->PostTask(
  85         FROM_HERE, base::Bind(&AppCacheURLRequestJob::BeginDelivery,
  86                               weak_factory_.GetWeakPtr()));
  87   }
  88 }
  89
  90 void AppCacheURLRequestJob::BeginDelivery() {
  91   DCHECK(has_delivery_orders() && has_been_started());
  92
  93   if (has_been_killed())
  94     return;
  95
  96   switch (delivery_type_) {
  97     case NETWORK_DELIVERY:
  98       AppCacheHistograms::AddNetworkJobStartDelaySample(
  99           base::TimeTicks::Now() - start_time_tick_);
 100       // To fallthru to the network, we restart the request which will
 101       // cause a new job to be created to retrieve the resource from the
 102       // network. Our caller is responsible for arranging to not re-intercept
 103       // the same request.
 104       NotifyRestartRequired();
 105       break;
 106
 107     case ERROR_DELIVERY:
 108       AppCacheHistograms::AddErrorJobStartDelaySample(
 109           base::TimeTicks::Now() - start_time_tick_);
 110       request()->net_log().AddEvent(
 111           net::NetLog::TYPE_APPCACHE_DELIVERING_ERROR_RESPONSE);
 112       NotifyStartError(net::URLRequestStatus(net::URLRequestStatus::FAILED,
 113                                              net::ERR_FAILED));
 114       break;
 115
 116     case APPCACHED_DELIVERY:
 117       if (entry_.IsExecutable()) {
 118         BeginExecutableHandlerDelivery();
 119         return;
 120       }
 121       AppCacheHistograms::AddAppCacheJobStartDelaySample(
 122           base::TimeTicks::Now() - start_time_tick_);
 123       request()->net_log().AddEvent(
 124           is_fallback_ ?
 125               net::NetLog::TYPE_APPCACHE_DELIVERING_FALLBACK_RESPONSE :
 126               net::NetLog::TYPE_APPCACHE_DELIVERING_CACHED_RESPONSE);
 127       storage_->LoadResponseInfo(
 128           manifest_url_, group_id_, entry_.response_id(), this);
 129       break;
 130
 131     default:
 132       NOTREACHED();
 133       break;
 134   }
 135 }
 136
 137 void AppCacheURLRequestJob::BeginExecutableHandlerDelivery() {
 138   DCHECK(base::CommandLine::ForCurrentProcess()->HasSwitch(
 139       kEnableExecutableHandlers));
 140   if (!storage_->service()->handler_factory()) {
 141     BeginErrorDelivery("missing handler factory");
 142     return;
 143   }
 144
 145   request()->net_log().AddEvent(
 146       net::NetLog::TYPE_APPCACHE_DELIVERING_EXECUTABLE_RESPONSE);
 147
 148   // We defer job delivery until the executable handler is spun up and
 149   // provides a response. The sequence goes like this...
 150   //
 151   // 1. First we load the cache.
 152   // 2. Then if the handler is not spun up, we load the script resource which
 153   //    is needed to spin it up.
 154   // 3. Then we ask then we ask the handler to compute a response.
 155   // 4. Finally we deilver that response to the caller.
 156   storage_->LoadCache(cache_id_, this);
 157 }
 158
 159 void AppCacheURLRequestJob::OnCacheLoaded(AppCache* cache, int64 cache_id) {
 160   DCHECK_EQ(cache_id_, cache_id);
 161   DCHECK(!has_been_killed());
 162
 163   if (!cache) {
 164     BeginErrorDelivery("cache load failed");
 165     return;
 166   }
 167
 168   // Keep references to ensure they don't go out of scope until job completion.
 169   cache_ = cache;
 170   group_ = cache->owning_group();
 171
 172   // If the handler is spun up, ask it to compute a response.
 173   AppCacheExecutableHandler* handler =
 174       cache->GetExecutableHandler(entry_.response_id());
 175   if (handler) {
 176     InvokeExecutableHandler(handler);
 177     return;
 178   }
 179
 180   // Handler is not spun up yet, load the script resource to do that.
 181   // NOTE: This is not ideal since multiple jobs may be doing this,
 182   // concurrently but close enough for now, the first to load the script
 183   // will win.
 184
 185   // Read the script data, truncating if its too large.
 186   // NOTE: we just issue one read and don't bother chaining if the resource
 187   // is very (very) large, close enough for now.
 188   const int64 kLimit = 500 * 1000;
 189   handler_source_buffer_ = new net::GrowableIOBuffer();
 190   handler_source_buffer_->SetCapacity(kLimit);
 191   handler_source_reader_.reset(storage_->CreateResponseReader(
 192       manifest_url_, group_id_, entry_.response_id()));
 193   handler_source_reader_->ReadData(
 194       handler_source_buffer_.get(),
 195       kLimit,
 196       base::Bind(&AppCacheURLRequestJob::OnExecutableSourceLoaded,
 197                  base::Unretained(this)));
 198 }
 199
 200 void AppCacheURLRequestJob::OnExecutableSourceLoaded(int result) {
 201   DCHECK(!has_been_killed());
 202   handler_source_reader_.reset();
 203   if (result < 0) {
 204     BeginErrorDelivery("script source load failed");
 205     return;
 206   }
 207
 208   handler_source_buffer_->SetCapacity(result);  // Free up some memory.
 209
 210   AppCacheExecutableHandler* handler = cache_->GetOrCreateExecutableHandler(
 211       entry_.response_id(), handler_source_buffer_.get());
 212   handler_source_buffer_ = NULL;  // not needed anymore
 213   if (handler) {
 214     InvokeExecutableHandler(handler);
 215     return;
 216   }
 217
 218   BeginErrorDelivery("factory failed to produce a handler");
 219 }
 220
 221 void AppCacheURLRequestJob::InvokeExecutableHandler(
 222     AppCacheExecutableHandler* handler) {
 223   handler->HandleRequest(
 224       request(),
 225       base::Bind(&AppCacheURLRequestJob::OnExecutableResponseCallback,
 226                  weak_factory_.GetWeakPtr()));
 227 }
 228
 229 void AppCacheURLRequestJob::OnExecutableResponseCallback(
 230     const AppCacheExecutableHandler::Response& response) {
 231   DCHECK(!has_been_killed());
 232   if (response.use_network) {
 233     delivery_type_ = NETWORK_DELIVERY;
 234     storage_ = NULL;
 235     BeginDelivery();
 236     return;
 237   }
 238
 239   if (!response.cached_resource_url.is_empty()) {
 240     AppCacheEntry* entry_ptr = cache_->GetEntry(response.cached_resource_url);
 241     if (entry_ptr && !entry_ptr->IsExecutable()) {
 242       entry_ = *entry_ptr;
 243       BeginDelivery();
 244       return;
 245     }
 246   }
 247
 248   if (!response.redirect_url.is_empty()) {
 249     // TODO(michaeln): playback a redirect
 250     // response_headers_(new HttpResponseHeaders(response_headers)),
 251     // fallthru for now to deliver an error
 252   }
 253
 254   // Otherwise, return an error.
 255   BeginErrorDelivery("handler returned an invalid response");
 256 }
 257
 258 void AppCacheURLRequestJob::BeginErrorDelivery(const char* message) {
 259   if (host_)
 260     host_->frontend()->OnLogMessage(host_->host_id(), APPCACHE_LOG_ERROR,
 261                                     message);
 262   delivery_type_ = ERROR_DELIVERY;
 263   storage_ = NULL;
 264   BeginDelivery();
 265 }
 266
 267 AppCacheURLRequestJob::~AppCacheURLRequestJob() {
 268   if (storage_)
 269     storage_->CancelDelegateCallbacks(this);
 270 }
 271
 272 void AppCacheURLRequestJob::OnResponseInfoLoaded(
 273       AppCacheResponseInfo* response_info, int64 response_id) {
 274   DCHECK(is_delivering_appcache_response());
 275   scoped_refptr<AppCacheURLRequestJob> protect(this);
 276   if (response_info) {
 277     info_ = response_info;
 278     reader_.reset(storage_->CreateResponseReader(
 279         manifest_url_, group_id_, entry_.response_id()));
 280
 281     if (is_range_request())
 282       SetupRangeResponse();
 283
 284     NotifyHeadersComplete();
 285   } else {
 286     if (storage_->service()->storage() == storage_) {
 287       // A resource that is expected to be in the appcache is missing.
 288       // See http://code.google.com/p/chromium/issues/detail?id=50657
 289       // Instead of failing the request, we restart the request. The retry
 290       // attempt will fallthru to the network instead of trying to load
 291       // from the appcache.
 292       storage_->service()->CheckAppCacheResponse(manifest_url_, cache_id_,
 293                                                  entry_.response_id());
 294       AppCacheHistograms::CountResponseRetrieval(
 295           false, is_main_resource_, manifest_url_.GetOrigin());
 296     }
 297     cache_entry_not_found_ = true;
 298     NotifyRestartRequired();
 299   }
 300 }
 301
 302 const net::HttpResponseInfo* AppCacheURLRequestJob::http_info() const {
 303   if (!info_.get())
 304     return NULL;
 305   if (range_response_info_)
 306     return range_response_info_.get();
 307   return info_->http_response_info();
 308 }
 309
 310 void AppCacheURLRequestJob::SetupRangeResponse() {
 311   DCHECK(is_range_request() && info_.get() && reader_.get() &&
 312          is_delivering_appcache_response());
 313   int resource_size = static_cast<int>(info_->response_data_size());
 314   if (resource_size < 0 || !range_requested_.ComputeBounds(resource_size)) {
 315     range_requested_ = net::HttpByteRange();
 316     return;
 317   }
 318
 319   DCHECK(range_requested_.IsValid());
 320   int offset = static_cast<int>(range_requested_.first_byte_position());
 321   int length = static_cast<int>(range_requested_.last_byte_position() -
 322                                 range_requested_.first_byte_position() + 1);
 323
 324   // Tell the reader about the range to read.
 325   reader_->SetReadRange(offset, length);
 326
 327   // Make a copy of the full response headers and fix them up
 328   // for the range we'll be returning.
 329   range_response_info_.reset(
 330       new net::HttpResponseInfo(*info_->http_response_info()));
 331   net::HttpResponseHeaders* headers = range_response_info_->headers.get();
 332   headers->UpdateWithNewRange(
 333       range_requested_, resource_size, true /* replace status line */);
 334 }
 335
 336 void AppCacheURLRequestJob::OnReadComplete(int result) {
 337   DCHECK(is_delivering_appcache_response());
 338   if (result == 0) {
 339     NotifyDone(net::URLRequestStatus());
 340     AppCacheHistograms::CountResponseRetrieval(
 341         true, is_main_resource_, manifest_url_.GetOrigin());
 342   } else if (result < 0) {
 343     if (storage_->service()->storage() == storage_) {
 344       storage_->service()->CheckAppCacheResponse(manifest_url_, cache_id_,
 345                                                  entry_.response_id());
 346     }
 347     NotifyDone(net::URLRequestStatus(net::URLRequestStatus::FAILED, result));
 348     AppCacheHistograms::CountResponseRetrieval(
 349         false, is_main_resource_, manifest_url_.GetOrigin());
 350   } else {
 351     SetStatus(net::URLRequestStatus());  // Clear the IO_PENDING status
 352   }
 353   NotifyReadComplete(result);
 354 }
 355
 356 // net::URLRequestJob overrides ------------------------------------------------
 357
 358 void AppCacheURLRequestJob::Start() {
 359   DCHECK(!has_been_started());
 360   has_been_started_ = true;
 361   start_time_tick_ = base::TimeTicks::Now();
 362   MaybeBeginDelivery();
 363 }
 364
 365 void AppCacheURLRequestJob::Kill() {
 366   if (!has_been_killed_) {
 367     has_been_killed_ = true;
 368     reader_.reset();
 369     handler_source_reader_.reset();
 370     if (storage_) {
 371       storage_->CancelDelegateCallbacks(this);
 372       storage_ = NULL;
 373     }
 374     host_ = NULL;
 375     info_ = NULL;
 376     cache_ = NULL;
 377     group_ = NULL;
 378     range_response_info_.reset();
 379     net::URLRequestJob::Kill();
 380     weak_factory_.InvalidateWeakPtrs();
 381   }
 382 }
 383
 384 net::LoadState AppCacheURLRequestJob::GetLoadState() const {
 385   if (!has_been_started())
 386     return net::LOAD_STATE_IDLE;
 387   if (!has_delivery_orders())
 388     return net::LOAD_STATE_WAITING_FOR_APPCACHE;
 389   if (delivery_type_ != APPCACHED_DELIVERY)
 390     return net::LOAD_STATE_IDLE;
 391   if (!info_.get())
 392     return net::LOAD_STATE_WAITING_FOR_APPCACHE;
 393   if (reader_.get() && reader_->IsReadPending())
 394     return net::LOAD_STATE_READING_RESPONSE;
 395   return net::LOAD_STATE_IDLE;
 396 }
 397
 398 bool AppCacheURLRequestJob::GetMimeType(std::string* mime_type) const {
 399   if (!http_info())
 400     return false;
 401   return http_info()->headers->GetMimeType(mime_type);
 402 }
 403
 404 bool AppCacheURLRequestJob::GetCharset(std::string* charset) {
 405   if (!http_info())
 406     return false;
 407   return http_info()->headers->GetCharset(charset);
 408 }
 409
 410 void AppCacheURLRequestJob::GetResponseInfo(net::HttpResponseInfo* info) {
 411   if (!http_info())
 412     return;
 413   *info = *http_info();
 414 }
 415
 416 int AppCacheURLRequestJob::GetResponseCode() const {
 417   if (!http_info())
 418     return -1;
 419   return http_info()->headers->response_code();
 420 }
 421
 422 bool AppCacheURLRequestJob::ReadRawData(net::IOBuffer* buf, int buf_size,
 423                                         int *bytes_read) {
 424   DCHECK(is_delivering_appcache_response());
 425   DCHECK_NE(buf_size, 0);
 426   DCHECK(bytes_read);
 427   DCHECK(!reader_->IsReadPending());
 428   reader_->ReadData(
 429       buf, buf_size, base::Bind(&AppCacheURLRequestJob::OnReadComplete,
 430                                 base::Unretained(this)));
 431   SetStatus(net::URLRequestStatus(net::URLRequestStatus::IO_PENDING, 0));
 432   return false;
 433 }
 434
 435 void AppCacheURLRequestJob::SetExtraRequestHeaders(
 436     const net::HttpRequestHeaders& headers) {
 437   std::string value;
 438   std::vector<net::HttpByteRange> ranges;
 439   if (!headers.GetHeader(net::HttpRequestHeaders::kRange, &value) ||
 440       !net::HttpUtil::ParseRangeHeader(value, &ranges)) {
 441     return;
 442   }
 443
 444   // If multiple ranges are requested, we play dumb and
 445   // return the entire response with 200 OK.
 446   if (ranges.size() == 1U)
 447     range_requested_ = ranges[0];
 448 }
 449
 450 }  // namespace content