Add an async ChannelIDSource for testing.

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 20 matching lines @@
 class QuicCryptoServerStream;
 class QuicCryptoStream;
 class QuicRandom;
 
 namespace test {
 
 class PacketSavingConnection;
 
 class CryptoTestUtils {
  public:
+  // An interface for a source of work. This may be use for invoking callbacks
+  // asynchronously.
+  //
+  // Call the DoPendingWork method regularly to do the work from this source.
+  class WorkSource {
+   public:
+    virtual ~WorkSource() {}
+
+    // Does pending work in this source. If there is no pending work, does
+    // nothing.
+    virtual void DoPendingWork() = 0;
+  };
+
   // FakeClientOptions bundles together a number of options for configuring
   // HandshakeWithFakeClient.
   struct FakeClientOptions {
     FakeClientOptions();
 
     // If dont_verify_certs is true then no ProofVerifier is set on the client.
     // Thus no certificates will be requested or checked.
     bool dont_verify_certs;
 
     // 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;
   };
 
   // returns: the number of client hellos that the client sent.
   static int HandshakeWithFakeServer(PacketSavingConnection* client_conn,
                                      QuicCryptoClientStream* client);
 
   // returns: the number of client hellos that the client sent.
   static int HandshakeWithFakeClient(PacketSavingConnection* server_conn,
                                      QuicCryptoServerStream* server,
                                      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);
 
   // 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);
 
+  // CommunicateHandshakeMessagesAndDoWork moves messages from |a| to |b| and
+  // back until |a|'s handshake has completed. If |work_source| is not NULL,
+  // CommunicateHandshakeMessagesAndDoWork also does work from |work_source|
+  // between processing messages.
+  static void CommunicateHandshakeMessagesAndDoWork(
+      PacketSavingConnection* a_conn,
+      QuicCryptoStream* a,
+      PacketSavingConnection* b_conn,
+      QuicCryptoStream* b,
+      WorkSource* work_source);
+
   // AdvanceHandshake attempts to moves messages from |a| to |b| and |b| to |a|.
   // Returns the number of messages moved.
   static std::pair<size_t, size_t> AdvanceHandshake(
       PacketSavingConnection* a_conn,
       QuicCryptoStream* a,
       size_t a_i,
       PacketSavingConnection* b_conn,
       QuicCryptoStream* b,
       size_t b_i);
 
@@ skipping 63 matching lines @@
                                          QuicCryptoServerStream* server);
 
   DISALLOW_COPY_AND_ASSIGN(CryptoTestUtils);
 };
 
 }  // namespace test
 
 }  // namespace net
 
 #endif  // NET_QUIC_TEST_TOOLS_CRYPTO_TEST_UTILS_H_