Allow a callback to populate mock DNS responses.

net/dns/dns_test_util.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_DNS_DNS_TEST_UTIL_H_
 #define NET_DNS_DNS_TEST_UTIL_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #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"
 
 namespace net {
 
 //-----------------------------------------------------------------------------
 // Query/response set for www.google.com, ID is fixed to 0.
 static const char kT0HostName[] = "www.google.com";
 static const uint16_t kT0Qtype = dns_protocol::kTypeA;
@@ skipping 133 matching lines @@
 class MockTransactionFactory;
 
 struct MockDnsClientRule {
   enum Result {
     FAIL,     // Fail asynchronously with ERR_NAME_NOT_RESOLVED.
     TIMEOUT,  // Fail asynchronously with ERR_DNS_TIMEOUT.
     EMPTY,    // Return an empty response.
     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)>;
+
+  // 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) {}
+  MockDnsClientRule(const std::string& prefix,
+                    uint16_t qtype,
+                    Result result,
+                    bool delay);
 
-  Result result;
+  // 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();
+  MockDnsClientRule& operator=(MockDnsClientRule o);
+
+  friend void swap(MockDnsClientRule& x, MockDnsClientRule& y);
+
+  ResponseCallback response_callback;
   std::string prefix;
   uint16_t qtype;
   bool delay;
 };
 
 typedef std::vector<MockDnsClientRule> MockDnsClientRuleList;
 
 // MockDnsClient provides MockTransactionFactory.
 class MockDnsClient : public DnsClient {
  public:
@@ skipping 11 matching lines @@
 
  private:
   DnsConfig config_;
   std::unique_ptr<MockTransactionFactory> factory_;
   std::unique_ptr<AddressSorter> address_sorter_;
 };
 
 }  // namespace net
 
 #endif  // NET_DNS_DNS_TEST_UTIL_H_