Revert CLs landed in HttpStreamFactoryImpl to track down a crasher

net/http/http_stream_factory_impl_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/http/http_stream_factory_impl_job.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/feature_list.h"
 #include "base/location.h"
 #include "base/logging.h"
-#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "base/values.h"
@@ skipping 116 matching lines @@
 // stream.
 std::unique_ptr<base::Value> NetLogHttpStreamProtoCallback(
     NextProto negotiated_protocol,
     NetLogCaptureMode /* capture_mode */) {
   std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
 
   dict->SetString("proto", NextProtoToString(negotiated_protocol));
   return std::move(dict);
 }
 
+// Returns parameters associated with the proxy resolution.
+std::unique_ptr<base::Value> NetLogHttpStreamJobProxyServerResolved(
+    const ProxyServer& proxy_server,
+    NetLogCaptureMode /* capture_mode */) {
+  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+
+  dict->SetString("proxy_server", proxy_server.is_valid()
+                                      ? proxy_server.ToPacString()
+                                      : std::string());
+  return std::move(dict);
+}
+
 HttpStreamFactoryImpl::Job::Job(Delegate* delegate,
                                 JobType job_type,
                                 HttpNetworkSession* session,
                                 const HttpRequestInfo& request_info,
                                 RequestPriority priority,
-                                const ProxyInfo& proxy_info,
                                 const SSLConfig& server_ssl_config,
                                 const SSLConfig& proxy_ssl_config,
                                 HostPortPair destination,
                                 GURL origin_url,
                                 bool enable_ip_based_pooling,
                                 NetLog* net_log)
     : Job(delegate,
           job_type,
           session,
           request_info,
           priority,
-          proxy_info,
           server_ssl_config,
           proxy_ssl_config,
           destination,
           origin_url,
           AlternativeService(),
           ProxyServer(),
           enable_ip_based_pooling,
           net_log) {}
 
 HttpStreamFactoryImpl::Job::Job(Delegate* delegate,
                                 JobType job_type,
                                 HttpNetworkSession* session,
                                 const HttpRequestInfo& request_info,
                                 RequestPriority priority,
-                                const ProxyInfo& proxy_info,
                                 const SSLConfig& server_ssl_config,
                                 const SSLConfig& proxy_ssl_config,
                                 HostPortPair destination,
                                 GURL origin_url,
                                 AlternativeService alternative_service,
                                 const ProxyServer& alternative_proxy_server,
                                 bool enable_ip_based_pooling,
                                 NetLog* net_log)
     : request_info_(request_info),
       priority_(priority),
-      proxy_info_(proxy_info),
       server_ssl_config_(server_ssl_config),
       proxy_ssl_config_(proxy_ssl_config),
       net_log_(
           NetLogWithSource::Make(net_log, NetLogSourceType::HTTP_STREAM_JOB)),
       io_callback_(base::Bind(&Job::OnIOComplete, base::Unretained(this))),
       connection_(new ClientSocketHandle),
       session_(session),
       state_(STATE_NONE),
       next_state_(STATE_NONE),
+      pac_request_(NULL),
       destination_(destination),
       origin_url_(origin_url),
       alternative_service_(alternative_service),
       alternative_proxy_server_(alternative_proxy_server),
       enable_ip_based_pooling_(enable_ip_based_pooling),
       delegate_(delegate),
       job_type_(job_type),
       using_ssl_(origin_url_.SchemeIs(url::kHttpsScheme) ||
                  origin_url_.SchemeIs(url::kWssScheme)),
       using_spdy_(false),
       using_quic_(false),
-      should_reconsider_proxy_(false),
       quic_request_(session_->quic_stream_factory()),
       using_existing_quic_session_(false),
       establishing_tunnel_(false),
       was_alpn_negotiated_(false),
       negotiated_protocol_(kProtoUnknown),
       num_streams_(0),
       spdy_session_direct_(false),
       stream_type_(HttpStreamRequest::BIDIRECTIONAL_STREAM),
       ptr_factory_(this) {
   DCHECK(session);
@@ skipping 28 matching lines @@
   net_log_.EndEvent(NetLogEventType::HTTP_STREAM_JOB);
 
   // When we're in a partially constructed state, waiting for the user to
   // provide certificate handling information or authentication, we can't reuse
   // this stream at all.
   if (next_state_ == STATE_WAITING_USER_ACTION) {
     connection_->socket()->Disconnect();
     connection_.reset();
   }
 
+  if (pac_request_)
+    session_->proxy_service()->CancelPacRequest(pac_request_);
+
   // The stream could be in a partial state.  It is not reusable.
   if (stream_.get() && next_state_ != STATE_DONE)
     stream_->Close(true /* not reusable */);
 }
 
 void HttpStreamFactoryImpl::Job::Start(
     HttpStreamRequest::StreamType stream_type) {
   stream_type_ = stream_type;
   StartInternal();
 }
