Landing Recent QUIC changes until 4/15/2016 17:20 UTC

net/tools/quic/quic_client_base.h

 // Copyright (c) 2015 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.
 //
 // A base class for the toy client, which connects to a specified port and sends
 // QUIC request to that endpoint.
 
 #ifndef NET_TOOLS_QUIC_QUIC_CLIENT_BASE_H_
 #define NET_TOOLS_QUIC_QUIC_CLIENT_BASE_H_
 
 #include <memory>
 #include <string>
 
 #include "base/macros.h"
 #include "net/base/ip_endpoint.h"
 #include "net/log/net_log.h"
 #include "net/quic/crypto/crypto_handshake.h"
 #include "net/quic/crypto/quic_crypto_client_config.h"
+#include "net/quic/quic_alarm_factory.h"
 #include "net/quic/quic_bandwidth.h"
 #include "net/quic/quic_client_push_promise_index.h"
 #include "net/quic/quic_config.h"
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_packet_writer.h"
 #include "net/quic/quic_protocol.h"
 #include "net/tools/quic/quic_client_session.h"
 #include "net/tools/quic/quic_spdy_client_stream.h"
 
 namespace net {
 
 class ProofVerifier;
 class QuicServerId;
 
 class QuicClientBase {
  public:
   QuicClientBase(const QuicServerId& server_id,
                  const QuicVersionVector& supported_versions,
                  const QuicConfig& config,
                  QuicConnectionHelperInterface* helper,
+                 QuicAlarmFactory* alarm_factory,
                  ProofVerifier* proof_verifier);
 
   ~QuicClientBase();
 
   // Initializes the client to create a connection. Should be called exactly
   // once before calling StartConnect or Connect. Returns true if the
   // initialization succeeds, false otherwise.
   virtual bool Initialize();
 
   // Returns true if the crypto handshake has yet to establish encryption.
@@ skipping 125 matching lines @@
   // Returns the next server-designated ConnectionId from the cached config for
   // |server_id_|, if it exists.  Otherwise, returns 0.
   QuicConnectionId GetNextServerDesignatedConnectionId();
 
   // Generates a new, random connection ID (as opposed to a server-designated
   // connection ID).
   virtual QuicConnectionId GenerateNewConnectionId();
 
   QuicConnectionHelperInterface* helper() { return helper_.get(); }
 
+  QuicAlarmFactory* alarm_factory() { return alarm_factory_.get(); }
+
   void set_num_sent_client_hellos(int num_sent_client_hellos) {
     num_sent_client_hellos_ = num_sent_client_hellos;
   }
 
   void set_num_stateless_rejects_received(int num_stateless_rejects_received) {
     num_stateless_rejects_received_ = num_stateless_rejects_received;
   }
 
  private:
   // |server_id_| is a tuple (hostname, port, is_https) of the server.
   QuicServerId server_id_;
 
   // config_ and crypto_config_ contain configuration and cached state about
   // servers.
   QuicConfig config_;
   QuicCryptoClientConfig crypto_config_;
 
   // Helper to be used by created connections. Needs to outlive |session_|.
   std::unique_ptr<QuicConnectionHelperInterface> helper_;
 
+  // Helper to be used by created connections. Needs to outlive |session_|.
+  std::unique_ptr<QuicAlarmFactory> alarm_factory_;
+
   // Writer used to actually send packets to the wire. Needs to outlive
   // |session_|.
   std::unique_ptr<QuicPacketWriter> writer_;
 
   // Session which manages streams.
   std::unique_ptr<QuicClientSession> session_;
 
   // This vector contains QUIC versions which we currently support.
   // This should be ordered such that the highest supported version is the first
   // element, with subsequent elements in descending order (versions can be
@@ skipping 27 matching lines @@
   bool connected_or_attempting_connect_;
 
   QuicClientPushPromiseIndex push_promise_index_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicClientBase);
 };
 
 }  // namespace net
 
 #endif  // NET_TOOLS_QUIC_QUIC_CLIENT_BASE_H_