net: calculate dns header size only once per query/response

net/dns/dns_response.cc

 // 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.
 
 #include "net/dns/dns_response.h"
 
 #include <limits>
 
 #include "base/big_endian.h"
 #include "base/strings/string_util.h"
 #include "base/sys_byteorder.h"
 #include "net/base/address_list.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_address.h"
 #include "net/base/net_errors.h"
 #include "net/dns/dns_protocol.h"
 #include "net/dns/dns_query.h"
 #include "net/dns/dns_util.h"
 
 namespace net {
 
 namespace {
 
+const size_t kHeaderSize = sizeof(dns_protocol::Header);
+
 const uint8_t kRcodeMask = 0xf;
 
 }  // namespace
 
 DnsResourceRecord::DnsResourceRecord() {
 }
 
 DnsResourceRecord::~DnsResourceRecord() {
 }
 
@@ skipping 144 matching lines @@
 
   // Match the query id.
   if (base::NetToHost16(header()->id) != query.id())
     return false;
 
   // Match question count.
   if (base::NetToHost16(header()->qdcount) != 1)
     return false;
 
   // Match the question section.
-  const size_t hdr_size = sizeof(dns_protocol::Header);
   const base::StringPiece question = query.question();
-  if (question != base::StringPiece(io_buffer_->data() + hdr_size,
-                                    question.size())) {
+  if (question !=
+      base::StringPiece(io_buffer_->data() + kHeaderSize, question.size())) {
     return false;
   }
 
   // Construct the parser.
-  parser_ = DnsRecordParser(io_buffer_->data(),
-                            nbytes,
-                            hdr_size + question.size());
+  parser_ = DnsRecordParser(io_buffer_->data(), nbytes,
+                            kHeaderSize + question.size());
   return true;
 }
 
 bool DnsResponse::InitParseWithoutQuery(int nbytes) {
   DCHECK_GE(nbytes, 0);
 
-  size_t hdr_size = sizeof(dns_protocol::Header);
-
-  if (nbytes < static_cast<int>(hdr_size) || nbytes >= io_buffer_->size())
+  if (nbytes < static_cast<int>(kHeaderSize) || nbytes >= io_buffer_->size())
     return false;
 
-  parser_ = DnsRecordParser(
-      io_buffer_->data(), nbytes, hdr_size);
+  parser_ = DnsRecordParser(io_buffer_->data(), nbytes, kHeaderSize);
 
   unsigned qdcount = base::NetToHost16(header()->qdcount);
   for (unsigned i = 0; i < qdcount; ++i) {
     if (!parser_.SkipQuestion()) {
       parser_ = DnsRecordParser();  // Make parser invalid again.
       return false;
     }
   }
 
   return true;
@@ skipping 21 matching lines @@
 unsigned DnsResponse::additional_answer_count() const {
   DCHECK(parser_.IsValid());
   return base::NetToHost16(header()->arcount);
 }
 
 base::StringPiece DnsResponse::qname() const {
   DCHECK(parser_.IsValid());
   // The response is HEADER QNAME QTYPE QCLASS ANSWER.
   // |parser_| is positioned at the beginning of ANSWER, so the end of QNAME is
   // two uint16_ts before it.
-  const size_t hdr_size = sizeof(dns_protocol::Header);
   const size_t qname_size =
-      parser_.GetOffset() - 2 * sizeof(uint16_t) - hdr_size;
-  return base::StringPiece(io_buffer_->data() + hdr_size, qname_size);
+      parser_.GetOffset() - 2 * sizeof(uint16_t) - kHeaderSize;
+  return base::StringPiece(io_buffer_->data() + kHeaderSize, qname_size);
 }
 
 uint16_t DnsResponse::qtype() const {
   DCHECK(parser_.IsValid());
   // QTYPE starts where QNAME ends.
   const size_t type_offset = parser_.GetOffset() - 2 * sizeof(uint16_t);
   uint16_t type;
   base::ReadBigEndian<uint16_t>(io_buffer_->data() + type_offset, &type);
   return type;
 }
@@ skipping 73 matching lines @@
 
   // getcanonname in eglibc returns the first owner name of an A or AAAA RR.
   // If the response passed all the checks so far, then |expected_name| is it.
   *addr_list = AddressList::CreateFromIPAddressList(ip_addresses,
                                                     expected_name);
   *ttl = base::TimeDelta::FromSeconds(ttl_sec);
   return DNS_PARSE_OK;
 }
 
 }  // namespace net