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

net/base/net_util_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 "net/base/net_util.h"
 
 #include <string.h>
 
 #include <ostream>
 
@@ skipping 64 matching lines @@
 }
 
 }  // anonymous namespace
 
 TEST(NetUtilTest, GetIdentityFromURL) {
   struct {
     const char* input_url;
     const char* expected_username;
     const char* expected_password;
   } tests[] = {
-    {
-      "http://username:password@google.com",
-      "username",
-      "password",
-    },
-    { // Test for http://crbug.com/19200
-      "http://username:p@ssword@google.com",
-      "username",
-      "p@ssword",
-    },
-    { // Special URL characters should be unescaped.
-      "http://username:p%3fa%26s%2fs%23@google.com",
-      "username",
-      "p?a&s/s#",
-    },
-    { // Username contains %20.
-      "http://use rname:password@google.com",
-      "use rname",
-      "password",
-    },
-    { // Keep %00 as is.
-      "http://use%00rname:password@google.com",
-      "use%00rname",
-      "password",
-    },
-    { // Use a '+' in the username.
-      "http://use+rname:password@google.com",
-      "use+rname",
-      "password",
-    },
-    { // Use a '&' in the password.
-      "http://username:p&ssword@google.com",
-      "username",
-      "p&ssword",
-    },
-  };
+        {
+         "http://username:password@google.com", "username", "password",
+        },
+        {// Test for http://crbug.com/19200
+         "http://username:p@ssword@google.com",
+         "username",
+         "p@ssword",
+        },
+        {// Special URL characters should be unescaped.
+         "http://username:p%3fa%26s%2fs%23@google.com",
+         "username",
+         "p?a&s/s#",
+        },
+        {// Username contains %20.
+         "http://use rname:password@google.com",
+         "use rname",
+         "password",
+        },
+        {// Keep %00 as is.
+         "http://use%00rname:password@google.com",
+         "use%00rname",
+         "password",
+        },
+        {// Use a '+' in the username.
+         "http://use+rname:password@google.com",
+         "use+rname",
+         "password",
+        },
+        {// Use a '&' in the password.
+         "http://username:p&ssword@google.com",
+         "username",
+         "p&ssword",
+        },
+    };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
-    SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]: %s", i,
-                                    tests[i].input_url));
+    SCOPED_TRACE(
+        base::StringPrintf("Test[%" PRIuS "]: %s", i, tests[i].input_url));
     GURL url(tests[i].input_url);
 
     base::string16 username, password;
     GetIdentityFromURL(url, &username, &password);
 
     EXPECT_EQ(ASCIIToUTF16(tests[i].expected_username), username);
     EXPECT_EQ(ASCIIToUTF16(tests[i].expected_password), password);
   }
 }
 
@@ skipping 19 matching lines @@
     "Content-TYPE: text/html; charset=utf-8\n"
     "Content-disposition: attachment; filename=\"download.pdf\"\n"
     "Content-Length: 378557\n"
     "X-Google-Google1: 314159265\n"
     "X-Google-Google2: aaaa2:7783,bbb21:9441\n"
     "X-Google-Google4: home\n"
     "Transfer-Encoding: chunked\n"
     "Set-Cookie: HEHE_AT=6666x66beef666x6-66xx6666x66; Path=/mail\n"
     "Set-Cookie: HEHE_HELP=owned:0;Path=/\n"
     "Set-Cookie: S=gmail=Xxx-beefbeefbeef_beefb:gmail_yj=beefbeef000beefbee"