@@ skipping 24 matching lines @@
 int HttpStreamFactoryImpl::Job::RestartTunnelWithProxyAuth() {
   DCHECK(establishing_tunnel_);
   next_state_ = STATE_RESTART_TUNNEL_AUTH;
   stream_.reset();
   RunLoop(OK);
   return ERR_IO_PENDING;
 }
 
 LoadState HttpStreamFactoryImpl::Job::GetLoadState() const {
   switch (next_state_) {
+    case STATE_RESOLVE_PROXY_COMPLETE:
+      return session_->proxy_service()->GetLoadState(pac_request_);
     case STATE_INIT_CONNECTION_COMPLETE:
     case STATE_CREATE_STREAM_COMPLETE:
       return using_quic_ ? LOAD_STATE_CONNECTING : connection_->GetLoadState();
     default:
       return LOAD_STATE_IDLE;
   }
 }
 
 void HttpStreamFactoryImpl::Job::Resume() {
   DCHECK_EQ(job_type_, MAIN);
@@ skipping 76 matching lines @@
 }
 
 SpdySessionKey HttpStreamFactoryImpl::Job::GetSpdySessionKey() const {
   // In the case that we're using an HTTPS proxy for an HTTP url,
   // we look for a SPDY session *to* the proxy, instead of to the
   // origin server.
   if (IsHttpsProxyAndHttpUrl()) {
     return SpdySessionKey(proxy_info_.proxy_server().host_port_pair(),
                           ProxyServer::Direct(), PRIVACY_MODE_DISABLED);
   }
-  return SpdySessionKey(HostPortPair::FromURL(origin_url_),
-                        proxy_info_.proxy_server(), request_info_.privacy_mode);
+  return SpdySessionKey(destination_, proxy_info_.proxy_server(),
+                        request_info_.privacy_mode);
 }
 
 bool HttpStreamFactoryImpl::Job::CanUseExistingSpdySession() const {
   // We need to make sure that if a spdy session was created for
   // https://somehost/ that we don't use that session for http://somehost:443/.
   // The only time we can use an existing session is if the request URL is
   // https (the normal case) or if we're connection to a SPDY proxy.
   // https://crbug.com/133176
   // TODO(ricea): Add "wss" back to this list when SPDY WebSocket support is
   // working.
@@ skipping 252 matching lines @@
   do {
     State state = next_state_;
     // Added to investigate crbug.com/711721.
     state_ = state;
     next_state_ = STATE_NONE;
     switch (state) {
       case STATE_START:
         DCHECK_EQ(OK, rv);
         rv = DoStart();
         break;
+      case STATE_RESOLVE_PROXY:
+        DCHECK_EQ(OK, rv);
+        rv = DoResolveProxy();
+        break;
+      case STATE_RESOLVE_PROXY_COMPLETE:
+        rv = DoResolveProxyComplete(rv);
+        break;
       case STATE_WAIT:
         DCHECK_EQ(OK, rv);
         rv = DoWait();
         break;
       case STATE_WAIT_COMPLETE:
         rv = DoWaitComplete(rv);
         break;
       case STATE_INIT_CONNECTION:
         DCHECK_EQ(OK, rv);
         rv = DoInitConnection();
@@ skipping 46 matching lines @@
     net_log->AddEvent(NetLogEventType::HTTP_STREAM_REQUEST_STARTED_JOB,
                       net_log_.source().ToEventParametersCallback());
   }
 
   // Don't connect to restricted ports.
   if (!IsPortAllowedForScheme(destination_.port(),
                               request_info_.url.scheme())) {
     return ERR_UNSAFE_PORT;
   }
 
-  next_state_ = STATE_WAIT;
+  next_state_ = STATE_RESOLVE_PROXY;
   return OK;
 }
 
+int HttpStreamFactoryImpl::Job::DoResolveProxy() {
+  DCHECK(!pac_request_);
+  DCHECK(session_);
+
+  next_state_ = STATE_RESOLVE_PROXY_COMPLETE;
+
+  if (request_info_.load_flags & LOAD_BYPASS_PROXY) {
+    proxy_info_.UseDirect();
+    return OK;
+  }
+
+  // If an alternative proxy server was provided, use that.
+  if (alternative_proxy_server_.is_valid()) {
+    proxy_info_.UseProxyServer(alternative_proxy_server_);
+    return OK;
+  }
+
+  return session_->proxy_service()->ResolveProxy(
+      origin_url_, request_info_.method, &proxy_info_, io_callback_,
+      &pac_request_, session_->params().proxy_delegate, net_log_);
+}
+
+int HttpStreamFactoryImpl::Job::DoResolveProxyComplete(int result) {
+  pac_request_ = NULL;
+
+  net_log_.AddEvent(
+      NetLogEventType::HTTP_STREAM_JOB_PROXY_SERVER_RESOLVED,
+      base::Bind(
+          &NetLogHttpStreamJobProxyServerResolved,
+          proxy_info_.is_empty() ? ProxyServer() : proxy_info_.proxy_server()));
+
+  if (result == OK) {
+    // Remove unsupported proxies from the list.
+    int supported_proxies =
+        ProxyServer::SCHEME_DIRECT | ProxyServer::SCHEME_HTTP |
+        ProxyServer::SCHEME_HTTPS | ProxyServer::SCHEME_SOCKS4 |
+        ProxyServer::SCHEME_SOCKS5;
+
+    if (session_->IsQuicEnabled())
+      supported_proxies |= ProxyServer::SCHEME_QUIC;
+
+    proxy_info_.RemoveProxiesWithoutScheme(supported_proxies);
+
+    if (proxy_info_.is_empty()) {
+      // No proxies/direct to choose from. This happens when we don't support
+      // any of the proxies in the returned list.
+      result = ERR_NO_SUPPORTED_PROXIES;
+    } else if (using_quic_ &&
+               (!proxy_info_.is_quic() && !proxy_info_.is_direct())) {
+      // QUIC can not be spoken to non-QUIC proxies.  This error should not be
+      // user visible, because the non-alternative Job should be resumed.
+      result = ERR_NO_SUPPORTED_PROXIES;
+    }
+  }
+
+  if (result != OK) {
+    return result;
+  }
+
+  next_state_ = STATE_WAIT;
+
+  delegate_->OnResolveProxyComplete(this, request_info_, priority_,
+                                    server_ssl_config_, proxy_ssl_config_,
+                                    stream_type_);
+
+  return OK;
+}
+
 bool HttpStreamFactoryImpl::Job::ShouldForceQuic() const {
   return session_->IsQuicEnabled() &&
          (base::ContainsKey(session_->params().origins_to_force_quic_on,
                             HostPortPair()) ||
           base::ContainsKey(session_->params().origins_to_force_quic_on,
                             destination_)) &&
          proxy_info_.is_direct() && origin_url_.SchemeIs(url::kHttpsScheme);
 }
 
 int HttpStreamFactoryImpl::Job::DoWait() {
@@ skipping 22 matching lines @@
 
   return result;
 }
 
 int HttpStreamFactoryImpl::Job::DoInitConnectionImpl() {
   // TODO(pkasting): Remove ScopedTracker below once crbug.com/462812 is fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "462812 HttpStreamFactoryImpl::Job::DoInitConnection"));
   DCHECK(!connection_->is_initialized());
-
-  if (using_quic_ && !proxy_info_.is_quic() && !proxy_info_.is_direct()) {
-    // QUIC can not be spoken to non-QUIC proxies.  This error should not be
-    // user visible, because the non-alternative Job should be resumed.
-    return ERR_NO_SUPPORTED_PROXIES;
-  }
-
   DCHECK(proxy_info_.proxy_server().is_valid());
   next_state_ = STATE_INIT_CONNECTION_COMPLETE;
 
   if (delegate_->OnInitConnection(proxy_info_)) {
     // Return since the connection initialization can be skipped.
     return OK;
   }
 
   using_spdy_ = false;
 
@@ skipping 251 matching lines @@
         // Quic session is closed before stream can be created.
         return ERR_CONNECTION_CLOSED;
       }
     }
     next_state_ = STATE_NONE;
     return OK;
   }
 
   if (result < 0 && !ssl_started)
     return ReconsiderProxyAfterError(result);
