Convert ARRAYSIZE_UNSAFE -> arraysize in chrome/browser/.

chrome/browser/download/download_item_model_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 "chrome/browser/download/download_item_model.h"
 
 #include <vector>
 
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
@@ skipping 23 matching lines @@
 // Create a char array that has as many elements as there are download
 // interrupt reasons. We can then use that in a COMPILE_ASSERT to make sure
 // that all the interrupt reason codes are accounted for. The reason codes are
 // unfortunately sparse, making this necessary.
 char kInterruptReasonCounter[] = {
   0,                                // content::DOWNLOAD_INTERRUPT_REASON_NONE
 #define INTERRUPT_REASON(name,value) 0,
 #include "content/public/browser/download_interrupt_reason_values.h"
 #undef INTERRUPT_REASON
 };
-const size_t kInterruptReasonCount = ARRAYSIZE_UNSAFE(kInterruptReasonCounter);
+const size_t kInterruptReasonCount = arraysize(kInterruptReasonCounter);
 
 // Default target path for a mock download item in DownloadItemModelTest.
 const base::FilePath::CharType kDefaultTargetFilePath[] =
     FILE_PATH_LITERAL("/foo/bar/foo.bar");
 
 const base::FilePath::CharType kDefaultDisplayFileName[] =
     FILE_PATH_LITERAL("foo.bar");
 
 // Default URL for a mock download item in DownloadItemModelTest.
 const char kDefaultURL[] = "http://example.com/foo.bar";
@@ skipping 109 matching lines @@
       "Failed - Needs authorization" },
     { content::DOWNLOAD_INTERRUPT_REASON_SERVER_CERT_PROBLEM,
       "Failed - Bad certificate" },
     { content::DOWNLOAD_INTERRUPT_REASON_USER_CANCELED,
       "Cancelled" },
     { content::DOWNLOAD_INTERRUPT_REASON_USER_SHUTDOWN,
       "Failed - Shutdown" },
     { content::DOWNLOAD_INTERRUPT_REASON_CRASH,
       "Failed - Crash" },
   };
-  COMPILE_ASSERT(kInterruptReasonCount == ARRAYSIZE_UNSAFE(kTestCases),
+  COMPILE_ASSERT(kInterruptReasonCount == arraysize(kTestCases),
                  interrupt_reason_mismatch);
 
   SetupDownloadItemDefaults();
-  for (unsigned i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
+  for (unsigned i = 0; i < arraysize(kTestCases); ++i) {
     const TestCase& test_case = kTestCases[i];
     SetupInterruptedDownloadItem(test_case.reason);
     EXPECT_STREQ(test_case.expected_status,
                  base::UTF16ToUTF8(model().GetStatusText()).c_str());
   }
 }
 
 // Note: This test is currently skipped on Android. See http://crbug.com/139398
 TEST_F(DownloadItemModelTest, InterruptTooltip) {
   // Test that we have the correct interrupt tooltip for downloads that are in
@@ skipping 51 matching lines @@
       "foo.bar\nNeeds authorization" },
     { content::DOWNLOAD_INTERRUPT_REASON_SERVER_CERT_PROBLEM,
       "foo.bar\nBad certificate" },
     { content::DOWNLOAD_INTERRUPT_REASON_USER_CANCELED,
       "foo.bar" },
     { content::DOWNLOAD_INTERRUPT_REASON_USER_SHUTDOWN,
       "foo.bar\nShutdown" },
     { content::DOWNLOAD_INTERRUPT_REASON_CRASH,
       "foo.bar\nCrash" },
   };
-  COMPILE_ASSERT(kInterruptReasonCount == ARRAYSIZE_UNSAFE(kTestCases),
+  COMPILE_ASSERT(kInterruptReasonCount == arraysize(kTestCases),
                  interrupt_reason_mismatch);
 
   // Large tooltip width. Should be large enough to accommodate the entire
   // tooltip without truncation.
   const int kLargeTooltipWidth = 1000;
 
   // Small tooltip width. Small enough to require truncation of most
   // tooltips. Used to test eliding logic.
   const int kSmallTooltipWidth = 40;
 
   const gfx::FontList& font_list =
       ui::ResourceBundle::GetSharedInstance().GetFontList(
           ui::ResourceBundle::BaseFont);
   SetupDownloadItemDefaults();
-  for (unsigned i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
+  for (unsigned i = 0; i < arraysize(kTestCases); ++i) {
     const TestCase& test_case = kTestCases[i];
     SetupInterruptedDownloadItem(test_case.reason);
 
     // GetTooltipText() elides the tooltip so that the text would fit within a
     // given width. The following test would fail if kLargeTooltipWidth isn't
     // large enough to accomodate all the strings.
     EXPECT_STREQ(
         test_case.expected_tooltip,
         base::UTF16ToUTF8(model().GetTooltipText(font_list,
                                                  kLargeTooltipWidth)).c_str());
@@ skipping 52 matching lines @@
     { 0, 0, false, true,  true,  "0 B, Paused" },
     { 1, 0, false, true,  true,  "1 B, Paused" },
     { 0, 2, false, true,  true,  "0/2 B, Paused" },
     { 1, 2, false, true,  true,  "1/2 B, Paused" },
     { 0, 2, true,  true,  true,  "0/2 B, Paused" },
     { 1, 2, true,  true,  true,  "1/2 B, Paused" },
   };
 
   SetupDownloadItemDefaults();
 
-  for (unsigned i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); i++) {
+  for (unsigned i = 0; i < arraysize(kTestCases); i++) {
     const TestCase& test_case = kTestCases[i];
     Mock::VerifyAndClearExpectations(&item());
     Mock::VerifyAndClearExpectations(&model());
     EXPECT_CALL(item(), GetReceivedBytes())
         .WillRepeatedly(Return(test_case.received_bytes));
     EXPECT_CALL(item(), GetTotalBytes())
         .WillRepeatedly(Return(test_case.total_bytes));
     EXPECT_CALL(item(), TimeRemaining(_))
         .WillRepeatedly(testing::DoAll(
             testing::SetArgPointee<0>(base::TimeDelta::FromSeconds(10)),
@@ skipping 51 matching lines @@
     { DownloadItem::CANCELLED,   true , false, false, false},
     { DownloadItem::CANCELLED,   true , true , false, false},
     { DownloadItem::INTERRUPTED, false, false, false, false},
     { DownloadItem::INTERRUPTED, false, true , false, false},
     { DownloadItem::INTERRUPTED, true , false, false, false},
     { DownloadItem::INTERRUPTED, true , true , false, false}
   };
 
   SetupDownloadItemDefaults();
 
-  for (unsigned i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); i++) {
+  for (unsigned i = 0; i < arraysize(kTestCases); i++) {
     const TestCase& test_case = kTestCases[i];
     EXPECT_CALL(item(), GetOpenWhenComplete())
         .WillRepeatedly(Return(test_case.is_auto_open));
     EXPECT_CALL(item(), GetState())
         .WillRepeatedly(Return(test_case.state));
     EXPECT_CALL(item(), IsDangerous())
         .WillRepeatedly(Return(test_case.is_dangerous));
     EXPECT_CALL(item(), GetAutoOpened())
         .WillRepeatedly(Return(test_case.auto_opened));
 
     EXPECT_EQ(test_case.expected_result,
               model().ShouldRemoveFromShelfWhenComplete())
         << "Test case: " << i;
     Mock::VerifyAndClearExpectations(&item());
     Mock::VerifyAndClearExpectations(&model());
   }
 }