Allow a callback to populate mock DNS responses.

net/dns/dns_test_util.h

Index: net/dns/dns_test_util.h
diff --git a/net/dns/dns_test_util.h b/net/dns/dns_test_util.h
index d28c9e446092e9d177f34b6b52699397c81e65de..a65c094bc6767cf923faac397f30d594bad62d40 100644
--- a/net/dns/dns_test_util.h
+++ b/net/dns/dns_test_util.h
@@ -12,6 +12,8 @@
 #include <string>
 #include <vector>
 
+#include "base/big_endian.h"
+#include "base/callback_forward.h"
 #include "net/dns/dns_client.h"
 #include "net/dns/dns_config_service.h"
 #include "net/dns/dns_protocol.h"
@@ -165,18 +167,40 @@ struct MockDnsClientRule {
     OK,       // Return a response with loopback address.
   };
 
+  // The type of callback invoked in order to prepare a response to a mock DNS
+  // request. An empty response will be created, which can then be manipulated
+  // via the |response_header| and |answer_writer|. It must return net::OK
+  // when done, unless it is intended that the request fail, in which case it
+  // must return a different net::Error.
+  using ResponseCallback =
+      base::Callback<int(dns_protocol::Header* response_header,
+                         base::BigEndianWriter* answer_writer)>;

[mmenke, 2016/06/02 19:46:05]

Can you just use mock UDP sockets for this?

Reasons:

* That makes for integration-y tests, making sure DnsTransactions can handle
whever new requests you throw at it.
* That's more flexible.  Makes it easier to send malformed packets containing
whatever you want, so we don't end up having to add yet another API for that, if
we discover we need it.
* It's also less new code.

+
+  // Expect a mock DNS request with the given |prefix| and |qtype|.
+  // The response is dictated by |result|.
   // If |delay| is true, matching transactions will be delayed until triggered
   // by the consumer.
-  MockDnsClientRule(const std::string& prefix_arg,
-                    uint16_t qtype_arg,
-                    Result result_arg,
-                    bool delay)
-      : result(result_arg),
-        prefix(prefix_arg),
-        qtype(qtype_arg),
-        delay(delay) {}
-
-  Result result;
+  MockDnsClientRule(const std::string& prefix,
+                    uint16_t qtype,
+                    Result result,
+                    bool delay);
+
+  // Expect a mock DNS request with the given |prefix| and |qtype|.
+  // In response, invoke |response_callback|, which can modify the response
+  // header, write answers into the response, or return a net::Error.
+  // If |delay| is true, matching transactions will be delayed until triggered
+  // by the consumer.
+  MockDnsClientRule(const std::string& prefix,
+                    uint16_t qtype,
+                    ResponseCallback response_callback,
+                    bool delay);
+
+  MockDnsClientRule(const MockDnsClientRule& copy);
+  MockDnsClientRule(MockDnsClientRule&& move);
+
+  ~MockDnsClientRule();
+
+  ResponseCallback response_callback;
   std::string prefix;
   uint16_t qtype;
   bool delay;