git cl format the first third of the net/base directory

net/base/net_util_posix.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/net_util.h"
 
 #include <set>
 #include <sys/types.h>
 
 #include "base/files/file_path.h"
@@ skipping 62 matching lines @@
   } else {
     // Skip non-IP addresses.
     return true;
   }
   return false;
 }
 
 #if defined(OS_MACOSX)
 
 struct NetworkInterfaceInfo {
-  NetworkInterfaceInfo() : permanent(true) { }
+  NetworkInterfaceInfo() : permanent(true) {}
 
   bool permanent;  // IPv6 has notion of temporary address. If the address is
                    // IPv6 and it's temporary this field will be false.
   NetworkInterface interface;
 };
 
 // This method will remove permanent IPv6 addresses if a temporary address
 // is available for same network interface.
 void RemovePermanentIPv6AddressesWhereTemporaryExists(
     std::vector<NetworkInterfaceInfo>* infos) {
   if (!infos || infos->empty())
     return;
 
   // Build a set containing the names of interfaces with a temp IPv6 address
   std::set<std::string> ifaces_with_temp_addrs;
   std::vector<NetworkInterfaceInfo>::iterator i;
   for (i = infos->begin(); i != infos->end(); ++i) {
     if (!i->permanent && i->interface.address.size() == kIPv6AddressSize) {
       ifaces_with_temp_addrs.insert(i->interface.name);
     }
   }
 
   // If there are no such interfaces then there's no further work.
   if (ifaces_with_temp_addrs.empty())
     return;
 
   // Search for permenent addresses belonging to same network interface.
-  for (i = infos->begin(); i != infos->end(); ) {
+  for (i = infos->begin(); i != infos->end();) {
     // If the address is IPv6 and it's permanent and there is temporary
     // address for it, then we can remove this address.
     if ((i->interface.address.size() == kIPv6AddressSize) && i->permanent &&
         (ifaces_with_temp_addrs.find(i->interface.name) !=
-            ifaces_with_temp_addrs.end())) {
+         ifaces_with_temp_addrs.end())) {
       i = infos->erase(i);
     } else {
       ++i;
     }
   }
 }
 
 #if !defined(OS_IOS)
 NetworkChangeNotifier::ConnectionType GetNetworkInterfaceType(
-    int addr_family, const std::string& interface_name) {
+    int addr_family,
+    const std::string& interface_name) {
   NetworkChangeNotifier::ConnectionType type =
       NetworkChangeNotifier::CONNECTION_UNKNOWN;
 
   struct ifmediareq ifmr = {};
   strncpy(ifmr.ifm_name, interface_name.c_str(), sizeof(ifmr.ifm_name) - 1);
 
   int s = socket(addr_family, SOCK_DGRAM, 0);
   if (s == -1) {
     return type;
   }
@@ skipping 17 matching lines @@
 // layer.
 bool TryConvertNativeToNetIPAttributes(int native_attributes,
                                        int* net_attributes) {
   // For Linux/ChromeOS/Android, we disallow addresses with attributes
   // IFA_F_OPTIMISTIC, IFA_F_DADFAILED, and IFA_F_TENTATIVE as these
   // are still progressing through duplicated address detection (DAD)
   // and shouldn't be used by the application layer until DAD process
   // is completed.
   if (native_attributes & (
 #if !defined(OS_ANDROID)
-    IFA_F_OPTIMISTIC | IFA_F_DADFAILED |
+                              IFA_F_OPTIMISTIC | IFA_F_DADFAILED |
 #endif  // !OS_ANDROID
-    IFA_F_TENTATIVE)) {
+                              IFA_F_TENTATIVE)) {
     return false;
   }
 
   if (native_attributes & IFA_F_TEMPORARY) {
     *net_attributes |= IP_ADDRESS_ATTRIBUTE_TEMPORARY;
   }
 
   if (native_attributes & IFA_F_DEPRECATED) {
     *net_attributes |= IP_ADDRESS_ATTRIBUTE_DEPRECATED;
   }
@@ skipping 18 matching lines @@
 bool GetNetworkListImpl(
     NetworkInterfaceList* networks,
     int policy,
     const base::hash_set<int>& online_links,
     const internal::AddressTrackerLinux::AddressMap& address_map,
     GetInterfaceNameFunction get_interface_name) {
   std::map<int, std::string> ifnames;
 
   for (internal::AddressTrackerLinux::AddressMap::const_iterator it =
            address_map.begin();
-       it != address_map.end();
-       ++it) {
+       it != address_map.end(); ++it) {
     // Ignore addresses whose links are not online.
     if (online_links.find(it->second.ifa_index) == online_links.end())
       continue;
 
     sockaddr_storage sock_addr;
     socklen_t sock_len = sizeof(sockaddr_storage);
 
     // Convert to sockaddr for next check.
     if (!IPEndPoint(it->first, 0)
              .ToSockAddr(reinterpret_cast<sockaddr*>(&sock_addr), &sock_len)) {
@@ skipping 29 matching lines @@
     } else {
       ifname = itname->second;
     }
 
     // Based on the interface name and policy, determine whether we
     // should ignore it.
     if (ShouldIgnoreInterface(ifname, policy))
       continue;
 
     networks->push_back(
-        NetworkInterface(ifname,
-                         ifname,
-                         it->second.ifa_index,
-                         NetworkChangeNotifier::CONNECTION_UNKNOWN,
-                         it->first,
-                         it->second.ifa_prefixlen,
-                         ip_attributes));
+        NetworkInterface(ifname, ifname, it->second.ifa_index,
+                         NetworkChangeNotifier::CONNECTION_UNKNOWN, it->first,
+                         it->second.ifa_prefixlen, ip_attributes));
   }
 
   return true;
 }
 #endif
 
 }  // namespace internal
 
 bool GetNetworkList(NetworkInterfaceList* networks, int policy) {
   if (networks == NULL)
     return false;
 #if defined(OS_NACL)
   NOTIMPLEMENTED();
   return false;
 #elif !defined(OS_MACOSX)
 
   internal::AddressTrackerLinux tracker;
   tracker.Init();
 
-  return internal::GetNetworkListImpl(networks,
-                                      policy,
+  return internal::GetNetworkListImpl(networks, policy,
                                       tracker.GetOnlineLinks(),
-                                      tracker.GetAddressMap(),
-                                      &if_indextoname);
+                                      tracker.GetAddressMap(), &if_indextoname);
 
 #else  // Only OS_MACOSX and OS_IOS will run the code below
 
   // getifaddrs() may require IO operations.
   base::ThreadRestrictions::AssertIOAllowed();
 
 #if !defined(OS_IOS)
   int ioctl_socket = -1;
   if (policy & INCLUDE_ONLY_TEMP_IPV6_ADDRESS_IF_POSSIBLE) {
     // we need a socket to query information about temporary address.
     ioctl_socket = socket(AF_INET6, SOCK_DGRAM, 0);
     DCHECK_GT(ioctl_socket, 0);
   }
 #endif
 
   ifaddrs* interfaces;
   if (getifaddrs(&interfaces) < 0) {
     PLOG(ERROR) << "getifaddrs";
     return false;
   }
 
   std::vector<NetworkInterfaceInfo> network_infos;
 
   // Enumerate the addresses assigned to network interfaces which are up.
-  for (ifaddrs *interface = interfaces;
-       interface != NULL;
+  for (ifaddrs* interface = interfaces; interface != NULL;
        interface = interface->ifa_next) {
     // Skip loopback interfaces, and ones which are down.
     if (!(IFF_UP & interface->ifa_flags))
       continue;
     if (IFF_LOOPBACK & interface->ifa_flags)
       continue;
     // Skip interfaces with no address configured.
     struct sockaddr* addr = interface->ifa_addr;
     if (!addr)
       continue;
@@ skipping 43 matching lines @@
       if (interface->ifa_netmask) {
         // If not otherwise set, assume the same sa_family as ifa_addr.
         if (interface->ifa_netmask->sa_family == 0) {
           interface->ifa_netmask->sa_family = addr->sa_family;
         }
         IPEndPoint netmask;
         if (netmask.FromSockAddr(interface->ifa_netmask, addr_size)) {
           net_mask = MaskPrefixLength(netmask.address());
         }
       }
-      network_info.interface = NetworkInterface(name,
-                                                name,
-                                                if_nametoindex(name.c_str()),
-                                                connection_type,
-                                                address.address(),
-                                                net_mask,
-                                                IP_ADDRESS_ATTRIBUTE_NONE);
+      network_info.interface = NetworkInterface(
+          name, name, if_nametoindex(name.c_str()), connection_type,
+          address.address(), net_mask, IP_ADDRESS_ATTRIBUTE_NONE);
 
       network_infos.push_back(NetworkInterfaceInfo(network_info));
     }
   }
   freeifaddrs(interfaces);
 #if !defined(OS_IOS)
   if (ioctl_socket >= 0) {
     close(ioctl_socket);
   }
 #endif
@@ skipping 10 matching lines @@
 }
 
 WifiPHYLayerProtocol GetWifiPHYLayerProtocol() {
   return WIFI_PHY_LAYER_PROTOCOL_UNKNOWN;
 }
 
 scoped_ptr<ScopedWifiOptions> SetWifiOptions(int options) {
   return scoped_ptr<ScopedWifiOptions>();
 }
 
-
 }  // namespace net