[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 741 matching lines @@
   }
 }
 
 void QuicChromiumClientSession::OnCryptoHandshakeMessageReceived(
     const CryptoHandshakeMessage& message) {
   logger_->OnCryptoHandshakeMessageReceived(message);
 }
 
 void QuicChromiumClientSession::OnGoAway(const QuicGoAwayFrame& frame) {
   QuicSession::OnGoAway(frame);
-  NotifyFactoryOfSessionGoingAway();
+  NotifyFactoryOfSessionGoingAway(frame.reason_phrase ==
+                                  "peer connection migration");
 }
 
 void QuicChromiumClientSession::OnRstStream(const QuicRstStreamFrame& frame) {
   QuicSession::OnRstStream(frame);
   OnClosedStream();
 }
 
 void QuicChromiumClientSession::OnConnectionClosed(
     QuicErrorCode error,
     ConnectionCloseSource source) {
@@ skipping 69 matching lines @@
       UMA_HISTOGRAM_SPARSE_SLOWLY(
           "Net.QuicSession.ConnectionClose.HandshakeFailureUnknown.QuicError",
           error);
     }
   } else if (error == QUIC_PUBLIC_RESET) {
     disabled_reason_ = QUIC_DISABLED_PUBLIC_RESET_POST_HANDSHAKE;
   }
 
   UMA_HISTOGRAM_SPARSE_SLOWLY("Net.QuicSession.QuicVersion",
                               connection()->version());
-  NotifyFactoryOfSessionGoingAway();
+  NotifyFactoryOfSessionGoingAway(false);
   QuicSession::OnConnectionClosed(error, source);
 
   if (!callback_.is_null()) {
     base::ResetAndReturn(&callback_).Run(ERR_QUIC_PROTOCOL_ERROR);
   }
 
   for (auto& socket : sockets_) {
     socket->Close();
   }
   DCHECK(dynamic_streams().empty());
@@ skipping 145 matching lines @@
     int result,
     const DatagramClientSocket* socket) {
   DCHECK(socket != nullptr);
   if (socket != GetDefaultSocket()) {
     // Ignore read errors from old sockets that are no longer active.
     // TODO(jri): Maybe clean up old sockets on error.
     return;
   }
   DVLOG(1) << "Closing session on read error: " << result;
   UMA_HISTOGRAM_SPARSE_SLOWLY("Net.QuicSession.ReadError", -result);
-  NotifyFactoryOfSessionGoingAway();
+  NotifyFactoryOfSessionGoingAway(false);
   CloseSessionOnErrorInner(result, QUIC_PACKET_READ_ERROR);
   NotifyFactoryOfSessionClosedLater();
 }
 
 bool QuicChromiumClientSession::OnPacket(const QuicEncryptedPacket& packet,
                                          IPEndPoint local_address,
                                          IPEndPoint peer_address) {
   ProcessUdpPacket(local_address, peer_address, packet);
   if (!connection()->connected()) {
     NotifyFactoryOfSessionClosedLater();
     return false;
   }
   return true;
 }
 
-void QuicChromiumClientSession::NotifyFactoryOfSessionGoingAway() {
+void QuicChromiumClientSession::NotifyFactoryOfSessionGoingAway(
+    bool is_connection_migrated) {
   going_away_ = true;
-  if (stream_factory_)
+  if (stream_factory_) {
     stream_factory_->OnSessionGoingAway(this);
+    if (is_connection_migrated)
+      stream_factory_->OnSessionGoingAwayForConnectionMigration();

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

Instead of doing this, can we have the session store some piece of state
(did_server_send_goaway_because_of_migration_) that the factory can query in the
OnSessionGoingAway() method?

+  }
 }
 
 void QuicChromiumClientSession::NotifyFactoryOfSessionClosedLater() {
   if (!dynamic_streams().empty())
     RecordUnexpectedOpenStreams(NOTIFY_FACTORY_OF_SESSION_CLOSED_LATER);
 
   if (!going_away_)
     RecordUnexpectedNotGoingAway(NOTIFY_FACTORY_OF_SESSION_CLOSED_LATER);
 
   going_away_ = true;
@@ skipping 63 matching lines @@
 
 bool QuicChromiumClientSession::HasNonMigratableStreams() const {
   for (const auto& stream : dynamic_streams()) {
     if (!static_cast<QuicChromiumClientStream*>(stream.second)->can_migrate())
       return true;
   }
   return false;
 }
 
 }  // namespace net