src/content/browser/loader/resource_dispatcher_host_impl.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 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
   6
   7 #include "content/browser/loader/resource_dispatcher_host_impl.h"
   8
   9 #include <algorithm>
  10 #include <set>
  11 #include <vector>
  12
  13 #include "base/bind.h"
  14 #include "base/bind_helpers.h"
  15 #include "base/command_line.h"
  16 #include "base/compiler_specific.h"
  17 #include "base/debug/alias.h"
  18 #include "base/logging.h"
  19 #include "base/memory/scoped_ptr.h"
  20 #include "base/memory/shared_memory.h"
  21 #include "base/message_loop/message_loop.h"
  22 #include "base/metrics/histogram.h"
  23 #include "base/metrics/sparse_histogram.h"
  24 #include "base/stl_util.h"
  25 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
  26 #include "content/browser/appcache/chrome_appcache_service.h"
  27 #include "content/browser/cert_store_impl.h"
  28 #include "content/browser/child_process_security_policy_impl.h"
  29 #include "content/browser/cross_site_request_manager.h"
  30 #include "content/browser/download/download_resource_handler.h"
  31 #include "content/browser/download/save_file_manager.h"
  32 #include "content/browser/download/save_file_resource_handler.h"
  33 #include "content/browser/fileapi/chrome_blob_storage_context.h"
  34 #include "content/browser/loader/async_resource_handler.h"
  35 #include "content/browser/loader/buffered_resource_handler.h"
  36 #include "content/browser/loader/cross_site_resource_handler.h"
  37 #include "content/browser/loader/detachable_resource_handler.h"
  38 #include "content/browser/loader/power_save_block_resource_throttle.h"
  39 #include "content/browser/loader/redirect_to_file_resource_handler.h"
  40 #include "content/browser/loader/resource_message_filter.h"
  41 #include "content/browser/loader/resource_request_info_impl.h"
  42 #include "content/browser/loader/stream_resource_handler.h"
  43 #include "content/browser/loader/sync_resource_handler.h"
  44 #include "content/browser/loader/throttling_resource_handler.h"
  45 #include "content/browser/loader/upload_data_stream_builder.h"
  46 #include "content/browser/plugin_service_impl.h"
  47 #include "content/browser/renderer_host/render_view_host_delegate.h"
  48 #include "content/browser/renderer_host/render_view_host_impl.h"
  49 #include "content/browser/resource_context_impl.h"
  50 #include "content/browser/streams/stream.h"
  51 #include "content/browser/streams/stream_context.h"
  52 #include "content/browser/streams/stream_registry.h"
  53 #include "content/browser/worker_host/worker_service_impl.h"
  54 #include "content/browser/web_contents/web_contents_impl.h"
  55 #include "content/common/resource_messages.h"
  56 #include "content/common/ssl_status_serialization.h"
  57 #include "content/common/view_messages.h"
  58 #include "content/public/browser/browser_thread.h"
  59 #include "content/public/browser/content_browser_client.h"
  60 #include "content/public/browser/download_manager.h"
  61 #include "content/public/browser/download_url_parameters.h"
  62 #include "content/public/browser/global_request_id.h"
  63 #include "content/public/browser/resource_dispatcher_host_delegate.h"
  64 #include "content/public/browser/resource_request_details.h"
  65 #include "content/public/browser/resource_throttle.h"
  66 #include "content/public/browser/stream_handle.h"
  67 #include "content/public/browser/user_metrics.h"
  68 #include "content/public/common/content_switches.h"
  69 #include "content/public/common/process_type.h"
  70 #include "content/public/common/url_constants.h"
  71 #include "ipc/ipc_message_macros.h"
  72 #include "ipc/ipc_message_start.h"
  73 #include "net/base/auth.h"
  74 #include "net/base/load_flags.h"
  75 #include "net/base/mime_util.h"
  76 #include "net/base/net_errors.h"
  77 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
  78 #include "net/base/request_priority.h"
  79 #include "net/base/upload_data_stream.h"
  80 #include "net/cert/cert_status_flags.h"
  81 #include "net/cookies/cookie_monster.h"
  82 #include "net/http/http_response_headers.h"
  83 #include "net/http/http_response_info.h"
  84 #include "net/ssl/ssl_cert_request_info.h"
  85 #include "net/url_request/url_request.h"
  86 #include "net/url_request/url_request_context.h"
  87 #include "net/url_request/url_request_job_factory.h"
  88 #include "webkit/browser/appcache/appcache_interceptor.h"
  89 #include "webkit/common/blob/blob_data.h"
  90 #include "webkit/browser/blob/blob_data_handle.h"
  91 #include "webkit/browser/blob/blob_storage_context.h"
  92 #include "webkit/browser/blob/blob_url_request_job_factory.h"
  93 #include "webkit/browser/fileapi/file_permission_policy.h"
  94 #include "webkit/browser/fileapi/file_system_context.h"
  95 #include "webkit/common/appcache/appcache_interfaces.h"
  96 #include "webkit/common/blob/shareable_file_reference.h"
  97 #include "webkit/common/resource_request_body.h"
  98
  99 using base::Time;
 100 using base::TimeDelta;
 101 using base::TimeTicks;
 102 using webkit_blob::ShareableFileReference;
 103 using webkit_glue::ResourceRequestBody;
 104
 105 // ----------------------------------------------------------------------------
 106
 107 namespace content {
 108
 109 namespace {
 110
 111 static ResourceDispatcherHostImpl* g_resource_dispatcher_host;
 112
 113 // The interval for calls to ResourceDispatcherHostImpl::UpdateLoadStates
 114 const int kUpdateLoadStatesIntervalMsec = 100;
 115
 116 // Maximum byte "cost" of all the outstanding requests for a renderer.
 117 // See delcaration of |max_outstanding_requests_cost_per_process_| for details.
 118 // This bound is 25MB, which allows for around 6000 outstanding requests.
 119 const int kMaxOutstandingRequestsCostPerProcess = 26214400;
 120
 121 // The number of milliseconds after noting a user gesture that we will
 122 // tag newly-created URLRequest objects with the
 123 // net::LOAD_MAYBE_USER_GESTURE load flag. This is a fairly arbitrary
 124 // guess at how long to expect direct impact from a user gesture, but
 125 // this should be OK as the load flag is a best-effort thing only,
 126 // rather than being intended as fully accurate.
 127 const int kUserGestureWindowMs = 3500;
 128
 129 // Ratio of |max_num_in_flight_requests_| that any one renderer is allowed to
 130 // use. Arbitrarily chosen.
 131 const double kMaxRequestsPerProcessRatio = 0.45;
 132
 133 // TODO(jkarlin): The value is high to reduce the chance of the detachable
 134 // request timing out, forcing a blocked second request to open a new connection
 135 // and start over. Reduce this value once we have a better idea of what it
 136 // should be and once we stop blocking multiple simultaneous requests for the
 137 // same resource (see bugs 46104 and 31014).
 138 const int kDefaultDetachableCancelDelayMs = 30000;
 139
 140 bool IsDetachableResourceType(ResourceType::Type type) {
 141   switch (type) {
 142     case ResourceType::PREFETCH:
 143     case ResourceType::PING:
 144       return true;
 145     default:
 146       return false;
 147   }
 148 }
 149
 150 // Aborts a request before an URLRequest has actually been created.
 151 void AbortRequestBeforeItStarts(ResourceMessageFilter* filter,
 152                                 IPC::Message* sync_result,
 153                                 int request_id) {
 154   if (sync_result) {
 155     SyncLoadResult result;
 156     result.error_code = net::ERR_ABORTED;
 157     ResourceHostMsg_SyncLoad::WriteReplyParams(sync_result, result);
 158     filter->Send(sync_result);
 159   } else {
 160     // Tell the renderer that this request was disallowed.
 161     ResourceMsg_RequestCompleteData request_complete_data;
 162     request_complete_data.error_code = net::ERR_ABORTED;
 163     request_complete_data.was_ignored_by_handler = false;
 164     request_complete_data.exists_in_cache = false;
 165     // No security info needed, connection not established.
 166     request_complete_data.completion_time = base::TimeTicks();
 167     request_complete_data.encoded_data_length = 0;
 168     filter->Send(new ResourceMsg_RequestComplete(
 169         request_id, request_complete_data));
 170   }
 171 }
 172
 173 void SetReferrerForRequest(net::URLRequest* request, const Referrer& referrer) {
 174   if (!referrer.url.is_valid() ||
 175       CommandLine::ForCurrentProcess()->HasSwitch(switches::kNoReferrers)) {
 176     request->SetReferrer(std::string());
 177   } else {
 178     request->SetReferrer(referrer.url.spec());
 179   }
 180
 181   net::URLRequest::ReferrerPolicy net_referrer_policy =
 182       net::URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE;
 183   switch (referrer.policy) {
 184     case blink::WebReferrerPolicyDefault:
 185       net_referrer_policy =
 186           net::URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE;
 187       break;
 188     case blink::WebReferrerPolicyAlways:
 189     case blink::WebReferrerPolicyNever:
 190     case blink::WebReferrerPolicyOrigin:
 191       net_referrer_policy = net::URLRequest::NEVER_CLEAR_REFERRER;
 192       break;
 193   }
 194   request->set_referrer_policy(net_referrer_policy);
 195 }
 196
 197 // Consults the RendererSecurity policy to determine whether the
 198 // ResourceDispatcherHostImpl should service this request.  A request might be
 199 // disallowed if the renderer is not authorized to retrieve the request URL or
 200 // if the renderer is attempting to upload an unauthorized file.
 201 bool ShouldServiceRequest(int process_type,
 202                           int child_id,
 203                           const ResourceHostMsg_Request& request_data,
 204                           fileapi::FileSystemContext* file_system_context)  {
 205   if (process_type == PROCESS_TYPE_PLUGIN)
 206     return true;
 207
 208   ChildProcessSecurityPolicyImpl* policy =
 209       ChildProcessSecurityPolicyImpl::GetInstance();
 210
 211   // Check if the renderer is permitted to request the requested URL.
 212   if (!policy->CanRequestURL(child_id, request_data.url)) {
 213     VLOG(1) << "Denied unauthorized request for "
 214             << request_data.url.possibly_invalid_spec();
 215     return false;
 216   }
 217
 218   // Check if the renderer is permitted to upload the requested files.
 219   if (request_data.request_body.get()) {
 220     const std::vector<ResourceRequestBody::Element>* uploads =
 221         request_data.request_body->elements();
 222     std::vector<ResourceRequestBody::Element>::const_iterator iter;
 223     for (iter = uploads->begin(); iter != uploads->end(); ++iter) {
 224       if (iter->type() == ResourceRequestBody::Element::TYPE_FILE &&
 225           !policy->CanReadFile(child_id, iter->path())) {
 226         NOTREACHED() << "Denied unauthorized upload of "
 227                      << iter->path().value();
 228         return false;
 229       }
 230       if (iter->type() == ResourceRequestBody::Element::TYPE_FILE_FILESYSTEM) {
 231         fileapi::FileSystemURL url =
 232             file_system_context->CrackURL(iter->filesystem_url());
 233         if (!policy->CanReadFileSystemFile(child_id, url)) {
 234           NOTREACHED() << "Denied unauthorized upload of "
 235                        << iter->filesystem_url().spec();
 236           return false;
 237         }
 238       }
 239     }
 240   }
 241
 242   return true;
 243 }
 244
 245 void RemoveDownloadFileFromChildSecurityPolicy(int child_id,
 246                                                const base::FilePath& path) {
 247   ChildProcessSecurityPolicyImpl::GetInstance()->RevokeAllPermissionsForFile(
 248       child_id, path);
 249 }
 250
 251 #if defined(OS_WIN)
 252 #pragma warning(disable: 4748)
 253 #pragma optimize("", off)
 254 #endif
 255
 256 #if defined(OS_WIN)
 257 #pragma optimize("", on)
 258 #pragma warning(default: 4748)
 259 #endif
 260
 261 DownloadInterruptReason CallbackAndReturn(
 262     const DownloadUrlParameters::OnStartedCallback& started_cb,
 263     DownloadInterruptReason interrupt_reason) {
 264   if (started_cb.is_null())
 265     return interrupt_reason;
 266   BrowserThread::PostTask(
 267       BrowserThread::UI,
 268       FROM_HERE,
 269       base::Bind(
 270           started_cb, static_cast<DownloadItem*>(NULL), interrupt_reason));
 271
 272   return interrupt_reason;
 273 }
 274
 275 int GetCertID(net::URLRequest* request, int child_id) {
 276   if (request->ssl_info().cert.get()) {
 277     return CertStore::GetInstance()->StoreCert(request->ssl_info().cert.get(),
 278                                                child_id);
 279   }
 280   return 0;
 281 }
 282
 283 void NotifyRedirectOnUI(int render_process_id,
 284                         int render_frame_host,
 285                         scoped_ptr<ResourceRedirectDetails> details) {
 286   RenderFrameHostImpl* host =
 287       RenderFrameHostImpl::FromID(render_process_id, render_frame_host);
 288   WebContentsImpl* web_contents =
 289       static_cast<WebContentsImpl*>(WebContents::FromRenderFrameHost(host));
 290   if (!web_contents)
 291     return;
 292   web_contents->DidGetRedirectForResourceRequest(
 293       host->render_view_host(), *details.get());
 294 }
 295
 296 void NotifyResponseOnUI(int render_process_id,
 297                         int render_frame_host,
 298                         scoped_ptr<ResourceRequestDetails> details) {
 299   RenderFrameHostImpl* host =
 300       RenderFrameHostImpl::FromID(render_process_id, render_frame_host);
 301   WebContentsImpl* web_contents =
 302       static_cast<WebContentsImpl*>(WebContents::FromRenderFrameHost(host));
 303   if (!web_contents)
 304     return;
 305   web_contents->DidGetResourceResponseStart(*details.get());
 306 }
 307
 308 bool IsValidatedSCT(
 309     const net::SignedCertificateTimestampAndStatus& sct_status) {
 310   return sct_status.status == net::ct::SCT_STATUS_OK;
 311 }
 312
 313 }  // namespace
 314
 315 // static
 316 ResourceDispatcherHost* ResourceDispatcherHost::Get() {
 317   return g_resource_dispatcher_host;
 318 }
 319
 320 ResourceDispatcherHostImpl::ResourceDispatcherHostImpl()
 321     : save_file_manager_(new SaveFileManager()),
 322       request_id_(-1),
 323       is_shutdown_(false),
 324       num_in_flight_requests_(0),
 325       max_num_in_flight_requests_(base::SharedMemory::GetHandleLimit()),
 326       max_num_in_flight_requests_per_process_(
 327           static_cast<int>(
 328               max_num_in_flight_requests_ * kMaxRequestsPerProcessRatio)),
 329       max_outstanding_requests_cost_per_process_(
 330           kMaxOutstandingRequestsCostPerProcess),
 331       filter_(NULL),
 332       delegate_(NULL),
 333       allow_cross_origin_auth_prompt_(false) {
 334   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 335   DCHECK(!g_resource_dispatcher_host);
 336   g_resource_dispatcher_host = this;
 337
 338   GetContentClient()->browser()->ResourceDispatcherHostCreated();
 339
 340   ANNOTATE_BENIGN_RACE(
 341       &last_user_gesture_time_,
 342       "We don't care about the precise value, see http://crbug.com/92889");
 343
 344   BrowserThread::PostTask(BrowserThread::IO,
 345                           FROM_HERE,
 346                           base::Bind(&ResourceDispatcherHostImpl::OnInit,
 347                                      base::Unretained(this)));
 348
 349   update_load_states_timer_.reset(
 350       new base::RepeatingTimer<ResourceDispatcherHostImpl>());
 351 }
 352
 353 ResourceDispatcherHostImpl::~ResourceDispatcherHostImpl() {
 354   DCHECK(outstanding_requests_stats_map_.empty());
 355   DCHECK(g_resource_dispatcher_host);
 356   g_resource_dispatcher_host = NULL;
 357 }
 358
 359 // static
 360 ResourceDispatcherHostImpl* ResourceDispatcherHostImpl::Get() {
 361   return g_resource_dispatcher_host;
 362 }
 363
 364 void ResourceDispatcherHostImpl::SetDelegate(
 365     ResourceDispatcherHostDelegate* delegate) {
 366   delegate_ = delegate;
 367 }
 368
 369 void ResourceDispatcherHostImpl::SetAllowCrossOriginAuthPrompt(bool value) {
 370   allow_cross_origin_auth_prompt_ = value;
 371 }
 372
 373 void ResourceDispatcherHostImpl::AddResourceContext(ResourceContext* context) {
 374   active_resource_contexts_.insert(context);
 375 }
 376
 377 void ResourceDispatcherHostImpl::RemoveResourceContext(
 378     ResourceContext* context) {
 379   CHECK(ContainsKey(active_resource_contexts_, context));
 380   active_resource_contexts_.erase(context);
 381 }
 382
 383 void ResourceDispatcherHostImpl::CancelRequestsForContext(
 384     ResourceContext* context) {
 385   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 386   DCHECK(context);
 387
 388   CHECK(ContainsKey(active_resource_contexts_, context));
 389
 390   // Note that request cancellation has side effects. Therefore, we gather all
 391   // the requests to cancel first, and then we start cancelling. We assert at
 392   // the end that there are no more to cancel since the context is about to go
 393   // away.
 394   typedef std::vector<linked_ptr<ResourceLoader> > LoaderList;
 395   LoaderList loaders_to_cancel;
 396
 397   for (LoaderMap::iterator i = pending_loaders_.begin();
 398        i != pending_loaders_.end();) {
 399     if (i->second->GetRequestInfo()->GetContext() == context) {
 400       loaders_to_cancel.push_back(i->second);
 401       IncrementOutstandingRequestsMemory(-1, *i->second->GetRequestInfo());
 402       pending_loaders_.erase(i++);
 403     } else {
 404       ++i;
 405     }
 406   }
 407
 408   for (BlockedLoadersMap::iterator i = blocked_loaders_map_.begin();
 409        i != blocked_loaders_map_.end();) {
 410     BlockedLoadersList* loaders = i->second;
 411     if (loaders->empty()) {
 412       // This can happen if BlockRequestsForRoute() has been called for a route,
 413       // but we haven't blocked any matching requests yet.
 414       ++i;
 415       continue;
 416     }
 417     ResourceRequestInfoImpl* info = loaders->front()->GetRequestInfo();
 418     if (info->GetContext() == context) {
 419       blocked_loaders_map_.erase(i++);
 420       for (BlockedLoadersList::const_iterator it = loaders->begin();
 421            it != loaders->end(); ++it) {
 422         linked_ptr<ResourceLoader> loader = *it;
 423         info = loader->GetRequestInfo();
 424         // We make the assumption that all requests on the list have the same
 425         // ResourceContext.
 426         DCHECK_EQ(context, info->GetContext());
 427         IncrementOutstandingRequestsMemory(-1, *info);
 428         loaders_to_cancel.push_back(loader);
 429       }
 430       delete loaders;
 431     } else {
 432       ++i;
 433     }
 434   }
 435
 436 #ifndef NDEBUG
 437   for (LoaderList::iterator i = loaders_to_cancel.begin();
 438        i != loaders_to_cancel.end(); ++i) {
 439     // There is no strict requirement that this be the case, but currently
 440     // downloads, streams, detachable requests, and transferred requests are the
 441     // only requests that aren't cancelled when the associated processes go
 442     // away. It may be OK for this invariant to change in the future, but if
 443     // this assertion fires without the invariant changing, then it's indicative
 444     // of a leak.
 445     DCHECK((*i)->GetRequestInfo()->IsDownload() ||
 446            (*i)->GetRequestInfo()->is_stream() ||
 447            ((*i)->GetRequestInfo()->detachable_handler() &&
 448             (*i)->GetRequestInfo()->detachable_handler()->is_detached()) ||
 449            (*i)->is_transferring());
 450   }
 451 #endif
 452
 453   loaders_to_cancel.clear();
 454
 455   // Validate that no more requests for this context were added.
 456   for (LoaderMap::const_iterator i = pending_loaders_.begin();
 457        i != pending_loaders_.end(); ++i) {
 458     // http://crbug.com/90971
 459     CHECK_NE(i->second->GetRequestInfo()->GetContext(), context);
 460   }
 461
 462   for (BlockedLoadersMap::const_iterator i = blocked_loaders_map_.begin();
 463        i != blocked_loaders_map_.end(); ++i) {
 464     BlockedLoadersList* loaders = i->second;
 465     if (!loaders->empty()) {
 466       ResourceRequestInfoImpl* info = loaders->front()->GetRequestInfo();
 467       // http://crbug.com/90971
 468       CHECK_NE(info->GetContext(), context);
 469     }
 470   }
 471 }
 472
 473 DownloadInterruptReason ResourceDispatcherHostImpl::BeginDownload(
 474     scoped_ptr<net::URLRequest> request,
 475     const Referrer& referrer,
 476     bool is_content_initiated,
 477     ResourceContext* context,
 478     int child_id,
 479     int route_id,
 480     bool prefer_cache,
 481     scoped_ptr<DownloadSaveInfo> save_info,
 482     uint32 download_id,
 483     const DownloadStartedCallback& started_callback) {
 484   if (is_shutdown_)
 485     return CallbackAndReturn(started_callback,
 486                              DOWNLOAD_INTERRUPT_REASON_USER_SHUTDOWN);
 487
 488   const GURL& url = request->original_url();
 489
 490   // http://crbug.com/90971
 491   char url_buf[128];
 492   base::strlcpy(url_buf, url.spec().c_str(), arraysize(url_buf));
 493   base::debug::Alias(url_buf);
 494   CHECK(ContainsKey(active_resource_contexts_, context));
 495
 496   SetReferrerForRequest(request.get(), referrer);
 497
 498   int extra_load_flags = net::LOAD_IS_DOWNLOAD;
 499   if (prefer_cache) {
 500     // If there is upload data attached, only retrieve from cache because there
 501     // is no current mechanism to prompt the user for their consent for a
 502     // re-post. For GETs, try to retrieve data from the cache and skip
 503     // validating the entry if present.
 504     if (request->get_upload() != NULL)
 505       extra_load_flags |= net::LOAD_ONLY_FROM_CACHE;
 506     else
 507       extra_load_flags |= net::LOAD_PREFERRING_CACHE;
 508   } else {
 509     extra_load_flags |= net::LOAD_DISABLE_CACHE;
 510   }
 511   request->SetLoadFlags(request->load_flags() | extra_load_flags);
 512
 513   // No need to get offline load flags for downloads, but make sure
 514   // we have an OfflinePolicy to receive request completions.
 515   GlobalRoutingID id(child_id, route_id);
 516   if (!offline_policy_map_[id])
 517     offline_policy_map_[id] = new OfflinePolicy();
 518
 519   // Check if the renderer is permitted to request the requested URL.
 520   if (!ChildProcessSecurityPolicyImpl::GetInstance()->
 521           CanRequestURL(child_id, url)) {
 522     VLOG(1) << "Denied unauthorized download request for "
 523             << url.possibly_invalid_spec();
 524     return CallbackAndReturn(started_callback,
 525                              DOWNLOAD_INTERRUPT_REASON_NETWORK_INVALID_REQUEST);
 526   }
 527
 528   request_id_--;
 529
 530   const net::URLRequestContext* request_context = context->GetRequestContext();
 531   if (!request_context->job_factory()->IsHandledURL(url)) {
 532     VLOG(1) << "Download request for unsupported protocol: "
 533             << url.possibly_invalid_spec();
 534     return CallbackAndReturn(started_callback,
 535                              DOWNLOAD_INTERRUPT_REASON_NETWORK_INVALID_REQUEST);
 536   }
 537
 538   ResourceRequestInfoImpl* extra_info =
 539       CreateRequestInfo(child_id, route_id, true, context);
 540   extra_info->AssociateWithRequest(request.get());  // Request takes ownership.
 541
 542   if (request->url().SchemeIs(chrome::kBlobScheme)) {
 543     ChromeBlobStorageContext* blob_context =
 544         GetChromeBlobStorageContextForResourceContext(context);
 545     webkit_blob::BlobProtocolHandler::SetRequestedBlobDataHandle(
 546         request.get(),
 547         blob_context->context()->GetBlobDataFromPublicURL(request->url()));
 548   }
 549
 550   // From this point forward, the |DownloadResourceHandler| is responsible for
 551   // |started_callback|.
 552   scoped_ptr<ResourceHandler> handler(
 553       CreateResourceHandlerForDownload(request.get(), is_content_initiated,
 554                                        true, download_id, save_info.Pass(),
 555                                        started_callback));
 556
 557   BeginRequestInternal(request.Pass(), handler.Pass());
 558
 559   return DOWNLOAD_INTERRUPT_REASON_NONE;
 560 }
 561
 562 void ResourceDispatcherHostImpl::ClearLoginDelegateForRequest(
 563     net::URLRequest* request) {
 564   ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest(request);
 565   if (info) {
 566     ResourceLoader* loader = GetLoader(info->GetGlobalRequestID());
 567     if (loader)
 568       loader->ClearLoginDelegate();
 569   }
 570 }
 571
 572 void ResourceDispatcherHostImpl::Shutdown() {
 573   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 574   BrowserThread::PostTask(BrowserThread::IO,
 575                           FROM_HERE,
 576                           base::Bind(&ResourceDispatcherHostImpl::OnShutdown,
 577                                      base::Unretained(this)));
 578 }
 579
 580 scoped_ptr<ResourceHandler>
 581 ResourceDispatcherHostImpl::CreateResourceHandlerForDownload(
 582     net::URLRequest* request,
 583     bool is_content_initiated,
 584     bool must_download,
 585     uint32 id,
 586     scoped_ptr<DownloadSaveInfo> save_info,
 587     const DownloadUrlParameters::OnStartedCallback& started_cb) {
 588   scoped_ptr<ResourceHandler> handler(
 589       new DownloadResourceHandler(id, request, started_cb, save_info.Pass()));
 590   if (delegate_) {
 591     const ResourceRequestInfo* request_info(
 592         ResourceRequestInfo::ForRequest(request));
 593
 594     ScopedVector<ResourceThrottle> throttles;
 595     delegate_->DownloadStarting(
 596         request, request_info->GetContext(), request_info->GetChildID(),
 597         request_info->GetRouteID(), request_info->GetRequestID(),
 598         is_content_initiated, must_download, &throttles);
 599     if (!throttles.empty()) {
 600       handler.reset(
 601           new ThrottlingResourceHandler(
 602               handler.Pass(), request, throttles.Pass()));
 603     }
 604   }
 605   return handler.Pass();
 606 }
 607
 608 scoped_ptr<ResourceHandler>
 609 ResourceDispatcherHostImpl::MaybeInterceptAsStream(net::URLRequest* request,
 610                                                    ResourceResponse* response) {
 611   ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest(request);
 612   const std::string& mime_type = response->head.mime_type;
 613
 614   GURL origin;
 615   std::string target_id;
 616   if (!delegate_ ||
 617       !delegate_->ShouldInterceptResourceAsStream(info->GetContext(),
 618                                                   request->url(),
 619                                                   mime_type,
 620                                                   &origin,
 621                                                   &target_id)) {
 622     return scoped_ptr<ResourceHandler>();
 623   }
 624
 625   StreamContext* stream_context =
 626       GetStreamContextForResourceContext(info->GetContext());
 627
 628   scoped_ptr<StreamResourceHandler> handler(
 629       new StreamResourceHandler(request,
 630                                 stream_context->registry(),
 631                                 origin));
 632
 633   info->set_is_stream(true);
 634   delegate_->OnStreamCreated(
 635       info->GetContext(),
 636       info->GetChildID(),
 637       info->GetRouteID(),
 638       target_id,
 639       handler->stream()->CreateHandle(request->url(), mime_type),
 640       request->GetExpectedContentSize());
 641   return handler.PassAs<ResourceHandler>();
 642 }
 643
 644 void ResourceDispatcherHostImpl::ClearSSLClientAuthHandlerForRequest(
 645     net::URLRequest* request) {
 646   ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest(request);
 647   if (info) {
 648     ResourceLoader* loader = GetLoader(info->GetGlobalRequestID());
 649     if (loader)
 650       loader->ClearSSLClientAuthHandler();
 651   }
 652 }
 653
 654 ResourceDispatcherHostLoginDelegate*
 655 ResourceDispatcherHostImpl::CreateLoginDelegate(
 656     ResourceLoader* loader,
 657     net::AuthChallengeInfo* auth_info) {
 658   if (!delegate_)
 659     return NULL;
 660
 661   return delegate_->CreateLoginDelegate(auth_info, loader->request());
 662 }
 663
 664 bool ResourceDispatcherHostImpl::HandleExternalProtocol(ResourceLoader* loader,
 665                                                         const GURL& url) {
 666   if (!delegate_)
 667     return false;
 668
 669   ResourceRequestInfoImpl* info = loader->GetRequestInfo();
 670
 671   if (!ResourceType::IsFrame(info->GetResourceType()))
 672     return false;
 673
 674   const net::URLRequestJobFactory* job_factory =
 675       info->GetContext()->GetRequestContext()->job_factory();
 676   if (job_factory->IsHandledURL(url))
 677     return false;
 678
 679   return delegate_->HandleExternalProtocol(url, info->GetChildID(),
 680                                            info->GetRouteID());
 681 }
 682
 683 void ResourceDispatcherHostImpl::DidStartRequest(ResourceLoader* loader) {
 684   // Make sure we have the load state monitor running
 685   if (!update_load_states_timer_->IsRunning()) {
 686     update_load_states_timer_->Start(FROM_HERE,
 687         TimeDelta::FromMilliseconds(kUpdateLoadStatesIntervalMsec),
 688         this, &ResourceDispatcherHostImpl::UpdateLoadStates);
 689   }
 690 }
 691
 692 void ResourceDispatcherHostImpl::DidReceiveRedirect(ResourceLoader* loader,
 693                                                     const GURL& new_url) {
 694   ResourceRequestInfoImpl* info = loader->GetRequestInfo();
 695
 696   int render_process_id, render_frame_host;
 697   if (!info->GetAssociatedRenderFrame(&render_process_id, &render_frame_host))
 698     return;
 699
 700   // Notify the observers on the UI thread.
 701   scoped_ptr<ResourceRedirectDetails> detail(new ResourceRedirectDetails(
 702       loader->request(),
 703       GetCertID(loader->request(), info->GetChildID()),
 704       new_url));
 705   BrowserThread::PostTask(
 706       BrowserThread::UI, FROM_HERE,
 707       base::Bind(
 708           &NotifyRedirectOnUI,
 709           render_process_id, render_frame_host, base::Passed(&detail)));
 710 }
 711
 712 void ResourceDispatcherHostImpl::DidReceiveResponse(ResourceLoader* loader) {
 713   ResourceRequestInfoImpl* info = loader->GetRequestInfo();
 714
 715   if (loader->request()->was_fetched_via_proxy() &&
 716       loader->request()->was_fetched_via_spdy() &&
 717       loader->request()->url().SchemeIs("http")) {
 718     scheduler_->OnReceivedSpdyProxiedHttpResponse(
 719         info->GetChildID(), info->GetRouteID());
 720   }
 721
 722   // There should be an entry in the map created when we dispatched the
 723   // request unless it's been detached and the renderer has died.
 724   OfflineMap::iterator policy_it(
 725       offline_policy_map_.find(info->GetGlobalRoutingID()));
 726   if (offline_policy_map_.end() != policy_it) {
 727     policy_it->second->UpdateStateForSuccessfullyStartedRequest(
 728         loader->request()->response_info());
 729   } else {
 730     // Unless detached, we should have an entry in offline_policy_map_ from
 731     // when this request traversed Begin{Download,SaveFile,Request}.
 732     // TODO(rdsmith): This isn't currently true; see http://crbug.com/241176.
 733     DCHECK(info->detachable_handler() &&
 734            info->detachable_handler()->is_detached());
 735   }
 736
 737   int render_process_id, render_frame_host;
 738   if (!info->GetAssociatedRenderFrame(&render_process_id, &render_frame_host))
 739     return;
 740
 741   // Notify the observers on the UI thread.
 742   scoped_ptr<ResourceRequestDetails> detail(new ResourceRequestDetails(
 743       loader->request(),
 744       GetCertID(loader->request(), info->GetChildID())));
 745   BrowserThread::PostTask(
 746       BrowserThread::UI, FROM_HERE,
 747       base::Bind(
 748           &NotifyResponseOnUI,
 749           render_process_id, render_frame_host, base::Passed(&detail)));
 750 }
 751
 752 void ResourceDispatcherHostImpl::DidFinishLoading(ResourceLoader* loader) {
 753   ResourceRequestInfo* info = loader->GetRequestInfo();
 754
 755   // Record final result of all resource loads.
 756   if (info->GetResourceType() == ResourceType::MAIN_FRAME) {
 757     // This enumeration has "3" appended to its name to distinguish it from
 758     // older versions.
 759     UMA_HISTOGRAM_SPARSE_SLOWLY(
 760         "Net.ErrorCodesForMainFrame3",
 761         -loader->request()->status().error());
 762
 763     if (loader->request()->url().SchemeIsSecure()) {
 764       if (loader->request()->url().host() == "www.google.com") {
 765         UMA_HISTOGRAM_SPARSE_SLOWLY("Net.ErrorCodesForHTTPSGoogleMainFrame2",
 766                                     -loader->request()->status().error());
 767       }
 768
 769       int num_valid_scts = std::count_if(
 770           loader->request()->ssl_info().signed_certificate_timestamps.begin(),
 771           loader->request()->ssl_info().signed_certificate_timestamps.end(),
 772           IsValidatedSCT);
 773       UMA_HISTOGRAM_COUNTS_100(
 774           "Net.CertificateTransparency.MainFrameValidSCTCount", num_valid_scts);
 775     }
 776   } else {
 777     if (info->GetResourceType() == ResourceType::IMAGE) {
 778       UMA_HISTOGRAM_SPARSE_SLOWLY(
 779           "Net.ErrorCodesForImages",
 780           -loader->request()->status().error());
 781     }
 782     // This enumeration has "2" appended to distinguish it from older versions.
 783     UMA_HISTOGRAM_SPARSE_SLOWLY(
 784         "Net.ErrorCodesForSubresources2",
 785         -loader->request()->status().error());
 786   }
 787
 788   if (delegate_)
 789     delegate_->RequestComplete(loader->request());
 790
 791   // Destroy the ResourceLoader.
 792   RemovePendingRequest(info->GetChildID(), info->GetRequestID());
 793 }
 794
 795 void ResourceDispatcherHostImpl::OnInit() {
 796   scheduler_.reset(new ResourceScheduler);
 797   appcache::AppCacheInterceptor::EnsureRegistered();
 798 }
 799
 800 void ResourceDispatcherHostImpl::OnShutdown() {
 801   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 802
 803   is_shutdown_ = true;
 804   pending_loaders_.clear();
 805
 806   // Make sure we shutdown the timer now, otherwise by the time our destructor
 807   // runs if the timer is still running the Task is deleted twice (once by
 808   // the MessageLoop and the second time by RepeatingTimer).
 809   update_load_states_timer_.reset();
 810
 811   // Clear blocked requests if any left.
 812   // Note that we have to do this in 2 passes as we cannot call
 813   // CancelBlockedRequestsForRoute while iterating over
 814   // blocked_loaders_map_, as it modifies it.
 815   std::set<GlobalRoutingID> ids;
 816   for (BlockedLoadersMap::const_iterator iter = blocked_loaders_map_.begin();
 817        iter != blocked_loaders_map_.end(); ++iter) {
 818     std::pair<std::set<GlobalRoutingID>::iterator, bool> result =
 819         ids.insert(iter->first);
 820     // We should not have duplicates.
 821     DCHECK(result.second);
 822   }
 823   for (std::set<GlobalRoutingID>::const_iterator iter = ids.begin();
 824        iter != ids.end(); ++iter) {
 825     CancelBlockedRequestsForRoute(iter->child_id, iter->route_id);
 826   }
 827
 828   scheduler_.reset();
 829 }
 830
 831 bool ResourceDispatcherHostImpl::OnMessageReceived(
 832     const IPC::Message& message,
 833     ResourceMessageFilter* filter,
 834     bool* message_was_ok) {
 835   filter_ = filter;
 836   bool handled = true;
 837   IPC_BEGIN_MESSAGE_MAP_EX(ResourceDispatcherHostImpl, message, *message_was_ok)
 838     IPC_MESSAGE_HANDLER(ResourceHostMsg_RequestResource, OnRequestResource)
 839     IPC_MESSAGE_HANDLER_DELAY_REPLY(ResourceHostMsg_SyncLoad, OnSyncLoad)
 840     IPC_MESSAGE_HANDLER(ResourceHostMsg_ReleaseDownloadedFile,
 841                         OnReleaseDownloadedFile)
 842     IPC_MESSAGE_HANDLER(ResourceHostMsg_DataDownloaded_ACK, OnDataDownloadedACK)
 843     IPC_MESSAGE_HANDLER(ResourceHostMsg_UploadProgress_ACK, OnUploadProgressACK)
 844     IPC_MESSAGE_HANDLER(ResourceHostMsg_CancelRequest, OnCancelRequest)
 845     IPC_MESSAGE_UNHANDLED(handled = false)
 846   IPC_END_MESSAGE_MAP_EX()
 847
 848   if (!handled && IPC_MESSAGE_ID_CLASS(message.type()) == ResourceMsgStart) {
 849     PickleIterator iter(message);
 850     int request_id = -1;
 851     bool ok = iter.ReadInt(&request_id);
 852     DCHECK(ok);
 853     GlobalRequestID id(filter_->child_id(), request_id);
 854     DelegateMap::iterator it = delegate_map_.find(id);
 855     if (it != delegate_map_.end()) {
 856       ObserverList<ResourceMessageDelegate>::Iterator del_it(*it->second);
 857       ResourceMessageDelegate* delegate;
 858       while (!handled && (delegate = del_it.GetNext()) != NULL) {
 859         handled = delegate->OnMessageReceived(message, message_was_ok);
 860       }
 861     }
 862   }
 863
 864   filter_ = NULL;
 865   return handled;
 866 }
 867
 868 void ResourceDispatcherHostImpl::OnRequestResource(
 869     const IPC::Message& message,
 870     int request_id,
 871     const ResourceHostMsg_Request& request_data) {
 872   BeginRequest(request_id, request_data, NULL, message.routing_id());
 873 }
 874
 875 // Begins a resource request with the given params on behalf of the specified
 876 // child process.  Responses will be dispatched through the given receiver. The
 877 // process ID is used to lookup WebContentsImpl from routing_id's in the case of
 878 // a request from a renderer.  request_context is the cookie/cache context to be
 879 // used for this request.
 880 //
 881 // If sync_result is non-null, then a SyncLoad reply will be generated, else
 882 // a normal asynchronous set of response messages will be generated.
 883 void ResourceDispatcherHostImpl::OnSyncLoad(
 884     int request_id,
 885     const ResourceHostMsg_Request& request_data,
 886     IPC::Message* sync_result) {
 887   BeginRequest(request_id, request_data, sync_result,
 888                sync_result->routing_id());
 889 }
 890
 891 void ResourceDispatcherHostImpl::UpdateRequestForTransfer(
 892     int child_id,
 893     int route_id,
 894     int request_id,
 895     const ResourceHostMsg_Request& request_data,
 896     const linked_ptr<ResourceLoader>& loader) {
 897   ResourceRequestInfoImpl* info = loader->GetRequestInfo();
 898   GlobalRoutingID old_routing_id(
 899       request_data.transferred_request_child_id, info->GetRouteID());
 900   GlobalRequestID old_request_id(request_data.transferred_request_child_id,
 901                                  request_data.transferred_request_request_id);
 902   GlobalRoutingID new_routing_id(child_id, route_id);
 903   GlobalRequestID new_request_id(child_id, request_id);
 904
 905   // Clear out data that depends on |info| before updating it.
 906   IncrementOutstandingRequestsMemory(-1, *info);
 907   OustandingRequestsStats empty_stats = { 0, 0 };
 908   OustandingRequestsStats old_stats = GetOutstandingRequestsStats(*info);
 909   UpdateOutstandingRequestsStats(*info, empty_stats);
 910   pending_loaders_.erase(old_request_id);
 911
 912   // ResourceHandlers should always get state related to the request from the
 913   // ResourceRequestInfo rather than caching it locally.  This lets us update
 914   // the info object when a transfer occurs.
 915   info->UpdateForTransfer(child_id, route_id, request_data.origin_pid,
 916                           request_id, request_data.frame_id,
 917                           request_data.parent_frame_id, filter_->GetWeakPtr());
 918
 919   // Update maps that used the old IDs, if necessary.  Some transfers in tests
 920   // do not actually use a different ID, so not all maps need to be updated.
 921   pending_loaders_[new_request_id] = loader;
 922   UpdateOutstandingRequestsStats(*info, old_stats);
 923   IncrementOutstandingRequestsMemory(1, *info);
 924   if (old_routing_id != new_routing_id) {
 925     if (offline_policy_map_.find(old_routing_id) != offline_policy_map_.end()) {
 926       if (offline_policy_map_.find(new_routing_id) !=
 927           offline_policy_map_.end())
 928         delete offline_policy_map_[new_routing_id];
 929       offline_policy_map_[new_routing_id] = offline_policy_map_[old_routing_id];
 930       offline_policy_map_.erase(old_routing_id);
 931     }
 932     if (blocked_loaders_map_.find(old_routing_id) !=
 933             blocked_loaders_map_.end()) {
 934       blocked_loaders_map_[new_routing_id] =
 935           blocked_loaders_map_[old_routing_id];
 936       blocked_loaders_map_.erase(old_routing_id);
 937     }
 938   }
 939   if (old_request_id != new_request_id) {
 940     DelegateMap::iterator it = delegate_map_.find(old_request_id);
 941     if (it != delegate_map_.end()) {
 942       // Tell each delegate that the request ID has changed.
 943       ObserverList<ResourceMessageDelegate>::Iterator del_it(*it->second);
 944       ResourceMessageDelegate* delegate;
 945       while ((delegate = del_it.GetNext()) != NULL) {
 946         delegate->set_request_id(new_request_id);
 947       }
 948       // Now store the observer list under the new request ID.
 949       delegate_map_[new_request_id] = delegate_map_[old_request_id];
 950       delegate_map_.erase(old_request_id);
 951     }
 952   }
 953
 954   appcache::AppCacheInterceptor::CompleteCrossSiteTransfer(
 955       loader->request(),
 956       child_id,
 957       request_data.appcache_host_id);
 958
 959   // We should have a CrossSiteResourceHandler to finish the transfer.
 960   DCHECK(info->cross_site_handler());
 961 }
 962
 963 void ResourceDispatcherHostImpl::BeginRequest(
 964     int request_id,
 965     const ResourceHostMsg_Request& request_data,
 966     IPC::Message* sync_result,  // only valid for sync
 967     int route_id) {
 968   int process_type = filter_->process_type();
 969   int child_id = filter_->child_id();
 970
 971   // Reject invalid priority.
 972   if (request_data.priority < net::MINIMUM_PRIORITY ||
 973       request_data.priority > net::MAXIMUM_PRIORITY) {
 974     RecordAction(base::UserMetricsAction("BadMessageTerminate_RDH"));
 975     filter_->BadMessageReceived();
 976     return;
 977   }
 978
 979   // If we crash here, figure out what URL the renderer was requesting.
 980   // http://crbug.com/91398
 981   char url_buf[128];
 982   base::strlcpy(url_buf, request_data.url.spec().c_str(), arraysize(url_buf));
 983   base::debug::Alias(url_buf);
 984
 985   // If the request that's coming in is being transferred from another process,
 986   // we want to reuse and resume the old loader rather than start a new one.
 987   linked_ptr<ResourceLoader> deferred_loader;
 988   {
 989     LoaderMap::iterator it = pending_loaders_.find(
 990         GlobalRequestID(request_data.transferred_request_child_id,
 991                         request_data.transferred_request_request_id));
 992     if (it != pending_loaders_.end()) {
 993       // If the request is transferring to a new process, we can update our
 994       // state and let it resume with its existing ResourceHandlers.
 995       if (it->second->is_transferring()) {
 996         deferred_loader = it->second;
 997         UpdateRequestForTransfer(child_id, route_id, request_id,
 998                                  request_data, deferred_loader);
 999
1000         deferred_loader->CompleteTransfer();
1001       } else {
1002         RecordAction(base::UserMetricsAction("BadMessageTerminate_RDH"));
1003         filter_->BadMessageReceived();
1004       }
1005       return;
1006     }
1007   }
1008
1009   ResourceContext* resource_context = NULL;
1010   net::URLRequestContext* request_context = NULL;
1011   filter_->GetContexts(request_data, &resource_context, &request_context);
1012   // http://crbug.com/90971
1013   CHECK(ContainsKey(active_resource_contexts_, resource_context));
1014
1015   if (is_shutdown_ ||
1016       !ShouldServiceRequest(process_type, child_id, request_data,
1017                             filter_->file_system_context())) {
1018     AbortRequestBeforeItStarts(filter_, sync_result, request_id);
1019     return;
1020   }
1021
1022   const Referrer referrer(request_data.referrer, request_data.referrer_policy);
1023
1024   // Allow the observer to block/handle the request.
1025   if (delegate_ && !delegate_->ShouldBeginRequest(child_id,
1026                                                   route_id,
1027                                                   request_data.method,
1028                                                   request_data.url,
1029                                                   request_data.resource_type,
1030                                                   resource_context)) {
1031     AbortRequestBeforeItStarts(filter_, sync_result, request_id);
1032     return;
1033   }
1034
1035   bool is_sync_load = sync_result != NULL;
1036   int load_flags =
1037       BuildLoadFlagsForRequest(request_data, child_id, is_sync_load);
1038
1039   GlobalRoutingID id(child_id, route_id);
1040   if (!offline_policy_map_[id])
1041     offline_policy_map_[id] = new OfflinePolicy();
1042   load_flags |= offline_policy_map_[id]->GetAdditionalLoadFlags(
1043       load_flags, request_data.resource_type == ResourceType::MAIN_FRAME);
1044
1045   // Sync loads should have maximum priority and should be the only
1046   // requets that have the ignore limits flag set.
1047   if (is_sync_load) {
1048     DCHECK_EQ(request_data.priority, net::MAXIMUM_PRIORITY);
1049     DCHECK_NE(load_flags & net::LOAD_IGNORE_LIMITS, 0);
1050   } else {
1051     DCHECK_EQ(load_flags & net::LOAD_IGNORE_LIMITS, 0);
1052   }
1053
1054   // Construct the request.
1055   scoped_ptr<net::URLRequest> new_request;
1056   net::URLRequest* request;
1057   new_request = request_context->CreateRequest(
1058       request_data.url, request_data.priority, NULL);
1059   request = new_request.get();
1060
1061   request->set_method(request_data.method);
1062   request->set_first_party_for_cookies(request_data.first_party_for_cookies);
1063   SetReferrerForRequest(request, referrer);
1064
1065   net::HttpRequestHeaders headers;
1066   headers.AddHeadersFromString(request_data.headers);
1067   request->SetExtraRequestHeaders(headers);
1068
1069   request->SetLoadFlags(load_flags);
1070
1071   // Resolve elements from request_body and prepare upload data.
1072   if (request_data.request_body.get()) {
1073     webkit_blob::BlobStorageContext* blob_context = NULL;
1074     if (filter_->blob_storage_context())
1075       blob_context = filter_->blob_storage_context()->context();
1076     request->set_upload(UploadDataStreamBuilder::Build(
1077         request_data.request_body.get(),
1078         blob_context,
1079         filter_->file_system_context(),
1080         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE)
1081             .get()));
1082   }
1083
1084   bool allow_download = request_data.allow_download &&
1085       ResourceType::IsFrame(request_data.resource_type);
1086
1087   // Make extra info and read footer (contains request ID).
1088   ResourceRequestInfoImpl* extra_info =
1089       new ResourceRequestInfoImpl(
1090           process_type,
1091           child_id,
1092           route_id,
1093           request_data.origin_pid,
1094           request_id,
1095           request_data.render_frame_id,
1096           request_data.is_main_frame,
1097           request_data.frame_id,
1098           request_data.parent_is_main_frame,
1099           request_data.parent_frame_id,
1100           request_data.resource_type,
1101           request_data.transition_type,
1102           request_data.should_replace_current_entry,
1103           false,  // is download
1104           false,  // is stream
1105           allow_download,
1106           request_data.has_user_gesture,
1107           request_data.referrer_policy,
1108           request_data.visiblity_state,
1109           resource_context,
1110           filter_->GetWeakPtr(),
1111           !is_sync_load);
1112   extra_info->AssociateWithRequest(request);  // Request takes ownership.
1113
1114   if (request->url().SchemeIs(chrome::kBlobScheme)) {
1115     // Hang on to a reference to ensure the blob is not released prior
1116     // to the job being started.
1117     webkit_blob::BlobProtocolHandler::SetRequestedBlobDataHandle(
1118         request,
1119         filter_->blob_storage_context()->context()->
1120             GetBlobDataFromPublicURL(request->url()));
1121   }
1122
1123   // Have the appcache associate its extra info with the request.
1124   appcache::AppCacheInterceptor::SetExtraRequestInfo(
1125       request, filter_->appcache_service(), child_id,
1126       request_data.appcache_host_id, request_data.resource_type);
1127
1128   scoped_ptr<ResourceHandler> handler(
1129        CreateResourceHandler(
1130            request,
1131            request_data, sync_result, route_id, process_type, child_id,
1132            resource_context));
1133
1134   BeginRequestInternal(new_request.Pass(), handler.Pass());
1135 }
1136
1137 scoped_ptr<ResourceHandler> ResourceDispatcherHostImpl::CreateResourceHandler(
1138     net::URLRequest* request,
1139     const ResourceHostMsg_Request& request_data,
1140     IPC::Message* sync_result,
1141     int route_id,
1142     int process_type,
1143     int child_id,
1144     ResourceContext* resource_context) {
1145   // Construct the IPC resource handler.
1146   scoped_ptr<ResourceHandler> handler;
1147   if (sync_result) {
1148     handler.reset(new SyncResourceHandler(request, sync_result, this));
1149   } else {
1150     handler.reset(new AsyncResourceHandler(request, this));
1151     if (IsDetachableResourceType(request_data.resource_type)) {
1152       handler.reset(new DetachableResourceHandler(
1153           request,
1154           base::TimeDelta::FromMilliseconds(kDefaultDetachableCancelDelayMs),
1155           handler.Pass()));
1156     }
1157   }
1158
1159   // The RedirectToFileResourceHandler depends on being next in the chain.
1160   if (request_data.download_to_file) {
1161     handler.reset(
1162         new RedirectToFileResourceHandler(handler.Pass(), request, this));
1163   }
1164
1165   // Install a CrossSiteResourceHandler for all main frame requests.  This will
1166   // let us check whether a transfer is required and pause for the unload
1167   // handler either if so or if a cross-process navigation is already under way.
1168   bool is_swappable_navigation =
1169       request_data.resource_type == ResourceType::MAIN_FRAME;
1170   // If we are using --site-per-process, install it for subframes as well.
1171   if (!is_swappable_navigation &&
1172       CommandLine::ForCurrentProcess()->HasSwitch(switches::kSitePerProcess)) {
1173     is_swappable_navigation =
1174         request_data.resource_type == ResourceType::SUB_FRAME;
1175   }
1176   if (is_swappable_navigation && process_type == PROCESS_TYPE_RENDERER)
1177     handler.reset(new CrossSiteResourceHandler(handler.Pass(), request));
1178
1179   // Insert a buffered event handler before the actual one.
1180   handler.reset(
1181       new BufferedResourceHandler(handler.Pass(), this, request));
1182
1183   ScopedVector<ResourceThrottle> throttles;
1184   if (delegate_) {
1185     delegate_->RequestBeginning(request,
1186                                 resource_context,
1187                                 filter_->appcache_service(),
1188                                 request_data.resource_type,
1189                                 child_id,
1190                                 route_id,
1191                                 &throttles);
1192   }
1193
1194   if (request->has_upload()) {
1195     // Block power save while uploading data.
1196     throttles.push_back(new PowerSaveBlockResourceThrottle());
1197   }
1198
1199   throttles.push_back(
1200       scheduler_->ScheduleRequest(child_id, route_id, request).release());
1201
1202   handler.reset(
1203       new ThrottlingResourceHandler(handler.Pass(), request, throttles.Pass()));
1204
1205   return handler.Pass();
1206 }
1207
1208 void ResourceDispatcherHostImpl::OnReleaseDownloadedFile(int request_id) {
1209   UnregisterDownloadedTempFile(filter_->child_id(), request_id);
1210 }
1211
1212 void ResourceDispatcherHostImpl::OnDataDownloadedACK(int request_id) {
1213   // TODO(michaeln): maybe throttle DataDownloaded messages
1214 }
1215
1216 void ResourceDispatcherHostImpl::RegisterDownloadedTempFile(
1217     int child_id, int request_id, ShareableFileReference* reference) {
1218   registered_temp_files_[child_id][request_id] = reference;
1219   ChildProcessSecurityPolicyImpl::GetInstance()->GrantReadFile(
1220       child_id, reference->path());
1221
1222   // When the temp file is deleted, revoke permissions that the renderer has
1223   // to that file. This covers an edge case where the file is deleted and then
1224   // the same name is re-used for some other purpose, we don't want the old
1225   // renderer to still have access to it.
1226   //
1227   // We do this when the file is deleted because the renderer can take a blob
1228   // reference to the temp file that outlives the url loaded that it was
1229   // loaded with to keep the file (and permissions) alive.
1230   reference->AddFinalReleaseCallback(
1231       base::Bind(&RemoveDownloadFileFromChildSecurityPolicy,
1232                  child_id));
1233 }
1234
1235 void ResourceDispatcherHostImpl::UnregisterDownloadedTempFile(
1236     int child_id, int request_id) {
1237   DeletableFilesMap& map = registered_temp_files_[child_id];
1238   DeletableFilesMap::iterator found = map.find(request_id);
1239   if (found == map.end())
1240     return;
1241
1242   map.erase(found);
1243
1244   // Note that we don't remove the security bits here. This will be done
1245   // when all file refs are deleted (see RegisterDownloadedTempFile).
1246 }
1247
1248 bool ResourceDispatcherHostImpl::Send(IPC::Message* message) {
1249   delete message;
1250   return false;
1251 }
1252
1253 void ResourceDispatcherHostImpl::OnUploadProgressACK(int request_id) {
1254   ResourceLoader* loader = GetLoader(filter_->child_id(), request_id);
1255   if (loader)
1256     loader->OnUploadProgressACK();
1257 }
1258
1259 // Note that this cancel is subtly different from the other
1260 // CancelRequest methods in this file, which also tear down the loader.
1261 void ResourceDispatcherHostImpl::OnCancelRequest(int request_id) {
1262   int child_id = filter_->child_id();
1263
1264   // When the old renderer dies, it sends a message to us to cancel its
1265   // requests.
1266   if (IsTransferredNavigation(GlobalRequestID(child_id, request_id)))
1267     return;
1268
1269   ResourceLoader* loader = GetLoader(child_id, request_id);
1270   if (!loader) {
1271     // We probably want to remove this warning eventually, but I wanted to be
1272     // able to notice when this happens during initial development since it
1273     // should be rare and may indicate a bug.
1274     DVLOG(1) << "Canceling a request that wasn't found";
1275     return;
1276   }
1277
1278   loader->CancelRequest(true);
1279 }
1280
1281 ResourceRequestInfoImpl* ResourceDispatcherHostImpl::CreateRequestInfo(
1282     int child_id,
1283     int route_id,
1284     bool download,
1285     ResourceContext* context) {
1286   return new ResourceRequestInfoImpl(
1287       PROCESS_TYPE_RENDERER,
1288       child_id,
1289       route_id,
1290       0,
1291       request_id_,
1292       MSG_ROUTING_NONE,  // render_frame_id
1293       false,     // is_main_frame
1294       -1,        // frame_id
1295       false,     // parent_is_main_frame
1296       -1,        // parent_frame_id
1297       ResourceType::SUB_RESOURCE,
1298       PAGE_TRANSITION_LINK,
1299       false,     // should_replace_current_entry
1300       download,  // is_download
1301       false,     // is_stream
1302       download,  // allow_download
1303       false,     // has_user_gesture
1304       blink::WebReferrerPolicyDefault,
1305       blink::WebPageVisibilityStateVisible,
1306       context,
1307       base::WeakPtr<ResourceMessageFilter>(),  // filter
1308       true);     // is_async
1309 }
1310
1311 void ResourceDispatcherHostImpl::OnRenderViewHostCreated(
1312     int child_id,
1313     int route_id) {
1314   scheduler_->OnClientCreated(child_id, route_id);
1315 }
1316
1317 void ResourceDispatcherHostImpl::OnRenderViewHostDeleted(
1318     int child_id,
1319     int route_id) {
1320   scheduler_->OnClientDeleted(child_id, route_id);
1321   CancelRequestsForRoute(child_id, route_id);
1322 }
1323
1324 // This function is only used for saving feature.
1325 void ResourceDispatcherHostImpl::BeginSaveFile(
1326     const GURL& url,
1327     const Referrer& referrer,
1328     int child_id,
1329     int route_id,
1330     ResourceContext* context) {
1331   if (is_shutdown_)
1332     return;
1333
1334   // http://crbug.com/90971
1335   char url_buf[128];
1336   base::strlcpy(url_buf, url.spec().c_str(), arraysize(url_buf));
1337   base::debug::Alias(url_buf);
1338   CHECK(ContainsKey(active_resource_contexts_, context));
1339
1340   scoped_ptr<ResourceHandler> handler(
1341       new SaveFileResourceHandler(child_id,
1342                                   route_id,
1343                                   url,
1344                                   save_file_manager_.get()));
1345   request_id_--;
1346
1347   const net::URLRequestContext* request_context = context->GetRequestContext();
1348   bool known_proto =
1349       request_context->job_factory()->IsHandledURL(url);
1350   if (!known_proto) {
1351     // Since any URLs which have non-standard scheme have been filtered
1352     // by save manager(see GURL::SchemeIsStandard). This situation
1353     // should not happen.
1354     NOTREACHED();
1355     return;
1356   }
1357
1358   scoped_ptr<net::URLRequest> request(
1359       request_context->CreateRequest(url, net::DEFAULT_PRIORITY, NULL));
1360   request->set_method("GET");
1361   SetReferrerForRequest(request.get(), referrer);
1362
1363   // So far, for saving page, we need fetch content from cache, in the
1364   // future, maybe we can use a configuration to configure this behavior.
1365   request->SetLoadFlags(net::LOAD_PREFERRING_CACHE);
1366
1367   // No need to get offline load flags for save files, but make sure
1368   // we have an OfflinePolicy to receive request completions.
1369   GlobalRoutingID id(child_id, route_id);
1370   if (!offline_policy_map_[id])
1371     offline_policy_map_[id] = new OfflinePolicy();
1372
1373   // Since we're just saving some resources we need, disallow downloading.
1374   ResourceRequestInfoImpl* extra_info =
1375       CreateRequestInfo(child_id, route_id, false, context);
1376   extra_info->AssociateWithRequest(request.get());  // Request takes ownership.
1377
1378   BeginRequestInternal(request.Pass(), handler.Pass());
1379 }
1380
1381 void ResourceDispatcherHostImpl::MarkAsTransferredNavigation(
1382     const GlobalRequestID& id) {
1383   GetLoader(id)->MarkAsTransferring();
1384 }
1385
1386 void ResourceDispatcherHostImpl::CancelTransferringNavigation(
1387     const GlobalRequestID& id) {
1388   // Request should still exist and be in the middle of a transfer.
1389   DCHECK(IsTransferredNavigation(id));
1390   RemovePendingRequest(id.child_id, id.request_id);
1391 }
1392
1393 void ResourceDispatcherHostImpl::ResumeDeferredNavigation(
1394     const GlobalRequestID& id) {
1395   ResourceLoader* loader = GetLoader(id);
1396   if (loader) {
1397     // The response we were meant to resume could have already been canceled.
1398     ResourceRequestInfoImpl* info = loader->GetRequestInfo();
1399     if (info->cross_site_handler())
1400       info->cross_site_handler()->ResumeResponse();
1401   }
1402 }
1403
1404 // The object died, so cancel and detach all requests associated with it except
1405 // for downloads and detachable resources, which belong to the browser process
1406 // even if initiated via a renderer.
1407 void ResourceDispatcherHostImpl::CancelRequestsForProcess(int child_id) {
1408   CancelRequestsForRoute(child_id, -1 /* cancel all */);
1409   registered_temp_files_.erase(child_id);
1410 }
1411
1412 void ResourceDispatcherHostImpl::CancelRequestsForRoute(int child_id,
1413                                                         int route_id) {
1414   // Since pending_requests_ is a map, we first build up a list of all of the
1415   // matching requests to be cancelled, and then we cancel them.  Since there
1416   // may be more than one request to cancel, we cannot simply hold onto the map
1417   // iterators found in the first loop.
1418
1419   // Find the global ID of all matching elements.
1420   bool any_requests_transferring = false;
1421   std::vector<GlobalRequestID> matching_requests;
1422   for (LoaderMap::const_iterator i = pending_loaders_.begin();
1423        i != pending_loaders_.end(); ++i) {
1424     if (i->first.child_id != child_id)
1425       continue;
1426
1427     ResourceRequestInfoImpl* info = i->second->GetRequestInfo();
1428
1429     GlobalRequestID id(child_id, i->first.request_id);
1430     DCHECK(id == i->first);
1431     // Don't cancel navigations that are expected to live beyond this process.
1432     if (IsTransferredNavigation(id))
1433       any_requests_transferring = true;
1434     if (info->detachable_handler()) {
1435       info->detachable_handler()->Detach();
1436     } else if (!info->IsDownload() && !info->is_stream() &&
1437                !IsTransferredNavigation(id) &&
1438                (route_id == -1 || route_id == info->GetRouteID())) {
1439       matching_requests.push_back(id);
1440     }
1441   }
1442
1443   // Remove matches.
1444   for (size_t i = 0; i < matching_requests.size(); ++i) {
1445     LoaderMap::iterator iter = pending_loaders_.find(matching_requests[i]);
1446     // Although every matching request was in pending_requests_ when we built
1447     // matching_requests, it is normal for a matching request to be not found
1448     // in pending_requests_ after we have removed some matching requests from
1449     // pending_requests_.  For example, deleting a net::URLRequest that has
1450     // exclusive (write) access to an HTTP cache entry may unblock another
1451     // net::URLRequest that needs exclusive access to the same cache entry, and
1452     // that net::URLRequest may complete and remove itself from
1453     // pending_requests_. So we need to check that iter is not equal to
1454     // pending_requests_.end().
1455     if (iter != pending_loaders_.end())
1456       RemovePendingLoader(iter);
1457   }
1458
1459   // Don't clear the blocked loaders or offline policy maps if any of the
1460   // requests in route_id are being transferred to a new process, since those
1461   // maps will be updated with the new route_id after the transfer.  Otherwise
1462   // we will lose track of this info when the old route goes away, before the
1463   // new one is created.
1464   if (any_requests_transferring)
1465     return;
1466
1467   // Now deal with blocked requests if any.
1468   if (route_id != -1) {
1469     if (blocked_loaders_map_.find(GlobalRoutingID(child_id, route_id)) !=
1470         blocked_loaders_map_.end()) {
1471       CancelBlockedRequestsForRoute(child_id, route_id);
1472     }
1473   } else {
1474     // We have to do all render views for the process |child_id|.
1475     // Note that we have to do this in 2 passes as we cannot call
1476     // CancelBlockedRequestsForRoute while iterating over
1477     // blocked_loaders_map_, as it modifies it.
1478     std::set<int> route_ids;
1479     for (BlockedLoadersMap::const_iterator iter = blocked_loaders_map_.begin();
1480          iter != blocked_loaders_map_.end(); ++iter) {
1481       if (iter->first.child_id == child_id)
1482         route_ids.insert(iter->first.route_id);
1483     }
1484     for (std::set<int>::const_iterator iter = route_ids.begin();
1485         iter != route_ids.end(); ++iter) {
1486       CancelBlockedRequestsForRoute(child_id, *iter);
1487     }
1488   }
1489
1490   // Cleanup the offline state for the route.
1491   if (-1 != route_id) {
1492     OfflineMap::iterator it = offline_policy_map_.find(
1493         GlobalRoutingID(child_id, route_id));
1494     if (offline_policy_map_.end() != it) {
1495       delete it->second;
1496       offline_policy_map_.erase(it);
1497     }
1498   } else {
1499     for (OfflineMap::iterator it = offline_policy_map_.begin();
1500          offline_policy_map_.end() != it;) {
1501       // Increment iterator so deletion doesn't invalidate it.
1502       OfflineMap::iterator current_it = it++;
1503
1504       if (child_id == current_it->first.child_id) {
1505         delete current_it->second;
1506         offline_policy_map_.erase(current_it);
1507       }
1508     }
1509   }
1510 }
1511
1512 // Cancels the request and removes it from the list.
1513 void ResourceDispatcherHostImpl::RemovePendingRequest(int child_id,
1514                                                       int request_id) {
1515   LoaderMap::iterator i = pending_loaders_.find(
1516       GlobalRequestID(child_id, request_id));
1517   if (i == pending_loaders_.end()) {
1518     NOTREACHED() << "Trying to remove a request that's not here";
1519     return;
1520   }
1521   RemovePendingLoader(i);
1522 }
1523
1524 void ResourceDispatcherHostImpl::RemovePendingLoader(
1525     const LoaderMap::iterator& iter) {
1526   ResourceRequestInfoImpl* info = iter->second->GetRequestInfo();
1527
1528   // Remove the memory credit that we added when pushing the request onto
1529   // the pending list.
1530   IncrementOutstandingRequestsMemory(-1, *info);
1531
1532   pending_loaders_.erase(iter);
1533
1534   // If we have no more pending requests, then stop the load state monitor
1535   if (pending_loaders_.empty() && update_load_states_timer_)
1536     update_load_states_timer_->Stop();
1537 }
1538
1539 void ResourceDispatcherHostImpl::CancelRequest(int child_id,
1540                                                int request_id) {
1541   ResourceLoader* loader = GetLoader(child_id, request_id);
1542   if (!loader) {
1543     // We probably want to remove this warning eventually, but I wanted to be
1544     // able to notice when this happens during initial development since it
1545     // should be rare and may indicate a bug.
1546     DVLOG(1) << "Canceling a request that wasn't found";
1547     return;
1548   }
1549
1550   RemovePendingRequest(child_id, request_id);
1551 }
1552
1553 ResourceDispatcherHostImpl::OustandingRequestsStats
1554 ResourceDispatcherHostImpl::GetOutstandingRequestsStats(
1555     const ResourceRequestInfoImpl& info) {
1556   OutstandingRequestsStatsMap::iterator entry =
1557       outstanding_requests_stats_map_.find(info.GetChildID());
1558   OustandingRequestsStats stats = { 0, 0 };
1559   if (entry != outstanding_requests_stats_map_.end())
1560     stats = entry->second;
1561   return stats;
1562 }
1563
1564 void ResourceDispatcherHostImpl::UpdateOutstandingRequestsStats(
1565     const ResourceRequestInfoImpl& info,
1566     const OustandingRequestsStats& stats) {
1567   if (stats.memory_cost == 0 && stats.num_requests == 0)
1568     outstanding_requests_stats_map_.erase(info.GetChildID());
1569   else
1570     outstanding_requests_stats_map_[info.GetChildID()] = stats;
1571 }
1572
1573 ResourceDispatcherHostImpl::OustandingRequestsStats
1574 ResourceDispatcherHostImpl::IncrementOutstandingRequestsMemory(
1575     int count,
1576     const ResourceRequestInfoImpl& info) {
1577   DCHECK_EQ(1, abs(count));
1578
1579   // Retrieve the previous value (defaulting to 0 if not found).
1580   OustandingRequestsStats stats = GetOutstandingRequestsStats(info);
1581
1582   // Insert/update the total; delete entries when their count reaches 0.
1583   stats.memory_cost += count * info.memory_cost();
1584   DCHECK_GE(stats.memory_cost, 0);
1585   UpdateOutstandingRequestsStats(info, stats);
1586
1587   return stats;
1588 }
1589
1590 ResourceDispatcherHostImpl::OustandingRequestsStats
1591 ResourceDispatcherHostImpl::IncrementOutstandingRequestsCount(
1592     int count,
1593     const ResourceRequestInfoImpl& info) {
1594   DCHECK_EQ(1, abs(count));
1595   num_in_flight_requests_ += count;
1596
1597   OustandingRequestsStats stats = GetOutstandingRequestsStats(info);
1598   stats.num_requests += count;
1599   DCHECK_GE(stats.num_requests, 0);
1600   UpdateOutstandingRequestsStats(info, stats);
1601
1602   return stats;
1603 }
1604
1605 bool ResourceDispatcherHostImpl::HasSufficientResourcesForRequest(
1606     const net::URLRequest* request_) {
1607   const ResourceRequestInfoImpl* info =
1608       ResourceRequestInfoImpl::ForRequest(request_);
1609   OustandingRequestsStats stats = IncrementOutstandingRequestsCount(1, *info);
1610
1611   if (stats.num_requests > max_num_in_flight_requests_per_process_)
1612     return false;
1613   if (num_in_flight_requests_ > max_num_in_flight_requests_)
1614     return false;
1615
1616   return true;
1617 }
1618
1619 void ResourceDispatcherHostImpl::FinishedWithResourcesForRequest(
1620     const net::URLRequest* request_) {
1621   const ResourceRequestInfoImpl* info =
1622       ResourceRequestInfoImpl::ForRequest(request_);
1623   IncrementOutstandingRequestsCount(-1, *info);
1624 }
1625
1626 // static
1627 int ResourceDispatcherHostImpl::CalculateApproximateMemoryCost(
1628     net::URLRequest* request) {
1629   // The following fields should be a minor size contribution (experimentally
1630   // on the order of 100). However since they are variable length, it could
1631   // in theory be a sizeable contribution.
1632   int strings_cost = request->extra_request_headers().ToString().size() +
1633                      request->original_url().spec().size() +
1634                      request->referrer().size() +
1635                      request->method().size();
1636
1637   // Note that this expression will typically be dominated by:
1638   // |kAvgBytesPerOutstandingRequest|.
1639   return kAvgBytesPerOutstandingRequest + strings_cost;
1640 }
1641
1642 void ResourceDispatcherHostImpl::BeginRequestInternal(
1643     scoped_ptr<net::URLRequest> request,
1644     scoped_ptr<ResourceHandler> handler) {
1645   DCHECK(!request->is_pending());
1646   ResourceRequestInfoImpl* info =
1647       ResourceRequestInfoImpl::ForRequest(request.get());
1648
1649   if ((TimeTicks::Now() - last_user_gesture_time_) <
1650       TimeDelta::FromMilliseconds(kUserGestureWindowMs)) {
1651     request->SetLoadFlags(
1652         request->load_flags() | net::LOAD_MAYBE_USER_GESTURE);
1653   }
1654
1655   // Add the memory estimate that starting this request will consume.
1656   info->set_memory_cost(CalculateApproximateMemoryCost(request.get()));
1657
1658   // If enqueing/starting this request will exceed our per-process memory
1659   // bound, abort it right away.
1660   OustandingRequestsStats stats = IncrementOutstandingRequestsMemory(1, *info);
1661   if (stats.memory_cost > max_outstanding_requests_cost_per_process_) {
1662     // We call "CancelWithError()" as a way of setting the net::URLRequest's
1663     // status -- it has no effect beyond this, since the request hasn't started.
1664     request->CancelWithError(net::ERR_INSUFFICIENT_RESOURCES);
1665
1666     bool defer = false;
1667     handler->OnResponseCompleted(info->GetRequestID(), request->status(),
1668                                  std::string(), &defer);
1669     if (defer) {
1670       // TODO(darin): The handler is not ready for us to kill the request. Oops!
1671       NOTREACHED();
1672     }
1673
1674     IncrementOutstandingRequestsMemory(-1, *info);
1675
1676     // A ResourceHandler must not outlive its associated URLRequest.
1677     handler.reset();
1678     return;
1679   }
1680
1681   linked_ptr<ResourceLoader> loader(
1682       new ResourceLoader(request.Pass(), handler.Pass(), this));
1683
1684   GlobalRoutingID id(info->GetGlobalRoutingID());
1685   BlockedLoadersMap::const_iterator iter = blocked_loaders_map_.find(id);
1686   if (iter != blocked_loaders_map_.end()) {
1687     // The request should be blocked.
1688     iter->second->push_back(loader);
1689     return;
1690   }
1691
1692   StartLoading(info, loader);
1693 }
1694
1695 void ResourceDispatcherHostImpl::StartLoading(
1696     ResourceRequestInfoImpl* info,
1697     const linked_ptr<ResourceLoader>& loader) {
1698   pending_loaders_[info->GetGlobalRequestID()] = loader;
1699
1700   loader->StartRequest();
1701 }
1702
1703 void ResourceDispatcherHostImpl::OnUserGesture(WebContentsImpl* contents) {
1704   last_user_gesture_time_ = TimeTicks::Now();
1705 }
1706
1707 net::URLRequest* ResourceDispatcherHostImpl::GetURLRequest(
1708     const GlobalRequestID& id) {
1709   ResourceLoader* loader = GetLoader(id);
1710   if (!loader)
1711     return NULL;
1712
1713   return loader->request();
1714 }
1715
1716 namespace {
1717
1718 // This function attempts to return the "more interesting" load state of |a|
1719 // and |b|.  We don't have temporal information about these load states
1720 // (meaning we don't know when we transitioned into these states), so we just
1721 // rank them according to how "interesting" the states are.
1722 //
1723 // We take advantage of the fact that the load states are an enumeration listed
1724 // in the order in which they occur during the lifetime of a request, so we can
1725 // regard states with larger numeric values as being further along toward
1726 // completion.  We regard those states as more interesting to report since they
1727 // represent progress.
1728 //
1729 // For example, by this measure "tranferring data" is a more interesting state
1730 // than "resolving host" because when we are transferring data we are actually
1731 // doing something that corresponds to changes that the user might observe,
1732 // whereas waiting for a host name to resolve implies being stuck.
1733 //
1734 const net::LoadStateWithParam& MoreInterestingLoadState(
1735     const net::LoadStateWithParam& a, const net::LoadStateWithParam& b) {
1736   return (a.state < b.state) ? b : a;
1737 }
1738
1739 // Carries information about a load state change.
1740 struct LoadInfo {
1741   GURL url;
1742   net::LoadStateWithParam load_state;
1743   uint64 upload_position;
1744   uint64 upload_size;
1745 };
1746
1747 // Map from ProcessID+RouteID pair to LoadState
1748 typedef std::map<GlobalRoutingID, LoadInfo> LoadInfoMap;
1749
1750 // Used to marshal calls to LoadStateChanged from the IO to UI threads.  We do
1751 // them all as a single callback to avoid spamming the UI thread.
1752 void LoadInfoUpdateCallback(const LoadInfoMap& info_map) {
1753   LoadInfoMap::const_iterator i;
1754   for (i = info_map.begin(); i != info_map.end(); ++i) {
1755     RenderViewHostImpl* view =
1756         RenderViewHostImpl::FromID(i->first.child_id, i->first.route_id);
1757     if (view)  // The view could be gone at this point.
1758       view->LoadStateChanged(i->second.url, i->second.load_state,
1759                              i->second.upload_position,
1760                              i->second.upload_size);
1761   }
1762 }
1763
1764 }  // namespace
1765
1766 void ResourceDispatcherHostImpl::UpdateLoadStates() {
1767   // Populate this map with load state changes, and then send them on to the UI
1768   // thread where they can be passed along to the respective RVHs.
1769   LoadInfoMap info_map;
1770
1771   LoaderMap::const_iterator i;
1772
1773   // Determine the largest upload size of all requests
1774   // in each View (good chance it's zero).
1775   std::map<GlobalRoutingID, uint64> largest_upload_size;
1776   for (i = pending_loaders_.begin(); i != pending_loaders_.end(); ++i) {
1777     net::URLRequest* request = i->second->request();
1778     ResourceRequestInfoImpl* info = i->second->GetRequestInfo();
1779     uint64 upload_size = request->GetUploadProgress().size();
1780     if (request->GetLoadState().state != net::LOAD_STATE_SENDING_REQUEST)
1781       upload_size = 0;
1782     GlobalRoutingID id(info->GetGlobalRoutingID());
1783     if (upload_size && largest_upload_size[id] < upload_size)
1784       largest_upload_size[id] = upload_size;
1785   }
1786
1787   for (i = pending_loaders_.begin(); i != pending_loaders_.end(); ++i) {
1788     net::URLRequest* request = i->second->request();
1789     ResourceRequestInfoImpl* info = i->second->GetRequestInfo();
1790     net::LoadStateWithParam load_state = request->GetLoadState();
1791     net::UploadProgress progress = request->GetUploadProgress();
1792
1793     // We also poll for upload progress on this timer and send upload
1794     // progress ipc messages to the plugin process.
1795     i->second->ReportUploadProgress();
1796
1797     GlobalRoutingID id(info->GetGlobalRoutingID());
1798
1799     // If a request is uploading data, ignore all other requests so that the
1800     // upload progress takes priority for being shown in the status bar.
1801     if (largest_upload_size.find(id) != largest_upload_size.end() &&
1802         progress.size() < largest_upload_size[id])
1803       continue;
1804
1805     net::LoadStateWithParam to_insert = load_state;
1806     LoadInfoMap::iterator existing = info_map.find(id);
1807     if (existing != info_map.end()) {
1808       to_insert =
1809           MoreInterestingLoadState(existing->second.load_state, load_state);
1810       if (to_insert.state == existing->second.load_state.state)
1811         continue;
1812     }
1813     LoadInfo& load_info = info_map[id];
1814     load_info.url = request->url();
1815     load_info.load_state = to_insert;
1816     load_info.upload_size = progress.size();
1817     load_info.upload_position = progress.position();
1818   }
1819
1820   if (info_map.empty())
1821     return;
1822
1823   BrowserThread::PostTask(
1824       BrowserThread::UI, FROM_HERE,
1825       base::Bind(&LoadInfoUpdateCallback, info_map));
1826 }
1827
1828 void ResourceDispatcherHostImpl::BlockRequestsForRoute(int child_id,
1829                                                        int route_id) {
1830   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
1831   GlobalRoutingID key(child_id, route_id);
1832   DCHECK(blocked_loaders_map_.find(key) == blocked_loaders_map_.end()) <<
1833       "BlockRequestsForRoute called  multiple time for the same RVH";
1834   blocked_loaders_map_[key] = new BlockedLoadersList();
1835 }
1836
1837 void ResourceDispatcherHostImpl::ResumeBlockedRequestsForRoute(int child_id,
1838                                                                int route_id) {
1839   ProcessBlockedRequestsForRoute(child_id, route_id, false);
1840 }
1841
1842 void ResourceDispatcherHostImpl::CancelBlockedRequestsForRoute(int child_id,
1843                                                                int route_id) {
1844   ProcessBlockedRequestsForRoute(child_id, route_id, true);
1845 }
1846
1847 void ResourceDispatcherHostImpl::ProcessBlockedRequestsForRoute(
1848     int child_id,
1849     int route_id,
1850     bool cancel_requests) {
1851   BlockedLoadersMap::iterator iter = blocked_loaders_map_.find(
1852       GlobalRoutingID(child_id, route_id));
1853   if (iter == blocked_loaders_map_.end()) {
1854     // It's possible to reach here if the renderer crashed while an interstitial
1855     // page was showing.
1856     return;
1857   }
1858
1859   BlockedLoadersList* loaders = iter->second;
1860
1861   // Removing the vector from the map unblocks any subsequent requests.
1862   blocked_loaders_map_.erase(iter);
1863
1864   for (BlockedLoadersList::iterator loaders_iter = loaders->begin();
1865        loaders_iter != loaders->end(); ++loaders_iter) {
1866     linked_ptr<ResourceLoader> loader = *loaders_iter;
1867     ResourceRequestInfoImpl* info = loader->GetRequestInfo();
1868     if (cancel_requests) {
1869       IncrementOutstandingRequestsMemory(-1, *info);
1870     } else {
1871       StartLoading(info, loader);
1872     }
1873   }
1874
1875   delete loaders;
1876 }
1877
1878 ResourceDispatcherHostImpl::HttpAuthRelationType
1879 ResourceDispatcherHostImpl::HttpAuthRelationTypeOf(
1880     const GURL& request_url,
1881     const GURL& first_party) {
1882   if (!first_party.is_valid())
1883     return HTTP_AUTH_RELATION_TOP;
1884
1885   if (net::registry_controlled_domains::SameDomainOrHost(
1886           first_party, request_url,
1887           net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES))
1888     return HTTP_AUTH_RELATION_SAME_DOMAIN;
1889
1890   if (allow_cross_origin_auth_prompt())
1891     return HTTP_AUTH_RELATION_ALLOWED_CROSS;
1892
1893   return HTTP_AUTH_RELATION_BLOCKED_CROSS;
1894 }
1895
1896 bool ResourceDispatcherHostImpl::allow_cross_origin_auth_prompt() {
1897   return allow_cross_origin_auth_prompt_;
1898 }
1899
1900 bool ResourceDispatcherHostImpl::IsTransferredNavigation(
1901     const GlobalRequestID& id) const {
1902   ResourceLoader* loader = GetLoader(id);
1903   return loader ? loader->is_transferring() : false;
1904 }
1905
1906 ResourceLoader* ResourceDispatcherHostImpl::GetLoader(
1907     const GlobalRequestID& id) const {
1908   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
1909
1910   LoaderMap::const_iterator i = pending_loaders_.find(id);
1911   if (i == pending_loaders_.end())
1912     return NULL;
1913
1914   return i->second.get();
1915 }
1916
1917 ResourceLoader* ResourceDispatcherHostImpl::GetLoader(int child_id,
1918                                                       int request_id) const {
1919   return GetLoader(GlobalRequestID(child_id, request_id));
1920 }
1921
1922 void ResourceDispatcherHostImpl::RegisterResourceMessageDelegate(
1923     const GlobalRequestID& id, ResourceMessageDelegate* delegate) {
1924   DelegateMap::iterator it = delegate_map_.find(id);
1925   if (it == delegate_map_.end()) {
1926     it = delegate_map_.insert(
1927         std::make_pair(id, new ObserverList<ResourceMessageDelegate>)).first;
1928   }
1929   it->second->AddObserver(delegate);
1930 }
1931
1932 void ResourceDispatcherHostImpl::UnregisterResourceMessageDelegate(
1933     const GlobalRequestID& id, ResourceMessageDelegate* delegate) {
1934   DCHECK(ContainsKey(delegate_map_, id));
1935   DelegateMap::iterator it = delegate_map_.find(id);
1936   DCHECK(it->second->HasObserver(delegate));
1937   it->second->RemoveObserver(delegate);
1938   if (!it->second->might_have_observers()) {
1939     delete it->second;
1940     delegate_map_.erase(it);
1941   }
1942 }
1943
1944 int ResourceDispatcherHostImpl::BuildLoadFlagsForRequest(
1945     const ResourceHostMsg_Request& request_data,
1946     int child_id,
1947     bool is_sync_load) {
1948   int load_flags = request_data.load_flags;
1949
1950   // Although EV status is irrelevant to sub-frames and sub-resources, we have
1951   // to perform EV certificate verification on all resources because an HTTP
1952   // keep-alive connection created to load a sub-frame or a sub-resource could
1953   // be reused to load a main frame.
1954   load_flags |= net::LOAD_VERIFY_EV_CERT;
1955   if (request_data.resource_type == ResourceType::MAIN_FRAME) {
1956     load_flags |= net::LOAD_MAIN_FRAME;
1957   } else if (request_data.resource_type == ResourceType::SUB_FRAME) {
1958     load_flags |= net::LOAD_SUB_FRAME;
1959   } else if (request_data.resource_type == ResourceType::PREFETCH) {
1960     load_flags |= (net::LOAD_PREFETCH | net::LOAD_DO_NOT_PROMPT_FOR_LOGIN);
1961   } else if (request_data.resource_type == ResourceType::FAVICON) {
1962     load_flags |= net::LOAD_DO_NOT_PROMPT_FOR_LOGIN;
1963   } else if (request_data.resource_type == ResourceType::IMAGE) {
1964     // Prevent third-party image content from prompting for login, as this
1965     // is often a scam to extract credentials for another domain from the user.
1966     // Only block image loads, as the attack applies largely to the "src"
1967     // property of the <img> tag. It is common for web properties to allow
1968     // untrusted values for <img src>; this is considered a fair thing for an
1969     // HTML sanitizer to do. Conversely, any HTML sanitizer that didn't
1970     // filter sources for <script>, <link>, <embed>, <object>, <iframe> tags
1971     // would be considered vulnerable in and of itself.
1972     HttpAuthRelationType relation_type = HttpAuthRelationTypeOf(
1973         request_data.url, request_data.first_party_for_cookies);
1974     if (relation_type == HTTP_AUTH_RELATION_BLOCKED_CROSS) {
1975       load_flags |= (net::LOAD_DO_NOT_USE_EMBEDDED_IDENTITY |
1976                      net::LOAD_DO_NOT_PROMPT_FOR_LOGIN);
1977     }
1978   }
1979
1980   if (is_sync_load)
1981     load_flags |= net::LOAD_IGNORE_LIMITS;
1982
1983   ChildProcessSecurityPolicyImpl* policy =
1984       ChildProcessSecurityPolicyImpl::GetInstance();
1985   if (!policy->CanSendCookiesForOrigin(child_id, request_data.url)) {
1986     load_flags |= (net::LOAD_DO_NOT_SEND_COOKIES |
1987                    net::LOAD_DO_NOT_SEND_AUTH_DATA |
1988                    net::LOAD_DO_NOT_SAVE_COOKIES);
1989   }
1990
1991   // Raw headers are sensitive, as they include Cookie/Set-Cookie, so only
1992   // allow requesting them if requester has ReadRawCookies permission.
1993   if ((load_flags & net::LOAD_REPORT_RAW_HEADERS)
1994       && !policy->CanReadRawCookies(child_id)) {
1995     VLOG(1) << "Denied unauthorized request for raw headers";
1996     load_flags &= ~net::LOAD_REPORT_RAW_HEADERS;
1997   }
1998
1999   return load_flags;
2000 }
2001
2002 }  // namespace content