-       "fbee:gmproxy=bee-fbeefbe; Domain=.google.com; Path=/\n"
+    "fbee:gmproxy=bee-fbeefbe; Domain=.google.com; Path=/\n"
     "X-Google-Google2: /one/two/three/four/five/six/seven-height/nine:9411\n"
     "Server: GFE/1.3\n"
     "Transfer-Encoding: chunked\n"
     "Date: Mon, 13 Nov 2006 21:38:09 GMT\n"
     "Expires: Tue, 14 Nov 2006 19:23:58 GMT\n"
     "X-Malformed: bla; arg=test\"\n"
     "X-Malformed2: bla; arg=\n"
     "X-Test: bla; arg1=val1; arg2=val2";
 
 TEST(NetUtilTest, GetSpecificHeader) {
   const HeaderCase tests[] = {
-    {"content-type", "text/html; charset=utf-8"},
-    {"CONTENT-LENGTH", "378557"},
-    {"Date", "Mon, 13 Nov 2006 21:38:09 GMT"},
-    {"Bad-Header", ""},
-    {"", ""},
+      {"content-type", "text/html; charset=utf-8"},
+      {"CONTENT-LENGTH", "378557"},
+      {"Date", "Mon, 13 Nov 2006 21:38:09 GMT"},
+      {"Bad-Header", ""},
+      {"", ""},
   };
 
   // Test first with google_headers.
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     std::string result =
         GetSpecificHeader(google_headers, tests[i].header_name);
     EXPECT_EQ(result, tests[i].expected);
   }
 
   // Test again with empty headers.
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     std::string result = GetSpecificHeader(std::string(), tests[i].header_name);
     EXPECT_EQ(result, std::string());
   }
 }
 
 TEST(NetUtilTest, CompliantHost) {
   struct CompliantHostCase {
     const char* host;
     bool expected_output;
   };
 
   const CompliantHostCase compliant_host_cases[] = {
-    {"", false},
-    {"a", true},
-    {"-", false},
-    {".", false},
-    {"9", true},
-    {"9a", true},
-    {"a.", true},
-    {"a.a", true},
-    {"9.a", true},
-    {"a.9", true},
-    {"_9a", false},
-    {"-9a", false},
-    {"a.a9", true},
-    {"a.-a9", false},
-    {"a+9a", false},
-    {"-a.a9", true},
-    {"1-.a-b", true},
-    {"1_.a-b", false},
-    {"1-2.a_b", true},
-    {"a.b.c.d.e", true},
-    {"1.2.3.4.5", true},
-    {"1.2.3.4.5.", true},
+      {"", false},
+      {"a", true},
+      {"-", false},
+      {".", false},
+      {"9", true},
+      {"9a", true},
+      {"a.", true},
+      {"a.a", true},
+      {"9.a", true},
+      {"a.9", true},
+      {"_9a", false},
+      {"-9a", false},
+      {"a.a9", true},
+      {"a.-a9", false},
+      {"a+9a", false},
+      {"-a.a9", true},
+      {"1-.a-b", true},
+      {"1_.a-b", false},
+      {"1-2.a_b", true},
+      {"a.b.c.d.e", true},
+      {"1.2.3.4.5", true},
+      {"1.2.3.4.5.", true},
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(compliant_host_cases); ++i) {
     EXPECT_EQ(compliant_host_cases[i].expected_output,
               IsCanonicalizedHostCompliant(compliant_host_cases[i].host));
   }
 }
 
 TEST(NetUtilTest, ParseHostAndPort) {
   const struct {
     const char* input;
     bool success;
     const char* expected_host;
     int expected_port;
-  } tests[] = {
-    // Valid inputs:
-    {"foo:10", true, "foo", 10},
-    {"foo", true, "foo", -1},
-    {
-      "[1080:0:0:0:8:800:200C:4171]:11",
-      true,
-      "1080:0:0:0:8:800:200C:4171",
-      11
-    },
-    {
-      "[1080:0:0:0:8:800:200C:4171]",
-      true,
-      "1080:0:0:0:8:800:200C:4171",
-      -1
-    },
+  } tests[] = {// Valid inputs:
+               {"foo:10", true, "foo", 10},

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

This looks worth a bug. I think it overlaps with an earlier instance? It seems
to get confused with line-comments within an array literal.

+               {"foo", true, "foo", -1},
+               {"[1080:0:0:0:8:800:200C:4171]:11",
+                true,
+                "1080:0:0:0:8:800:200C:4171",
+                11},
+               {"[1080:0:0:0:8:800:200C:4171]",
+                true,
+                "1080:0:0:0:8:800:200C:4171",
+                -1},
 
-    // Because no validation is done on the host, the following are accepted,
-    // even though they are invalid names.
-    {"]", true, "]", -1},
-    {"::1", true, ":", 1},
-    // Invalid inputs:
-    {"foo:bar", false, "", -1},
-    {"foo:", false, "", -1},
-    {":", false, "", -1},
-    {":80", false, "", -1},
-    {"", false, "", -1},
-    {"porttoolong:300000", false, "", -1},
-    {"usrname@host", false, "", -1},
-    {"usrname:password@host", false, "", -1},
-    {":password@host", false, "", -1},
-    {":password@host:80", false, "", -1},
-    {":password@host", false, "", -1},
-    {"@host", false, "", -1},
-    {"[", false, "", -1},
-    {"[]", false, "", -1},
-  };
+               // Because no validation is done on the host, the following are
+               // accepted,
+               // even though they are invalid names.
+               {"]", true, "]", -1},
+               {"::1", true, ":", 1},
+               // Invalid inputs:
+               {"foo:bar", false, "", -1},
+               {"foo:", false, "", -1},
+               {":", false, "", -1},
+               {":80", false, "", -1},
+               {"", false, "", -1},
+               {"porttoolong:300000", false, "", -1},
+               {"usrname@host", false, "", -1},
+               {"usrname:password@host", false, "", -1},
+               {":password@host", false, "", -1},
+               {":password@host:80", false, "", -1},
+               {":password@host", false, "", -1},
+               {"@host", false, "", -1},
+               {"[", false, "", -1},
+               {"[]", false, "", -1},
+    };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     std::string host;
     int port;
     bool ok = ParseHostAndPort(tests[i].input, &host, &port);
 
     EXPECT_EQ(tests[i].success, ok);
 
     if (tests[i].success) {
       EXPECT_EQ(tests[i].expected_host, host);
       EXPECT_EQ(tests[i].expected_port, port);
     }
   }
 }
 
 TEST(NetUtilTest, GetHostAndPort) {
   const struct {
     GURL url;
     const char* expected_host_and_port;
   } tests[] = {
-    { GURL("http://www.foo.com/x"), "www.foo.com:80"},
-    { GURL("http://www.foo.com:21/x"), "www.foo.com:21"},
+        {GURL("http://www.foo.com/x"), "www.foo.com:80"},
+        {GURL("http://www.foo.com:21/x"), "www.foo.com:21"},
 
-    // For IPv6 literals should always include the brackets.
-    { GURL("http://[1::2]/x"), "[1::2]:80"},
-    { GURL("http://[::a]:33/x"), "[::a]:33"},
-  };
+        // For IPv6 literals should always include the brackets.
+        {GURL("http://[1::2]/x"), "[1::2]:80"},
+        {GURL("http://[::a]:33/x"), "[::a]:33"},
+    };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     std::string host_and_port = GetHostAndPort(tests[i].url);
     EXPECT_EQ(std::string(tests[i].expected_host_and_port), host_and_port);
   }
 }
 
 TEST(NetUtilTest, GetHostAndOptionalPort) {
   const struct {
     GURL url;
     const char* expected_host_and_port;
   } tests[] = {
-    { GURL("http://www.foo.com/x"), "www.foo.com"},
-    { GURL("http://www.foo.com:21/x"), "www.foo.com:21"},
+        {GURL("http://www.foo.com/x"), "www.foo.com"},
+        {GURL("http://www.foo.com:21/x"), "www.foo.com:21"},
 
-    // For IPv6 literals should always include the brackets.
-    { GURL("http://[1::2]/x"), "[1::2]"},
-    { GURL("http://[::a]:33/x"), "[::a]:33"},
-  };
+        // For IPv6 literals should always include the brackets.
+        {GURL("http://[1::2]/x"), "[1::2]"},
+        {GURL("http://[::a]:33/x"), "[::a]:33"},
+    };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     std::string host_and_port = GetHostAndOptionalPort(tests[i].url);
     EXPECT_EQ(std::string(tests[i].expected_host_and_port), host_and_port);
   }
 }
 
 TEST(NetUtilTest, IPAddressToString) {
   uint8 addr1[4] = {0, 0, 0, 0};
   EXPECT_EQ("0.0.0.0", IPAddressToString(addr1, sizeof(addr1)));
 
@@ skipping 15 matching lines @@
   uint8 addr3[16] = {0xFE, 0xDC, 0xBA, 0x98};
   EXPECT_EQ("[fedc:ba98::]:8080",
             IPAddressToStringWithPort(addr3, sizeof(addr3), 8080));
 }
 
 TEST(NetUtilTest, NetAddressToString_IPv4) {
   const struct {
     uint8 addr[4];
     const char* result;
   } tests[] = {
-    {{0, 0, 0, 0}, "0.0.0.0"},
-    {{127, 0, 0, 1}, "127.0.0.1"},
-    {{192, 168, 0, 1}, "192.168.0.1"},
-  };
+        {{0, 0, 0, 0}, "0.0.0.0"},
+        {{127, 0, 0, 1}, "127.0.0.1"},
+        {{192, 168, 0, 1}, "192.168.0.1"},
+    };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     SockaddrStorage storage;
     MakeIPv4Address(tests[i].addr, 80, &storage);
     std::string result = NetAddressToString(storage.addr, storage.addr_len);
     EXPECT_EQ(std::string(tests[i].result), result);
   }
 }
 
 TEST(NetUtilTest, NetAddressToString_IPv6) {
   const struct {
     uint8 addr[16];
     const char* result;
   } tests[] = {
-    {{0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, 0xFE, 0xDC, 0xBA,
-      0x98, 0x76, 0x54, 0x32, 0x10},
-     "fedc:ba98:7654:3210:fedc:ba98:7654:3210"},
-  };
+        {{0xFE,
+          0xDC,
+          0xBA,
+          0x98,
+          0x76,
+          0x54,
+          0x32,
+          0x10,
+          0xFE,
+          0xDC,
+          0xBA,
+          0x98,
+          0x76,
+          0x54,
+          0x32,
+          0x10},
+         "fedc:ba98:7654:3210:fedc:ba98:7654:3210"},

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

This block also looks bizarrely indented.

+    };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     SockaddrStorage storage;
     MakeIPv6Address(tests[i].addr, 80, &storage);
     EXPECT_EQ(std::string(tests[i].result),
-        NetAddressToString(storage.addr, storage.addr_len));
+              NetAddressToString(storage.addr, storage.addr_len));
   }
 }
 
 TEST(NetUtilTest, NetAddressToStringWithPort_IPv4) {
   uint8 addr[] = {127, 0, 0, 1};
   SockaddrStorage storage;
   MakeIPv4Address(addr, 166, &storage);
-  std::string result = NetAddressToStringWithPort(storage.addr,
-                                                  storage.addr_len);
+  std::string result =
+      NetAddressToStringWithPort(storage.addr, storage.addr_len);
   EXPECT_EQ("127.0.0.1:166", result);
 }
 
 TEST(NetUtilTest, NetAddressToStringWithPort_IPv6) {
-  uint8 addr[] = {
-      0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, 0xFE, 0xDC, 0xBA,
-      0x98, 0x76, 0x54, 0x32, 0x10
-  };
+  uint8 addr[] = {0xFE,
+                  0xDC,
+                  0xBA,
+                  0x98,
+                  0x76,
+                  0x54,
+                  0x32,
+                  0x10,
+                  0xFE,
+                  0xDC,
+                  0xBA,
+                  0x98,
+                  0x76,
+                  0x54,
+                  0x32,
+                  0x10};

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

Might also be worth a bug to get this on one line?

   SockaddrStorage storage;
   MakeIPv6Address(addr, 361, &storage);
-  std::string result = NetAddressToStringWithPort(storage.addr,
-                                                  storage.addr_len);
+  std::string result =
+      NetAddressToStringWithPort(storage.addr, storage.addr_len);
 
   // May fail on systems that don't support IPv6.
   if (!result.empty())
     EXPECT_EQ("[fedc:ba98:7654:3210:fedc:ba98:7654:3210]:361", result);
 }
 
 TEST(NetUtilTest, GetHostName) {
   // We can't check the result of GetHostName() directly, since the result
   // will differ across machines. Our goal here is to simply exercise the
   // code path, and check that things "look about right".
   std::string hostname = GetHostName();
   EXPECT_FALSE(hostname.empty());
 }
 
 TEST(NetUtilTest, SimplifyUrlForRequest) {
   struct {
     const char* input_url;
     const char* expected_simplified_url;
   } tests[] = {
-    {
-      // Reference section should be stripped.
-      "http://www.google.com:78/foobar?query=1#hash",
-      "http://www.google.com:78/foobar?query=1",
-    },
-    {
-      // Reference section can itself contain #.
-      "http://192.168.0.1?query=1#hash#10#11#13#14",
-      "http://192.168.0.1?query=1",
-    },
-    { // Strip username/password.
-      "http://user:pass@google.com",
-      "http://google.com/",
-    },
-    { // Strip both the reference and the username/password.
-      "http://user:pass@google.com:80/sup?yo#X#X",
-      "http://google.com/sup?yo",
-    },
-    { // Try an HTTPS URL -- strip both the reference and the username/password.
-      "https://user:pass@google.com:80/sup?yo#X#X",
-      "https://google.com:80/sup?yo",
-    },
-    { // Try an FTP URL -- strip both the reference and the username/password.
-      "ftp://user:pass@google.com:80/sup?yo#X#X",
-      "ftp://google.com:80/sup?yo",
-    },
-    { // Try a nonstandard URL
-      "foobar://user:pass@google.com:80/sup?yo#X#X",
-      "foobar://user:pass@google.com:80/sup?yo",
-    },
-  };
+        {// Reference section should be stripped.

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

Array literal with line comment again.

+         "http://www.google.com:78/foobar?query=1#hash",
+         "http://www.google.com:78/foobar?query=1",
+        },
+        {// Reference section can itself contain #.
+         "http://192.168.0.1?query=1#hash#10#11#13#14",
+         "http://192.168.0.1?query=1",
+        },
+        {// Strip username/password.
+         "http://user:pass@google.com",
+         "http://google.com/",
+        },
+        {// Strip both the reference and the username/password.
+         "http://user:pass@google.com:80/sup?yo#X#X",
+         "http://google.com/sup?yo",
+        },
+        {// Try an HTTPS URL -- strip both the reference and the
+         // username/password.
+         "https://user:pass@google.com:80/sup?yo#X#X",
+         "https://google.com:80/sup?yo",
+        },
+        {// Try an FTP URL -- strip both the reference and the
+         // username/password.
+         "ftp://user:pass@google.com:80/sup?yo#X#X",
+         "ftp://google.com:80/sup?yo",
+        },
+        {// Try a nonstandard URL
+         "foobar://user:pass@google.com:80/sup?yo#X#X",
+         "foobar://user:pass@google.com:80/sup?yo",
+        },
+    };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
-    SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]: %s", i,
-                                    tests[i].input_url));
+    SCOPED_TRACE(
+        base::StringPrintf("Test[%" PRIuS "]: %s", i, tests[i].input_url));
     GURL input_url(GURL(tests[i].input_url));
     GURL expected_url(GURL(tests[i].expected_simplified_url));
     EXPECT_EQ(expected_url, SimplifyUrlForRequest(input_url));
   }
 }
 
 TEST(NetUtilTest, SetExplicitlyAllowedPortsTest) {
-  std::string invalid[] = { "1,2,a", "'1','2'", "1, 2, 3", "1 0,11,12" };
-  std::string valid[] = { "", "1", "1,2", "1,2,3", "10,11,12,13" };
+  std::string invalid[] = {"1,2,a", "'1','2'", "1, 2, 3", "1 0,11,12"};
+  std::string valid[] = {"", "1", "1,2", "1,2,3", "10,11,12,13"};
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(invalid); ++i) {
     SetExplicitlyAllowedPorts(invalid[i]);
     EXPECT_EQ(0, static_cast<int>(GetCountOfExplicitlyAllowedPorts()));
   }
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(valid); ++i) {
     SetExplicitlyAllowedPorts(valid[i]);
     EXPECT_EQ(i, GetCountOfExplicitlyAllowedPorts());
   }
