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 tasks to run.
+  class TaskSource {

[wtc, 2014/07/09 01:03:53]

I'd appreciate suggestion for a better name.

If the term "task" is not used elsewhere in the QUIC source code, I can use
"callback" instead of "task".

+   public:
+    virtual ~TaskSource() {}
+
+    // Runs all pending tasks in this source.
+    virtual void RunPending() = 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.
+  // CommunicateHandshakeMessages moves messages from |a| to |b| and back and
+  // runs pending tasks in |task_source| until |a|'s handshake has completed.
   static void CommunicateHandshakeMessages(PacketSavingConnection* a_conn,
                                            QuicCryptoStream* a,
                                            PacketSavingConnection* b_conn,
-                                           QuicCryptoStream* b);
+                                           QuicCryptoStream* b,
+                                           TaskSource* task_source = NULL);

[wtc, 2014/07/09 01:03:52]

It seems that the Style Guide allows this use of default argument:

http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Default_Arguments

This is a static method, and we may need to add additional TaskSource arguments
(to simulate a variable-length argument list) in the future, for example, if we
want to use an async ProofVerifier for testing.

[Ryan Hamilton, 2014/07/09 16:54:39]

The way I read the style guide, it's not just that the method is static, it's
that it's in a .cc file not  .h file:

  One specific exception is when the function is a static function (or in an
unnamed namespace) in a .cc file. In this case, the cons don't apply since the
function's use is so localized.
If we need to do more in the future we can figure it out then. In the meantime,
it doesn't seem like it's actually doing multiple arguments. I think that having
2 different methods (in which one simply invokes the other with NULL for then
last arg) would be most consistent with existing code.

[wtc, 2014/07/09 19:44:42]

Done. Added a CommunicateHandshakeMessagesAndDoWork method.

 
   // 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 64 matching lines @@
                                          QuicCryptoServerStream* server);
 
   DISALLOW_COPY_AND_ASSIGN(CryptoTestUtils);
 };
 
 }  // namespace test
 
 }  // namespace net
 
 #endif  // NET_QUIC_TEST_TOOLS_CRYPTO_TEST_UTILS_H_