-
   establishing_tunnel_ = false;
 
   // Handle SSL errors below.
   if (using_ssl_) {
     DCHECK(ssl_started);
     if (IsCertificateError(result)) {
       result = HandleCertificateError(result);
       if (result == OK && !connection_->socket()->IsConnectedAndIdle()) {
         ReturnToStateInitConnection(true /* close connection */);
         return result;
@@ skipping 247 matching lines @@
 
   if (request_info_.load_flags & LOAD_VERIFY_EV_CERT)
     ssl_config->verify_ev_cert = true;
 
   // Disable Channel ID if privacy mode is enabled.
   if (request_info_.privacy_mode == PRIVACY_MODE_ENABLED)
     ssl_config->channel_id_enabled = false;
 }
 
 int HttpStreamFactoryImpl::Job::ReconsiderProxyAfterError(int error) {
+  DCHECK(!pac_request_);
+  DCHECK(session_);
+
+  // A failure to resolve the hostname or any error related to establishing a
+  // TCP connection could be grounds for trying a new proxy configuration.
+  //
+  // Why do this when a hostname cannot be resolved?  Some URLs only make sense
+  // to proxy servers.  The hostname in those URLs might fail to resolve if we
+  // are still using a non-proxy config.  We need to check if a proxy config
+  // now exists that corresponds to a proxy server that could load the URL.
+  //
   switch (error) {
     case ERR_PROXY_CONNECTION_FAILED:
     case ERR_NAME_NOT_RESOLVED:
     case ERR_INTERNET_DISCONNECTED:
     case ERR_ADDRESS_UNREACHABLE:
     case ERR_CONNECTION_CLOSED:
     case ERR_CONNECTION_TIMED_OUT:
     case ERR_CONNECTION_RESET:
     case ERR_CONNECTION_REFUSED:
     case ERR_CONNECTION_ABORTED:
@@ skipping 18 matching lines @@
       //
       // Note that if the host resolving was done by the SOCKS5 proxy, we can't
       // differentiate between a proxy-side "host not found" versus a proxy-side
       // "address unreachable" error, and will report both of these failures as
       // ERR_ADDRESS_UNREACHABLE.
       return ERR_ADDRESS_UNREACHABLE;
     default:
       return error;
   }
 
+  // Do not bypass non-QUIC proxy on ERR_MSG_TOO_BIG.
+  if (!proxy_info_.is_quic() && error == ERR_MSG_TOO_BIG)
+    return error;
+
+  if (request_info_.load_flags & LOAD_BYPASS_PROXY)
+    return error;
+
   // Alternative proxy server job should not use fallback proxies, and instead
   // return. This would resume the main job (if possible) which may try the
   // fallback proxies.
-  if (alternative_proxy_server().is_valid()) {
+  if (alternative_proxy_server_.is_valid()) {
     DCHECK_EQ(STATE_NONE, next_state_);
     return error;
   }
 
-  should_reconsider_proxy_ = true;
-  return error;
+  if (proxy_info_.is_https() && proxy_ssl_config_.send_client_cert) {
+    session_->ssl_client_auth_cache()->Remove(
+        proxy_info_.proxy_server().host_port_pair());
+  }
+
+  int rv = session_->proxy_service()->ReconsiderProxyAfterError(
+      request_info_.url, request_info_.method, error, &proxy_info_,
+      io_callback_, &pac_request_, session_->params().proxy_delegate, net_log_);
+  if (rv == OK || rv == ERR_IO_PENDING) {
+    // If the error was during connection setup, there is no socket to
+    // disconnect.
+    if (connection_->socket())
+      connection_->socket()->Disconnect();
+    connection_->Reset();
+    delegate_->RemoveRequestFromSpdySessionRequestMapForJob(this);
+    next_state_ = STATE_RESOLVE_PROXY_COMPLETE;
+  } else {
+    // If ReconsiderProxyAfterError() failed synchronously, it means
+    // there was nothing left to fall-back to, so fail the transaction
+    // with the last connection error we got.
+    // TODO(eroman): This is a confusing contract, make it more obvious.
+    rv = error;
+  }
+
+  return rv;
 }
 
 int HttpStreamFactoryImpl::Job::HandleCertificateError(int error) {
   DCHECK(using_ssl_);
   DCHECK(IsCertificateError(error));
 
   SSLClientSocket* ssl_socket =
       static_cast<SSLClientSocket*>(connection_->socket());
   ssl_socket->GetSSLInfo(&ssl_info_);
 
@@ skipping 41 matching lines @@
     return;
 
   ConnectionAttempts socket_attempts = connection_->connection_attempts();
   if (connection_->socket()) {
     connection_->socket()->GetConnectionAttempts(&socket_attempts);
   }
 
   delegate_->AddConnectionAttemptsToRequest(this, socket_attempts);
 }
 
-HttpStreamFactoryImpl::JobFactory::JobFactory() {}
-
-HttpStreamFactoryImpl::JobFactory::~JobFactory() {}
-
-std::unique_ptr<HttpStreamFactoryImpl::Job>
-HttpStreamFactoryImpl::JobFactory::CreateMainJob(
-    HttpStreamFactoryImpl::Job::Delegate* delegate,
-    HttpStreamFactoryImpl::JobType job_type,
-    HttpNetworkSession* session,
-    const HttpRequestInfo& request_info,
-    RequestPriority priority,
-    const ProxyInfo& proxy_info,
-    const SSLConfig& server_ssl_config,
-    const SSLConfig& proxy_ssl_config,
-    HostPortPair destination,
-    GURL origin_url,
-    bool enable_ip_based_pooling,
-    NetLog* net_log) {
-  return base::MakeUnique<HttpStreamFactoryImpl::Job>(
-      delegate, job_type, session, request_info, priority, proxy_info,
-      server_ssl_config, proxy_ssl_config, destination, origin_url,
-      enable_ip_based_pooling, net_log);
-}
-
-std::unique_ptr<HttpStreamFactoryImpl::Job>
-HttpStreamFactoryImpl::JobFactory::CreateAltSvcJob(
-    HttpStreamFactoryImpl::Job::Delegate* delegate,
-    HttpStreamFactoryImpl::JobType job_type,
-    HttpNetworkSession* session,
-    const HttpRequestInfo& request_info,
-    RequestPriority priority,
-    const ProxyInfo& proxy_info,
-    const SSLConfig& server_ssl_config,
-    const SSLConfig& proxy_ssl_config,
-    HostPortPair destination,
-    GURL origin_url,
-    AlternativeService alternative_service,
-    bool enable_ip_based_pooling,
-    NetLog* net_log) {
-  return base::MakeUnique<HttpStreamFactoryImpl::Job>(
-      delegate, job_type, session, request_info, priority, proxy_info,
-      server_ssl_config, proxy_ssl_config, destination, origin_url,
-      alternative_service, ProxyServer(), enable_ip_based_pooling, net_log);
-}
-
-std::unique_ptr<HttpStreamFactoryImpl::Job>
-HttpStreamFactoryImpl::JobFactory::CreateAltProxyJob(
-    HttpStreamFactoryImpl::Job::Delegate* delegate,
-    HttpStreamFactoryImpl::JobType job_type,
-    HttpNetworkSession* session,
-    const HttpRequestInfo& request_info,
-    RequestPriority priority,
-    const ProxyInfo& proxy_info,
-    const SSLConfig& server_ssl_config,
-    const SSLConfig& proxy_ssl_config,
-    HostPortPair destination,
-    GURL origin_url,
-    const ProxyServer& alternative_proxy_server,
-    bool enable_ip_based_pooling,
-    NetLog* net_log) {
-  return base::MakeUnique<HttpStreamFactoryImpl::Job>(
-      delegate, job_type, session, request_info, priority, proxy_info,
-      server_ssl_config, proxy_ssl_config, destination, origin_url,
-      AlternativeService(), alternative_proxy_server, enable_ip_based_pooling,
-      net_log);
-}
-
 }  // namespace net