Clang format slam.

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 "base/big_endian.h"
 #include "base/strings/string_util.h"
 #include "base/sys_byteorder.h"
 #include "net/base/address_list.h"
@@ skipping 98 matching lines @@
 }
 
 bool DnsRecordParser::ReadRecord(DnsResourceRecord* out) {
   DCHECK(packet_);
   size_t consumed = ReadName(cur_, &out->name);
   if (!consumed)
     return false;
   base::BigEndianReader reader(cur_ + consumed,
                                packet_ + length_ - (cur_ + consumed));
   uint16 rdlen;
-  if (reader.ReadU16(&out->type) &&
-      reader.ReadU16(&out->klass) &&
-      reader.ReadU32(&out->ttl) &&
-      reader.ReadU16(&rdlen) &&
+  if (reader.ReadU16(&out->type) && reader.ReadU16(&out->klass) &&
+      reader.ReadU32(&out->ttl) && reader.ReadU16(&rdlen) &&
       reader.ReadPiece(&out->rdata, rdlen)) {
     cur_ = reader.ptr();
     return true;
   }
   return false;
 }
 
 bool DnsRecordParser::SkipQuestion() {
   size_t consumed = ReadName(cur_, NULL);
   if (!consumed)
     return false;
 
   const char* next = cur_ + consumed + 2 * sizeof(uint16);  // QTYPE + QCLASS
   if (next > packet_ + length_)
     return false;
 
   cur_ = next;
 
   return true;
 }
 
 DnsResponse::DnsResponse()
     : io_buffer_(new IOBufferWithSize(dns_protocol::kMaxUDPSize + 1)) {
 }
 
 DnsResponse::DnsResponse(size_t length)
     : io_buffer_(new IOBufferWithSize(length)) {
 }
 
-DnsResponse::DnsResponse(const void* data,
-                         size_t length,
-                         size_t answer_offset)
+DnsResponse::DnsResponse(const void* data, size_t length, size_t answer_offset)
     : io_buffer_(new IOBufferWithSize(length)),
       parser_(io_buffer_->data(), length, answer_offset) {
   DCHECK(data);
   memcpy(io_buffer_->data(), data, length);
 }
 
 DnsResponse::~DnsResponse() {
 }
 
 bool DnsResponse::InitParse(int nbytes, const DnsQuery& query) {
   DCHECK_GE(nbytes, 0);
   // Response includes query, it should be at least that size.
   if (nbytes < query.io_buffer()->size() || nbytes >= io_buffer_->size())
     return false;
 
   // 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() + hdr_size, question.size())) {
     return false;
   }
 
   // Construct the parser.
-  parser_ = DnsRecordParser(io_buffer_->data(),
-                            nbytes,
-                            hdr_size + question.size());
+  parser_ =
+      DnsRecordParser(io_buffer_->data(), nbytes, hdr_size + 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())
     return false;
 
-  parser_ = DnsRecordParser(
-      io_buffer_->data(), nbytes, hdr_size);
+  parser_ = DnsRecordParser(io_buffer_->data(), nbytes, hdr_size);
 
   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 67 matching lines @@
   // we can always fall back to the system getaddrinfo.
 
   // Expected owner of record. No trailing dot.
   std::string expected_name = GetDottedName();
 
   uint16 expected_type = qtype();
   DCHECK(expected_type == dns_protocol::kTypeA ||
          expected_type == dns_protocol::kTypeAAAA);
 
   size_t expected_size = (expected_type == dns_protocol::kTypeAAAA)
-      ? kIPv6AddressSize : kIPv4AddressSize;
+                             ? kIPv6AddressSize
+                             : kIPv4AddressSize;
 
   uint32 ttl_sec = kuint32max;
   IPAddressList ip_addresses;
   DnsRecordParser parser = Parser();
   DnsResourceRecord record;
   unsigned ancount = answer_count();
   for (unsigned i = 0; i < ancount; ++i) {
     if (!parser.ReadRecord(&record))
       return DNS_MALFORMED_RESPONSE;
 
@@ skipping 11 matching lines @@
 
       ttl_sec = std::min(ttl_sec, record.ttl);
     } else if (record.type == expected_type) {
       if (record.rdata.size() != expected_size)
         return DNS_SIZE_MISMATCH;
 
       if (base::strcasecmp(record.name.c_str(), expected_name.c_str()) != 0)
         return DNS_NAME_MISMATCH;
 
       ttl_sec = std::min(ttl_sec, record.ttl);
-      ip_addresses.push_back(IPAddressNumber(record.rdata.begin(),
-                                             record.rdata.end()));
+      ip_addresses.push_back(
+          IPAddressNumber(record.rdata.begin(), record.rdata.end()));
     }
   }
 
   // TODO(szym): Extract TTL for NODATA results. http://crbug.com/115051
 
   // 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);
+  *addr_list =
+      AddressList::CreateFromIPAddressList(ip_addresses, expected_name);
   *ttl = base::TimeDelta::FromSeconds(ttl_sec);
   return DNS_PARSE_OK;
 }
 
 }  // namespace net