@@ skipping 42 matching lines @@
   EXPECT_TRUE(ParseIPLiteralToNumber("1:abcd::3:4:ff", &number));
   EXPECT_EQ("0,1,171,205,0,0,0,0,0,0,0,3,0,4,0,255", DumpIPNumber(number));
   EXPECT_EQ("1:abcd::3:4:ff", IPAddressToString(number));
 }
 
 // Test mapping an IPv4 address to an IPv6 address.
 TEST(NetUtilTest, ConvertIPv4NumberToIPv6Number) {
   IPAddressNumber ipv4_number;
   EXPECT_TRUE(ParseIPLiteralToNumber("192.168.0.1", &ipv4_number));
 
-  IPAddressNumber ipv6_number =
-      ConvertIPv4NumberToIPv6Number(ipv4_number);
+  IPAddressNumber ipv6_number = ConvertIPv4NumberToIPv6Number(ipv4_number);
 
   // ::ffff:192.168.0.1
   EXPECT_EQ("0,0,0,0,0,0,0,0,0,0,255,255,192,168,0,1",
             DumpIPNumber(ipv6_number));
   EXPECT_EQ("::ffff:c0a8:1", IPAddressToString(ipv6_number));
 }
 
 TEST(NetUtilTest, ParseURLHostnameToNumber_FailParse) {
   IPAddressNumber number;
 
@@ skipping 37 matching lines @@
   IPAddressNumber ipv4mapped_number;
   EXPECT_TRUE(ParseIPLiteralToNumber("::ffff:0101:1", &ipv4mapped_number));
   IPAddressNumber expected;
   EXPECT_TRUE(ParseIPLiteralToNumber("1.1.0.1", &expected));
   IPAddressNumber result = ConvertIPv4MappedToIPv4(ipv4mapped_number);
   EXPECT_EQ(expected, result);
 }
 
 // Test parsing invalid CIDR notation literals.
 TEST(NetUtilTest, ParseCIDRBlock_Invalid) {
-  const char* bad_literals[] = {
-      "foobar",
-      "",
-      "192.168.0.1",
-      "::1",
-      "/",
-      "/1",
-      "1",
-      "192.168.1.1/-1",
-      "192.168.1.1/33",
-      "::1/-3",
-      "a::3/129",
-      "::1/x",
-      "192.168.0.1//11"
-  };
+  const char* bad_literals[] = {"foobar",
+                                "",
+                                "192.168.0.1",
+                                "::1",
+                                "/",
+                                "/1",
+                                "1",
+                                "192.168.1.1/-1",
+                                "192.168.1.1/33",
+                                "::1/-3",
+                                "a::3/129",
+                                "::1/x",
+                                "192.168.0.1//11"};
 
   for (size_t i = 0; i < arraysize(bad_literals); ++i) {
     IPAddressNumber ip_number;
     size_t prefix_length_in_bits;
 
-    EXPECT_FALSE(ParseCIDRBlock(bad_literals[i],
-                                     &ip_number,
-                                     &prefix_length_in_bits));
+    EXPECT_FALSE(
+        ParseCIDRBlock(bad_literals[i], &ip_number, &prefix_length_in_bits));
   }
 }
 
 // Test parsing a valid CIDR notation literal.
 TEST(NetUtilTest, ParseCIDRBlock_Valid) {
   IPAddressNumber ip_number;
   size_t prefix_length_in_bits;
 
-  EXPECT_TRUE(ParseCIDRBlock("192.168.0.1/11",
-                                  &ip_number,
-                                  &prefix_length_in_bits));
+  EXPECT_TRUE(
+      ParseCIDRBlock("192.168.0.1/11", &ip_number, &prefix_length_in_bits));
 
   EXPECT_EQ("192,168,0,1", DumpIPNumber(ip_number));
   EXPECT_EQ(11u, prefix_length_in_bits);
 }
 
 TEST(NetUtilTest, IPNumberMatchesPrefix) {
   struct {
     const char* cidr_literal;
     const char* ip_literal;
     bool expected_to_match;
-  } tests[] = {
-    // IPv4 prefix with IPv4 inputs.
-    {
-      "10.10.1.32/27",
-      "10.10.1.44",
-      true
-    },
-    {
-      "10.10.1.32/27",
-      "10.10.1.90",
-      false
-    },
-    {
-      "10.10.1.32/27",
-      "10.10.1.90",
-      false
-    },
+  } tests[] = {// IPv4 prefix with IPv4 inputs.
+               {"10.10.1.32/27", "10.10.1.44", true},
+               {"10.10.1.32/27", "10.10.1.90", false},
+               {"10.10.1.32/27", "10.10.1.90", false},

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

Array literal with line comment again.

 
-    // IPv6 prefix with IPv6 inputs.
-    {
-      "2001:db8::/32",
-      "2001:DB8:3:4::5",
-      true
-    },
-    {
-      "2001:db8::/32",
-      "2001:c8::",
-      false
-    },
+               // IPv6 prefix with IPv6 inputs.
+               {"2001:db8::/32", "2001:DB8:3:4::5", true},
+               {"2001:db8::/32", "2001:c8::", false},
 
-    // IPv6 prefix with IPv4 inputs.
-    {
-      "2001:db8::/33",
-      "192.168.0.1",
-      false
-    },
-    {
-      "::ffff:192.168.0.1/112",
-      "192.168.33.77",
-      true
-    },
+               // IPv6 prefix with IPv4 inputs.
+               {"2001:db8::/33", "192.168.0.1", false},
+               {"::ffff:192.168.0.1/112", "192.168.33.77", true},
 
-    // IPv4 prefix with IPv6 inputs.
-    {
-      "10.11.33.44/16",
-      "::ffff:0a0b:89",
-      true
-    },
-    {
-      "10.11.33.44/16",
-      "::ffff:10.12.33.44",
-      false
-    },
-  };
+               // IPv4 prefix with IPv6 inputs.
+               {"10.11.33.44/16", "::ffff:0a0b:89", true},
+               {"10.11.33.44/16", "::ffff:10.12.33.44", false},
+    };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
-    SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]: %s, %s", i,
+    SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]: %s, %s",
+                                    i,
                                     tests[i].cidr_literal,
                                     tests[i].ip_literal));
 
     IPAddressNumber ip_number;
     EXPECT_TRUE(ParseIPLiteralToNumber(tests[i].ip_literal, &ip_number));
 
     IPAddressNumber ip_prefix;
     size_t prefix_length_in_bits;
 
