Update from https://crrev.com/316786

net/url_request/url_request_http_job.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/url_request/url_request_http_job.h"
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
-#include "base/debug/alias.h"
-#include "base/debug/dump_without_crashing.h"
 #include "base/file_version_info.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/rand_util.h"
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/load_flags.h"
@@ skipping 178 matching lines @@
       done_(false),
       bytes_observed_in_packets_(0),
       request_time_snapshot_(),
       final_packet_time_(),
       filter_context_(new HttpFilterContext(this)),
       on_headers_received_callback_(
           base::Bind(&URLRequestHttpJob::OnHeadersReceivedCallback,
                      base::Unretained(this))),
       awaiting_callback_(false),
       http_user_agent_settings_(http_user_agent_settings),
-      transaction_state_(TRANSACTION_WAS_NOT_INITIALIZED),
       weak_factory_(this) {
   URLRequestThrottlerManager* manager = request->context()->throttler_manager();
   if (manager)
     throttling_entry_ = manager->RegisterRequestUrl(request->url());
 
-  // TODO(battre) Remove this overriding once crbug.com/289715 has been
-  // resolved.
-  on_headers_received_callback_ =
-      base::Bind(&URLRequestHttpJob::OnHeadersReceivedCallbackForDebugging,
-                 weak_factory_.GetWeakPtr());
-
   ResetTimer();
 }
 
 URLRequestHttpJob::~URLRequestHttpJob() {
   CHECK(!awaiting_callback_);
 
   DCHECK(!sdch_test_control_ || !sdch_test_activated_);
   if (!is_cached_content_) {
     if (sdch_test_control_)
       RecordPacketStats(FilterContext::SDCH_EXPERIMENT_HOLDBACK);
@@ skipping 49 matching lines @@
   request_info_.extra_headers.SetHeaderIfMissing(
       HttpRequestHeaders::kUserAgent,
       http_user_agent_settings_ ?
           http_user_agent_settings_->GetUserAgent() : std::string());
 
   AddExtraHeaders();
   AddCookieHeaderAndStart();
 }
 
 void URLRequestHttpJob::Kill() {
-  if (awaiting_callback_) {
-    // TODO(battre) crbug.com/289715
-    // Simulate a crash to see who kills the job while it is waiting for a
-    // callback. This should not happen, see URLRequest::OrphanJob().
-    base::debug::DumpWithoutCrashing();
-  }
   if (!transaction_.get())
     return;
 
   weak_factory_.InvalidateWeakPtrs();
   DestroyTransaction();
   URLRequestJob::Kill();
 }
 
 void URLRequestHttpJob::NotifyBeforeSendProxyHeadersCallback(
     const ProxyInfo& proxy_info,
@@ skipping 106 matching lines @@
 void URLRequestHttpJob::NotifyDone(const URLRequestStatus& status) {
   DoneWithRequest(FINISHED);
   URLRequestJob::NotifyDone(status);
 }
 
 void URLRequestHttpJob::DestroyTransaction() {
   DCHECK(transaction_.get());
 
   DoneWithRequest(ABORTED);
   transaction_.reset();
-  transaction_state_ = TRANSACTION_WAS_DESTROYED;
   response_info_ = NULL;
   receive_headers_end_ = base::TimeTicks();
 }
 
 void URLRequestHttpJob::StartTransaction() {
   if (network_delegate()) {
     OnCallToDelegate();
     int rv = network_delegate()->NotifyBeforeSendHeaders(
         request_, notify_before_headers_sent_callback_,
         &request_info_.extra_headers);
@@ skipping 41 matching lines @@
   }
 
   if (transaction_.get()) {
     rv = transaction_->RestartWithAuth(auth_credentials_, start_callback_);
     auth_credentials_ = AuthCredentials();
   } else {
     DCHECK(request_->context()->http_transaction_factory());
 
     rv = request_->context()->http_transaction_factory()->CreateTransaction(
         priority_, &transaction_);
-    if (rv == OK)
-      transaction_state_ = TRANSACTION_WAS_INITIALIZED;
 
     if (rv == OK && request_info_.url.SchemeIsWSOrWSS()) {
       base::SupportsUserData::Data* data = request_->GetUserData(
           WebSocketHandshakeStreamBase::CreateHelper::DataKey());
       if (data) {
         transaction_->SetWebSocketHandshakeStreamCreateHelper(
             static_cast<WebSocketHandshakeStreamBase::CreateHelper*>(data));
       } else {
         rv = ERR_DISALLOWED_URL_SCHEME;
       }
@@ skipping 445 matching lines @@
         transaction_->GetResponseInfo()->cert_request_info.get());
   } else {
     // Even on an error, there may be useful information in the response
     // info (e.g. whether there's a cached copy).
     if (transaction_.get())
       response_info_ = transaction_->GetResponseInfo();
     NotifyStartError(URLRequestStatus(URLRequestStatus::FAILED, result));
   }
 }
 
-// TODO(battre) Use URLRequestHttpJob::OnHeadersReceivedCallback again, once
-// crbug.com/289715 has been resolved.
-// static
-void URLRequestHttpJob::OnHeadersReceivedCallbackForDebugging(
-    base::WeakPtr<net::URLRequestHttpJob> job,
-    int result) {
-  CHECK(job.get());
-  net::URLRequestHttpJob::TransactionState state = job->transaction_state_;
-  base::debug::Alias(&state);
-  CHECK(job->transaction_.get());
-  job->OnHeadersReceivedCallback(result);
-}
-
 void URLRequestHttpJob::OnHeadersReceivedCallback(int result) {
   awaiting_callback_ = false;
 
   // Check that there are no callbacks to already canceled requests.
   DCHECK_NE(URLRequestStatus::CANCELED, GetStatus().status());
 
   SaveCookiesAndNotifyHeadersComplete(result);
 }
 
 void URLRequestHttpJob::OnReadCompleted(int result) {
@@ skipping 63 matching lines @@
   return transaction_.get() ?
       transaction_->GetUploadProgress() : UploadProgress();
 }
 
 bool URLRequestHttpJob::GetMimeType(std::string* mime_type) const {
   DCHECK(transaction_.get());
 
   if (!response_info_)
     return false;
 
-  return GetResponseHeaders()->GetMimeType(mime_type);
+  HttpResponseHeaders* headers = GetResponseHeaders();
+  if (!headers)
+    return false;
+  return headers->GetMimeType(mime_type);
 }
 
 bool URLRequestHttpJob::GetCharset(std::string* charset) {
   DCHECK(transaction_.get());
 
   if (!response_info_)
     return false;
 
   return GetResponseHeaders()->GetCharset(charset);
 }
@@ skipping 415 matching lines @@
                                   base::TimeDelta::FromMilliseconds(20),
                                   base::TimeDelta::FromMinutes(10), 100);
       return;
     }
     default:
       NOTREACHED();
       return;
   }
 }
 
