Clang format slam.

net/base/address_tracker_linux.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/base/address_tracker_linux.h"
 
 #include <errno.h>
 #include <linux/if.h>
 #include <sys/ioctl.h>
 
@@ skipping 41 matching lines @@
     switch (attr->rta_type) {
       case IFA_ADDRESS:
         DCHECK_GE(RTA_PAYLOAD(attr), address_length);
         address = reinterpret_cast<unsigned char*>(RTA_DATA(attr));
         break;
       case IFA_LOCAL:
         DCHECK_GE(RTA_PAYLOAD(attr), address_length);
         local = reinterpret_cast<unsigned char*>(RTA_DATA(attr));
         break;
       case IFA_CACHEINFO: {
-        const struct ifa_cacheinfo *cache_info =
+        const struct ifa_cacheinfo* cache_info =
             reinterpret_cast<const struct ifa_cacheinfo*>(RTA_DATA(attr));
         if (really_deprecated)
           *really_deprecated = (cache_info->ifa_prefered == 0);
       } break;
       default:
         break;
     }
   }
   if (local)
     address = local;
@@ skipping 49 matching lines @@
     PLOG(ERROR) << "Could not create NETLINK socket";
     AbortAndForceOnline();
     return;
   }
 
   // Request notifications.
   struct sockaddr_nl addr = {};
   addr.nl_family = AF_NETLINK;
   addr.nl_pid = getpid();
   // TODO(szym): Track RTMGRP_LINK as well for ifi_type, http://crbug.com/113993
-  addr.nl_groups = RTMGRP_IPV4_IFADDR | RTMGRP_IPV6_IFADDR | RTMGRP_NOTIFY |
-      RTMGRP_LINK;
-  int rv = bind(netlink_fd_,
-                reinterpret_cast<struct sockaddr*>(&addr),
-                sizeof(addr));
+  addr.nl_groups =
+      RTMGRP_IPV4_IFADDR | RTMGRP_IPV6_IFADDR | RTMGRP_NOTIFY | RTMGRP_LINK;
+  int rv = bind(
+      netlink_fd_, reinterpret_cast<struct sockaddr*>(&addr), sizeof(addr));
   if (rv < 0) {
     PLOG(ERROR) << "Could not bind NETLINK socket";
     AbortAndForceOnline();
     return;
   }
 
   // Request dump of addresses.
   struct sockaddr_nl peer = {};
   peer.nl_family = AF_NETLINK;
 
   struct {
     struct nlmsghdr header;
     struct rtgenmsg msg;
   } request = {};
 
   request.header.nlmsg_len = NLMSG_LENGTH(sizeof(request.msg));
   request.header.nlmsg_type = RTM_GETADDR;
   request.header.nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP;
   request.header.nlmsg_pid = getpid();
   request.msg.rtgen_family = AF_UNSPEC;
 
