QUIC - disable QUIC if packet loss rate is bad for a connection.

net/quic/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 <list>
 #include <map>
 #include <string>
@@ skipping 90 matching lines @@
       size_t max_packet_length,
       const std::string& user_agent_id,
       const QuicVersionVector& supported_versions,
       bool enable_port_selection,
       bool always_require_handshake_confirmation,
       bool disable_connection_pooling,
       float load_server_info_timeout_srtt_multiplier,
       bool enable_connection_racing,
       bool enable_non_blocking_io,
       bool disable_disk_cache,
+      int max_number_of_lossy_connections,
+      float packet_loss_threshold,
       int socket_receive_buffer_size,
       const QuicTagVector& connection_options);
   ~QuicStreamFactory() override;
 
   // Creates a new QuicHttpStream to |host_port_pair| which will be
   // owned by |request|. |is_https| specifies if the protocol is https or not.
   // If a matching session already exists, this method will return OK.  If no
   // matching session exists, this will return ERR_IO_PENDING and will invoke
   // OnRequestComplete asynchronously.
   int Create(const HostPortPair& host_port_pair,
              bool is_https,
              PrivacyMode privacy_mode,
              base::StringPiece method,
              const BoundNetLog& net_log,
              QuicStreamRequest* request);
 
+  // Returns false if |packet_loss_rate| is less than |packet_loss_threshold_|
+  // otherwise it returns true and closes the session and marks QUIC as recently
+  // broken for the given |server_id|. Increments |number_of_lossy_connections_|
+  // for the server_id's port.
+  bool OnBadPacketLoss(QuicClientSession* session,
+                       const QuicServerId& server_id,

[Ryan Hamilton, 2015/03/24 03:43:00]

I think |session| has a server_id() method so perhaps you can drop the
|server_id| argument.

[ramant (doing other things), 2015/03/24 17:19:24]

Done.

+                       float packet_loss_rate);
+
+  // Returns true if the |number_of_lossy_connections_| for the given port is
+  // greater than |max_number_of_lossy_connections_|.

[Ryan Hamilton, 2015/03/24 03:43:00]

I think I would simply say
  // Returns true if QUIC is disabled for this port.
Typically it's best to document the interface here, and the implementation in
the method in the .cc file if it needs to be documented.

[ramant (doing other things), 2015/03/24 17:19:23]

Done.

+  bool IsQuicDisabled(uint16 port);
+
   // Called by a session when it becomes idle.
   void OnIdleSession(QuicClientSession* session);
 
   // Called by a session when it is going away and no more streams should be
   // created on it.
   void OnSessionGoingAway(QuicClientSession* session);
 
   // Called by a session after it shuts down.
   void OnSessionClosed(QuicClientSession* session);
 
@@ skipping 183 matching lines @@
   // INCHOATE_HELLO and another connection that sends CHLO after loading server
   // config from the disk cache.
   bool enable_connection_racing_;
 
   // Set if experimental non-blocking IO should be used on windows sockets.
   bool enable_non_blocking_io_;
 
   // Set if we do not want to load server config from the disk cache.
   bool disable_disk_cache_;
 
+  // Set if we want to disable QUIC when there is high packet loss rate.
+  int max_number_of_lossy_connections_;
+  float packet_loss_threshold_;
+  // Count number of lossy connections by port.
+  std::map<uint16, int> number_of_lossy_connections_;
+
   // Size of the UDP receive buffer.
   int socket_receive_buffer_size_;
 
   // Each profile will (probably) have a unique port_seed_ value.  This value
   // is used to help seed a pseudo-random number generator (PortSuggester) so
   // that we consistently (within this profile) suggest the same ephemeral
   // port when we re-connect to any given server/port.  The differences between
   // profiles (probablistically) prevent two profiles from colliding in their
   // ephemeral port requests.
   uint64 port_seed_;
 
   // Local address of socket that was created in CreateSession.
   IPEndPoint local_address_;
   bool check_persisted_supports_quic_;
   std::set<HostPortPair> quic_supported_servers_at_startup_;
 
   NetworkConnection network_connection_;
 
   base::TaskRunner* task_runner_;
 
   base::WeakPtrFactory<QuicStreamFactory> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicStreamFactory);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_STREAM_FACTORY_H_