net/url_request/url_request_job.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/url_request/url_request_job.h"
   6
   7 #include "base/bind.h"
   8 #include "base/compiler_specific.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "base/power_monitor/power_monitor.h"
  11 #include "base/profiler/scoped_tracker.h"
  12 #include "base/strings/string_number_conversions.h"
  13 #include "base/strings/string_util.h"
  14 #include "base/values.h"
  15 #include "net/base/auth.h"
  16 #include "net/base/host_port_pair.h"
  17 #include "net/base/io_buffer.h"
  18 #include "net/base/load_states.h"
  19 #include "net/base/net_errors.h"
  20 #include "net/base/network_delegate.h"
  21 #include "net/filter/filter.h"
  22 #include "net/http/http_response_headers.h"
  23
  24 namespace {
  25
  26 // Callback for TYPE_URL_REQUEST_FILTERS_SET net-internals event.
  27 base::Value* FiltersSetCallback(net::Filter* filter,
  28                                 enum net::NetLog::LogLevel /* log_level */) {
  29   base::DictionaryValue* event_params = new base::DictionaryValue();
  30   event_params->SetString("filters", filter->OrderedFilterList());
  31   return event_params;
  32 }
  33
  34 }  // namespace
  35
  36 namespace net {
  37
  38 URLRequestJob::URLRequestJob(URLRequest* request,
  39                              NetworkDelegate* network_delegate)
  40     : request_(request),
  41       done_(false),
  42       prefilter_bytes_read_(0),
  43       postfilter_bytes_read_(0),
  44       filter_input_byte_count_(0),
  45       filter_needs_more_output_space_(false),
  46       filtered_read_buffer_len_(0),
  47       has_handled_response_(false),
  48       expected_content_size_(-1),
  49       network_delegate_(network_delegate),
  50       weak_factory_(this) {
  51   base::PowerMonitor* power_monitor = base::PowerMonitor::Get();
  52   if (power_monitor)
  53     power_monitor->AddObserver(this);
  54 }
  55
  56 void URLRequestJob::SetUpload(UploadDataStream* upload) {
  57 }
  58
  59 void URLRequestJob::SetExtraRequestHeaders(const HttpRequestHeaders& headers) {
  60 }
  61
  62 void URLRequestJob::SetPriority(RequestPriority priority) {
  63 }
  64
  65 void URLRequestJob::Kill() {
  66   weak_factory_.InvalidateWeakPtrs();
  67   // Make sure the request is notified that we are done.  We assume that the
  68   // request took care of setting its error status before calling Kill.
  69   if (request_)
  70     NotifyCanceled();
  71 }
  72
  73 void URLRequestJob::DetachRequest() {
  74   request_ = NULL;
  75 }
  76
  77 // This function calls ReadData to get stream data. If a filter exists, passes
  78 // the data to the attached filter. Then returns the output from filter back to
  79 // the caller.
  80 bool URLRequestJob::Read(IOBuffer* buf, int buf_size, int *bytes_read) {
  81   bool rv = false;
  82
  83   DCHECK_LT(buf_size, 1000000);  // Sanity check.
  84   DCHECK(buf);
  85   DCHECK(bytes_read);
  86   DCHECK(filtered_read_buffer_.get() == NULL);
  87   DCHECK_EQ(0, filtered_read_buffer_len_);
  88
  89   *bytes_read = 0;
  90
  91   // Skip Filter if not present.
  92   if (!filter_.get()) {
  93     rv = ReadRawDataHelper(buf, buf_size, bytes_read);
  94   } else {
  95     // Save the caller's buffers while we do IO
  96     // in the filter's buffers.
  97     filtered_read_buffer_ = buf;
  98     filtered_read_buffer_len_ = buf_size;
  99
 100     // TODO(vadimt): Remove ScopedTracker below once crbug.com/423948 is fixed.
 101     tracked_objects::ScopedTracker tracking_profile2(
 102         FROM_HERE_WITH_EXPLICIT_FUNCTION("423948 URLRequestJob::Read2"));
 103
 104     if (ReadFilteredData(bytes_read)) {
 105       rv = true;   // We have data to return.
 106
 107       // It is fine to call DoneReading even if ReadFilteredData receives 0
 108       // bytes from the net, but we avoid making that call if we know for
 109       // sure that's the case (ReadRawDataHelper path).
 110       // TODO(vadimt): Remove ScopedTracker below once crbug.com/423948 is
 111       // fixed.
 112       tracked_objects::ScopedTracker tracking_profile3(
 113           FROM_HERE_WITH_EXPLICIT_FUNCTION("423948 URLRequestJob::Read3"));
 114
 115       if (*bytes_read == 0)
 116         DoneReading();
 117     } else {
 118       rv = false;  // Error, or a new IO is pending.
 119     }
 120   }
 121
 122   // TODO(vadimt): Remove ScopedTracker below once crbug.com/423948 is fixed.
 123   tracked_objects::ScopedTracker tracking_profile4(
 124       FROM_HERE_WITH_EXPLICIT_FUNCTION("423948 URLRequestJob::Read4"));
 125
 126   if (rv && *bytes_read == 0)
 127     NotifyDone(URLRequestStatus());
 128   return rv;
 129 }
 130
 131 void URLRequestJob::StopCaching() {
 132   // Nothing to do here.
 133 }
 134
 135 bool URLRequestJob::GetFullRequestHeaders(HttpRequestHeaders* headers) const {
 136   // Most job types don't send request headers.
 137   return false;
 138 }
 139
 140 int64 URLRequestJob::GetTotalReceivedBytes() const {
 141   return 0;
 142 }
 143
 144 LoadState URLRequestJob::GetLoadState() const {
 145   return LOAD_STATE_IDLE;
 146 }
 147
 148 UploadProgress URLRequestJob::GetUploadProgress() const {
 149   return UploadProgress();
 150 }
 151
 152 bool URLRequestJob::GetCharset(std::string* charset) {
 153   return false;
 154 }
 155
 156 void URLRequestJob::GetResponseInfo(HttpResponseInfo* info) {
 157 }
 158
 159 void URLRequestJob::GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const {
 160   // Only certain request types return more than just request start times.
 161 }
 162
 163 bool URLRequestJob::GetResponseCookies(std::vector<std::string>* cookies) {
 164   return false;
 165 }
 166
 167 Filter* URLRequestJob::SetupFilter() const {
 168   return NULL;
 169 }
 170
 171 bool URLRequestJob::IsRedirectResponse(GURL* location,
 172                                        int* http_status_code) {
 173   // For non-HTTP jobs, headers will be null.
 174   HttpResponseHeaders* headers = request_->response_headers();
 175   if (!headers)
 176     return false;
 177
 178   std::string value;
 179   if (!headers->IsRedirect(&value))
 180     return false;
 181
 182   *location = request_->url().Resolve(value);
 183   *http_status_code = headers->response_code();
 184   return true;
 185 }
 186
 187 bool URLRequestJob::CopyFragmentOnRedirect(const GURL& location) const {
 188   return true;
 189 }
 190
 191 bool URLRequestJob::IsSafeRedirect(const GURL& location) {
 192   return true;
 193 }
 194
 195 bool URLRequestJob::NeedsAuth() {
 196   return false;
 197 }
 198
 199 void URLRequestJob::GetAuthChallengeInfo(
 200     scoped_refptr<AuthChallengeInfo>* auth_info) {
 201   // This will only be called if NeedsAuth() returns true, in which
 202   // case the derived class should implement this!
 203   NOTREACHED();
 204 }
 205
 206 void URLRequestJob::SetAuth(const AuthCredentials& credentials) {
 207   // This will only be called if NeedsAuth() returns true, in which
 208   // case the derived class should implement this!
 209   NOTREACHED();
 210 }
 211
 212 void URLRequestJob::CancelAuth() {
 213   // This will only be called if NeedsAuth() returns true, in which
 214   // case the derived class should implement this!
 215   NOTREACHED();
 216 }
 217
 218 void URLRequestJob::ContinueWithCertificate(
 219     X509Certificate* client_cert) {
 220   // The derived class should implement this!
 221   NOTREACHED();
 222 }
 223
 224 void URLRequestJob::ContinueDespiteLastError() {
 225   // Implementations should know how to recover from errors they generate.
 226   // If this code was reached, we are trying to recover from an error that
 227   // we don't know how to recover from.
 228   NOTREACHED();
 229 }
 230
 231 void URLRequestJob::FollowDeferredRedirect() {
 232   DCHECK_NE(-1, deferred_redirect_info_.status_code);
 233
 234   // NOTE: deferred_redirect_info_ may be invalid, and attempting to follow it
 235   // will fail inside FollowRedirect.  The DCHECK above asserts that we called
 236   // OnReceivedRedirect.
 237
 238   // It is also possible that FollowRedirect will drop the last reference to
 239   // this job, so we need to reset our members before calling it.
 240
 241   RedirectInfo redirect_info = deferred_redirect_info_;
 242   deferred_redirect_info_ = RedirectInfo();
 243   FollowRedirect(redirect_info);
 244 }
 245
 246 void URLRequestJob::ResumeNetworkStart() {
 247   // This should only be called for HTTP Jobs, and implemented in the derived
 248   // class.
 249   NOTREACHED();
 250 }
 251
 252 bool URLRequestJob::GetMimeType(std::string* mime_type) const {
 253   return false;
 254 }
 255
 256 int URLRequestJob::GetResponseCode() const {
 257   return -1;
 258 }
 259
 260 HostPortPair URLRequestJob::GetSocketAddress() const {
 261   return HostPortPair();
 262 }
 263
 264 void URLRequestJob::OnSuspend() {
 265   Kill();
 266 }
 267
 268 void URLRequestJob::NotifyURLRequestDestroyed() {
 269 }
 270
 271 // static
 272 GURL URLRequestJob::ComputeReferrerForRedirect(
 273     URLRequest::ReferrerPolicy policy,
 274     const std::string& referrer,
 275     const GURL& redirect_destination) {
 276   GURL original_referrer(referrer);
 277   bool secure_referrer_but_insecure_destination =
 278       original_referrer.SchemeIsSecure() &&
 279       !redirect_destination.SchemeIsSecure();
 280   bool same_origin =
 281       original_referrer.GetOrigin() == redirect_destination.GetOrigin();
 282   switch (policy) {
 283     case URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE:
 284       return secure_referrer_but_insecure_destination ? GURL()
 285                                                       : original_referrer;
 286
 287     case URLRequest::REDUCE_REFERRER_GRANULARITY_ON_TRANSITION_CROSS_ORIGIN:
 288       if (same_origin) {
 289         return original_referrer;
 290       } else if (secure_referrer_but_insecure_destination) {
 291         return GURL();
 292       } else {
 293         return original_referrer.GetOrigin();
 294       }
 295
 296     case URLRequest::ORIGIN_ONLY_ON_TRANSITION_CROSS_ORIGIN:
 297       return same_origin ? original_referrer : original_referrer.GetOrigin();
 298
 299     case URLRequest::NEVER_CLEAR_REFERRER:
 300       return original_referrer;
 301   }
 302
 303   NOTREACHED();
 304   return GURL();
 305 }
 306
 307 URLRequestJob::~URLRequestJob() {
 308   base::PowerMonitor* power_monitor = base::PowerMonitor::Get();
 309   if (power_monitor)
 310     power_monitor->RemoveObserver(this);
 311 }
 312
 313 void URLRequestJob::NotifyCertificateRequested(
 314     SSLCertRequestInfo* cert_request_info) {
 315   if (!request_)
 316     return;  // The request was destroyed, so there is no more work to do.
 317
 318   request_->NotifyCertificateRequested(cert_request_info);
 319 }
 320
 321 void URLRequestJob::NotifySSLCertificateError(const SSLInfo& ssl_info,
 322                                               bool fatal) {
 323   if (!request_)
 324     return;  // The request was destroyed, so there is no more work to do.
 325
 326   request_->NotifySSLCertificateError(ssl_info, fatal);
 327 }
 328
 329 bool URLRequestJob::CanGetCookies(const CookieList& cookie_list) const {
 330   if (!request_)
 331     return false;  // The request was destroyed, so there is no more work to do.
 332
 333   return request_->CanGetCookies(cookie_list);
 334 }
 335
 336 bool URLRequestJob::CanSetCookie(const std::string& cookie_line,
 337                                  CookieOptions* options) const {
 338   if (!request_)
 339     return false;  // The request was destroyed, so there is no more work to do.
 340
 341   return request_->CanSetCookie(cookie_line, options);
 342 }
 343
 344 bool URLRequestJob::CanEnablePrivacyMode() const {
 345   if (!request_)
 346     return false;  // The request was destroyed, so there is no more work to do.
 347
 348   return request_->CanEnablePrivacyMode();
 349 }
 350
 351 CookieStore* URLRequestJob::GetCookieStore() const {
 352   DCHECK(request_);
 353
 354   return request_->cookie_store();
 355 }
 356
 357 void URLRequestJob::NotifyBeforeNetworkStart(bool* defer) {
 358   if (!request_)
 359     return;
 360
 361   request_->NotifyBeforeNetworkStart(defer);
 362 }
 363
 364 void URLRequestJob::NotifyHeadersComplete() {
 365   // TODO(vadimt): Remove ScopedTracker below once crbug.com/423948 is fixed.
 366   tracked_objects::ScopedTracker tracking_profile(
 367       FROM_HERE_WITH_EXPLICIT_FUNCTION(
 368           "423948 URLRequestJob::NotifyHeadersComplete"));
 369
 370   if (!request_ || !request_->has_delegate())
 371     return;  // The request was destroyed, so there is no more work to do.
 372
 373   if (has_handled_response_)
 374     return;
 375
 376   DCHECK(!request_->status().is_io_pending());
 377
 378   // Initialize to the current time, and let the subclass optionally override
 379   // the time stamps if it has that information.  The default request_time is
 380   // set by URLRequest before it calls our Start method.
 381   request_->response_info_.response_time = base::Time::Now();
 382   GetResponseInfo(&request_->response_info_);
 383
 384   // When notifying the delegate, the delegate can release the request
 385   // (and thus release 'this').  After calling to the delgate, we must
 386   // check the request pointer to see if it still exists, and return
 387   // immediately if it has been destroyed.  self_preservation ensures our
 388   // survival until we can get out of this method.
 389   scoped_refptr<URLRequestJob> self_preservation(this);
 390
 391   if (request_) {
 392     // TODO(vadimt): Remove ScopedTracker below once crbug.com/423948 is fixed.
 393     tracked_objects::ScopedTracker tracking_profile1(
 394         FROM_HERE_WITH_EXPLICIT_FUNCTION(
 395             "423948 URLRequestJob::NotifyHeadersComplete 1"));
 396
 397     request_->OnHeadersComplete();
 398   }
 399
 400   // TODO(vadimt): Remove ScopedTracker below once crbug.com/423948 is fixed.
 401   tracked_objects::ScopedTracker tracking_profile2(
 402       FROM_HERE_WITH_EXPLICIT_FUNCTION(
 403           "423948 URLRequestJob::NotifyHeadersComplete 2"));
 404
 405   GURL new_location;
 406   int http_status_code;
 407   if (IsRedirectResponse(&new_location, &http_status_code)) {
 408     // TODO(vadimt): Remove ScopedTracker below once crbug.com/423948 is fixed.
 409     tracked_objects::ScopedTracker tracking_profile3(
 410         FROM_HERE_WITH_EXPLICIT_FUNCTION(
 411             "423948 URLRequestJob::NotifyHeadersComplete 3"));
 412
 413     // Redirect response bodies are not read. Notify the transaction
 414     // so it does not treat being stopped as an error.
 415     DoneReadingRedirectResponse();
 416
 417     // TODO(vadimt): Remove ScopedTracker below once crbug.com/423948 is fixed.
 418     tracked_objects::ScopedTracker tracking_profile4(
 419         FROM_HERE_WITH_EXPLICIT_FUNCTION(
 420             "423948 URLRequestJob::NotifyHeadersComplete 4"));
 421
 422     RedirectInfo redirect_info =
 423         ComputeRedirectInfo(new_location, http_status_code);
 424
 425     // TODO(vadimt): Remove ScopedTracker below once crbug.com/423948 is fixed.
 426     tracked_objects::ScopedTracker tracking_profile5(
 427         FROM_HERE_WITH_EXPLICIT_FUNCTION(
 428             "423948 URLRequestJob::NotifyHeadersComplete 5"));
 429
 430     bool defer_redirect = false;
 431     request_->NotifyReceivedRedirect(redirect_info, &defer_redirect);
 432
 433     // Ensure that the request wasn't detached or destroyed in
 434     // NotifyReceivedRedirect
 435     if (!request_ || !request_->has_delegate())
 436       return;
 437
 438     // TODO(vadimt): Remove ScopedTracker below once crbug.com/423948 is fixed.
 439     tracked_objects::ScopedTracker tracking_profile6(
 440         FROM_HERE_WITH_EXPLICIT_FUNCTION(
 441             "423948 URLRequestJob::NotifyHeadersComplete 6"));
 442
 443     // If we were not cancelled, then maybe follow the redirect.
 444     if (request_->status().is_success()) {
 445       if (defer_redirect) {
 446         deferred_redirect_info_ = redirect_info;
 447       } else {
 448         FollowRedirect(redirect_info);
 449       }
 450       return;
 451     }
 452   } else if (NeedsAuth()) {
 453     // TODO(vadimt): Remove ScopedTracker below once crbug.com/423948 is fixed.
 454     tracked_objects::ScopedTracker tracking_profile7(
 455         FROM_HERE_WITH_EXPLICIT_FUNCTION(
 456             "423948 URLRequestJob::NotifyHeadersComplete 7"));
 457
 458     scoped_refptr<AuthChallengeInfo> auth_info;
 459     GetAuthChallengeInfo(&auth_info);
 460
 461     // TODO(vadimt): Remove ScopedTracker below once crbug.com/423948 is fixed.
 462     tracked_objects::ScopedTracker tracking_profile8(
 463         FROM_HERE_WITH_EXPLICIT_FUNCTION(
 464             "423948 URLRequestJob::NotifyHeadersComplete 8"));
 465
 466     // Need to check for a NULL auth_info because the server may have failed
 467     // to send a challenge with the 401 response.
 468     if (auth_info.get()) {
 469       request_->NotifyAuthRequired(auth_info.get());
 470       // Wait for SetAuth or CancelAuth to be called.
 471       return;
 472     }
 473   }
 474
 475   // TODO(vadimt): Remove ScopedTracker below once crbug.com/423948 is fixed.
 476   tracked_objects::ScopedTracker tracking_profile9(
 477       FROM_HERE_WITH_EXPLICIT_FUNCTION(
 478           "423948 URLRequestJob::NotifyHeadersComplete 9"));
 479
 480   has_handled_response_ = true;
 481   if (request_->status().is_success())
 482     filter_.reset(SetupFilter());
 483
 484   if (!filter_.get()) {
 485     std::string content_length;
 486     request_->GetResponseHeaderByName("content-length", &content_length);
 487     if (!content_length.empty())
 488       base::StringToInt64(content_length, &expected_content_size_);
 489   } else {
 490     request_->net_log().AddEvent(
 491         NetLog::TYPE_URL_REQUEST_FILTERS_SET,
 492         base::Bind(&FiltersSetCallback, base::Unretained(filter_.get())));
 493   }
 494
 495   // TODO(vadimt): Remove ScopedTracker below once crbug.com/423948 is fixed.
 496   tracked_objects::ScopedTracker tracking_profile10(
 497       FROM_HERE_WITH_EXPLICIT_FUNCTION(
 498           "423948 URLRequestJob::NotifyHeadersComplete 10"));
 499
 500   request_->NotifyResponseStarted();
 501 }
 502
 503 void URLRequestJob::NotifyReadComplete(int bytes_read) {
 504   // TODO(vadimt): Remove ScopedTracker below once crbug.com/423948 is fixed.
 505   tracked_objects::ScopedTracker tracking_profile(
 506       FROM_HERE_WITH_EXPLICIT_FUNCTION("URLRequestJob::NotifyReadComplete"));
 507
 508   if (!request_ || !request_->has_delegate())
 509     return;  // The request was destroyed, so there is no more work to do.
 510
 511   // TODO(darin): Bug 1004233. Re-enable this test once all of the chrome
 512   // unit_tests have been fixed to not trip this.
 513 #if 0
 514   DCHECK(!request_->status().is_io_pending());
 515 #endif
 516   // The headers should be complete before reads complete
 517   DCHECK(has_handled_response_);
 518
 519   OnRawReadComplete(bytes_read);
 520
 521   // Don't notify if we had an error.
 522   if (!request_->status().is_success())
 523     return;
 524
 525   // When notifying the delegate, the delegate can release the request
 526   // (and thus release 'this').  After calling to the delegate, we must
 527   // check the request pointer to see if it still exists, and return
 528   // immediately if it has been destroyed.  self_preservation ensures our
 529   // survival until we can get out of this method.
 530   scoped_refptr<URLRequestJob> self_preservation(this);
 531
 532   if (filter_.get()) {
 533     // Tell the filter that it has more data
 534     FilteredDataRead(bytes_read);
 535
 536     // Filter the data.
 537     int filter_bytes_read = 0;
 538     if (ReadFilteredData(&filter_bytes_read)) {
 539       if (!filter_bytes_read)
 540         DoneReading();
 541       request_->NotifyReadCompleted(filter_bytes_read);
 542     }
 543   } else {
 544     request_->NotifyReadCompleted(bytes_read);
 545   }
 546   DVLOG(1) << __FUNCTION__ << "() "
 547            << "\"" << (request_ ? request_->url().spec() : "???") << "\""
 548            << " pre bytes read = " << bytes_read
 549            << " pre total = " << prefilter_bytes_read_
 550            << " post total = " << postfilter_bytes_read_;
 551 }
 552
 553 void URLRequestJob::NotifyStartError(const URLRequestStatus &status) {
 554   DCHECK(!has_handled_response_);
 555   has_handled_response_ = true;
 556   if (request_) {
 557     // There may be relevant information in the response info even in the
 558     // error case.
 559     GetResponseInfo(&request_->response_info_);
 560
 561     request_->set_status(status);
 562     request_->NotifyResponseStarted();
 563     // We may have been deleted.
 564   }
 565 }
 566
 567 void URLRequestJob::NotifyDone(const URLRequestStatus &status) {
 568   DCHECK(!done_) << "Job sending done notification twice";
 569   if (done_)
 570     return;
 571   done_ = true;
 572
 573   // Unless there was an error, we should have at least tried to handle
 574   // the response before getting here.
 575   DCHECK(has_handled_response_ || !status.is_success());
 576
 577   // As with NotifyReadComplete, we need to take care to notice if we were
 578   // destroyed during a delegate callback.
 579   if (request_) {
 580     request_->set_is_pending(false);
 581     // With async IO, it's quite possible to have a few outstanding
 582     // requests.  We could receive a request to Cancel, followed shortly
 583     // by a successful IO.  For tracking the status(), once there is
 584     // an error, we do not change the status back to success.  To
 585     // enforce this, only set the status if the job is so far
 586     // successful.
 587     if (request_->status().is_success()) {
 588       if (status.status() == URLRequestStatus::FAILED) {
 589         request_->net_log().AddEventWithNetErrorCode(NetLog::TYPE_FAILED,
 590                                                      status.error());
 591       }
 592       request_->set_status(status);
 593     }
 594   }
 595
 596   // Complete this notification later.  This prevents us from re-entering the
 597   // delegate if we're done because of a synchronous call.
 598   base::MessageLoop::current()->PostTask(
 599       FROM_HERE,
 600       base::Bind(&URLRequestJob::CompleteNotifyDone,
 601                  weak_factory_.GetWeakPtr()));
 602 }
 603
 604 void URLRequestJob::CompleteNotifyDone() {
 605   // Check if we should notify the delegate that we're done because of an error.
 606   if (request_ &&
 607       !request_->status().is_success() &&
 608       request_->has_delegate()) {
 609     // We report the error differently depending on whether we've called
 610     // OnResponseStarted yet.
 611     if (has_handled_response_) {
 612       // We signal the error by calling OnReadComplete with a bytes_read of -1.
 613       request_->NotifyReadCompleted(-1);
 614     } else {
 615       has_handled_response_ = true;
 616       request_->NotifyResponseStarted();
 617     }
 618   }
 619 }
 620
 621 void URLRequestJob::NotifyCanceled() {
 622   if (!done_) {
 623     NotifyDone(URLRequestStatus(URLRequestStatus::CANCELED, ERR_ABORTED));
 624   }
 625 }
 626
 627 void URLRequestJob::NotifyRestartRequired() {
 628   DCHECK(!has_handled_response_);
 629   if (GetStatus().status() != URLRequestStatus::CANCELED)
 630     request_->Restart();
 631 }
 632
 633 void URLRequestJob::OnCallToDelegate() {
 634   request_->OnCallToDelegate();
 635 }
 636
 637 void URLRequestJob::OnCallToDelegateComplete() {
 638   request_->OnCallToDelegateComplete();
 639 }
 640
 641 bool URLRequestJob::ReadRawData(IOBuffer* buf, int buf_size,
 642                                 int *bytes_read) {
 643   DCHECK(bytes_read);
 644   *bytes_read = 0;
 645   return true;
 646 }
 647
 648 void URLRequestJob::DoneReading() {
 649   // Do nothing.
 650 }
 651
 652 void URLRequestJob::DoneReadingRedirectResponse() {
 653 }
 654
 655 void URLRequestJob::FilteredDataRead(int bytes_read) {
 656   DCHECK(filter_);
 657   filter_->FlushStreamBuffer(bytes_read);
 658 }
 659
 660 bool URLRequestJob::ReadFilteredData(int* bytes_read) {
 661   DCHECK(filter_);
 662   DCHECK(filtered_read_buffer_.get());
 663   DCHECK_GT(filtered_read_buffer_len_, 0);
 664   DCHECK_LT(filtered_read_buffer_len_, 1000000);  // Sanity check.
 665   DCHECK(!raw_read_buffer_.get());
 666
 667   *bytes_read = 0;
 668   bool rv = false;
 669
 670   for (;;) {
 671     if (is_done())
 672       return true;
 673
 674     if (!filter_needs_more_output_space_ && !filter_->stream_data_len()) {
 675       // We don't have any raw data to work with, so read from the transaction.
 676       int filtered_data_read;
 677       if (ReadRawDataForFilter(&filtered_data_read)) {
 678         if (filtered_data_read > 0) {
 679           // Give data to filter.
 680           filter_->FlushStreamBuffer(filtered_data_read);
 681         } else {
 682           return true;  // EOF.
 683         }
 684       } else {
 685         return false;  // IO Pending (or error).
 686       }
 687     }
 688
 689     if ((filter_->stream_data_len() || filter_needs_more_output_space_) &&
 690         !is_done()) {
 691       // Get filtered data.
 692       int filtered_data_len = filtered_read_buffer_len_;
 693       int output_buffer_size = filtered_data_len;
 694       Filter::FilterStatus status =
 695           filter_->ReadData(filtered_read_buffer_->data(), &filtered_data_len);
 696
 697       if (filter_needs_more_output_space_ && !filtered_data_len) {
 698         // filter_needs_more_output_space_ was mistaken... there are no more
 699         // bytes and we should have at least tried to fill up the filter's input
 700         // buffer. Correct the state, and try again.
 701         filter_needs_more_output_space_ = false;
 702         continue;
 703       }
 704       filter_needs_more_output_space_ =
 705           (filtered_data_len == output_buffer_size);
 706
 707       switch (status) {
 708         case Filter::FILTER_DONE: {
 709           filter_needs_more_output_space_ = false;
 710           *bytes_read = filtered_data_len;
 711           postfilter_bytes_read_ += filtered_data_len;
 712           rv = true;
 713           break;
 714         }
 715         case Filter::FILTER_NEED_MORE_DATA: {
 716           // We have finished filtering all data currently in the buffer.
 717           // There might be some space left in the output buffer. One can
 718           // consider reading more data from the stream to feed the filter
 719           // and filling up the output buffer. This leads to more complicated
 720           // buffer management and data notification mechanisms.
 721           // We can revisit this issue if there is a real perf need.
 722           if (filtered_data_len > 0) {
 723             *bytes_read = filtered_data_len;
 724             postfilter_bytes_read_ += filtered_data_len;
 725             rv = true;
 726           } else {
 727             // Read again since we haven't received enough data yet (e.g., we
 728             // may not have a complete gzip header yet).
 729             continue;
 730           }
 731           break;
 732         }
 733         case Filter::FILTER_OK: {
 734           *bytes_read = filtered_data_len;
 735           postfilter_bytes_read_ += filtered_data_len;
 736           rv = true;
 737           break;
 738         }
 739         case Filter::FILTER_ERROR: {
 740           DVLOG(1) << __FUNCTION__ << "() "
 741                    << "\"" << (request_ ? request_->url().spec() : "???")
 742                    << "\"" << " Filter Error";
 743           filter_needs_more_output_space_ = false;
 744           NotifyDone(URLRequestStatus(URLRequestStatus::FAILED,
 745                      ERR_CONTENT_DECODING_FAILED));
 746           rv = false;
 747           break;
 748         }
 749         default: {
 750           NOTREACHED();
 751           filter_needs_more_output_space_ = false;
 752           rv = false;
 753           break;
 754         }
 755       }
 756
 757       // If logging all bytes is enabled, log the filtered bytes read.
 758       if (rv && request() && request()->net_log().IsLoggingBytes() &&
 759           filtered_data_len > 0) {
 760         request()->net_log().AddByteTransferEvent(
 761             NetLog::TYPE_URL_REQUEST_JOB_FILTERED_BYTES_READ,
 762             filtered_data_len, filtered_read_buffer_->data());
 763       }
 764     } else {
 765       // we are done, or there is no data left.
 766       rv = true;
 767     }
 768     break;
 769   }
 770
 771   if (rv) {
 772     // When we successfully finished a read, we no longer need to save the
 773     // caller's buffers. Release our reference.
 774     filtered_read_buffer_ = NULL;
 775     filtered_read_buffer_len_ = 0;
 776   }
 777   return rv;
 778 }
 779
 780 void URLRequestJob::DestroyFilters() {
 781   filter_.reset();
 782 }
 783
 784 const URLRequestStatus URLRequestJob::GetStatus() {
 785   if (request_)
 786     return request_->status();
 787   // If the request is gone, we must be cancelled.
 788   return URLRequestStatus(URLRequestStatus::CANCELED,
 789                           ERR_ABORTED);
 790 }
 791
 792 void URLRequestJob::SetStatus(const URLRequestStatus &status) {
 793   if (request_)
 794     request_->set_status(status);
 795 }
 796
 797 void URLRequestJob::SetProxyServer(const HostPortPair& proxy_server) {
 798   request_->proxy_server_ = proxy_server;
 799 }
 800
 801 bool URLRequestJob::ReadRawDataForFilter(int* bytes_read) {
 802   bool rv = false;
 803
 804   DCHECK(bytes_read);
 805   DCHECK(filter_.get());
 806
 807   *bytes_read = 0;
 808
 809   // Get more pre-filtered data if needed.
 810   // TODO(mbelshe): is it possible that the filter needs *MORE* data
 811   //    when there is some data already in the buffer?
 812   if (!filter_->stream_data_len() && !is_done()) {
 813     IOBuffer* stream_buffer = filter_->stream_buffer();
 814     int stream_buffer_size = filter_->stream_buffer_size();
 815     rv = ReadRawDataHelper(stream_buffer, stream_buffer_size, bytes_read);
 816   }
 817   return rv;
 818 }
 819
 820 bool URLRequestJob::ReadRawDataHelper(IOBuffer* buf, int buf_size,
 821                                       int* bytes_read) {
 822   // TODO(vadimt): Remove ScopedTracker below once crbug.com/423948 is fixed.
 823   tracked_objects::ScopedTracker tracking_profile(
 824       FROM_HERE_WITH_EXPLICIT_FUNCTION(
 825           "423948 URLRequestJob::ReadRawDataHelper"));
 826
 827   DCHECK(!request_->status().is_io_pending());
 828   DCHECK(raw_read_buffer_.get() == NULL);
 829
 830   // Keep a pointer to the read buffer, so we have access to it in the
 831   // OnRawReadComplete() callback in the event that the read completes
 832   // asynchronously.
 833   raw_read_buffer_ = buf;
 834   bool rv = ReadRawData(buf, buf_size, bytes_read);
 835
 836   if (!request_->status().is_io_pending()) {
 837     // TODO(vadimt): Remove ScopedTracker below once crbug.com/423948 is fixed.
 838     tracked_objects::ScopedTracker tracking_profile1(
 839         FROM_HERE_WITH_EXPLICIT_FUNCTION(
 840             "423948 URLRequestJob::ReadRawDataHelper1"));
 841
 842     // If the read completes synchronously, either success or failure,
 843     // invoke the OnRawReadComplete callback so we can account for the
 844     // completed read.
 845     OnRawReadComplete(*bytes_read);
 846   }
 847   return rv;
 848 }
 849
 850 void URLRequestJob::FollowRedirect(const RedirectInfo& redirect_info) {
 851   int rv = request_->Redirect(redirect_info);
 852   if (rv != OK)
 853     NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, rv));
 854 }
 855
 856 void URLRequestJob::OnRawReadComplete(int bytes_read) {
 857   DCHECK(raw_read_buffer_.get());
 858   // If |filter_| is non-NULL, bytes will be logged after it is applied instead.
 859   if (!filter_.get() && request() && request()->net_log().IsLoggingBytes() &&
 860       bytes_read > 0) {
 861     request()->net_log().AddByteTransferEvent(
 862         NetLog::TYPE_URL_REQUEST_JOB_BYTES_READ,
 863         bytes_read, raw_read_buffer_->data());
 864   }
 865
 866   if (bytes_read > 0) {
 867     RecordBytesRead(bytes_read);
 868   }
 869   raw_read_buffer_ = NULL;
 870 }
 871
 872 void URLRequestJob::RecordBytesRead(int bytes_read) {
 873   filter_input_byte_count_ += bytes_read;
 874   prefilter_bytes_read_ += bytes_read;
 875   if (!filter_.get())
 876     postfilter_bytes_read_ += bytes_read;
 877   DVLOG(2) << __FUNCTION__ << "() "
 878            << "\"" << (request_ ? request_->url().spec() : "???") << "\""
 879            << " pre bytes read = " << bytes_read
 880            << " pre total = " << prefilter_bytes_read_
 881            << " post total = " << postfilter_bytes_read_;
 882   UpdatePacketReadTimes();  // Facilitate stats recording if it is active.
 883   if (network_delegate_) {
 884     // TODO(vadimt): Remove ScopedTracker below once crbug.com/423948 is fixed.
 885     tracked_objects::ScopedTracker tracking_profile(
 886         FROM_HERE_WITH_EXPLICIT_FUNCTION(
 887             "423948 URLRequestJob::RecordBytesRead NotifyRawBytesRead"));
 888
 889     network_delegate_->NotifyRawBytesRead(*request_, bytes_read);
 890   }
 891 }
 892
 893 bool URLRequestJob::FilterHasData() {
 894     return filter_.get() && filter_->stream_data_len();
 895 }
 896
 897 void URLRequestJob::UpdatePacketReadTimes() {
 898 }
 899
 900 RedirectInfo URLRequestJob::ComputeRedirectInfo(const GURL& location,
 901                                                 int http_status_code) {
 902   const GURL& url = request_->url();
 903
 904   RedirectInfo redirect_info;
 905
 906   redirect_info.status_code = http_status_code;
 907
 908   // The request method may change, depending on the status code.
 909   redirect_info.new_method = URLRequest::ComputeMethodForRedirect(
 910       request_->method(), http_status_code);
 911
 912   // Move the reference fragment of the old location to the new one if the
 913   // new one has none. This duplicates mozilla's behavior.
 914   if (url.is_valid() && url.has_ref() && !location.has_ref() &&
 915       CopyFragmentOnRedirect(location)) {
 916     GURL::Replacements replacements;
 917     // Reference the |ref| directly out of the original URL to avoid a
 918     // malloc.
 919     replacements.SetRef(url.spec().data(),
 920                         url.parsed_for_possibly_invalid_spec().ref);
 921     redirect_info.new_url = location.ReplaceComponents(replacements);
 922   } else {
 923     redirect_info.new_url = location;
 924   }
 925
 926   // Update the first-party URL if appropriate.
 927   if (request_->first_party_url_policy() ==
 928           URLRequest::UPDATE_FIRST_PARTY_URL_ON_REDIRECT) {
 929     redirect_info.new_first_party_for_cookies = redirect_info.new_url;
 930   } else {
 931     redirect_info.new_first_party_for_cookies =
 932         request_->first_party_for_cookies();
 933   }
 934
 935   // Alter the referrer if redirecting cross-origin (especially HTTP->HTTPS).
 936   redirect_info.new_referrer =
 937       ComputeReferrerForRedirect(request_->referrer_policy(),
 938                                  request_->referrer(),
 939                                  redirect_info.new_url).spec();
 940
 941   return redirect_info;
 942 }
 943
 944 }  // namespace net