[Domain Reliabiliy: net stack] Plumb received go away from server due to connection migration.

net/quic/quic_stream_factory.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/quic/quic_stream_factory.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 
@@ skipping 600 matching lines @@
                                                transport_security_state,
                                                cert_transparency_verifier)),
       supported_versions_(supported_versions),
       enable_port_selection_(enable_port_selection),
       always_require_handshake_confirmation_(
           always_require_handshake_confirmation),
       disable_connection_pooling_(disable_connection_pooling),
       load_server_info_timeout_srtt_multiplier_(
           load_server_info_timeout_srtt_multiplier),
       enable_connection_racing_(enable_connection_racing),
+      goaway_received_for_connection_mirgation_(false),
       enable_non_blocking_io_(enable_non_blocking_io),
       disable_disk_cache_(disable_disk_cache),
       prefer_aes_(prefer_aes),
       max_number_of_lossy_connections_(max_number_of_lossy_connections),
       packet_loss_threshold_(packet_loss_threshold),
       max_disabled_reasons_(max_disabled_reasons),
       num_public_resets_post_handshake_(0),
       num_timeouts_with_open_streams_(0),
       max_public_resets_post_handshake_(0),
       max_timeouts_with_open_streams_(0),
@@ skipping 433 matching lines @@
   if (!aliases.empty()) {
     const IPEndPoint peer_address = session->connection()->peer_address();
     ip_aliases_[peer_address].erase(session);
     if (ip_aliases_[peer_address].empty()) {
       ip_aliases_.erase(peer_address);
     }
   }
   session_aliases_.erase(session);
 }
 
+void QuicStreamFactory::OnSessionGoingAwayForConnectionMigration() {
+  goaway_received_for_connection_mirgation_ = true;
+}
+
 void QuicStreamFactory::MaybeDisableQuic(QuicChromiumClientSession* session) {
   DCHECK(session);
   uint16_t port = session->server_id().port();
   if (IsQuicDisabled(port))
     return;
 
   // Expire the oldest disabled_reason if appropriate.  This enforces that we
   // only consider the max_disabled_reasons_ most recent sessions.
   QuicChromiumClientSession::QuicDisabledReason disabled_reason;
   if (static_cast<int>(disabled_reasons_.size()) == max_disabled_reasons_) {
@@ skipping 601 matching lines @@
 
   // Since the session was active, there's no longer an
   // HttpStreamFactoryImpl::Job running which can mark it broken, unless the TCP
   // job also fails. So to avoid not using QUIC when we otherwise could, we mark
   // it as recently broken, which means that 0-RTT will be disabled but we'll
   // still race.
   http_server_properties_->MarkAlternativeServiceRecentlyBroken(
       alternative_service);
 }
 
+void QuicStreamFactory::PopulateNetErrorDetails(NetErrorDetails* details) {
+  details->goaway_received_for_connection_mirgation =
+      goaway_received_for_connection_mirgation_;

[Ryan Hamilton, 2016/03/09 19:53:03]

I don't understand how this works. The HttpNetworkTransaction is associated with
a single request. It then queries the HttpNetworkSession, which queries the
QuicStreamFactory. But the Factory is not associated with a request. It looks
like if there are 2 requests they will both end up getting the same value for
this field, even if one of them does not use QUIC. I think you'll need to move
this logic to something that is per-request (or per stream).

+}
+
 }  // namespace net