Makes migration on write error asynchronous to avoid reentrancy issues

net/quic/chromium/quic_stream_factory.h

 // 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.
 
 #ifndef NET_QUIC_QUIC_STREAM_FACTORY_H_
 #define NET_QUIC_QUIC_STREAM_FACTORY_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 55 matching lines @@
 
 // When a connection is idle for 30 seconds it will be closed.
 const int kIdleConnectionTimeoutSeconds = 30;
 
 // Indicates cause when connection migration is triggered.
 enum MigrationCause {
   EARLY_MIGRATION,  // Migration due to path degradation.
   WRITE_ERROR       // Migration due to socket write error.
 };
 
+// Result of a session migration attempt.
+enum class MigrationResult {
+  SUCCESS,         // Migration succeeded.
+  NO_NEW_NETWORK,  // Migration failed since no new network was found.
+  FAILURE          // Migration failed for other reasons.
+};
+
 // Encapsulates a pending request for a QuicHttpStream.
 // If the request is still pending when it is destroyed, it will
 // cancel the request with the factory.
 class NET_EXPORT_PRIVATE QuicStreamRequest {
  public:
   explicit QuicStreamRequest(QuicStreamFactory* factory);
   ~QuicStreamRequest();
 
   // |cert_verify_flags| is bitwise OR'd of CertVerifier::VerifyFlags and it is
   // passed to CertVerifier::Verify.
@@ skipping 210 matching lines @@
   // If |new_network| is NetworkChangeNotifier::kInvalidNetworkHandle,
   // there is no new network to migrate sessions onto, and all sessions are
   // closed.
   void MaybeMigrateOrCloseSessions(
       NetworkChangeNotifier::NetworkHandle new_network,
       bool close_if_cannot_migrate,
       const BoundNetLog& bound_net_log);
 
   // Method that initiates migration of |session| if |session| is
   // active and if there is an alternate network than the one to which
-  // |session| is currently bound. If not null, |packet| is sent on
-  // the new network, else a PING frame is sent.
-  void MaybeMigrateSingleSession(QuicChromiumClientSession* session,
-                                 MigrationCause migration_cause,
-                                 scoped_refptr<StringIOBuffer> packet);
+  // |session| is currently bound.
+  MigrationResult MaybeMigrateSingleSession(QuicChromiumClientSession* session,
+                                            MigrationCause migration_cause);
 
   // Migrates |session| over to using |network|. If |network| is
-  // kInvalidNetworkHandle, default network is used. If |packet| is
-  // not null, it is sent on the new network, else a PING frame is
-  // sent.
-  void MigrateSessionToNewNetwork(QuicChromiumClientSession* session,
-                                  NetworkChangeNotifier::NetworkHandle network,
-                                  bool close_session_on_error,
-                                  const BoundNetLog& bound_net_log,
-                                  scoped_refptr<StringIOBuffer> packet);
+  // kInvalidNetworkHandle, default network is used.
+  MigrationResult MigrateSessionToNewNetwork(
+      QuicChromiumClientSession* session,
+      NetworkChangeNotifier::NetworkHandle network,
+      bool close_session_on_error,
+      const BoundNetLog& bound_net_log);
 
   // Migrates |session| over to using |peer_address|. Causes a PING frame
   // to be sent to the new peer address.
   void MigrateSessionToNewPeerAddress(QuicChromiumClientSession* session,
                                       IPEndPoint peer_address,
                                       const BoundNetLog& bound_net_log);
 
   // NetworkChangeNotifier::IPAddressObserver methods:
 
   // Until the servers support roaming, close all connections when the local
@@ skipping 45 matching lines @@
 
   bool enable_connection_racing() const { return enable_connection_racing_; }
   void set_enable_connection_racing(bool enable_connection_racing) {
     enable_connection_racing_ = enable_connection_racing;
   }
 
   int socket_receive_buffer_size() const { return socket_receive_buffer_size_; }
 
   bool delay_tcp_race() const { return delay_tcp_race_; }
 
+  bool migrate_sessions_on_network_change() const {
+    return migrate_sessions_on_network_change_;
+  }
+
  private:
   class Job;
   class CertVerifierJob;
   friend class test::QuicStreamFactoryPeer;
   FRIEND_TEST_ALL_PREFIXES(HttpStreamFactoryTest, QuicLossyProxyMarkedAsBad);
 
   typedef std::map<QuicServerId, QuicChromiumClientSession*> SessionMap;
   typedef std::map<QuicChromiumClientSession*, QuicSessionKey> SessionIdMap;
   typedef std::set<QuicSessionKey> AliasSet;
   typedef std::map<QuicChromiumClientSession*, AliasSet> SessionAliasMap;
@@ skipping 77 matching lines @@
   void ProcessGoingAwaySession(QuicChromiumClientSession* session,
                                const QuicServerId& server_id,
                                bool was_session_active);
 
   // Collect stats from recent connections, possibly disabling Quic.
   void MaybeDisableQuic(QuicChromiumClientSession* session);
 
   void MaybeDisableQuic(uint16_t port);
 
   // Internal method that migrates |session| over to using
-  // |peer_address| and |network|. If |network| is kInvalidNetworkHandle,
-  // default network is used. If |packet| is not null, it is sent
-  // on the new network, else a PING frame is sent.
-  void MigrateSession(QuicChromiumClientSession* session,
-                      IPEndPoint peer_address,
-                      NetworkChangeNotifier::NetworkHandle network,
-                      bool close_session_on_error,
-                      const BoundNetLog& bound_net_log,
-                      scoped_refptr<StringIOBuffer> packet);
+  // |peer_address| and |network|. If |network| is
+  // kInvalidNetworkHandle, default network is used. If the migration
+  // fails and |close_session_on_error| is true, connection is closed.
+  MigrationResult MigrateSessionInner(
+      QuicChromiumClientSession* session,
+      IPEndPoint peer_address,
+      NetworkChangeNotifier::NetworkHandle network,
+      bool close_session_on_error,
+      const BoundNetLog& bound_net_log);
 
   bool require_confirmation_;
   NetLog* net_log_;
   HostResolver* host_resolver_;
   ClientSocketFactory* client_socket_factory_;
   HttpServerProperties* http_server_properties_;
   TransportSecurityState* transport_security_state_;
   CTVerifier* cert_transparency_verifier_;
   std::unique_ptr<QuicServerInfoFactory> quic_server_info_factory_;
   QuicCryptoClientStreamFactory* quic_crypto_client_stream_factory_;
@@ skipping 163 matching lines @@
   const scoped_refptr<SSLConfigService> ssl_config_service_;
 
   base::WeakPtrFactory<QuicStreamFactory> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicStreamFactory);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_STREAM_FACTORY_H_