Landing Recent QUIC changes until 2015-11-09 20:32 UTC

net/quic/test_tools/crypto_test_utils.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_TEST_TOOLS_CRYPTO_TEST_UTILS_H_
 #define NET_QUIC_TEST_TOOLS_CRYPTO_TEST_UTILS_H_
 
 #include <stdarg.h>
 
 #include <utility>
@@ skipping 36 matching lines @@
   // this source.
   class CallbackSource {
    public:
     virtual ~CallbackSource() {}
 
     // Runs pending callbacks from this source. If there is no pending
     // callback, does nothing.
     virtual void RunPendingCallbacks() = 0;
   };
 
+  // FakeServerOptions bundles together a number of options for configuring the
+  // server in HandshakeWithFakeServer.
+  struct FakeServerOptions {
+    FakeServerOptions();
+
+    // If token_binding_enabled is true, then the server will attempt to
+    // negotiate Token Binding.
+    bool token_binding_enabled;
+  };
+
   // FakeClientOptions bundles together a number of options for configuring
   // HandshakeWithFakeClient.
   struct FakeClientOptions {
     FakeClientOptions();
 
     // If channel_id_enabled is true then the client will attempt to send a
     // ChannelID.
     bool channel_id_enabled;
 
     // If channel_id_source_async is true then the client will use an async
     // ChannelIDSource for testing. Ignored if channel_id_enabled is false.
     bool channel_id_source_async;
+
+    // If token_binding_enabled is true, then the client will attempt to
+    // negotiate Token Binding.
+    bool token_binding_enabled;
   };
 
   // returns: the number of client hellos that the client sent.
   static int HandshakeWithFakeServer(MockConnectionHelper* helper,
                                      PacketSavingConnection* client_conn,
-                                     QuicCryptoClientStream* client);
+                                     QuicCryptoClientStream* client,
+                                     const FakeServerOptions& options);
 
   // returns: the number of client hellos that the client sent.
   static int HandshakeWithFakeClient(MockConnectionHelper* helper,
                                      PacketSavingConnection* server_conn,
                                      QuicCryptoServerStream* server,
                                      const QuicServerId& server_id,
                                      const FakeClientOptions& options);
 
   // SetupCryptoServerConfigForTest configures |config| and |crypto_config|
   // with sensible defaults for testing.
   static void SetupCryptoServerConfigForTest(
       const QuicClock* clock,
       QuicRandom* rand,
       QuicConfig* config,
-      QuicCryptoServerConfig* crypto_config);
+      QuicCryptoServerConfig* crypto_config,
+      const FakeServerOptions& options);
 
   // CommunicateHandshakeMessages moves messages from |a| to |b| and back until
   // |a|'s handshake has completed.
   static void CommunicateHandshakeMessages(PacketSavingConnection* a_conn,
                                            QuicCryptoStream* a,
                                            PacketSavingConnection* b_conn,
                                            QuicCryptoStream* b);
 
   // CommunicateHandshakeMessagesAndRunCallbacks moves messages from |a| to |b|
   // and back until |a|'s handshake has completed. If |callback_source| is not
@@ skipping 58 matching lines @@
   //       "SNI", "www.example.com",
   //       nullptr);
   static CryptoHandshakeMessage Message(const char* message_tag, ...);
 
   // ChannelIDSourceForTesting returns a ChannelIDSource that generates keys
   // deterministically based on the hostname given in the GetChannelIDKey call.
   // This ChannelIDSource works in synchronous mode, i.e., its GetChannelIDKey
   // method never returns QUIC_PENDING.
   static ChannelIDSource* ChannelIDSourceForTesting();
 
+  // MovePackets parses crypto handshake messages from packet number
+  // |*inout_packet_index| through to the last packet (or until a packet fails
+  // to decrypt) and has |dest_stream| process them. |*inout_packet_index| is
+  // updated with an index one greater than the last packet processed.
+  static void MovePackets(PacketSavingConnection* source_conn,
+                          size_t* inout_packet_index,
+                          QuicCryptoStream* dest_stream,
+                          PacketSavingConnection* dest_conn);
+
  private:
   static void CompareClientAndServerKeys(QuicCryptoClientStream* client,
                                          QuicCryptoServerStream* server);
 
   DISALLOW_COPY_AND_ASSIGN(CryptoTestUtils);
 };
 
 }  // namespace test
 
 }  // namespace net
 
 #endif  // NET_QUIC_TEST_TOOLS_CRYPTO_TEST_UTILS_H_