Convert ARRAYSIZE_UNSAFE -> arraysize in net/.

net/websockets/websocket_frame_test.cc

 // Copyright 2013 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/websockets/websocket_frame.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 13 matching lines @@
   };
   static const TestCase kTests[] = {
     { "\x81\x00", 2, GG_UINT64_C(0) },
     { "\x81\x7D", 2, GG_UINT64_C(125) },
     { "\x81\x7E\x00\x7E", 4, GG_UINT64_C(126) },
     { "\x81\x7E\xFF\xFF", 4, GG_UINT64_C(0xFFFF) },
     { "\x81\x7F\x00\x00\x00\x00\x00\x01\x00\x00", 10, GG_UINT64_C(0x10000) },
     { "\x81\x7F\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF", 10,
       GG_UINT64_C(0x7FFFFFFFFFFFFFFF) }
   };
-  static const int kNumTests = ARRAYSIZE_UNSAFE(kTests);
+  static const int kNumTests = arraysize(kTests);
 
   for (int i = 0; i < kNumTests; ++i) {
     WebSocketFrameHeader header(WebSocketFrameHeader::kOpCodeText);
     header.final = true;
     header.payload_length = kTests[i].frame_length;
 
     std::vector<char> expected_output(
         kTests[i].frame_header,
         kTests[i].frame_header + kTests[i].frame_header_length);
     std::vector<char> output(expected_output.size());
     EXPECT_EQ(static_cast<int>(expected_output.size()),
               WriteWebSocketFrameHeader(
                   header, NULL, &output.front(), output.size()));
     EXPECT_EQ(expected_output, output);
   }
 }
 
 TEST(WebSocketFrameHeaderTest, FrameLengthsWithMasking) {
   static const char kMaskingKey[] = "\xDE\xAD\xBE\xEF";
-  COMPILE_ASSERT(ARRAYSIZE_UNSAFE(kMaskingKey) - 1 ==
+  COMPILE_ASSERT(arraysize(kMaskingKey) - 1 ==
                      WebSocketFrameHeader::kMaskingKeyLength,
                  incorrect_masking_key_size);
 
   struct TestCase {
     const char* frame_header;
     size_t frame_header_length;
     uint64 frame_length;
   };
   static const TestCase kTests[] = {
     { "\x81\x80\xDE\xAD\xBE\xEF", 6, GG_UINT64_C(0) },
     { "\x81\xFD\xDE\xAD\xBE\xEF", 6, GG_UINT64_C(125) },
     { "\x81\xFE\x00\x7E\xDE\xAD\xBE\xEF", 8, GG_UINT64_C(126) },
     { "\x81\xFE\xFF\xFF\xDE\xAD\xBE\xEF", 8, GG_UINT64_C(0xFFFF) },
     { "\x81\xFF\x00\x00\x00\x00\x00\x01\x00\x00\xDE\xAD\xBE\xEF", 14,
       GG_UINT64_C(0x10000) },
     { "\x81\xFF\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xDE\xAD\xBE\xEF", 14,
       GG_UINT64_C(0x7FFFFFFFFFFFFFFF) }
   };
-  static const int kNumTests = ARRAYSIZE_UNSAFE(kTests);
+  static const int kNumTests = arraysize(kTests);
 
   WebSocketMaskingKey masking_key;
   std::copy(kMaskingKey,
             kMaskingKey + WebSocketFrameHeader::kMaskingKeyLength,
             masking_key.key);
 
   for (int i = 0; i < kNumTests; ++i) {
     WebSocketFrameHeader header(WebSocketFrameHeader::kOpCodeText);
     header.final = true;
     header.masked = true;
@@ skipping 28 matching lines @@
     { "\x84\x00", 2, 0x4 },
     { "\x85\x00", 2, 0x5 },
     { "\x86\x00", 2, 0x6 },
     { "\x87\x00", 2, 0x7 },
     { "\x8B\x00", 2, 0xB },
     { "\x8C\x00", 2, 0xC },
     { "\x8D\x00", 2, 0xD },
     { "\x8E\x00", 2, 0xE },
     { "\x8F\x00", 2, 0xF }
   };
-  static const int kNumTests = ARRAYSIZE_UNSAFE(kTests);
+  static const int kNumTests = arraysize(kTests);
 
   for (int i = 0; i < kNumTests; ++i) {
     WebSocketFrameHeader header(kTests[i].opcode);
     header.final = true;
     header.payload_length = 0;
 
     std::vector<char> expected_output(
         kTests[i].frame_header,
         kTests[i].frame_header + kTests[i].frame_header_length);
     std::vector<char> output(expected_output.size());
@@ skipping 15 matching lines @@
   };
   static const TestCase kTests[] = {
     { "\x81\x00", 2, true, false, false, false },
     { "\x01\x00", 2, false, false, false, false },
     { "\xC1\x00", 2, true, true, false, false },
     { "\xA1\x00", 2, true, false, true, false },
     { "\x91\x00", 2, true, false, false, true },
     { "\x71\x00", 2, false, true, true, true },
     { "\xF1\x00", 2, true, true, true, true }
   };
-  static const int kNumTests = ARRAYSIZE_UNSAFE(kTests);
+  static const int kNumTests = arraysize(kTests);
 
   for (int i = 0; i < kNumTests; ++i) {
     WebSocketFrameHeader header(WebSocketFrameHeader::kOpCodeText);
     header.final = kTests[i].final;
     header.reserved1 = kTests[i].reserved1;
     header.reserved2 = kTests[i].reserved2;
     header.reserved3 = kTests[i].reserved3;
     header.payload_length = 0;
 
     std::vector<char> expected_output(
@@ skipping 20 matching lines @@
     { GG_UINT64_C(0xFFFF), false, 4u },
     { GG_UINT64_C(0x10000), false, 10u },
     { GG_UINT64_C(0x7FFFFFFFFFFFFFFF), false, 10u },
     { GG_UINT64_C(0), true, 6u },
     { GG_UINT64_C(125), true, 6u },
     { GG_UINT64_C(126), true, 8u },
     { GG_UINT64_C(0xFFFF), true, 8u },
     { GG_UINT64_C(0x10000), true, 14u },
     { GG_UINT64_C(0x7FFFFFFFFFFFFFFF), true, 14u }
   };
-  static const int kNumTests = ARRAYSIZE_UNSAFE(kTests);
+  static const int kNumTests = arraysize(kTests);
 
   for (int i = 0; i < kNumTests; ++i) {
     WebSocketFrameHeader header(WebSocketFrameHeader::kOpCodeText);
     header.final = true;
     header.opcode = WebSocketFrameHeader::kOpCodeText;
     header.masked = kTests[i].masked;
     header.payload_length = kTests[i].payload_length;
 
     char dummy_buffer[14];
     // Set an insufficient size to |buffer_size|.
@@ skipping 18 matching lines @@
     { "\xDE\xAD\xBE\xEF", 2, "FooBar", "\xF8\x80\xB1\xEF\xDF\x9D", 6 },
     { "\xDE\xAD\xBE\xEF", 3, "FooBar", "\xA9\xB1\xC2\xFC\x8E\xAC", 6 },
     { "\xDE\xAD\xBE\xEF", 4, "FooBar", "\x98\xC2\xD1\xAD\xBF\xDF", 6 },
     { "\xDE\xAD\xBE\xEF", 42, "FooBar", "\xF8\x80\xB1\xEF\xDF\x9D", 6 },
     { "\xDE\xAD\xBE\xEF", 0, "", "", 0 },
     { "\xDE\xAD\xBE\xEF", 0, "\xDE\xAD\xBE\xEF", "\x00\x00\x00\x00", 4 },
     { "\xDE\xAD\xBE\xEF", 0, "\x00\x00\x00\x00", "\xDE\xAD\xBE\xEF", 4 },
     { "\x00\x00\x00\x00", 0, "FooBar", "FooBar", 6 },
     { "\xFF\xFF\xFF\xFF", 0, "FooBar", "\xB9\x90\x90\xBD\x9E\x8D", 6 },
   };
-  static const int kNumTests = ARRAYSIZE_UNSAFE(kTests);
+  static const int kNumTests = arraysize(kTests);
 
   for (int i = 0; i < kNumTests; ++i) {
     WebSocketMaskingKey masking_key;
     std::copy(kTests[i].masking_key,
               kTests[i].masking_key + WebSocketFrameHeader::kMaskingKeyLength,
               masking_key.key);
     std::vector<char> frame_data(kTests[i].input,
                                  kTests[i].input + kTests[i].data_length);
     std::vector<char> expected_output(kTests[i].output,
                                       kTests[i].output + kTests[i].data_length);
@@ skipping 136 matching lines @@
   EXPECT_FALSE(Frame::IsKnownControlOpCode(0xF));
 
   // Check that out-of-range opcodes return false
   EXPECT_FALSE(Frame::IsKnownControlOpCode(-1));
   EXPECT_FALSE(Frame::IsKnownControlOpCode(0xFF));
 }
 
 }  // namespace
 
 }  // namespace net