Convert ARRAYSIZE_UNSAFE -> arraysize in chrome/browser/.

chrome/browser/password_manager/password_store_mac_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/password_manager/password_store_mac.h"
 
 #include "base/basictypes.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_vector.h"
 #include "base/path_service.h"
@@ skipping 306 matching lines @@
     { PasswordForm::SCHEME_DIGEST, "https://some.domain.com/high_security",
       "https://some.domain.com/", L"digest_auth_user", L"digest", true,
       1998,  3, 30, 10,  0,  0 },
     // This one gives us an invalid date, which we will treat as a "NULL" date
     // which is 1601.
     { PasswordForm::SCHEME_OTHER, "http://a.server.com/",
       "http://a.server.com/", L"abc", L"123", false,
       1601,  1,  1,  0,  0,  0 },
   };
 
-  for (unsigned int i = 0; i < ARRAYSIZE_UNSAFE(expected); ++i) {
+  for (unsigned int i = 0; i < arraysize(expected); ++i) {
     // Create our fake KeychainItemRef; see MockAppleKeychain docs.
     SecKeychainItemRef keychain_item =
         reinterpret_cast<SecKeychainItemRef>(i + 1);
     PasswordForm form;
     bool parsed = internal_keychain_helpers::FillPasswordFormFromKeychainItem(
         *keychain_, keychain_item, &form, true);
 
     EXPECT_TRUE(parsed) << "In iteration " << i;
 
     EXPECT_EQ(expected[i].scheme, form.scheme) << "In iteration " << i;
@@ skipping 80 matching lines @@
         0 },
       0, 0 },
     // Garbage forms should have no matches.
     { { PasswordForm::SCHEME_HTML, "foo/bar/baz",
         NULL, NULL, NULL, NULL, NULL, NULL, NULL, false, false, 0 }, 0, 0 },
   };
 
   MacKeychainPasswordFormAdapter keychain_adapter(keychain_);
   MacKeychainPasswordFormAdapter owned_keychain_adapter(keychain_);
   owned_keychain_adapter.SetFindsOnlyOwnedItems(true);
-  for (unsigned int i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
+  for (unsigned int i = 0; i < arraysize(test_data); ++i) {
     scoped_ptr<PasswordForm> query_form(
         CreatePasswordFormFromData(test_data[i].data));
 
     // Check matches treating the form as a fill target.
     std::vector<PasswordForm*> matching_items =
         keychain_adapter.PasswordsFillingForm(query_form->signon_realm,
                                               query_form->scheme);
     EXPECT_EQ(test_data[i].expected_fill_matches, matching_items.size());
     STLDeleteElements(&matching_items);
 
@@ skipping 136 matching lines @@
     // password; see MockAppleKeychain::ItemModifyAttributesAndData) is
     // reported.
     { { PasswordForm::SCHEME_HTML, "http://some.domain.com",
         "http://some.domain.com/insecure.html", NULL, NULL, NULL, NULL,
         L"joe_user", L"fail_me", false, false, 0 }, false },
   };
 
   MacKeychainPasswordFormAdapter owned_keychain_adapter(keychain_);
   owned_keychain_adapter.SetFindsOnlyOwnedItems(true);
 
-  for (unsigned int i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
+  for (unsigned int i = 0; i < arraysize(test_data); ++i) {
     scoped_ptr<PasswordForm> in_form(
         CreatePasswordFormFromData(test_data[i].data));
     bool add_succeeded = owned_keychain_adapter.AddPassword(*in_form);
     EXPECT_EQ(test_data[i].should_succeed, add_succeeded);
     if (add_succeeded) {
       EXPECT_TRUE(owned_keychain_adapter.HasPasswordsMergeableWithForm(
           *in_form));
       EXPECT_TRUE(owned_keychain_adapter.HasPasswordExactlyMatchingForm(
           *in_form));
     }
@@ skipping 36 matching lines @@
   };
 
   MacKeychainPasswordFormAdapter owned_keychain_adapter(keychain_);
   owned_keychain_adapter.SetFindsOnlyOwnedItems(true);
 
   // Add our test item so that we can delete it.
   PasswordForm* add_form = CreatePasswordFormFromData(test_data[0].data);
   EXPECT_TRUE(owned_keychain_adapter.AddPassword(*add_form));
   delete add_form;
 
-  for (unsigned int i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
+  for (unsigned int i = 0; i < arraysize(test_data); ++i) {
     scoped_ptr<PasswordForm> form(CreatePasswordFormFromData(
         test_data[i].data));
     EXPECT_EQ(test_data[i].should_succeed,
               owned_keychain_adapter.RemovePassword(*form));
 
     MacKeychainPasswordFormAdapter keychain_adapter(keychain_);
     bool match = keychain_adapter.HasPasswordExactlyMatchingForm(*form);
     EXPECT_EQ(test_data[i].should_succeed, !match);
   }
 }
@@ skipping 235 matching lines @@
       "http://dont.remember.com/",
       "http://dont.remember.com/handlepage.cgi",
       L"submit", L"username", L"password", L"joe_user", L"",
       true, false, 1240000000 },
     { PasswordForm::SCHEME_HTML, "http://some.domain.com/",
       "http://some.domain.com/path.html", "http://some.domain.com/action.cgi",
       L"submit", L"username", L"password", NULL, NULL,
       true, false, 1212121212 },
   };
   std::vector<PasswordForm*> database_forms;
