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

net/base/address_tracker_linux_unittest.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 "base/memory/scoped_ptr.h"
 #include "net/base/address_tracker_linux.h"
 
 #include <linux/if.h>
 
 #include <vector>
@@ skipping 35 matching lines @@
     }
     original_get_interface_name_ = tracker_->get_interface_name_;
     tracker_->get_interface_name_ = TestGetInterfaceName;
   }
 
   bool HandleAddressMessage(const Buffer& buf) {
     Buffer writable_buf = buf;
     bool address_changed = false;
     bool link_changed = false;
     bool tunnel_changed = false;
-    tracker_->HandleMessage(&writable_buf[0], buf.size(),
-                           &address_changed, &link_changed, &tunnel_changed);
+    tracker_->HandleMessage(&writable_buf[0], buf.size(), &address_changed,
+                            &link_changed, &tunnel_changed);
     EXPECT_FALSE(link_changed);
     return address_changed;
   }
 
   bool HandleLinkMessage(const Buffer& buf) {
     Buffer writable_buf = buf;
     bool address_changed = false;
     bool link_changed = false;
     bool tunnel_changed = false;
-    tracker_->HandleMessage(&writable_buf[0], buf.size(),
-                           &address_changed, &link_changed, &tunnel_changed);
+    tracker_->HandleMessage(&writable_buf[0], buf.size(), &address_changed,
+                            &link_changed, &tunnel_changed);
     EXPECT_FALSE(address_changed);
     return link_changed;
   }
 
   bool HandleTunnelMessage(const Buffer& buf) {
     Buffer writable_buf = buf;
     bool address_changed = false;
     bool link_changed = false;
     bool tunnel_changed = false;
-    tracker_->HandleMessage(&writable_buf[0], buf.size(),
-                           &address_changed, &link_changed, &tunnel_changed);
+    tracker_->HandleMessage(&writable_buf[0], buf.size(), &address_changed,
+                            &link_changed, &tunnel_changed);
     EXPECT_FALSE(address_changed);
     return tunnel_changed;
   }
 
   AddressTrackerLinux::AddressMap GetAddressMap() {
     return tracker_->GetAddressMap();
   }
 
   const base::hash_set<int> GetOnlineLinks() const {
     return tracker_->GetOnlineLinks();
   }
 
   scoped_ptr<AddressTrackerLinux> tracker_;
   AddressTrackerLinux::GetInterfaceNameFunction original_get_interface_name_;
 };
 
 namespace {
 
 class NetlinkMessage {
  public:
   explicit NetlinkMessage(uint16 type) : buffer_(NLMSG_HDRLEN) {
     header()->nlmsg_type = type;
     Align();
   }
 
   void AddPayload(const void* data, size_t length) {
-    CHECK_EQ(static_cast<size_t>(NLMSG_HDRLEN),
-             buffer_.size()) << "Payload must be added first";
+    CHECK_EQ(static_cast<size_t>(NLMSG_HDRLEN), buffer_.size())
+        << "Payload must be added first";
     Append(data, length);
     Align();
   }
 
   void AddAttribute(uint16 type, const void* data, size_t length) {
     struct nlattr attr;
     attr.nla_len = NLA_HDRLEN + length;
     attr.nla_type = type;
     Append(&attr, sizeof(attr));
     Align();
@@ skipping 65 matching lines @@
 void MakeLinkMessage(uint16 type, uint32 flags, uint32 index, Buffer* output) {
   NetlinkMessage nlmsg(type);
   struct ifinfomsg msg = {};
   msg.ifi_index = index;
   msg.ifi_flags = flags;
   nlmsg.AddPayload(&msg, sizeof(msg));
   output->clear();
   nlmsg.AppendTo(output);
 }
 
-const unsigned char kAddress0[] = { 127, 0, 0, 1 };
-const unsigned char kAddress1[] = { 10, 0, 0, 1 };
-const unsigned char kAddress2[] = { 192, 168, 0, 1 };
-const unsigned char kAddress3[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                                    0, 0, 0, 1 };
+const unsigned char kAddress0[] = {127, 0, 0, 1};
+const unsigned char kAddress1[] = {10, 0, 0, 1};
+const unsigned char kAddress2[] = {192, 168, 0, 1};
+const unsigned char kAddress3[] =
+    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
 
 TEST_F(AddressTrackerLinuxTest, NewAddress) {
   InitializeAddressTracker(true);
 
   const IPAddressNumber kEmpty;
   const IPAddressNumber kAddr0(kAddress0, kAddress0 + arraysize(kAddress0));
   const IPAddressNumber kAddr1(kAddress1, kAddress1 + arraysize(kAddress1));
   const IPAddressNumber kAddr2(kAddress2, kAddress2 + arraysize(kAddress2));
   const IPAddressNumber kAddr3(kAddress3, kAddress3 + arraysize(kAddress3));
 
@@ skipping 191 matching lines @@
   EXPECT_EQ(1u, GetAddressMap().size());
 }
 
 TEST_F(AddressTrackerLinuxTest, AddInterface) {
   InitializeAddressTracker(true);
 
   Buffer buffer;
 
   // Ignores loopback.
   MakeLinkMessage(RTM_NEWLINK,
-                  IFF_LOOPBACK | IFF_UP | IFF_LOWER_UP | IFF_RUNNING,
-                  0, &buffer);
+                  IFF_LOOPBACK | IFF_UP | IFF_LOWER_UP | IFF_RUNNING, 0,
+                  &buffer);
   EXPECT_FALSE(HandleLinkMessage(buffer));
   EXPECT_TRUE(GetOnlineLinks().empty());
 
   // Ignores not IFF_LOWER_UP.
   MakeLinkMessage(RTM_NEWLINK, IFF_UP | IFF_RUNNING, 0, &buffer);
   EXPECT_FALSE(HandleLinkMessage(buffer));
   EXPECT_TRUE(GetOnlineLinks().empty());
 
   // Ignores deletion.
   MakeLinkMessage(RTM_DELLINK, IFF_UP | IFF_LOWER_UP | IFF_RUNNING, 0, &buffer);
@@ skipping 52 matching lines @@
   EXPECT_TRUE(GetOnlineLinks().empty());
 }
 
 TEST_F(AddressTrackerLinuxTest, TunnelInterface) {
   InitializeAddressTracker(true);
 
   Buffer buffer;
 
   // Ignores without "tun" prefixed name.
   MakeLinkMessage(RTM_NEWLINK,
-                  IFF_UP | IFF_LOWER_UP | IFF_RUNNING | IFF_POINTOPOINT,
-                  0, &buffer);
+                  IFF_UP | IFF_LOWER_UP | IFF_RUNNING | IFF_POINTOPOINT, 0,
+                  &buffer);
   EXPECT_FALSE(HandleTunnelMessage(buffer));
 
   // Verify success.
   MakeLinkMessage(RTM_NEWLINK,
                   IFF_UP | IFF_LOWER_UP | IFF_RUNNING | IFF_POINTOPOINT,
                   kTestInterfaceTun, &buffer);
   EXPECT_TRUE(HandleTunnelMessage(buffer));
 
   // Ignores redundant enables.
   MakeLinkMessage(RTM_NEWLINK,
                   IFF_UP | IFF_LOWER_UP | IFF_RUNNING | IFF_POINTOPOINT,
                   kTestInterfaceTun, &buffer);
   EXPECT_FALSE(HandleTunnelMessage(buffer));
 
   // Ignores deleting without "tun" prefixed name.
   MakeLinkMessage(RTM_DELLINK,
-                  IFF_UP | IFF_LOWER_UP | IFF_RUNNING | IFF_POINTOPOINT,
-                  0, &buffer);
+                  IFF_UP | IFF_LOWER_UP | IFF_RUNNING | IFF_POINTOPOINT, 0,
+                  &buffer);
   EXPECT_FALSE(HandleTunnelMessage(buffer));
 
   // Verify successful deletion
   MakeLinkMessage(RTM_DELLINK,
                   IFF_UP | IFF_LOWER_UP | IFF_RUNNING | IFF_POINTOPOINT,
                   kTestInterfaceTun, &buffer);
   EXPECT_TRUE(HandleTunnelMessage(buffer));
 
   // Ignores redundant deletions.
   MakeLinkMessage(RTM_DELLINK,
@@ skipping 11 matching lines @@
     EXPECT_NE((const char*)NULL, original_get_interface_name_(i));
 }
 
 TEST_F(AddressTrackerLinuxTest, NonTrackingMode) {
   InitializeAddressTracker(false);
 
   const IPAddressNumber kEmpty;
   const IPAddressNumber kAddr0(kAddress0, kAddress0 + arraysize(kAddress0));
 
   Buffer buffer;
-  MakeAddrMessage(
-      RTM_NEWADDR, IFA_F_TEMPORARY, AF_INET, kAddr0, kEmpty, &buffer);
+  MakeAddrMessage(RTM_NEWADDR, IFA_F_TEMPORARY, AF_INET, kAddr0, kEmpty,
+                  &buffer);
   EXPECT_TRUE(HandleAddressMessage(buffer));
   AddressTrackerLinux::AddressMap map = GetAddressMap();
   EXPECT_EQ(1u, map.size());
   EXPECT_EQ(1u, map.count(kAddr0));
   EXPECT_EQ(IFA_F_TEMPORARY, map[kAddr0].ifa_flags);
 
   MakeLinkMessage(RTM_NEWLINK, IFF_UP | IFF_LOWER_UP | IFF_RUNNING, 0, &buffer);
   EXPECT_TRUE(HandleLinkMessage(buffer));
   EXPECT_EQ(1u, GetOnlineLinks().count(0));
   EXPECT_EQ(1u, GetOnlineLinks().size());
 }
 
 TEST_F(AddressTrackerLinuxTest, NonTrackingModeInit) {
   AddressTrackerLinux tracker;
   tracker.Init();
 }
 
 }  // namespace
 
 }  // namespace internal
 }  // namespace net