-    EXPECT_TRUE(ParseCIDRBlock(tests[i].cidr_literal,
-                               &ip_prefix,
-                               &prefix_length_in_bits));
+    EXPECT_TRUE(ParseCIDRBlock(
+        tests[i].cidr_literal, &ip_prefix, &prefix_length_in_bits));
 
-    EXPECT_EQ(tests[i].expected_to_match,
-              IPNumberMatchesPrefix(ip_number,
-                                    ip_prefix,
-                                    prefix_length_in_bits));
+    EXPECT_EQ(
+        tests[i].expected_to_match,
+        IPNumberMatchesPrefix(ip_number, ip_prefix, prefix_length_in_bits));
   }
 }
 
 TEST(NetUtilTest, IsLocalhost) {
   EXPECT_TRUE(net::IsLocalhost("localhost"));
   EXPECT_TRUE(net::IsLocalhost("localhost.localdomain"));
   EXPECT_TRUE(net::IsLocalhost("localhost6"));
   EXPECT_TRUE(net::IsLocalhost("localhost6.localdomain6"));
   EXPECT_TRUE(net::IsLocalhost("127.0.0.1"));
   EXPECT_TRUE(net::IsLocalhost("127.0.1.0"));
@@ skipping 15 matching lines @@
   EXPECT_FALSE(net::IsLocalhost("::1:1"));
   EXPECT_FALSE(net::IsLocalhost("0:0:0:0:1:0:0:1"));
   EXPECT_FALSE(net::IsLocalhost("::1:1"));
   EXPECT_FALSE(net::IsLocalhost("0:0:0:0:0:0:0:0:1"));
 }
 
 // Verify GetNetworkList().
 TEST(NetUtilTest, GetNetworkList) {
   NetworkInterfaceList list;
   ASSERT_TRUE(GetNetworkList(&list, INCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES));
-  for (NetworkInterfaceList::iterator it = list.begin();
-       it != list.end(); ++it) {
+  for (NetworkInterfaceList::iterator it = list.begin(); it != list.end();
+       ++it) {
     // Verify that the names are not empty.
     EXPECT_FALSE(it->name.empty());
     EXPECT_FALSE(it->friendly_name.empty());
 
     // Verify that the address is correct.
     EXPECT_TRUE(it->address.size() == kIPv4AddressSize ||
                 it->address.size() == kIPv6AddressSize)
         << "Invalid address of size " << it->address.size();
     bool all_zeroes = true;
     for (size_t i = 0; i < it->address.size(); ++i) {
       if (it->address[i] != 0) {
         all_zeroes = false;
         break;
       }
     }
     EXPECT_FALSE(all_zeroes);
     EXPECT_GT(it->network_prefix, 1u);
     EXPECT_LE(it->network_prefix, it->address.size() * 8);
 
 #if defined(OS_WIN)
     // On Windows |name| is NET_LUID.
     base::ScopedNativeLibrary phlpapi_lib(
         base::FilePath(FILE_PATH_LITERAL("iphlpapi.dll")));
     ASSERT_TRUE(phlpapi_lib.is_valid());
-    typedef NETIO_STATUS (WINAPI* ConvertInterfaceIndexToLuid)(NET_IFINDEX,
+    typedef NETIO_STATUS(WINAPI * ConvertInterfaceIndexToLuid)(NET_IFINDEX,
                                                                PNET_LUID);
     ConvertInterfaceIndexToLuid interface_to_luid =
         reinterpret_cast<ConvertInterfaceIndexToLuid>(
             phlpapi_lib.GetFunctionPointer("ConvertInterfaceIndexToLuid"));
 
-    typedef NETIO_STATUS (WINAPI* ConvertInterfaceLuidToGuid)(NET_LUID*,
-                                                              GUID*);
+    typedef NETIO_STATUS(WINAPI * ConvertInterfaceLuidToGuid)(NET_LUID*, GUID*);
     ConvertInterfaceLuidToGuid luid_to_guid =
         reinterpret_cast<ConvertInterfaceLuidToGuid>(
             phlpapi_lib.GetFunctionPointer("ConvertInterfaceLuidToGuid"));
 
     if (interface_to_luid && luid_to_guid) {
       NET_LUID luid;
       EXPECT_EQ(interface_to_luid(it->interface_index, &luid), NO_ERROR);
       GUID guid;
       EXPECT_EQ(luid_to_guid(&luid, &guid), NO_ERROR);
       LPOLESTR name;
       StringFromCLSID(guid, &name);
       EXPECT_STREQ(base::UTF8ToWide(it->name).c_str(), name);
       CoTaskMemFree(name);
       continue;
     } else {
       EXPECT_LT(base::win::GetVersion(), base::win::VERSION_VISTA);
       EXPECT_LT(it->interface_index, 1u << 24u);  // Must fit 0.x.x.x.
-      EXPECT_NE(it->interface_index, 0u);  // 0 means to use default.
+      EXPECT_NE(it->interface_index, 0u);         // 0 means to use default.
     }
     if (it->type == NetworkChangeNotifier::CONNECTION_WIFI) {
       EXPECT_NE(WIFI_PHY_LAYER_PROTOCOL_NONE, GetWifiPHYLayerProtocol());
     }
 #elif !defined(OS_ANDROID)
     char name[IF_NAMESIZE];
     EXPECT_TRUE(if_indextoname(it->interface_index, name));
     EXPECT_STREQ(it->name.c_str(), name);
 #endif
   }
 }
 
 namespace {
 
 #if defined(OS_WIN)
-bool read_int_or_bool(DWORD data_size,
-                      PVOID data) {
+bool read_int_or_bool(DWORD data_size, PVOID data) {
   switch (data_size) {
     case 1:
       return !!*reinterpret_cast<uint8*>(data);
     case 4:
       return !!*reinterpret_cast<uint32*>(data);
     default:
       LOG(FATAL) << "That is not a type I know!";
       return false;
   }
 }
 
 int GetWifiOptions() {
   const internal::WlanApi& wlanapi = internal::WlanApi::GetInstance();
   if (!wlanapi.initialized)
     return -1;
 
   internal::WlanHandle client;
   DWORD cur_version = 0;
   const DWORD kMaxClientVersion = 2;
-  DWORD result = wlanapi.OpenHandle(
-      kMaxClientVersion, &cur_version, &client);
+  DWORD result = wlanapi.OpenHandle(kMaxClientVersion, &cur_version, &client);
   if (result != ERROR_SUCCESS)
     return -1;
 
   WLAN_INTERFACE_INFO_LIST* interface_list_ptr = NULL;
-  result = wlanapi.enum_interfaces_func(client.Get(), NULL,
-                                        &interface_list_ptr);
+  result =
+      wlanapi.enum_interfaces_func(client.Get(), NULL, &interface_list_ptr);
   if (result != ERROR_SUCCESS)
     return -1;
   scoped_ptr<WLAN_INTERFACE_INFO_LIST, internal::WlanApiDeleter> interface_list(
       interface_list_ptr);
 
   for (unsigned i = 0; i < interface_list->dwNumberOfItems; ++i) {
     WLAN_INTERFACE_INFO* info = &interface_list->InterfaceInfo[i];
     DWORD data_size;
     PVOID data;
     int options = 0;
-    result = wlanapi.query_interface_func(
-        client.Get(),
-        &info->InterfaceGuid,
-        wlan_intf_opcode_background_scan_enabled,
-        NULL,
-        &data_size,
-        &data,
-        NULL);
+    result =
+        wlanapi.query_interface_func(client.Get(),
+                                     &info->InterfaceGuid,
+                                     wlan_intf_opcode_background_scan_enabled,
+                                     NULL,
+                                     &data_size,
+                                     &data,
+                                     NULL);
     if (result != ERROR_SUCCESS)
       continue;
     if (!read_int_or_bool(data_size, data)) {
       options |= WIFI_OPTIONS_DISABLE_SCAN;
     }
     internal::WlanApi::GetInstance().free_memory_func(data);
 
-    result = wlanapi.query_interface_func(
-        client.Get(),
-        &info->InterfaceGuid,
-        wlan_intf_opcode_media_streaming_mode,
-        NULL,
-        &data_size,
-        &data,
-        NULL);
+    result = wlanapi.query_interface_func(client.Get(),
+                                          &info->InterfaceGuid,
+                                          wlan_intf_opcode_media_streaming_mode,
+                                          NULL,
+                                          &data_size,
+                                          &data,
+                                          NULL);
     if (result != ERROR_SUCCESS)
       continue;
     if (read_int_or_bool(data_size, data)) {
       options |= WIFI_OPTIONS_MEDIA_STREAMING_MODE;
     }
     internal::WlanApi::GetInstance().free_memory_func(data);
 
     // Just the the options from the first succesful
     // interface.
     return options;
@@ skipping 38 matching lines @@
 
 // Google Test pretty-printer.
 void PrintTo(const NonUniqueNameTestData& data, std::ostream* os) {
   ASSERT_TRUE(data.hostname);
   *os << " hostname: " << testing::PrintToString(data.hostname)
       << "; is_unique: " << testing::PrintToString(data.is_unique);
 }
 
 const NonUniqueNameTestData kNonUniqueNameTestData[] = {
     // Domains under ICANN-assigned domains.
-    { true, "google.com" },
-    { true, "google.co.uk" },
+    {true, "google.com"},
+    {true, "google.co.uk"},
     // Domains under private registries.
-    { true, "appspot.com" },
-    { true, "test.appspot.com" },
+    {true, "appspot.com"},
+    {true, "test.appspot.com"},
     // Unreserved IPv4 addresses (in various forms).
-    { true, "8.8.8.8" },
-    { true, "99.64.0.0" },
-    { true, "212.15.0.0" },
-    { true, "212.15" },
-    { true, "212.15.0" },
-    { true, "3557752832" },
+    {true, "8.8.8.8"},
+    {true, "99.64.0.0"},
+    {true, "212.15.0.0"},
+    {true, "212.15"},
+    {true, "212.15.0"},
+    {true, "3557752832"},
     // Reserved IPv4 addresses (in various forms).
-    { false, "192.168.0.0" },
-    { false, "192.168.0.6" },
-    { false, "10.0.0.5" },
-    { false, "10.0" },
-    { false, "10.0.0" },
-    { false, "3232235526" },
+    {false, "192.168.0.0"},
+    {false, "192.168.0.6"},
+    {false, "10.0.0.5"},
+    {false, "10.0"},
+    {false, "10.0.0"},
+    {false, "3232235526"},
     // Unreserved IPv6 addresses.
-    { true, "FFC0:ba98:7654:3210:FEDC:BA98:7654:3210" },
-    { true, "2000:ba98:7654:2301:EFCD:BA98:7654:3210" },
+    {true, "FFC0:ba98:7654:3210:FEDC:BA98:7654:3210"},
+    {true, "2000:ba98:7654:2301:EFCD:BA98:7654:3210"},
     // Reserved IPv6 addresses.
-    { false, "::192.9.5.5" },
-    { false, "FEED::BEEF" },
-    { false, "FEC0:ba98:7654:3210:FEDC:BA98:7654:3210" },
+    {false, "::192.9.5.5"},
+    {false, "FEED::BEEF"},
+    {false, "FEC0:ba98:7654:3210:FEDC:BA98:7654:3210"},
     // 'internal'/non-IANA assigned domains.
-    { false, "intranet" },
-    { false, "intranet." },
-    { false, "intranet.example" },
-    { false, "host.intranet.example" },
+    {false, "intranet"},
+    {false, "intranet."},
+    {false, "intranet.example"},
+    {false, "host.intranet.example"},
     // gTLDs under discussion, but not yet assigned.
-    { false, "intranet.corp" },
-    { false, "example.tech" },
-    { false, "intranet.internal" },
+    {false, "intranet.corp"},
+    {false, "example.tech"},
+    {false, "intranet.internal"},
     // Invalid host names are treated as unique - but expected to be
     // filtered out before then.
-    { true, "junk)(£)$*!@~#" },
-    { true, "w$w.example.com" },
-    { true, "nocolonsallowed:example" },
-    { true, "[::4.5.6.9]" },
+    {true, "junk)(£)$*!@~#"},
+    {true, "w$w.example.com"},
+    {true, "nocolonsallowed:example"},
+    {true, "[::4.5.6.9]"},
 };
 
 class NetUtilNonUniqueNameTest
     : public testing::TestWithParam<NonUniqueNameTestData> {
  public:
   virtual ~NetUtilNonUniqueNameTest() {}
 
  protected:
   bool IsUnique(const std::string& hostname) {
     return !IsHostnameNonUnique(hostname);
   }
 };
 
 // Test that internal/non-unique names are properly identified as such, but
 // that IP addresses and hosts beneath registry-controlled domains are flagged
 // as unique names.
 TEST_P(NetUtilNonUniqueNameTest, IsHostnameNonUnique) {
   const NonUniqueNameTestData& test_data = GetParam();
 
   EXPECT_EQ(test_data.is_unique, IsUnique(test_data.hostname));
 }
 
-INSTANTIATE_TEST_CASE_P(, NetUtilNonUniqueNameTest,
+INSTANTIATE_TEST_CASE_P(,

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

No action: I think this is going to look weird no matter how we indent it...
what is up with this first argument? :-)

+                        NetUtilNonUniqueNameTest,
                         testing::ValuesIn(kNonUniqueNameTestData));
 
 }  // namespace net