Clang format slam.

net/tools/dns_fuzz_stub/dns_fuzz_stub.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 <algorithm>
 #include <sstream>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/json/json_reader.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "net/base/address_list.h"
 #include "net/base/dns_util.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
 #include "net/dns/dns_protocol.h"
 #include "net/dns/dns_query.h"
 #include "net/dns/dns_response.h"
 
 namespace {
 
 void CrashDoubleFree(void) {
   // Cause ASAN to detect a double-free
-  void *p = malloc(1);
+  void* p = malloc(1);
   LOG(INFO) << "Allocated p=" << p << ".  Double-freeing...";
   free(p);
   free(p);
 }
 
 void CrashNullPointerDereference(void) {
   // Cause the program to segfault with a NULL pointer dereference
-  int *p = NULL;
+  int* p = NULL;
   *p = 0;
 }
 
 bool FitsUint8(int num) {
   return (num >= 0) && (num <= kuint8max);
 }
 
 bool FitsUint16(int num) {
   return (num >= 0) && (num <= kuint16max);
 }
 
 bool ReadTestCase(const char* filename,
-                  uint16* id, std::string* qname, uint16* qtype,
+                  uint16* id,
+                  std::string* qname,
+                  uint16* qtype,
                   std::vector<char>* resp_buf,
                   bool* crash_test) {
   base::FilePath filepath = base::FilePath::FromUTF8Unsafe(filename);
 
   std::string json;
   if (!base::ReadFileToString(filepath, &json)) {
     LOG(ERROR) << filename << ": couldn't read file.";
     return false;
   }
 
@@ skipping 66 matching lines @@
   DCHECK(resp_buf->size() == resp_size);
 
   LOG(INFO) << "Query: id=" << id_int << ", "
             << "qname=" << *qname << ", "
             << "qtype=" << qtype_int << ", "
             << "resp_size=" << resp_size;
 
   return true;
 }
 
-void RunTestCase(uint16 id, std::string& qname, uint16 qtype,
+void RunTestCase(uint16 id,
+                 std::string& qname,
+                 uint16 qtype,
                  std::vector<char>& resp_buf) {
   net::DnsQuery query(id, qname, qtype);
   net::DnsResponse response;
   std::copy(resp_buf.begin(), resp_buf.end(), response.io_buffer()->data());
 
   if (!response.InitParse(resp_buf.size(), query)) {
     LOG(INFO) << "InitParse failed.";
     return;
   }
 
   net::AddressList address_list;
   base::TimeDelta ttl;
-  net::DnsResponse::Result result = response.ParseToAddressList(
-      &address_list, &ttl);
+  net::DnsResponse::Result result =
+      response.ParseToAddressList(&address_list, &ttl);
   if (result != net::DnsResponse::DNS_PARSE_OK) {
     LOG(INFO) << "ParseToAddressList failed: " << result;
     return;
   }
 
   // Print the response in one compact line.
   std::stringstream result_line;
   result_line << "Response: address_list={ ";
   for (unsigned int i = 0; i < address_list.size(); i++)
     result_line << address_list[i].ToString() << " ";
@@ skipping 27 matching lines @@
   std::string qname_dns;
   if (!net::DNSDomainFromDot(qname, &qname_dns)) {
     LOG(ERROR) << filename << ": DNSDomainFromDot(" << qname << ") failed.";
     return false;
   }
 
   RunTestCase(id, qname_dns, qtype, resp_buf);
 
   return true;
 }
-
 }
 
 int main(int argc, char** argv) {
   int ret = 0;
 
   for (int i = 1; i < argc; i++)
     if (!ReadAndRunTestCase(argv[i]))
       ret = 2;
 
   // Cluster-Fuzz likes "#EOF" as the last line of output to help distinguish
   // successful runs from crashes.
   printf("#EOF\n");
 
   return ret;
 }
-