-// The common type of histogram we use for all compression-tracking histograms.
-#define COMPRESSION_HISTOGRAM(name, sample) \
-    do { \
-      UMA_HISTOGRAM_CUSTOM_COUNTS("Net.Compress." name, sample, \
-                                  500, 1000000, 100); \
-    } while (0)
-
-void URLRequestHttpJob::RecordCompressionHistograms() {
-  DCHECK(request_);
-  if (!request_)
-    return;
-
-  if (is_cached_content_ ||                // Don't record cached content
-      !GetStatus().is_success() ||         // Don't record failed content
-      !IsCompressibleContent() ||          // Only record compressible content
-      !prefilter_bytes_read())       // Zero-byte responses aren't useful.
-    return;
-
-  // Miniature requests aren't really compressible. Don't count them.
-  const int kMinSize = 16;
-  if (prefilter_bytes_read() < kMinSize)
-    return;
-
-  // Only record for http or https urls.
-  bool is_http = request_->url().SchemeIs("http");
-  bool is_https = request_->url().SchemeIs("https");
-  if (!is_http && !is_https)
-    return;
-
-  int compressed_B = prefilter_bytes_read();
-  int decompressed_B = postfilter_bytes_read();
-  bool was_filtered = HasFilter();
-
-  // We want to record how often downloaded resources are compressed.
-  // But, we recognize that different protocols may have different
-  // properties. So, for each request, we'll put it into one of 3
-  // groups:
-  //      a) SSL resources
-  //         Proxies cannot tamper with compression headers with SSL.
-  //      b) Non-SSL, loaded-via-proxy resources
-  //         In this case, we know a proxy might have interfered.
-  //      c) Non-SSL, loaded-without-proxy resources
-  //         In this case, we know there was no explicit proxy. However,
-  //         it is possible that a transparent proxy was still interfering.
-  //
-  // For each group, we record the same 3 histograms.
-
-  if (is_https) {
-    if (was_filtered) {
-      COMPRESSION_HISTOGRAM("SSL.BytesBeforeCompression", compressed_B);
-      COMPRESSION_HISTOGRAM("SSL.BytesAfterCompression", decompressed_B);
-    } else {
-      COMPRESSION_HISTOGRAM("SSL.ShouldHaveBeenCompressed", decompressed_B);
-    }
-    return;
-  }
-
-  if (request_->was_fetched_via_proxy()) {
-    if (was_filtered) {
-      COMPRESSION_HISTOGRAM("Proxy.BytesBeforeCompression", compressed_B);
-      COMPRESSION_HISTOGRAM("Proxy.BytesAfterCompression", decompressed_B);
-    } else {
-      COMPRESSION_HISTOGRAM("Proxy.ShouldHaveBeenCompressed", decompressed_B);
-    }
-    return;
-  }
-
-  if (was_filtered) {
-    COMPRESSION_HISTOGRAM("NoProxy.BytesBeforeCompression", compressed_B);
-    COMPRESSION_HISTOGRAM("NoProxy.BytesAfterCompression", decompressed_B);
-  } else {
-    COMPRESSION_HISTOGRAM("NoProxy.ShouldHaveBeenCompressed", decompressed_B);
-  }
-}
-
-bool URLRequestHttpJob::IsCompressibleContent() const {
-  std::string mime_type;
-  return GetMimeType(&mime_type) &&
-      (IsSupportedJavascriptMimeType(mime_type.c_str()) ||
-       IsSupportedNonImageMimeType(mime_type.c_str()));
-}
-
 void URLRequestHttpJob::RecordPerfHistograms(CompletionCause reason) {
   if (start_time_.is_null())
     return;
 
   base::TimeDelta total_time = base::TimeTicks::Now() - start_time_;
   UMA_HISTOGRAM_TIMES("Net.HttpJob.TotalTime", total_time);
 
   if (reason == FINISHED) {
     UMA_HISTOGRAM_TIMES("Net.HttpJob.TotalTimeSuccess", total_time);
   } else {
@@ skipping 15 matching lines @@
   start_time_ = base::TimeTicks();
 }
 
 void URLRequestHttpJob::DoneWithRequest(CompletionCause reason) {
   if (done_)
     return;
   done_ = true;
   RecordPerfHistograms(reason);
   if (reason == FINISHED) {
     request_->set_received_response_content_length(prefilter_bytes_read());
-    RecordCompressionHistograms();
   }
 }
 
 HttpResponseHeaders* URLRequestHttpJob::GetResponseHeaders() const {
   DCHECK(transaction_.get());
   DCHECK(transaction_->GetResponseInfo());
   return override_response_headers_.get() ?
              override_response_headers_.get() :
              transaction_->GetResponseInfo()->headers.get();
 }
 
 void URLRequestHttpJob::NotifyURLRequestDestroyed() {
   awaiting_callback_ = false;
 }
 
 }  // namespace net