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

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 92 matching lines @@
     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 36 matching lines @@
 AddressTrackerLinux::GetCurrentConnectionType() {
   // http://crbug.com/125097
   base::ThreadRestrictions::ScopedAllowWait allow_wait;
   AddressTrackerAutoLock lock(*this, 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;
   for (;;) {
     int rv = HANDLE_EINTR(recv(netlink_fd_,
                                buffer,
                                sizeof(buffer),
                                // Block the first time through loop.
-                               first_loop ? 0 : MSG_DONTWAIT));
+                                   first_loop
+                                   ? 0
+                                   : MSG_DONTWAIT));

[davidben, 2014/10/10 20:24:15]

This looks like a clang-format bug.

     first_loop = false;
     if (rv == 0) {
       LOG(ERROR) << "Unexpected shutdown of NETLINK socket.";
       return;
     }
     if (rv < 0) {
       if ((errno == EAGAIN) || (errno == EWOULDBLOCK))
         break;
       PLOG(ERROR) << "Failed to recv from netlink socket";
       return;
@@ skipping 20 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;

[davidben, 2014/10/10 20:24:15]

Both of these seem pretty off. Move the return inside the block?

       case RTM_NEWADDR: {
         IPAddressNumber address;
         bool really_deprecated;
         if (GetAddress(header, &address, &really_deprecated)) {
           AddressTrackerAutoLock lock(*this, 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 66 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;
@@ skipping 12 matching lines @@
 
 AddressTrackerLinux::AddressTrackerAutoLock::~AddressTrackerAutoLock() {
   if (tracker_.tracking_) {
     lock_.AssertAcquired();
     lock_.Release();
   }
 }
 
 }  // namespace internal
 }  // namespace net