[NaCl SDK] nacl_io: Run clang-format over nacl_io sources.

native_client_sdk/src/libraries/nacl_io/host_resolver.cc

 // Copyright 2013 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 "nacl_io/host_resolver.h"
 
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ skipping 40 matching lines @@
     case AF_INET6: {
       sockaddr_in6* in =
           static_cast<sockaddr_in6*>(malloc(sizeof(sockaddr_in6)));
       *in = *(sockaddr_in6*)addr;
       ai->ai_family = AF_INET6;
       ai->ai_addr = reinterpret_cast<sockaddr*>(in);
       ai->ai_addrlen = sizeof(*in);
       break;
     }
     case AF_INET: {
-      sockaddr_in* in =
-          static_cast<sockaddr_in*>(malloc(sizeof(sockaddr_in)));
+      sockaddr_in* in = static_cast<sockaddr_in*>(malloc(sizeof(sockaddr_in)));
       *in = *(sockaddr_in*)addr;
       ai->ai_family = AF_INET;
       ai->ai_addr = reinterpret_cast<sockaddr*>(in);
       ai->ai_addrlen = sizeof(*in);
       break;
     }
     default:
       assert(0);
       return;
   }
@@ skipping 126 matching lines @@
 
 #if !defined(h_addr)
   // Copy element zero of h_addr_list to h_addr when h_addr is not defined
   // as in some libc's h_addr may be a separate member instead of a macro.
   hostent_.h_addr = hostent_.h_addr_list[0];
 #endif
 
   return &hostent_;
 }
 
-void HostResolver::freeaddrinfo(struct addrinfo *res) {
+void HostResolver::freeaddrinfo(struct addrinfo* res) {
   while (res) {
     struct addrinfo* cur = res;
     res = res->ai_next;
     free(cur->ai_addr);
     free(cur->ai_canonname);
     free(cur);
   }
 }
 
-int HostResolver::getaddrinfo(const char* node, const char* service,
+int HostResolver::getaddrinfo(const char* node,
+                              const char* service,
                               const struct addrinfo* hints_in,
                               struct addrinfo** result) {
   *result = NULL;
   struct addrinfo* end = NULL;
 
   if (node == NULL && service == NULL)
     return EAI_NONAME;
 
   // Check the service name (port).  Currently we only handle numeric
   // services.
@@ skipping 106 matching lines @@
   if (hints->ai_flags & AI_CANONNAME) {
     PP_Var name_var = resolver_iface->GetCanonicalName(resolver);
     if (PP_VARTYPE_STRING == name_var.type) {
       uint32_t len = 0;
       const char* tmp = var_interface->VarToUtf8(name_var, &len);
       // For some reason GetCanonicalName alway returns an empty
       // string so this condition is never true.
       // TODO(sbc): investigate this issue with PPAPI team.
       if (len > 0) {
         // Copy and NULL-terminate the UTF8 string var.
-        canon_name = static_cast<char*>(malloc(len+1));
+        canon_name = static_cast<char*>(malloc(len + 1));
         strncpy(canon_name, tmp, len);
         canon_name[len] = '\0';
       }
     }
     if (!canon_name)
       canon_name = strdup(node);
     var_interface->Release(name_var);
   }
 
   int num_addresses = resolver_iface->GetNetAddressCount(resolver);
@@ skipping 17 matching lines @@
         memcpy(&addr_in.sin_addr.s_addr, pp_addr.addr, sizeof(in_addr_t));
         sockaddr = (struct sockaddr*)&addr_in;
         break;
       }
       case PP_NETADDRESS_FAMILY_IPV6: {
         struct PP_NetAddress_IPv6 pp_addr;
         if (!netaddr_iface->DescribeAsIPv6Address(resource, &pp_addr)) {
           assert(false);
           break;
         }
-        memcpy(&addr_in6.sin6_addr.s6_addr, pp_addr.addr,
-               sizeof(in6_addr));
+        memcpy(&addr_in6.sin6_addr.s6_addr, pp_addr.addr, sizeof(in6_addr));
         sockaddr = (struct sockaddr*)&addr_in6;
         break;
       }
       default:
         return EAI_SYSTEM;
     }
 
     if (sockaddr != NULL)
       CreateAddrInfo(hints, sockaddr, canon_name, result, &end);
 
     if (canon_name) {
       free(canon_name);
       canon_name = NULL;
     }
   }
 
   return 0;
 }
 
 // Frees all of the deep pointers in a hostent struct. Called between uses of
 // gethostbyname, and when the kernel_proxy object is destroyed.
 void HostResolver::hostent_cleanup() {
   if (NULL != hostent_.h_name) {
     free(hostent_.h_name);
   }
   if (NULL != hostent_.h_aliases) {
-    for (int i = 0;  NULL != hostent_.h_aliases[i]; i++) {
+    for (int i = 0; NULL != hostent_.h_aliases[i]; i++) {
       free(hostent_.h_aliases[i]);
     }
     free(hostent_.h_aliases);
   }
   if (NULL != hostent_.h_addr_list) {
-    for (int i = 0;  NULL != hostent_.h_addr_list[i]; i++) {
+    for (int i = 0; NULL != hostent_.h_addr_list[i]; i++) {
       free(hostent_.h_addr_list[i]);
     }
     free(hostent_.h_addr_list);
   }
   hostent_.h_name = NULL;
   hostent_.h_aliases = NULL;
   hostent_.h_addr_list = NULL;
 #if !defined(h_addr)
   // Initialize h_addr separately in the case where it is not a macro.
   hostent_.h_addr = NULL;
 #endif
 }
 
 }  // namespace nacl_io
 
 #endif  // PROVIDES_SOCKET_API