net/url_request/url_request.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 "net/url_request/url_request.h"
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/callback.h"
  10 #include "base/compiler_specific.h"
  11 #include "base/debug/stack_trace.h"
  12 #include "base/lazy_instance.h"
  13 #include "base/memory/singleton.h"
  14 #include "base/message_loop/message_loop.h"
  15 #include "base/profiler/scoped_tracker.h"
  16 #include "base/stl_util.h"
  17 #include "base/strings/utf_string_conversions.h"
  18 #include "base/synchronization/lock.h"
  19 #include "base/values.h"
  20 #include "net/base/auth.h"
  21 #include "net/base/chunked_upload_data_stream.h"
  22 #include "net/base/host_port_pair.h"
  23 #include "net/base/load_flags.h"
  24 #include "net/base/load_timing_info.h"
  25 #include "net/base/net_errors.h"
  26 #include "net/base/net_log.h"
  27 #include "net/base/network_change_notifier.h"
  28 #include "net/base/network_delegate.h"
  29 #include "net/base/upload_data_stream.h"
  30 #include "net/http/http_response_headers.h"
  31 #include "net/http/http_util.h"
  32 #include "net/ssl/ssl_cert_request_info.h"
  33 #include "net/url_request/redirect_info.h"
  34 #include "net/url_request/url_request_context.h"
  35 #include "net/url_request/url_request_error_job.h"
  36 #include "net/url_request/url_request_job.h"
  37 #include "net/url_request/url_request_job_manager.h"
  38 #include "net/url_request/url_request_netlog_params.h"
  39 #include "net/url_request/url_request_redirect_job.h"
  40
  41 using base::Time;
  42 using std::string;
  43
  44 namespace net {
  45
  46 namespace {
  47
  48 // Max number of http redirects to follow.  Same number as gecko.
  49 const int kMaxRedirects = 20;
  50
  51 // Discard headers which have meaning in POST (Content-Length, Content-Type,
  52 // Origin).
  53 void StripPostSpecificHeaders(HttpRequestHeaders* headers) {
  54   // These are headers that may be attached to a POST.
  55   headers->RemoveHeader(HttpRequestHeaders::kContentLength);
  56   headers->RemoveHeader(HttpRequestHeaders::kContentType);
  57   headers->RemoveHeader(HttpRequestHeaders::kOrigin);
  58 }
  59
  60 // TODO(battre): Delete this, see http://crbug.com/89321:
  61 // This counter keeps track of the identifiers used for URL requests so far.
  62 // 0 is reserved to represent an invalid ID.
  63 uint64 g_next_url_request_identifier = 1;
  64
  65 // This lock protects g_next_url_request_identifier.
  66 base::LazyInstance<base::Lock>::Leaky
  67     g_next_url_request_identifier_lock = LAZY_INSTANCE_INITIALIZER;
  68
  69 // Returns an prior unused identifier for URL requests.
  70 uint64 GenerateURLRequestIdentifier() {
  71   base::AutoLock lock(g_next_url_request_identifier_lock.Get());
  72   return g_next_url_request_identifier++;
  73 }
  74
  75 // True once the first URLRequest was started.
  76 bool g_url_requests_started = false;
  77
  78 // True if cookies are accepted by default.
  79 bool g_default_can_use_cookies = true;
  80
  81 // When the URLRequest first assempts load timing information, it has the times
  82 // at which each event occurred.  The API requires the time which the request
  83 // was blocked on each phase.  This function handles the conversion.
  84 //
  85 // In the case of reusing a SPDY session, old proxy results may have been
  86 // reused, so proxy resolution times may be before the request was started.
  87 //
  88 // Due to preconnect and late binding, it is also possible for the connection
  89 // attempt to start before a request has been started, or proxy resolution
  90 // completed.
  91 //
  92 // This functions fixes both those cases.
  93 void ConvertRealLoadTimesToBlockingTimes(
  94     net::LoadTimingInfo* load_timing_info) {
  95   DCHECK(!load_timing_info->request_start.is_null());
  96
  97   // Earliest time possible for the request to be blocking on connect events.
  98   base::TimeTicks block_on_connect = load_timing_info->request_start;
  99
 100   if (!load_timing_info->proxy_resolve_start.is_null()) {
 101     DCHECK(!load_timing_info->proxy_resolve_end.is_null());
 102
 103     // Make sure the proxy times are after request start.
 104     if (load_timing_info->proxy_resolve_start < load_timing_info->request_start)
 105       load_timing_info->proxy_resolve_start = load_timing_info->request_start;
 106     if (load_timing_info->proxy_resolve_end < load_timing_info->request_start)
 107       load_timing_info->proxy_resolve_end = load_timing_info->request_start;
 108
 109     // Connect times must also be after the proxy times.
 110     block_on_connect = load_timing_info->proxy_resolve_end;
 111   }
 112
 113   // Make sure connection times are after start and proxy times.
 114
 115   net::LoadTimingInfo::ConnectTiming* connect_timing =
 116       &load_timing_info->connect_timing;
 117   if (!connect_timing->dns_start.is_null()) {
 118     DCHECK(!connect_timing->dns_end.is_null());
 119     if (connect_timing->dns_start < block_on_connect)
 120       connect_timing->dns_start = block_on_connect;
 121     if (connect_timing->dns_end < block_on_connect)
 122       connect_timing->dns_end = block_on_connect;
 123   }
 124
 125   if (!connect_timing->connect_start.is_null()) {
 126     DCHECK(!connect_timing->connect_end.is_null());
 127     if (connect_timing->connect_start < block_on_connect)
 128       connect_timing->connect_start = block_on_connect;
 129     if (connect_timing->connect_end < block_on_connect)
 130       connect_timing->connect_end = block_on_connect;
 131   }
 132
 133   if (!connect_timing->ssl_start.is_null()) {
 134     DCHECK(!connect_timing->ssl_end.is_null());
 135     if (connect_timing->ssl_start < block_on_connect)
 136       connect_timing->ssl_start = block_on_connect;
 137     if (connect_timing->ssl_end < block_on_connect)
 138       connect_timing->ssl_end = block_on_connect;
 139   }
 140 }
 141
 142 }  // namespace
 143
 144 ///////////////////////////////////////////////////////////////////////////////
 145 // URLRequest::Delegate
 146
 147 void URLRequest::Delegate::OnReceivedRedirect(URLRequest* request,
 148                                               const RedirectInfo& redirect_info,
 149                                               bool* defer_redirect) {
 150 }
 151
 152 void URLRequest::Delegate::OnAuthRequired(URLRequest* request,
 153                                           AuthChallengeInfo* auth_info) {
 154   request->CancelAuth();
 155 }
 156
 157 void URLRequest::Delegate::OnCertificateRequested(
 158     URLRequest* request,
 159     SSLCertRequestInfo* cert_request_info) {
 160   request->Cancel();
 161 }
 162
 163 void URLRequest::Delegate::OnSSLCertificateError(URLRequest* request,
 164                                                  const SSLInfo& ssl_info,
 165                                                  bool is_hsts_ok) {
 166   request->Cancel();
 167 }
 168
 169 void URLRequest::Delegate::OnBeforeNetworkStart(URLRequest* request,
 170                                                 bool* defer) {
 171 }
 172
 173 ///////////////////////////////////////////////////////////////////////////////
 174 // URLRequest
 175
 176 URLRequest::~URLRequest() {
 177   Cancel();
 178
 179   if (network_delegate_) {
 180     network_delegate_->NotifyURLRequestDestroyed(this);
 181     if (job_.get())
 182       job_->NotifyURLRequestDestroyed();
 183   }
 184
 185   if (job_.get())
 186     OrphanJob();
 187
 188   int deleted = context_->url_requests()->erase(this);
 189   CHECK_EQ(1, deleted);
 190
 191   int net_error = OK;
 192   // Log error only on failure, not cancellation, as even successful requests
 193   // are "cancelled" on destruction.
 194   if (status_.status() == URLRequestStatus::FAILED)
 195     net_error = status_.error();
 196   net_log_.EndEventWithNetErrorCode(NetLog::TYPE_REQUEST_ALIVE, net_error);
 197 }
 198
 199 void URLRequest::EnableChunkedUpload() {
 200   DCHECK(!upload_data_stream_ || upload_data_stream_->is_chunked());
 201   if (!upload_data_stream_) {
 202     upload_chunked_data_stream_ = new ChunkedUploadDataStream(0);
 203     upload_data_stream_.reset(upload_chunked_data_stream_);
 204   }
 205 }
 206
 207 void URLRequest::AppendChunkToUpload(const char* bytes,
 208                                      int bytes_len,
 209                                      bool is_last_chunk) {
 210   DCHECK(upload_data_stream_);
 211   DCHECK(upload_data_stream_->is_chunked());
 212   upload_chunked_data_stream_->AppendData(bytes, bytes_len, is_last_chunk);
 213 }
 214
 215 void URLRequest::set_upload(scoped_ptr<UploadDataStream> upload) {
 216   DCHECK(!upload->is_chunked());
 217   upload_data_stream_ = upload.Pass();
 218 }
 219
 220 const UploadDataStream* URLRequest::get_upload() const {
 221   return upload_data_stream_.get();
 222 }
 223
 224 bool URLRequest::has_upload() const {
 225   return upload_data_stream_.get() != NULL;
 226 }
 227
 228 void URLRequest::SetExtraRequestHeaderByName(const string& name,
 229                                              const string& value,
 230                                              bool overwrite) {
 231   DCHECK(!is_pending_ || is_redirecting_);
 232   if (overwrite) {
 233     extra_request_headers_.SetHeader(name, value);
 234   } else {
 235     extra_request_headers_.SetHeaderIfMissing(name, value);
 236   }
 237 }
 238
 239 void URLRequest::RemoveRequestHeaderByName(const string& name) {
 240   DCHECK(!is_pending_ || is_redirecting_);
 241   extra_request_headers_.RemoveHeader(name);
 242 }
 243
 244 void URLRequest::SetExtraRequestHeaders(
 245     const HttpRequestHeaders& headers) {
 246   DCHECK(!is_pending_);
 247   extra_request_headers_ = headers;
 248
 249   // NOTE: This method will likely become non-trivial once the other setters
 250   // for request headers are implemented.
 251 }
 252
 253 bool URLRequest::GetFullRequestHeaders(HttpRequestHeaders* headers) const {
 254   if (!job_.get())
 255     return false;
 256
 257   return job_->GetFullRequestHeaders(headers);
 258 }
 259
 260 int64 URLRequest::GetTotalReceivedBytes() const {
 261   if (!job_.get())
 262     return 0;
 263
 264   return job_->GetTotalReceivedBytes();
 265 }
 266
 267 LoadStateWithParam URLRequest::GetLoadState() const {
 268   // The !blocked_by_.empty() check allows |this| to report it's blocked on a
 269   // delegate before it has been started.
 270   if (calling_delegate_ || !blocked_by_.empty()) {
 271     return LoadStateWithParam(
 272         LOAD_STATE_WAITING_FOR_DELEGATE,
 273         use_blocked_by_as_load_param_ ? base::UTF8ToUTF16(blocked_by_) :
 274                                         base::string16());
 275   }
 276   return LoadStateWithParam(job_.get() ? job_->GetLoadState() : LOAD_STATE_IDLE,
 277                             base::string16());
 278 }
 279
 280 base::Value* URLRequest::GetStateAsValue() const {
 281   base::DictionaryValue* dict = new base::DictionaryValue();
 282   dict->SetString("url", original_url().possibly_invalid_spec());
 283
 284   if (url_chain_.size() > 1) {
 285     base::ListValue* list = new base::ListValue();
 286     for (std::vector<GURL>::const_iterator url = url_chain_.begin();
 287          url != url_chain_.end(); ++url) {
 288       list->AppendString(url->possibly_invalid_spec());
 289     }
 290     dict->Set("url_chain", list);
 291   }
 292
 293   dict->SetInteger("load_flags", load_flags_);
 294
 295   LoadStateWithParam load_state = GetLoadState();
 296   dict->SetInteger("load_state", load_state.state);
 297   if (!load_state.param.empty())
 298     dict->SetString("load_state_param", load_state.param);
 299   if (!blocked_by_.empty())
 300     dict->SetString("delegate_info", blocked_by_);
 301
 302   dict->SetString("method", method_);
 303   dict->SetBoolean("has_upload", has_upload());
 304   dict->SetBoolean("is_pending", is_pending_);
 305
 306   // Add the status of the request.  The status should always be IO_PENDING, and
 307   // the error should always be OK, unless something is holding onto a request
 308   // that has finished or a request was leaked.  Neither of these should happen.
 309   switch (status_.status()) {
 310     case URLRequestStatus::SUCCESS:
 311       dict->SetString("status", "SUCCESS");
 312       break;
 313     case URLRequestStatus::IO_PENDING:
 314       dict->SetString("status", "IO_PENDING");
 315       break;
 316     case URLRequestStatus::CANCELED:
 317       dict->SetString("status", "CANCELED");
 318       break;
 319     case URLRequestStatus::FAILED:
 320       dict->SetString("status", "FAILED");
 321       break;
 322   }
 323   if (status_.error() != OK)
 324     dict->SetInteger("net_error", status_.error());
 325   return dict;
 326 }
 327
 328 void URLRequest::LogBlockedBy(const char* blocked_by) {
 329   DCHECK(blocked_by);
 330   DCHECK_GT(strlen(blocked_by), 0u);
 331
 332   // Only log information to NetLog during startup and certain deferring calls
 333   // to delegates.  For all reads but the first, do nothing.
 334   if (!calling_delegate_ && !response_info_.request_time.is_null())
 335     return;
 336
 337   LogUnblocked();
 338   blocked_by_ = blocked_by;
 339   use_blocked_by_as_load_param_ = false;
 340
 341   net_log_.BeginEvent(
 342       NetLog::TYPE_DELEGATE_INFO,
 343       NetLog::StringCallback("delegate_info", &blocked_by_));
 344 }
 345
 346 void URLRequest::LogAndReportBlockedBy(const char* source) {
 347   LogBlockedBy(source);
 348   use_blocked_by_as_load_param_ = true;
 349 }
 350
 351 void URLRequest::LogUnblocked() {
 352   if (blocked_by_.empty())
 353     return;
 354
 355   net_log_.EndEvent(NetLog::TYPE_DELEGATE_INFO);
 356   blocked_by_.clear();
 357 }
 358
 359 UploadProgress URLRequest::GetUploadProgress() const {
 360   if (!job_.get()) {
 361     // We haven't started or the request was cancelled
 362     return UploadProgress();
 363   }
 364   if (final_upload_progress_.position()) {
 365     // The first job completed and none of the subsequent series of
 366     // GETs when following redirects will upload anything, so we return the
 367     // cached results from the initial job, the POST.
 368     return final_upload_progress_;
 369   }
 370   return job_->GetUploadProgress();
 371 }
 372
 373 void URLRequest::GetResponseHeaderByName(const string& name, string* value) {
 374   DCHECK(value);
 375   if (response_info_.headers.get()) {
 376     response_info_.headers->GetNormalizedHeader(name, value);
 377   } else {
 378     value->clear();
 379   }
 380 }
 381
 382 HostPortPair URLRequest::GetSocketAddress() const {
 383   DCHECK(job_.get());
 384   return job_->GetSocketAddress();
 385 }
 386
 387 HttpResponseHeaders* URLRequest::response_headers() const {
 388   return response_info_.headers.get();
 389 }
 390
 391 void URLRequest::GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const {
 392   *load_timing_info = load_timing_info_;
 393 }
 394
 395 bool URLRequest::GetResponseCookies(ResponseCookies* cookies) {
 396   DCHECK(job_.get());
 397   return job_->GetResponseCookies(cookies);
 398 }
 399
 400 void URLRequest::GetMimeType(string* mime_type) const {
 401   DCHECK(job_.get());
 402   job_->GetMimeType(mime_type);
 403 }
 404
 405 void URLRequest::GetCharset(string* charset) const {
 406   DCHECK(job_.get());
 407   job_->GetCharset(charset);
 408 }
 409
 410 int URLRequest::GetResponseCode() const {
 411   DCHECK(job_.get());
 412   return job_->GetResponseCode();
 413 }
 414
 415 void URLRequest::SetLoadFlags(int flags) {
 416   if ((load_flags_ & LOAD_IGNORE_LIMITS) != (flags & LOAD_IGNORE_LIMITS)) {
 417     DCHECK(!job_.get());
 418     DCHECK(flags & LOAD_IGNORE_LIMITS);
 419     DCHECK_EQ(priority_, MAXIMUM_PRIORITY);
 420   }
 421   load_flags_ = flags;
 422
 423   // This should be a no-op given the above DCHECKs, but do this
 424   // anyway for release mode.
 425   if ((load_flags_ & LOAD_IGNORE_LIMITS) != 0)
 426     SetPriority(MAXIMUM_PRIORITY);
 427 }
 428
 429 // static
 430 void URLRequest::SetDefaultCookiePolicyToBlock() {
 431   CHECK(!g_url_requests_started);
 432   g_default_can_use_cookies = false;
 433 }
 434
 435 // static
 436 bool URLRequest::IsHandledProtocol(const std::string& scheme) {
 437   return URLRequestJobManager::SupportsScheme(scheme);
 438 }
 439
 440 // static
 441 bool URLRequest::IsHandledURL(const GURL& url) {
 442   if (!url.is_valid()) {
 443     // We handle error cases.
 444     return true;
 445   }
 446
 447   return IsHandledProtocol(url.scheme());
 448 }
 449
 450 void URLRequest::set_first_party_for_cookies(
 451     const GURL& first_party_for_cookies) {
 452   DCHECK(!is_pending_);
 453   first_party_for_cookies_ = first_party_for_cookies;
 454 }
 455
 456 void URLRequest::set_first_party_url_policy(
 457     FirstPartyURLPolicy first_party_url_policy) {
 458   DCHECK(!is_pending_);
 459   first_party_url_policy_ = first_party_url_policy;
 460 }
 461
 462 void URLRequest::set_method(const std::string& method) {
 463   DCHECK(!is_pending_);
 464   method_ = method;
 465 }
 466
 467 void URLRequest::SetReferrer(const std::string& referrer) {
 468   DCHECK(!is_pending_);
 469   GURL referrer_url(referrer);
 470   if (referrer_url.is_valid()) {
 471     referrer_ = referrer_url.GetAsReferrer().spec();
 472   } else {
 473     referrer_ = referrer;
 474   }
 475 }
 476
 477 void URLRequest::set_referrer_policy(ReferrerPolicy referrer_policy) {
 478   DCHECK(!is_pending_);
 479   referrer_policy_ = referrer_policy;
 480 }
 481
 482 void URLRequest::set_delegate(Delegate* delegate) {
 483   delegate_ = delegate;
 484 }
 485
 486 void URLRequest::Start() {
 487   // Some values can be NULL, but the job factory must not be.
 488   DCHECK(context_->job_factory());
 489
 490   // Anything that sets |blocked_by_| before start should have cleaned up after
 491   // itself.
 492   DCHECK(blocked_by_.empty());
 493
 494   g_url_requests_started = true;
 495   response_info_.request_time = base::Time::Now();
 496
 497   load_timing_info_ = LoadTimingInfo();
 498   load_timing_info_.request_start_time = response_info_.request_time;
 499   load_timing_info_.request_start = base::TimeTicks::Now();
 500
 501   // Only notify the delegate for the initial request.
 502   if (network_delegate_) {
 503     OnCallToDelegate();
 504     int error = network_delegate_->NotifyBeforeURLRequest(
 505         this, before_request_callback_, &delegate_redirect_url_);
 506     // If ERR_IO_PENDING is returned, the delegate will invoke
 507     // |before_request_callback_| later.
 508     if (error != ERR_IO_PENDING)
 509       BeforeRequestComplete(error);
 510     return;
 511   }
 512
 513   StartJob(URLRequestJobManager::GetInstance()->CreateJob(
 514       this, network_delegate_));
 515 }
 516
 517 ///////////////////////////////////////////////////////////////////////////////
 518
 519 URLRequest::URLRequest(const GURL& url,
 520                        RequestPriority priority,
 521                        Delegate* delegate,
 522                        const URLRequestContext* context,
 523                        CookieStore* cookie_store,
 524                        NetworkDelegate* network_delegate)
 525     : context_(context),
 526       network_delegate_(network_delegate ? network_delegate
 527                                          : context->network_delegate()),
 528       net_log_(BoundNetLog::Make(context->net_log(),
 529                                  NetLog::SOURCE_URL_REQUEST)),
 530       url_chain_(1, url),
 531       method_("GET"),
 532       referrer_policy_(CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE),
 533       first_party_url_policy_(NEVER_CHANGE_FIRST_PARTY_URL),
 534       load_flags_(LOAD_NORMAL),
 535       delegate_(delegate),
 536       is_pending_(false),
 537       is_redirecting_(false),
 538       redirect_limit_(kMaxRedirects),
 539       priority_(priority),
 540       identifier_(GenerateURLRequestIdentifier()),
 541       calling_delegate_(false),
 542       use_blocked_by_as_load_param_(false),
 543       before_request_callback_(base::Bind(&URLRequest::BeforeRequestComplete,
 544                                           base::Unretained(this))),
 545       has_notified_completion_(false),
 546       received_response_content_length_(0),
 547       creation_time_(base::TimeTicks::Now()),
 548       notified_before_network_start_(false),
 549       cookie_store_(cookie_store ? cookie_store : context->cookie_store()) {
 550   // Sanity check out environment.
 551   DCHECK(base::MessageLoop::current())
 552       << "The current base::MessageLoop must exist";
 553
 554   context->url_requests()->insert(this);
 555   net_log_.BeginEvent(NetLog::TYPE_REQUEST_ALIVE);
 556 }
 557
 558 void URLRequest::BeforeRequestComplete(int error) {
 559   DCHECK(!job_.get());
 560   DCHECK_NE(ERR_IO_PENDING, error);
 561
 562   // Check that there are no callbacks to already canceled requests.
 563   DCHECK_NE(URLRequestStatus::CANCELED, status_.status());
 564
 565   OnCallToDelegateComplete();
 566
 567   if (error != OK) {
 568     std::string source("delegate");
 569     net_log_.AddEvent(NetLog::TYPE_CANCELLED,
 570                       NetLog::StringCallback("source", &source));
 571     StartJob(new URLRequestErrorJob(this, network_delegate_, error));
 572   } else if (!delegate_redirect_url_.is_empty()) {
 573     GURL new_url;
 574     new_url.Swap(&delegate_redirect_url_);
 575
 576     URLRequestRedirectJob* job = new URLRequestRedirectJob(
 577         this, network_delegate_, new_url,
 578         // Use status code 307 to preserve the method, so POST requests work.
 579         URLRequestRedirectJob::REDIRECT_307_TEMPORARY_REDIRECT, "Delegate");
 580     StartJob(job);
 581   } else {
 582     StartJob(URLRequestJobManager::GetInstance()->CreateJob(
 583         this, network_delegate_));
 584   }
 585 }
 586
 587 void URLRequest::StartJob(URLRequestJob* job) {
 588   DCHECK(!is_pending_);
 589   DCHECK(!job_.get());
 590
 591   net_log_.BeginEvent(
 592       NetLog::TYPE_URL_REQUEST_START_JOB,
 593       base::Bind(&NetLogURLRequestStartCallback,
 594                  &url(), &method_, load_flags_, priority_,
 595                  upload_data_stream_ ? upload_data_stream_->identifier() : -1));
 596
 597   job_ = job;
 598   job_->SetExtraRequestHeaders(extra_request_headers_);
 599   job_->SetPriority(priority_);
 600
 601   if (upload_data_stream_.get())
 602     job_->SetUpload(upload_data_stream_.get());
 603
 604   is_pending_ = true;
 605   is_redirecting_ = false;
 606
 607   response_info_.was_cached = false;
 608
 609   if (GURL(referrer_) != URLRequestJob::ComputeReferrerForRedirect(
 610                              referrer_policy_, referrer_, url())) {
 611     if (!network_delegate_ ||
 612         !network_delegate_->CancelURLRequestWithPolicyViolatingReferrerHeader(
 613             *this, url(), GURL(referrer_))) {
 614       referrer_.clear();
 615     } else {
 616       // We need to clear the referrer anyway to avoid an infinite recursion
 617       // when starting the error job.
 618       referrer_.clear();
 619       std::string source("delegate");
 620       net_log_.AddEvent(NetLog::TYPE_CANCELLED,
 621                         NetLog::StringCallback("source", &source));
 622       RestartWithJob(new URLRequestErrorJob(
 623           this, network_delegate_, ERR_BLOCKED_BY_CLIENT));
 624       return;
 625     }
 626   }
 627
 628   // Don't allow errors to be sent from within Start().
 629   // TODO(brettw) this may cause NotifyDone to be sent synchronously,
 630   // we probably don't want this: they should be sent asynchronously so
 631   // the caller does not get reentered.
 632   job_->Start();
 633 }
 634
 635 void URLRequest::Restart() {
 636   // Should only be called if the original job didn't make any progress.
 637   DCHECK(job_.get() && !job_->has_response_started());
 638   RestartWithJob(
 639       URLRequestJobManager::GetInstance()->CreateJob(this, network_delegate_));
 640 }
 641
 642 void URLRequest::RestartWithJob(URLRequestJob *job) {
 643   DCHECK(job->request() == this);
 644   PrepareToRestart();
 645   StartJob(job);
 646 }
 647
 648 void URLRequest::Cancel() {
 649   DoCancel(ERR_ABORTED, SSLInfo());
 650 }
 651
 652 void URLRequest::CancelWithError(int error) {
 653   DoCancel(error, SSLInfo());
 654 }
 655
 656 void URLRequest::CancelWithSSLError(int error, const SSLInfo& ssl_info) {
 657   // This should only be called on a started request.
 658   if (!is_pending_ || !job_.get() || job_->has_response_started()) {
 659     NOTREACHED();
 660     return;
 661   }
 662   DoCancel(error, ssl_info);
 663 }
 664
 665 void URLRequest::DoCancel(int error, const SSLInfo& ssl_info) {
 666   DCHECK(error < 0);
 667   // If cancelled while calling a delegate, clear delegate info.
 668   if (calling_delegate_) {
 669     LogUnblocked();
 670     OnCallToDelegateComplete();
 671   }
 672
 673   // If the URL request already has an error status, then canceling is a no-op.
 674   // Plus, we don't want to change the error status once it has been set.
 675   if (status_.is_success()) {
 676     status_.set_status(URLRequestStatus::CANCELED);
 677     status_.set_error(error);
 678     response_info_.ssl_info = ssl_info;
 679
 680     // If the request hasn't already been completed, log a cancellation event.
 681     if (!has_notified_completion_) {
 682       // Don't log an error code on ERR_ABORTED, since that's redundant.
 683       net_log_.AddEventWithNetErrorCode(NetLog::TYPE_CANCELLED,
 684                                         error == ERR_ABORTED ? OK : error);
 685     }
 686   }
 687
 688   if (is_pending_ && job_.get())
 689     job_->Kill();
 690
 691   // We need to notify about the end of this job here synchronously. The
 692   // Job sends an asynchronous notification but by the time this is processed,
 693   // our |context_| is NULL.
 694   NotifyRequestCompleted();
 695
 696   // The Job will call our NotifyDone method asynchronously.  This is done so
 697   // that the Delegate implementation can call Cancel without having to worry
 698   // about being called recursively.
 699 }
 700
 701 bool URLRequest::Read(IOBuffer* dest, int dest_size, int* bytes_read) {
 702   DCHECK(job_.get());
 703   DCHECK(bytes_read);
 704   *bytes_read = 0;
 705
 706   // If this is the first read, end the delegate call that may have started in
 707   // OnResponseStarted.
 708   OnCallToDelegateComplete();
 709
 710   // This handles a cancel that happens while paused.
 711   // TODO(ahendrickson): DCHECK() that it is not done after
 712   // http://crbug.com/115705 is fixed.
 713   if (job_->is_done())
 714     return false;
 715
 716   if (dest_size == 0) {
 717     // Caller is not too bright.  I guess we've done what they asked.
 718     return true;
 719   }
 720
 721   // Once the request fails or is cancelled, read will just return 0 bytes
 722   // to indicate end of stream.
 723   if (!status_.is_success()) {
 724     return true;
 725   }
 726
 727   // TODO(vadimt): Remove ScopedTracker below once crbug.com/423948 is fixed.
 728   tracked_objects::ScopedTracker tracking_profile1(
 729       FROM_HERE_WITH_EXPLICIT_FUNCTION("423948 URLRequest::Read1"));
 730
 731   bool rv = job_->Read(dest, dest_size, bytes_read);
 732   // If rv is false, the status cannot be success.
 733   DCHECK(rv || status_.status() != URLRequestStatus::SUCCESS);
 734
 735   // TODO(vadimt): Remove ScopedTracker below once crbug.com/423948 is fixed.
 736   tracked_objects::ScopedTracker tracking_profile2(
 737       FROM_HERE_WITH_EXPLICIT_FUNCTION("423948 URLRequest::Read2"));
 738
 739   if (rv && *bytes_read <= 0 && status_.is_success())
 740     NotifyRequestCompleted();
 741   return rv;
 742 }
 743
 744 void URLRequest::StopCaching() {
 745   DCHECK(job_.get());
 746   job_->StopCaching();
 747 }
 748
 749 void URLRequest::NotifyReceivedRedirect(const RedirectInfo& redirect_info,
 750                                         bool* defer_redirect) {
 751   is_redirecting_ = true;
 752
 753   // TODO(davidben): Pass the full RedirectInfo down to MaybeInterceptRedirect?
 754   URLRequestJob* job =
 755       URLRequestJobManager::GetInstance()->MaybeInterceptRedirect(
 756           this, network_delegate_, redirect_info.new_url);
 757   if (job) {
 758     RestartWithJob(job);
 759   } else if (delegate_) {
 760     OnCallToDelegate();
 761
 762     // TODO(vadimt): Remove ScopedTracker below once crbug.com/423948 is fixed.
 763     tracked_objects::ScopedTracker tracking_profile(
 764         FROM_HERE_WITH_EXPLICIT_FUNCTION(
 765             "423948 URLRequest::Delegate::OnReceivedRedirect"));
 766     delegate_->OnReceivedRedirect(this, redirect_info, defer_redirect);
 767     // |this| may be have been destroyed here.
 768   }
 769 }
 770
 771 void URLRequest::NotifyBeforeNetworkStart(bool* defer) {
 772   if (delegate_ && !notified_before_network_start_) {
 773     OnCallToDelegate();
 774     {
 775       // TODO(vadimt): Remove ScopedTracker below once crbug.com/423948 is
 776       // fixed.
 777       tracked_objects::ScopedTracker tracking_profile(
 778           FROM_HERE_WITH_EXPLICIT_FUNCTION(
 779               "423948 URLRequest::Delegate::OnBeforeNetworkStart"));
 780       delegate_->OnBeforeNetworkStart(this, defer);
 781     }
 782     if (!*defer)
 783       OnCallToDelegateComplete();
 784     notified_before_network_start_ = true;
 785   }
 786 }
 787
 788 void URLRequest::ResumeNetworkStart() {
 789   DCHECK(job_.get());
 790   DCHECK(notified_before_network_start_);
 791
 792   OnCallToDelegateComplete();
 793   job_->ResumeNetworkStart();
 794 }
 795
 796 void URLRequest::NotifyResponseStarted() {
 797   int net_error = OK;
 798   if (!status_.is_success())
 799     net_error = status_.error();
 800   net_log_.EndEventWithNetErrorCode(NetLog::TYPE_URL_REQUEST_START_JOB,
 801                                     net_error);
 802
 803   URLRequestJob* job =
 804       URLRequestJobManager::GetInstance()->MaybeInterceptResponse(
 805           this, network_delegate_);
 806   if (job) {
 807     RestartWithJob(job);
 808   } else {
 809     if (delegate_) {
 810       // In some cases (e.g. an event was canceled), we might have sent the
 811       // completion event and receive a NotifyResponseStarted() later.
 812       if (!has_notified_completion_ && status_.is_success()) {
 813         if (network_delegate_)
 814           network_delegate_->NotifyResponseStarted(this);
 815       }
 816
 817       // Notify in case the entire URL Request has been finished.
 818       if (!has_notified_completion_ && !status_.is_success())
 819         NotifyRequestCompleted();
 820
 821       OnCallToDelegate();
 822       // TODO(vadimt): Remove ScopedTracker below once crbug.com/423948 is
 823       // fixed.
 824       tracked_objects::ScopedTracker tracking_profile(
 825           FROM_HERE_WITH_EXPLICIT_FUNCTION(
 826               "423948 URLRequest::Delegate::OnResponseStarted"));
 827       delegate_->OnResponseStarted(this);
 828       // Nothing may appear below this line as OnResponseStarted may delete
 829       // |this|.
 830     }
 831   }
 832 }
 833
 834 void URLRequest::FollowDeferredRedirect() {
 835   CHECK(job_.get());
 836   CHECK(status_.is_success());
 837
 838   job_->FollowDeferredRedirect();
 839 }
 840
 841 void URLRequest::SetAuth(const AuthCredentials& credentials) {
 842   DCHECK(job_.get());
 843   DCHECK(job_->NeedsAuth());
 844
 845   job_->SetAuth(credentials);
 846 }
 847
 848 void URLRequest::CancelAuth() {
 849   DCHECK(job_.get());
 850   DCHECK(job_->NeedsAuth());
 851
 852   job_->CancelAuth();
 853 }
 854
 855 void URLRequest::ContinueWithCertificate(X509Certificate* client_cert) {
 856   DCHECK(job_.get());
 857
 858   job_->ContinueWithCertificate(client_cert);
 859 }
 860
 861 void URLRequest::ContinueDespiteLastError() {
 862   DCHECK(job_.get());
 863
 864   job_->ContinueDespiteLastError();
 865 }
 866
 867 void URLRequest::PrepareToRestart() {
 868   DCHECK(job_.get());
 869
 870   // Close the current URL_REQUEST_START_JOB, since we will be starting a new
 871   // one.
 872   net_log_.EndEvent(NetLog::TYPE_URL_REQUEST_START_JOB);
 873
 874   OrphanJob();
 875
 876   response_info_ = HttpResponseInfo();
 877   response_info_.request_time = base::Time::Now();
 878
 879   load_timing_info_ = LoadTimingInfo();
 880   load_timing_info_.request_start_time = response_info_.request_time;
 881   load_timing_info_.request_start = base::TimeTicks::Now();
 882
 883   status_ = URLRequestStatus();
 884   is_pending_ = false;
 885 }
 886
 887 void URLRequest::OrphanJob() {
 888   // When calling this function, please check that URLRequestHttpJob is
 889   // not in between calling NetworkDelegate::NotifyHeadersReceived receiving
 890   // the call back. This is currently guaranteed by the following strategies:
 891   // - OrphanJob is called on JobRestart, in this case the URLRequestJob cannot
 892   //   be receiving any headers at that time.
 893   // - OrphanJob is called in ~URLRequest, in this case
 894   //   NetworkDelegate::NotifyURLRequestDestroyed notifies the NetworkDelegate
 895   //   that the callback becomes invalid.
 896   job_->Kill();
 897   job_->DetachRequest();  // ensures that the job will not call us again
 898   job_ = NULL;
 899 }
 900
 901 int URLRequest::Redirect(const RedirectInfo& redirect_info) {
 902   // Matches call in NotifyReceivedRedirect.
 903   OnCallToDelegateComplete();
 904   if (net_log_.IsLogging()) {
 905     net_log_.AddEvent(
 906         NetLog::TYPE_URL_REQUEST_REDIRECTED,
 907         NetLog::StringCallback("location",
 908                                &redirect_info.new_url.possibly_invalid_spec()));
 909   }
 910
 911   // TODO(davidben): Pass the full RedirectInfo to the NetworkDelegate.
 912   if (network_delegate_)
 913     network_delegate_->NotifyBeforeRedirect(this, redirect_info.new_url);
 914
 915   if (redirect_limit_ <= 0) {
 916     DVLOG(1) << "disallowing redirect: exceeds limit";
 917     return ERR_TOO_MANY_REDIRECTS;
 918   }
 919
 920   if (!redirect_info.new_url.is_valid())
 921     return ERR_INVALID_URL;
 922
 923   if (!job_->IsSafeRedirect(redirect_info.new_url)) {
 924     DVLOG(1) << "disallowing redirect: unsafe protocol";
 925     return ERR_UNSAFE_REDIRECT;
 926   }
 927
 928   if (!final_upload_progress_.position())
 929     final_upload_progress_ = job_->GetUploadProgress();
 930   PrepareToRestart();
 931
 932   if (redirect_info.new_method != method_) {
 933     // TODO(davidben): This logic still needs to be replicated at the consumers.
 934     if (method_ == "POST") {
 935       // If being switched from POST, must remove headers that were specific to
 936       // the POST and don't have meaning in other methods. For example the
 937       // inclusion of a multipart Content-Type header in GET can cause problems
 938       // with some servers:
 939       // http://code.google.com/p/chromium/issues/detail?id=843
 940       StripPostSpecificHeaders(&extra_request_headers_);
 941     }
 942     upload_data_stream_.reset();
 943     method_ = redirect_info.new_method;
 944   }
 945
 946   referrer_ = redirect_info.new_referrer;
 947   first_party_for_cookies_ = redirect_info.new_first_party_for_cookies;
 948
 949   url_chain_.push_back(redirect_info.new_url);
 950   --redirect_limit_;
 951
 952   Start();
 953   return OK;
 954 }
 955
 956 const URLRequestContext* URLRequest::context() const {
 957   return context_;
 958 }
 959
 960 int64 URLRequest::GetExpectedContentSize() const {
 961   int64 expected_content_size = -1;
 962   if (job_.get())
 963     expected_content_size = job_->expected_content_size();
 964
 965   return expected_content_size;
 966 }
 967
 968 void URLRequest::SetPriority(RequestPriority priority) {
 969   DCHECK_GE(priority, MINIMUM_PRIORITY);
 970   DCHECK_LE(priority, MAXIMUM_PRIORITY);
 971
 972   if ((load_flags_ & LOAD_IGNORE_LIMITS) && (priority != MAXIMUM_PRIORITY)) {
 973     NOTREACHED();
 974     // Maintain the invariant that requests with IGNORE_LIMITS set
 975     // have MAXIMUM_PRIORITY for release mode.
 976     return;
 977   }
 978
 979   if (priority_ == priority)
 980     return;
 981
 982   priority_ = priority;
 983   if (job_.get()) {
 984     net_log_.AddEvent(NetLog::TYPE_URL_REQUEST_SET_PRIORITY,
 985                       NetLog::IntegerCallback("priority", priority_));
 986     job_->SetPriority(priority_);
 987   }
 988 }
 989
 990 bool URLRequest::GetHSTSRedirect(GURL* redirect_url) const {
 991   const GURL& url = this->url();
 992   bool scheme_is_http = url.SchemeIs("http");
 993   if (!scheme_is_http && !url.SchemeIs("ws"))
 994     return false;
 995   TransportSecurityState* state = context()->transport_security_state();
 996   if (state && state->ShouldUpgradeToSSL(url.host())) {
 997     GURL::Replacements replacements;
 998     const char* new_scheme = scheme_is_http ? "https" : "wss";
 999     replacements.SetSchemeStr(new_scheme);
1000     *redirect_url = url.ReplaceComponents(replacements);
1001     return true;
1002   }
1003   return false;
1004 }
1005
1006 void URLRequest::NotifyAuthRequired(AuthChallengeInfo* auth_info) {
1007   NetworkDelegate::AuthRequiredResponse rv =
1008       NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION;
1009   auth_info_ = auth_info;
1010   if (network_delegate_) {
1011     OnCallToDelegate();
1012     rv = network_delegate_->NotifyAuthRequired(
1013         this,
1014         *auth_info,
1015         base::Bind(&URLRequest::NotifyAuthRequiredComplete,
1016                    base::Unretained(this)),
1017         &auth_credentials_);
1018     if (rv == NetworkDelegate::AUTH_REQUIRED_RESPONSE_IO_PENDING)
1019       return;
1020   }
1021
1022   NotifyAuthRequiredComplete(rv);
1023 }
1024
1025 void URLRequest::NotifyAuthRequiredComplete(
1026     NetworkDelegate::AuthRequiredResponse result) {
1027   OnCallToDelegateComplete();
1028
1029   // Check that there are no callbacks to already canceled requests.
1030   DCHECK_NE(URLRequestStatus::CANCELED, status_.status());
1031
1032   // NotifyAuthRequired may be called multiple times, such as
1033   // when an authentication attempt fails. Clear out the data
1034   // so it can be reset on another round.
1035   AuthCredentials credentials = auth_credentials_;
1036   auth_credentials_ = AuthCredentials();
1037   scoped_refptr<AuthChallengeInfo> auth_info;
1038   auth_info.swap(auth_info_);
1039
1040   switch (result) {
1041     case NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION:
1042       // Defer to the URLRequest::Delegate, since the NetworkDelegate
1043       // didn't take an action.
1044       if (delegate_) {
1045         // TODO(vadimt): Remove ScopedTracker below once crbug.com/423948 is
1046         // fixed.
1047         tracked_objects::ScopedTracker tracking_profile(
1048             FROM_HERE_WITH_EXPLICIT_FUNCTION(
1049                 "423948 URLRequest::Delegate::OnAuthRequired"));
1050         delegate_->OnAuthRequired(this, auth_info.get());
1051       }
1052       break;
1053
1054     case NetworkDelegate::AUTH_REQUIRED_RESPONSE_SET_AUTH:
1055       SetAuth(credentials);
1056       break;
1057
1058     case NetworkDelegate::AUTH_REQUIRED_RESPONSE_CANCEL_AUTH:
1059       CancelAuth();
1060       break;
1061
1062     case NetworkDelegate::AUTH_REQUIRED_RESPONSE_IO_PENDING:
1063       NOTREACHED();
1064       break;
1065   }
1066 }
1067
1068 void URLRequest::NotifyCertificateRequested(
1069     SSLCertRequestInfo* cert_request_info) {
1070   if (delegate_) {
1071     // TODO(vadimt): Remove ScopedTracker below once crbug.com/423948 is fixed.
1072     tracked_objects::ScopedTracker tracking_profile(
1073         FROM_HERE_WITH_EXPLICIT_FUNCTION(
1074             "423948 URLRequest::Delegate::OnCertificateRequested"));
1075     delegate_->OnCertificateRequested(this, cert_request_info);
1076   }
1077 }
1078
1079 void URLRequest::NotifySSLCertificateError(const SSLInfo& ssl_info,
1080                                            bool fatal) {
1081   if (delegate_) {
1082     // TODO(vadimt): Remove ScopedTracker below once crbug.com/423948 is fixed.
1083     tracked_objects::ScopedTracker tracking_profile(
1084         FROM_HERE_WITH_EXPLICIT_FUNCTION(
1085             "423948 URLRequest::Delegate::OnSSLCertificateError"));
1086     delegate_->OnSSLCertificateError(this, ssl_info, fatal);
1087   }
1088 }
1089
1090 bool URLRequest::CanGetCookies(const CookieList& cookie_list) const {
1091   DCHECK(!(load_flags_ & LOAD_DO_NOT_SEND_COOKIES));
1092   if (network_delegate_) {
1093     return network_delegate_->CanGetCookies(*this, cookie_list);
1094   }
1095   return g_default_can_use_cookies;
1096 }
1097
1098 bool URLRequest::CanSetCookie(const std::string& cookie_line,
1099                               CookieOptions* options) const {
1100   DCHECK(!(load_flags_ & LOAD_DO_NOT_SAVE_COOKIES));
1101   if (network_delegate_) {
1102     return network_delegate_->CanSetCookie(*this, cookie_line, options);
1103   }
1104   return g_default_can_use_cookies;
1105 }
1106
1107 bool URLRequest::CanEnablePrivacyMode() const {
1108   if (network_delegate_) {
1109     return network_delegate_->CanEnablePrivacyMode(url(),
1110                                                    first_party_for_cookies_);
1111   }
1112   return !g_default_can_use_cookies;
1113 }
1114
1115
1116 void URLRequest::NotifyReadCompleted(int bytes_read) {
1117   // Notify in case the entire URL Request has been finished.
1118   if (bytes_read <= 0)
1119     NotifyRequestCompleted();
1120
1121   // Notify NetworkChangeNotifier that we just received network data.
1122   // This is to identify cases where the NetworkChangeNotifier thinks we
1123   // are off-line but we are still receiving network data (crbug.com/124069),
1124   // and to get rough network connection measurements.
1125   if (bytes_read > 0 && !was_cached())
1126     NetworkChangeNotifier::NotifyDataReceived(*this, bytes_read);
1127
1128   if (delegate_) {
1129     // TODO(vadimt): Remove ScopedTracker below once crbug.com/423948 is fixed.
1130     tracked_objects::ScopedTracker tracking_profile(
1131         FROM_HERE_WITH_EXPLICIT_FUNCTION(
1132             "423948 URLRequest::Delegate::OnReadCompleted"));
1133     delegate_->OnReadCompleted(this, bytes_read);
1134   }
1135
1136   // Nothing below this line as OnReadCompleted may delete |this|.
1137 }
1138
1139 void URLRequest::OnHeadersComplete() {
1140   // Cache load timing information now, as information will be lost once the
1141   // socket is closed and the ClientSocketHandle is Reset, which will happen
1142   // once the body is complete.  The start times should already be populated.
1143   if (job_.get()) {
1144     // Keep a copy of the two times the URLRequest sets.
1145     base::TimeTicks request_start = load_timing_info_.request_start;
1146     base::Time request_start_time = load_timing_info_.request_start_time;
1147
1148     // Clear load times.  Shouldn't be neded, but gives the GetLoadTimingInfo a
1149     // consistent place to start from.
1150     load_timing_info_ = LoadTimingInfo();
1151     job_->GetLoadTimingInfo(&load_timing_info_);
1152
1153     load_timing_info_.request_start = request_start;
1154     load_timing_info_.request_start_time = request_start_time;
1155
1156     ConvertRealLoadTimesToBlockingTimes(&load_timing_info_);
1157   }
1158 }
1159
1160 void URLRequest::NotifyRequestCompleted() {
1161   // TODO(battre): Get rid of this check, according to willchan it should
1162   // not be needed.
1163   if (has_notified_completion_)
1164     return;
1165
1166   is_pending_ = false;
1167   is_redirecting_ = false;
1168   has_notified_completion_ = true;
1169   if (network_delegate_)
1170     network_delegate_->NotifyCompleted(this, job_.get() != NULL);
1171 }
1172
1173 void URLRequest::OnCallToDelegate() {
1174   DCHECK(!calling_delegate_);
1175   DCHECK(blocked_by_.empty());
1176   calling_delegate_ = true;
1177   net_log_.BeginEvent(NetLog::TYPE_URL_REQUEST_DELEGATE);
1178 }
1179
1180 void URLRequest::OnCallToDelegateComplete() {
1181   // This should have been cleared before resuming the request.
1182   DCHECK(blocked_by_.empty());
1183   if (!calling_delegate_)
1184     return;
1185   calling_delegate_ = false;
1186   net_log_.EndEvent(NetLog::TYPE_URL_REQUEST_DELEGATE);
1187 }
1188
1189 void URLRequest::set_stack_trace(const base::debug::StackTrace& stack_trace) {
1190   base::debug::StackTrace* stack_trace_copy =
1191       new base::debug::StackTrace(NULL, 0);
1192   *stack_trace_copy = stack_trace;
1193   stack_trace_.reset(stack_trace_copy);
1194 }
1195
1196 const base::debug::StackTrace* URLRequest::stack_trace() const {
1197   return stack_trace_.get();
1198 }
1199
1200 }  // namespace net