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

net/quic/quic_chromium_client_session.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_chromium_client_session.h"
 
 #include <utility>
 
 #include "base/callback_helpers.h"
 #include "base/location.h"
@@ skipping 139 matching lines @@
   return rv;
 }
 
 void QuicChromiumClientSession::StreamRequest::CancelRequest() {
   if (session_)
     session_->CancelRequest(this);
   session_.reset();
   callback_.Reset();
 }
 
+void QuicChromiumClientSession::StreamRequest::PopulateNetErrorDetails(
+    NetErrorDetails* details) {
+  if (session_)
+    session_->PopulateNetErrorDetails(details);
+}
+
 void QuicChromiumClientSession::StreamRequest::OnRequestCompleteSuccess(
     QuicChromiumClientStream* stream) {
   session_.reset();
   *stream_ = stream;
   base::ResetAndReturn(&callback_).Run(OK);
 }
 
 void QuicChromiumClientSession::StreamRequest::OnRequestCompleteFailure(
     int rv) {
   session_.reset();
@@ skipping 28 matching lines @@
       server_info_(std::move(server_info)),
       num_total_streams_(0),
       task_runner_(task_runner),
       net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_QUIC_SESSION)),
       dns_resolution_end_time_(dns_resolution_end_time),
       logger_(new QuicConnectionLogger(this,
                                        connection_description,
                                        std::move(socket_performance_watcher),
                                        net_log_)),
       going_away_(false),
+      received_goaway_because_of_migrating_port_(false),
       disabled_reason_(QUIC_DISABLED_NOT),
       token_binding_signatures_(kTokenBindingSignatureMapSize),
       weak_factory_(this) {
   sockets_.push_back(std::move(socket));
   packet_readers_.push_back(make_scoped_ptr(new QuicChromiumPacketReader(
       sockets_.back().get(), clock, this, yield_after_packets,
       yield_after_duration, net_log_)));
   crypto_stream_.reset(
       crypto_client_stream_factory->CreateQuicCryptoClientStream(
           server_id, this, make_scoped_ptr(new ProofVerifyContextChromium(
@@ skipping 535 matching lines @@
 }
 
 void QuicChromiumClientSession::OnCryptoHandshakeMessageReceived(
     const CryptoHandshakeMessage& message) {
   logger_->OnCryptoHandshakeMessageReceived(message);
 }
 
 void QuicChromiumClientSession::OnGoAway(const QuicGoAwayFrame& frame) {
   QuicSession::OnGoAway(frame);
   NotifyFactoryOfSessionGoingAway();
+  received_goaway_because_of_migrating_port_ =
+      frame.error_code == QUIC_ERROR_MIGRATING_PORT;
 }
 
 void QuicChromiumClientSession::OnRstStream(const QuicRstStreamFrame& frame) {
   QuicSession::OnRstStream(frame);
   OnClosedStream();
 }
 
 void QuicChromiumClientSession::OnConnectionClosed(
     QuicErrorCode error,
     ConnectionCloseSource source) {
@@ skipping 318 matching lines @@
   }
   // TODO(jri): Make SetQuicPacketWriter take a scoped_ptr.
   connection()->SetQuicPacketWriter(writer.release(), /*owns_writer=*/true);
   packet_readers_.push_back(std::move(reader));
   sockets_.push_back(std::move(socket));
   StartReading();
   connection()->SendPing();
   return true;
 }
 
+void QuicChromiumClientSession::PopulateNetErrorDetails(
+    NetErrorDetails* details) {
+  details->received_goaway_because_of_migrating_port =
+      received_goaway_because_of_migrating_port_;
+}
+
 const DatagramClientSocket* QuicChromiumClientSession::GetDefaultSocket()
     const {
   DCHECK(sockets_.back().get() != nullptr);
   // The most recently added socket is the currently active one.
   return sockets_.back().get();
 }
 
 bool QuicChromiumClientSession::IsAuthorized(const std::string& hostname) {
   return CanPool(hostname, server_id_.privacy_mode());
 }
 
 bool QuicChromiumClientSession::HasNonMigratableStreams() const {
   for (const auto& stream : dynamic_streams()) {
     if (!static_cast<QuicChromiumClientStream*>(stream.second)->can_migrate())
       return true;
   }
   return false;
 }
 
 }  // namespace net