-  rv = HANDLE_EINTR(sendto(netlink_fd_, &request, request.header.nlmsg_len,
-                           0, reinterpret_cast<struct sockaddr*>(&peer),
+  rv = HANDLE_EINTR(sendto(netlink_fd_,
+                           &request,
+                           request.header.nlmsg_len,
+                           0,
+                           reinterpret_cast<struct sockaddr*>(&peer),
                            sizeof(peer)));
   if (rv < 0) {
     PLOG(ERROR) << "Could not send NETLINK request";
     AbortAndForceOnline();
     return;
   }
 
   // Consume pending message to populate the AddressMap, but don't notify.
   // Sending another request without first reading responses results in EBUSY.
   bool address_changed;
   bool link_changed;
   bool tunnel_changed;
   ReadMessages(&address_changed, &link_changed, &tunnel_changed);
 
   // Request dump of link state
   request.header.nlmsg_type = RTM_GETLINK;
 
-  rv = HANDLE_EINTR(sendto(netlink_fd_, &request, request.header.nlmsg_len, 0,
+  rv = HANDLE_EINTR(sendto(netlink_fd_,
+                           &request,
+                           request.header.nlmsg_len,
+                           0,
                            reinterpret_cast<struct sockaddr*>(&peer),
                            sizeof(peer)));
   if (rv < 0) {
     PLOG(ERROR) << "Could not send NETLINK request";
     AbortAndForceOnline();
     return;
   }
 
   // Consume pending message to populate links_online_, but don't notify.
   ReadMessages(&address_changed, &link_changed, &tunnel_changed);
@@ skipping 29 matching lines @@
 AddressTrackerLinux::GetCurrentConnectionType() {
   // http://crbug.com/125097
   base::ThreadRestrictions::ScopedAllowWait allow_wait;
   base::AutoLock lock(is_offline_lock_);
   // Make sure the initial offline state is set before returning.
   while (!is_offline_initialized_) {
     is_offline_initialized_cv_.Wait();
   }
   // TODO(droger): Return something more detailed than CONNECTION_UNKNOWN.
   // http://crbug.com/160537
-  return is_offline_ ? NetworkChangeNotifier::CONNECTION_NONE :
-                       NetworkChangeNotifier::CONNECTION_UNKNOWN;
+  return is_offline_ ? NetworkChangeNotifier::CONNECTION_NONE
+                     : NetworkChangeNotifier::CONNECTION_UNKNOWN;
 }
 
 void AddressTrackerLinux::ReadMessages(bool* address_changed,
                                        bool* link_changed,
                                        bool* tunnel_changed) {
   *address_changed = false;
   *link_changed = false;
   *tunnel_changed = false;
   char buffer[4096];
   bool first_loop = true;
@@ skipping 31 matching lines @@
   for (struct nlmsghdr* header = reinterpret_cast<struct nlmsghdr*>(buffer);
        NLMSG_OK(header, length);
        header = NLMSG_NEXT(header, length)) {
     switch (header->nlmsg_type) {
       case NLMSG_DONE:
         return;
       case NLMSG_ERROR: {
         const struct nlmsgerr* msg =
             reinterpret_cast<struct nlmsgerr*>(NLMSG_DATA(header));
         LOG(ERROR) << "Unexpected netlink error " << msg->error << ".";
-      } return;
+      }
+        return;
       case RTM_NEWADDR: {
         IPAddressNumber address;
         bool really_deprecated;
         if (GetAddress(header, &address, &really_deprecated)) {
           base::AutoLock lock(address_map_lock_);
           struct ifaddrmsg* msg =
               reinterpret_cast<struct ifaddrmsg*>(NLMSG_DATA(header));
           // Routers may frequently (every few seconds) output the IPv6 ULA
           // prefix which can cause the linux kernel to frequently output two
           // back-to-back messages, one without the deprecated flag and one with
@@ skipping 63 matching lines @@
   bool tunnel_changed;
   ReadMessages(&address_changed, &link_changed, &tunnel_changed);
   if (address_changed)
     address_callback_.Run();
   if (link_changed)
     link_callback_.Run();
   if (tunnel_changed)
     tunnel_callback_.Run();
 }
 
-void AddressTrackerLinux::OnFileCanWriteWithoutBlocking(int /* fd */) {}
+void AddressTrackerLinux::OnFileCanWriteWithoutBlocking(int /* fd */) {
+}
 
 void AddressTrackerLinux::CloseSocket() {
   if (netlink_fd_ >= 0 && IGNORE_EINTR(close(netlink_fd_)) < 0)
     PLOG(ERROR) << "Could not close NETLINK socket.";
   netlink_fd_ = -1;
 }
 
 bool AddressTrackerLinux::IsTunnelInterface(const struct ifinfomsg* msg) const {
   // Linux kernel drivers/net/tun.c uses "tun" name prefix.
   return strncmp(get_interface_name_(msg->ifi_index), "tun", 3) == 0;
 }
 
 }  // namespace internal
 }  // namespace net