[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 187 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),
+      port_migration_detected_(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 145 matching lines @@
 
   // Record number of frames per stream in packet.
   UMA_HISTOGRAM_COUNTS("Net.QuicNumStreamFramesPerStreamInPacket", 1);
 
   return QuicSpdySession::OnStreamFrame(frame);
 }
 
 void QuicChromiumClientSession::AddObserver(Observer* observer) {
   if (going_away_) {
     RecordUnexpectedObservers(ADD_OBSERVER);
-    observer->OnSessionClosed(ERR_UNEXPECTED);
+    observer->OnSessionClosed(ERR_UNEXPECTED, port_migration_detected_);
     return;
   }
 
   DCHECK(!ContainsKey(observers_, observer));
   observers_.insert(observer);
 }
 
 void QuicChromiumClientSession::RemoveObserver(Observer* observer) {
   DCHECK(ContainsKey(observers_, observer));
   observers_.erase(observer);
@@ skipping 369 matching lines @@
 }
 
 void QuicChromiumClientSession::OnCryptoHandshakeMessageReceived(
     const CryptoHandshakeMessage& message) {
   logger_->OnCryptoHandshakeMessageReceived(message);
 }
 
 void QuicChromiumClientSession::OnGoAway(const QuicGoAwayFrame& frame) {
   QuicSession::OnGoAway(frame);
   NotifyFactoryOfSessionGoingAway();
+  port_migration_detected_ = 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 181 matching lines @@
     QuicStreamId id = stream->id();
     static_cast<QuicChromiumClientStream*>(stream)->OnError(net_error);
     CloseStream(id);
   }
 }
 
 void QuicChromiumClientSession::CloseAllObservers(int net_error) {
   while (!observers_.empty()) {
     Observer* observer = *observers_.begin();
     observers_.erase(observer);
-    observer->OnSessionClosed(net_error);
+    observer->OnSessionClosed(net_error, port_migration_detected_);
   }
 }
 
 scoped_ptr<base::Value> QuicChromiumClientSession::GetInfoAsValue(
     const std::set<HostPortPair>& aliases) {
   scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetString("version", QuicVersionToString(connection()->version()));
   dict->SetInteger("open_streams", GetNumOpenOutgoingStreams());
   scoped_ptr<base::ListValue> stream_list(new base::ListValue());
   for (StreamMap::const_iterator it = dynamic_streams().begin();
@@ skipping 116 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->quic_port_migration_detected = port_migration_detected_;
+}
+
 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