-  for (unsigned int i = 0; i < ARRAYSIZE_UNSAFE(db_data); ++i) {
+  for (unsigned int i = 0; i < arraysize(db_data); ++i) {
     database_forms.push_back(CreatePasswordFormFromData(db_data[i]));
   }
   std::vector<PasswordForm*> merged_forms =
       internal_keychain_helpers::GetPasswordsForForms(*keychain_,
                                                       &database_forms);
   EXPECT_EQ(2U, database_forms.size());
   ASSERT_EQ(3U, merged_forms.size());
   EXPECT_EQ(ASCIIToUTF16("sekrit"), merged_forms[0]->password_value);
   EXPECT_EQ(ASCIIToUTF16("sekrit"), merged_forms[1]->password_value);
   EXPECT_TRUE(merged_forms[2]->blacklisted_by_user);
 
   STLDeleteElements(&database_forms);
   STLDeleteElements(&merged_forms);
 }
 
 TEST_F(PasswordStoreMacInternalsTest, TestBlacklistedFiltering) {
   PasswordFormData db_data[] = {
     { PasswordForm::SCHEME_HTML, "http://dont.remember.com/",
       "http://dont.remember.com/",
       "http://dont.remember.com/handlepage.cgi",
       L"submit", L"username", L"password", L"joe_user", L"non_empty_password",
       true, false, 1240000000 },
     { PasswordForm::SCHEME_HTML, "https://dont.remember.com/",
       "https://dont.remember.com/",
       "https://dont.remember.com/handlepage_secure.cgi",
       L"submit", L"username", L"password", L"joe_user", L"non_empty_password",
       true, false, 1240000000 },
   };
   std::vector<PasswordForm*> database_forms;
-  for (unsigned int i = 0; i < ARRAYSIZE_UNSAFE(db_data); ++i) {
+  for (unsigned int i = 0; i < arraysize(db_data); ++i) {
     database_forms.push_back(CreatePasswordFormFromData(db_data[i]));
   }
   std::vector<PasswordForm*> merged_forms =
       internal_keychain_helpers::GetPasswordsForForms(*keychain_,
                                                       &database_forms);
   EXPECT_EQ(2U, database_forms.size());
   ASSERT_EQ(0U, merged_forms.size());
 
   STLDeleteElements(&database_forms);
   STLDeleteElements(&merged_forms);
@@ skipping 209 matching lines @@
     // Update a password that doesn't exist in either location. This tests the
     // case where a form is filled, then the stored login is removed, then the
     // form is submitted.
     { { PasswordForm::SCHEME_HTML, "http://different.com/",
         "http://different.com/index.html", "login.cgi",
         L"username", L"password", L"submit", L"abc", L"123",
         true, false, 2 },
       NULL,
     },
   };
-  for (unsigned int i = 0; i < ARRAYSIZE_UNSAFE(updates); ++i) {
+  for (unsigned int i = 0; i < arraysize(updates); ++i) {
     scoped_ptr<PasswordForm> form(CreatePasswordFormFromData(
         updates[i].form_data));
     store_->UpdateLogin(*form);
   }
 
   WaitForStoreUpdate();
 
   MacKeychainPasswordFormAdapter keychain_adapter(keychain_);
-  for (unsigned int i = 0; i < ARRAYSIZE_UNSAFE(updates); ++i) {
+  for (unsigned int i = 0; i < arraysize(updates); ++i) {
     scoped_ptr<PasswordForm> query_form(
         CreatePasswordFormFromData(updates[i].form_data));
 
     std::vector<PasswordForm*> matching_items =
         keychain_adapter.PasswordsFillingForm(query_form->signon_realm,
                                               query_form->scheme);
     if (updates[i].password) {
       EXPECT_GT(matching_items.size(), 0U) << "iteration " << i;
       if (matching_items.size() >= 1)
         EXPECT_EQ(ASCIIToUTF16(updates[i].password),
@@ skipping 258 matching lines @@
   ASSERT_EQ(1u, matching_items.size());
   EXPECT_EQ(ASCIIToUTF16("joe_user"), matching_items[0]->username_value);
   matching_items.clear();
 
   // Check the third-party password is still there.
   owned_keychain_adapter.SetFindsOnlyOwnedItems(false);
   matching_items.get() = owned_keychain_adapter.PasswordsFillingForm(
       "http://some.domain.com/insecure.html", PasswordForm::SCHEME_HTML);
   ASSERT_EQ(1u, matching_items.size());
 }