Break the dependency of DnsQuery and DnsResponse from AddressList

net/base/dns_query.cc

 // Copyright (c) 2011 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.
 
 #include "net/base/dns_query.h"
 
 #include <string>
 
 #include "base/rand_util.h"
-#include "net/base/address_family.h"
 #include "net/base/dns_util.h"
 
 namespace net {
 
 namespace {
 
 void PackUint16BE(char buf[2], uint16 v) {
   buf[0] = v >> 8;
   buf[1] = v & 0xff;
 }
 
-uint16 QTypeFromAddressFamily(AddressFamily address_family) {
-  switch (address_family) {
-    case ADDRESS_FAMILY_IPV4:
-      return kDNS_A;
-    case ADDRESS_FAMILY_IPV6:
-      return kDNS_AAAA;
-    default:
-      NOTREACHED() << "Bad address family";
-      return kDNS_A;
-  }
+uint16 UnpackUint16BE(char buf[2]) {
+  return static_cast<uint8>(buf[0]) << 8 | static_cast<uint8>(buf[1]);
 }
 
 }  // namespace
 
 // DNS query consists of a 12-byte header followed by a question section.
 // For details, see RFC 1035 section 4.1.1.  This header template sets RD
 // bit, which directs the name server to pursue query recursively, and sets
 // the QDCOUNT to 1, meaning the question section has a single entry.  The
 // first two bytes of the header form a 16-bit random query ID to be copied
 // in the corresponding reply by the name server -- randomized during
 // DnsQuery construction.
 static const char kHeader[] = {0x00, 0x00, 0x01, 0x00, 0x00, 0x01,
                                0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-static const size_t kHeaderLen = arraysize(kHeader);
+static const size_t kHeaderSize = arraysize(kHeader);
 
-DnsQuery::DnsQuery(const std::string& hostname,
-                   AddressFamily address_family,
-                   int port)
-    : port_(port),
-      id_(0),
-      qtype_(QTypeFromAddressFamily(address_family)),
-      hostname_(hostname) {
-  std::string qname;
-  if (!net::DNSDomainFromDot(hostname, &qname))
-    return;
+DnsQuery::DnsQuery(const std::string& dns_name, uint16 qtype)
+    : dns_name_size_(dns_name.size()) {
+  DCHECK(DnsResponseBuffer(reinterpret_cast<const uint8*>(dns_name.c_str()),
+                           dns_name.size()).DNSName(NULL));
+  DCHECK(qtype == kDNS_A || qtype == kDNS_AAAA);
 
-  size_t query_size = kHeaderLen + qname.size() +
-    sizeof(qtype_) + sizeof(kClassIN);
-
-  io_buffer_ = new IOBufferWithSize(query_size);
+  io_buffer_ = new IOBufferWithSize(kHeaderSize + question_size());
 
   int byte_offset = 0;
   char* buffer_head = io_buffer_->data();
-  memcpy(&buffer_head[byte_offset], kHeader, kHeaderLen);
-  byte_offset += kHeaderLen;
-  memcpy(&buffer_head[byte_offset], &qname[0], qname.size());
-  byte_offset += qname.size();
-  PackUint16BE(&buffer_head[byte_offset], qtype_);
-  byte_offset += sizeof(qtype_);
+  memcpy(&buffer_head[byte_offset], kHeader, kHeaderSize);
+  byte_offset += kHeaderSize;
+  memcpy(&buffer_head[byte_offset], &dns_name[0], dns_name_size_);
+  byte_offset += dns_name_size_;
+  PackUint16BE(&buffer_head[byte_offset], qtype);
+  byte_offset += sizeof(qtype);
   PackUint16BE(&buffer_head[byte_offset], kClassIN);
+  RandomizeId();
+}
 
-  // Randomize ID, first two bytes.
-  id_ = base::RandUint64() & 0xffff;
-  PackUint16BE(&buffer_head[0], id_);
+DnsQuery::DnsQuery(const DnsQuery& rhs) {

[cbentzel, 2011/06/09 01:16:06]

Use initializer arguments rather than assignment where appropriate - maybe only
dns_name_size_

[agayev, 2011/06/09 14:23:02]

Done.

+  dns_name_size_ = rhs.dns_name_size_;
+  io_buffer_ = new IOBufferWithSize(rhs.io_buffer()->size());
+  memcpy(io_buffer_->data(), rhs.io_buffer()->data(), rhs.io_buffer()->size());
+  RandomizeId();
 }
 
 DnsQuery::~DnsQuery() {
 }
 
-int DnsQuery::port() const {
-  DCHECK(IsValid());
-  return port_;
-}
-
 uint16 DnsQuery::id() const {
-  DCHECK(IsValid());
-  return id_;
+  return UnpackUint16BE(&io_buffer_->data()[0]);
 }
 
 uint16 DnsQuery::qtype() const {
-  DCHECK(IsValid());
-  return qtype_;
+  return UnpackUint16BE(&io_buffer_->data()[kHeaderSize + dns_name_size_]);
 }
 
-AddressFamily DnsQuery::address_family() const {
-  DCHECK(IsValid());
-  return address_family_;
+DnsQuery* DnsQuery::CloneWithNewId() const {
+  return new DnsQuery(*this);
 }
 
-const std::string& DnsQuery::hostname() const {
-  DCHECK(IsValid());
-  return hostname_;
+size_t DnsQuery::question_size() const {
+  return dns_name_size_       // QNAME
+    + sizeof(uint16)          // QTYPE
+    + sizeof(uint16);         // QCLASS
 }
 
-IOBufferWithSize* DnsQuery::io_buffer() const {
-  DCHECK(IsValid());
-  return io_buffer_.get();
+char* DnsQuery::question_data() const {
+  return &io_buffer_->data()[kHeaderSize];
+}
+
+void DnsQuery::RandomizeId() {
+  PackUint16BE(&io_buffer_->data()[0], base::RandUint64() & 0xffff);
 }
 
 }  // namespace net