Convert ARRAYSIZE_UNSAFE -> arraysize in net/.

net/http/http_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 <algorithm>
 
 #include "base/basictypes.h"
 #include "base/strings/string_util.h"
 #include "net/http/http_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 96 matching lines @@
     bool expected_result;
   } tests[] = {
     { "", "foo", false },
     { "foo\r\nbar", "foo", false },
     { "ffoo: 1", "foo", false },
     { "foo: 1", "foo", true },
     { "foo: 1\r\nbar: 2", "foo", true },
     { "fOO: 1\r\nbar: 2", "foo", true },
     { "g: 0\r\nfoo: 1\r\nbar: 2", "foo", true },
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     bool result = HttpUtil::HasHeader(tests[i].headers, tests[i].name);
     EXPECT_EQ(tests[i].expected_result, result);
   }
 }
 
 TEST(HttpUtilTest, StripHeaders) {
   static const char* headers =
       "Origin: origin\r\n"
       "Content-Type: text/plain\r\n"
       "Cookies: foo1\r\n"
@@ skipping 137 matching lines @@
     const char* input;
     int expected_result;
   } tests[] = {
     { "foo\r\nbar\r\n\r\n", 12 },
     { "foo\nbar\n\n", 9 },
     { "foo\r\nbar\r\n\r\njunk", 12 },
     { "foo\nbar\n\njunk", 9 },
     { "foo\nbar\n\r\njunk", 10 },
     { "foo\nbar\r\n\njunk", 10 },
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     int input_len = static_cast<int>(strlen(tests[i].input));
     int eoh = HttpUtil::LocateEndOfHeaders(tests[i].input, input_len);
     EXPECT_EQ(tests[i].expected_result, eoh);
   }
 }
 
 TEST(HttpUtilTest, AssembleRawHeaders) {
   struct {
     const char* input;  // with '|' representing '\0'
     const char* expected_result;  // with '\0' changed to '|'
@@ skipping 289 matching lines @@
       "HTTP/1.0 200 OKBar2:0Baz2:1|Foo: 1|Bar: 2||"
     },
 
     // Embed NULLs in a header line. They should not be understood as
     // line separators.
     {
       "HTTP/1.0 200 OK\nFoo: 1|Foo2: 3\nBar: 2\n\n",
       "HTTP/1.0 200 OK|Foo: 1Foo2: 3|Bar: 2||"
     },
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     std::string input = tests[i].input;
     std::replace(input.begin(), input.end(), '|', '\0');
     std::string raw = HttpUtil::AssembleRawHeaders(input.data(), input.size());
     std::replace(raw.begin(), raw.end(), '\0', '|');
     EXPECT_EQ(tests[i].expected_result, raw);
   }
 }
 
 // Test SpecForRequest() and PathForRequest().
 TEST(HttpUtilTest, RequestUrlSanitize) {
@@ skipping 26 matching lines @@
       "ws://www.google.com:78/foobar?query=1#hash",
       "ws://www.google.com:78/foobar?query=1",
       "/foobar?query=1"
     },
     { // WebSocket's wss scheme
       "wss://www.google.com:78/foobar?query=1#hash",
       "wss://www.google.com:78/foobar?query=1",
       "/foobar?query=1"
     }
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     GURL url(GURL(tests[i].url));
     std::string expected_spec(tests[i].expected_spec);
     std::string expected_path(tests[i].expected_path);
 
     EXPECT_EQ(expected_spec, HttpUtil::SpecForRequest(url));
     EXPECT_EQ(expected_path, HttpUtil::PathForRequest(url));
   }
 }
 
 // Test SpecForRequest() for "ftp" scheme.
@@ skipping 75 matching lines @@
       "\"WebKit-ada-df-dsf-adsfadsfs  \""
     },
     { "text/html; boundary=WebKit-ada-df-dsf-adsfadsfs",
       "text/html",
       "",
       false,
       "WebKit-ada-df-dsf-adsfadsfs"
     },
     // TODO(abarth): Add more interesting test cases.
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     std::string mime_type;
     std::string charset;
     bool had_charset = false;
     std::string boundary;
     net::HttpUtil::ParseContentType(tests[i].content_type, &mime_type,
                                     &charset, &had_charset, &boundary);
     EXPECT_EQ(tests[i].expected_mime_type, mime_type) << "i=" << i;
     EXPECT_EQ(tests[i].expected_charset, charset) << "i=" << i;
     EXPECT_EQ(tests[i].expected_had_charset, had_charset) << "i=" << i;
     EXPECT_EQ(tests[i].expected_boundary, boundary) << "i=" << i;
@@ skipping 107 matching lines @@
       5,
       { {0, 1, -1},
         {10, 20, -1},
         {100, 200, -1},
         {100, -1, -1},
         {-1, -1, 200},
       }
     },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     std::vector<net::HttpByteRange> ranges;
     bool return_value = HttpUtil::ParseRanges(std::string(tests[i].headers),
                                               &ranges);
     EXPECT_EQ(tests[i].expected_return_value, return_value);
     if (return_value) {
       EXPECT_EQ(tests[i].expected_ranges_size, ranges.size());
       for (size_t j = 0; j < ranges.size(); ++j) {
         EXPECT_EQ(tests[i].expected_ranges[j].expected_first_byte_position,
                   ranges[j].first_byte_position());
         EXPECT_EQ(tests[i].expected_ranges[j].expected_last_byte_position,
@@ skipping 197 matching lines @@
 TEST(HttpUtilTest, NameValuePairsIteratorMissingEndQuote) {
   std::string data = "name='value";
   HttpUtil::NameValuePairsIterator parser(data.begin(), data.end(), ';');
   EXPECT_TRUE(parser.valid());
 
   ASSERT_NO_FATAL_FAILURE(
       CheckNextNameValuePair(&parser, true, true, "name", "value"));
   ASSERT_NO_FATAL_FAILURE(CheckNextNameValuePair(
       &parser, false, true, std::string(), std::string()));
 }