Retry upon 421 status code without IP pooling.

net/http/http_network_transaction.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_network_transaction.h"
 
 #include <memory>
 #include <set>
 #include <utility>
 #include <vector>
@@ skipping 82 matching lines @@
       session_(session),
       request_(NULL),
       priority_(priority),
       headers_valid_(false),
       request_headers_(),
       read_buf_len_(0),
       total_received_bytes_(0),
       total_sent_bytes_(0),
       next_state_(STATE_NONE),
       establishing_tunnel_(false),
+      enable_ip_based_pooling_(true),
       websocket_handshake_stream_base_create_helper_(NULL),
-      net_error_details_() {
-}
+      net_error_details_() {}
 
 HttpNetworkTransaction::~HttpNetworkTransaction() {
   if (stream_.get()) {
     // TODO(mbelshe): The stream_ should be able to compute whether or not the
     //                stream should be kept alive.  No reason to compute here
     //                and pass it in.
     if (!stream_->CanReuseConnection() || next_state_ != STATE_NONE) {
       stream_->Close(true /* not reusable */);
     } else if (stream_->IsResponseBodyComplete()) {
       // If the response body is complete, we can just reuse the socket.
@@ skipping 724 matching lines @@
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "424359 HttpNetworkTransaction::DoCreateStream"));
 
   response_.network_accessed = true;
 
   next_state_ = STATE_CREATE_STREAM_COMPLETE;
   if (ForWebSocketHandshake()) {
     stream_request_.reset(
         session_->http_stream_factory_for_websocket()
             ->RequestWebSocketHandshakeStream(
-                  *request_,
-                  priority_,
-                  server_ssl_config_,
-                  proxy_ssl_config_,
-                  this,
-                  websocket_handshake_stream_base_create_helper_,
-                  net_log_));
+                *request_, priority_, server_ssl_config_, proxy_ssl_config_,
+                this, websocket_handshake_stream_base_create_helper_,
+                enable_ip_based_pooling_, net_log_));
   } else {
-    stream_request_.reset(
-        session_->http_stream_factory()->RequestStream(
-            *request_,
-            priority_,
-            server_ssl_config_,
-            proxy_ssl_config_,
-            this,
-            net_log_));
+    stream_request_.reset(session_->http_stream_factory()->RequestStream(
+        *request_, priority_, server_ssl_config_, proxy_ssl_config_, this,
+        enable_ip_based_pooling_, net_log_));
   }
   DCHECK(stream_request_.get());
   return ERR_IO_PENDING;
 }
 
 int HttpNetworkTransaction::DoCreateStreamComplete(int result) {
   // If |result| is ERR_HTTPS_PROXY_TUNNEL_RESPONSE, then
   // DoCreateStreamComplete is being called from OnHttpsProxyTunnelResponse,
   // which resets the stream request first. Therefore, we have to grab the
   // connection attempts in *that* function instead of here in that case.
@@ skipping 409 matching lines @@
   // We treat any other 1xx in this same way (although in practice getting
   // a 1xx that isn't a 100 is rare).
   // Unless this is a WebSocket request, in which case we pass it on up.
   if (response_.headers->response_code() / 100 == 1 &&
       !ForWebSocketHandshake()) {
     response_.headers = new HttpResponseHeaders(std::string());
     next_state_ = STATE_READ_HEADERS;
     return OK;
   }
 
+  if (response_.headers->response_code() == 421) {
+    return HandleIOError(ERR_MISDIRECTED_REQUEST);
+  }
+
   if (IsSecureRequest()) {
     session_->http_stream_factory()->ProcessAlternativeServices(
         session_, response_.headers.get(), url::SchemeHostPort(request_->url));
   }
 
   if (IsSecureRequest())
     stream_->GetSSLInfo(&response_.ssl_info);
 
   int rv = HandleAuthChallenge();
   if (rv != OK)
@@ skipping 234 matching lines @@
       }
       break;
     case ERR_SPDY_PING_FAILED:
     case ERR_SPDY_SERVER_REFUSED_STREAM:
     case ERR_QUIC_HANDSHAKE_FAILED:
       net_log_.AddEventWithNetErrorCode(
           NetLogEventType::HTTP_TRANSACTION_RESTART_AFTER_ERROR, error);
       ResetConnectionAndRequestForResend();
       error = OK;
       break;
+    case ERR_MISDIRECTED_REQUEST:

[Ryan Hamilton, 2017/03/30 23:51:07]

It's a bit weird that ERR_MISDIRECTED_REQUEST is a new error code which is only
used in a single .cc file. It seems like we could just do the retry inline when
we find the 421 status code. But HTTP_TRANSACTION_RESTART_AFTER_ERROR seems
logical, so adding a new error seems reasonable.

[Bence, 2017/03/31 00:09:33]

Yes, I absolutely agree with you.  I was thinking about inlining, but decided
that introducing a new net error code is worth the clarity we get in NetLog.

+      // If this is the second try, just give up.
+      if (!enable_ip_based_pooling_)
+        return OK;
+      // Otherwise, since the response status was 421 Misdirected Request,
+      // retry the request with IP based pooling disabled.
+      enable_ip_based_pooling_ = false;
+      net_log_.AddEventWithNetErrorCode(
+          NetLogEventType::HTTP_TRANSACTION_RESTART_AFTER_ERROR, error);
+      ResetConnectionAndRequestForResend();
+      error = OK;
+      break;
   }
   return error;
 }
 
 void HttpNetworkTransaction::ResetStateForRestart() {
   ResetStateForAuthRestart();
   if (stream_) {
     total_received_bytes_ += stream_->GetTotalReceivedBytes();
     total_sent_bytes_ += stream_->GetTotalSentBytes();
   }
@@ skipping 146 matching lines @@
   DCHECK(stream_request_);
 
   // Since the transaction can restart with auth credentials, it may create a
   // stream more than once. Accumulate all of the connection attempts across
   // those streams by appending them to the vector:
   for (const auto& attempt : stream_request_->connection_attempts())
     connection_attempts_.push_back(attempt);
 }
 
 }  // namespace net