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