Convert ARRAYSIZE_UNSAFE -> arraysize in chrome/, outside of chrome/browser/.

chrome/common/extensions/api/extension_api_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 "extensions/common/extension_api.h"
 
 #include <string>
 #include <vector>
 
 #include "base/files/file_path.h"
@@ skipping 39 matching lines @@
 
   struct {
     ExtensionAPI* api;
     bool expect_populated;
   } test_data[] = {
     { shared_instance, true },
     { new_instance.get(), true },
     { &empty_instance, false }
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
+  for (size_t i = 0; i < arraysize(test_data); ++i) {
     EXPECT_EQ(test_data[i].expect_populated,
               test_data[i].api->GetSchema("bookmarks.create") != NULL);
   }
 }
 
 TEST(ExtensionAPITest, SplitDependencyName) {
   struct {
     std::string input;
     std::string expected_feature_type;
     std::string expected_feature_name;
   } test_data[] = {{"", "api", ""},  // assumes "api" when no type is present
                    {"foo", "api", "foo"},
                    {"foo:", "foo", ""},
                    {":foo", "", "foo"},
                    {"foo:bar", "foo", "bar"},
                    {"foo:bar.baz", "foo", "bar.baz"}};
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
+  for (size_t i = 0; i < arraysize(test_data); ++i) {
     std::string feature_type;
     std::string feature_name;
     ExtensionAPI::SplitDependencyName(
         test_data[i].input, &feature_type, &feature_name);
     EXPECT_EQ(test_data[i].expected_feature_type, feature_type) << i;
     EXPECT_EQ(test_data[i].expected_feature_name, feature_name) << i;
   }
 }
 
 TEST(ExtensionAPITest, IsAvailableInUntrustedContext) {
@@ skipping 74 matching lines @@
   ASSERT_TRUE(base::ReadFileToString(
       api_features_path, &api_features_str)) << "privileged_api_features.json";
 
   scoped_ptr<base::DictionaryValue> value(static_cast<base::DictionaryValue*>(
       base::JSONReader::Read(api_features_str)));
   BaseFeatureProvider api_feature_provider(*value, CreateAPIFeature);
 
   scoped_refptr<Extension> extension =
       BuildExtension(ExtensionBuilder().Pass()).Build();
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
+  for (size_t i = 0; i < arraysize(test_data); ++i) {
     ExtensionAPI api;
     api.RegisterDependencyProvider("api", &api_feature_provider);
     EXPECT_EQ(test_data[i].expect_is_available,
               api.IsAvailableInUntrustedContext(test_data[i].api_full_name,
                                                 extension.get()))
         << i;
   }
 }
 
 TEST(ExtensionAPITest, APIFeatures) {
@@ skipping 77 matching lines @@
       .AppendASCII("api_features.json");
 
   std::string api_features_str;
   ASSERT_TRUE(base::ReadFileToString(
       api_features_path, &api_features_str)) << "api_features.json";
 
   scoped_ptr<base::DictionaryValue> value(static_cast<base::DictionaryValue*>(
       base::JSONReader::Read(api_features_str)));
   BaseFeatureProvider api_feature_provider(*value, CreateAPIFeature);
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
+  for (size_t i = 0; i < arraysize(test_data); ++i) {
     ExtensionAPI api;
     api.RegisterDependencyProvider("api", &api_feature_provider);
     for (base::DictionaryValue::Iterator iter(*value); !iter.IsAtEnd();
          iter.Advance()) {
       if (iter.key().find(".") == std::string::npos)
         api.RegisterSchemaResource(iter.key(), 0);
     }
 
     ExtensionAPI::OverrideSharedInstanceForTest scope(&api);
     bool expected = test_data[i].expect_is_available;
@@ skipping 59 matching lines @@
       .AppendASCII("api_features.json");
 
   std::string api_features_str;
   ASSERT_TRUE(base::ReadFileToString(
       api_features_path, &api_features_str)) << "api_features.json";
 
   scoped_ptr<base::DictionaryValue> value(static_cast<base::DictionaryValue*>(
       base::JSONReader::Read(api_features_str)));
   BaseFeatureProvider api_feature_provider(*value, CreateAPIFeature);
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
+  for (size_t i = 0; i < arraysize(test_data); ++i) {
     ExtensionAPI api;
     api.RegisterDependencyProvider("api", &api_feature_provider);
     for (base::DictionaryValue::Iterator iter(*value); !iter.IsAtEnd();
          iter.Advance()) {
       if (iter.key().find(".") == std::string::npos)
         api.RegisterSchemaResource(iter.key(), 0);
     }
 
     Feature* test_feature =
         api_feature_provider.GetFeature(test_data[i].api_full_name);
@@ skipping 342 matching lines @@
     { "bookmarks.", "bookmarks", "" },
     { ".bookmarks", "", "" },
     { "bookmarks.create", "bookmarks", "create" },
     { "bookmarks.create.", "bookmarks", "create." },
     { "bookmarks.create.monkey", "bookmarks", "create.monkey" },
     { "bookmarkManagerPrivate", "bookmarkManagerPrivate", "" },
     { "bookmarkManagerPrivate.copy", "bookmarkManagerPrivate", "copy" }
   };
 
   scoped_ptr<ExtensionAPI> api(ExtensionAPI::CreateWithDefaultConfiguration());
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
+  for (size_t i = 0; i < arraysize(test_data); ++i) {
     std::string child_name;
     std::string api_name = api->GetAPINameFromFullName(test_data[i].input,
                                                        &child_name);
     EXPECT_EQ(test_data[i].api_name, api_name) << test_data[i].input;
     EXPECT_EQ(test_data[i].child_name, child_name) << test_data[i].input;
   }
 }
 
 TEST(ExtensionAPITest, DefaultConfigurationFeatures) {
   scoped_ptr<ExtensionAPI> api(ExtensionAPI::CreateWithDefaultConfiguration());
 
   SimpleFeature* bookmarks = static_cast<SimpleFeature*>(
       api->GetFeatureDependency("api:bookmarks"));
   SimpleFeature* bookmarks_create = static_cast<SimpleFeature*>(
       api->GetFeatureDependency("api:bookmarks.create"));
 
   struct {
     SimpleFeature* feature;
     // TODO(aa): More stuff to test over time.
   } test_data[] = {
     { bookmarks },
     { bookmarks_create }
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
+  for (size_t i = 0; i < arraysize(test_data); ++i) {
     SimpleFeature* feature = test_data[i].feature;
     ASSERT_TRUE(feature) << i;
 
     EXPECT_TRUE(feature->whitelist()->empty());
     EXPECT_TRUE(feature->extension_types()->empty());
 
     EXPECT_EQ(SimpleFeature::UNSPECIFIED_LOCATION, feature->location());
     EXPECT_TRUE(feature->platforms()->empty());
     EXPECT_EQ(0, feature->min_manifest_version());
     EXPECT_EQ(0, feature->max_manifest_version());
@@ skipping 15 matching lines @@
   api_features2->Set("test", test2);
 
   struct {
     base::DictionaryValue* api_features;
     bool expect_success;
   } test_data[] = {
     { api_features1.get(), true },
     { api_features2.get(), false }
   };
 
-
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
+  for (size_t i = 0; i < arraysize(test_data); ++i) {
     BaseFeatureProvider api_feature_provider(*test_data[i].api_features,
                                              CreateAPIFeature);
     Feature* feature = api_feature_provider.GetFeature("test");
     EXPECT_EQ(test_data[i].expect_success, feature != NULL) << i;
   }
 }
 
 static void GetDictionaryFromList(const base::DictionaryValue* schema,
                                   const std::string& list_name,
                                   const int list_index,
@@ skipping 107 matching lines @@
     { "management.uninstallSelf", true },
     // But other functions in those modules do.
     { "management.getPermissionWarningsById", false },
   };
 
   scoped_ptr<ExtensionAPI> extension_api(
       ExtensionAPI::CreateWithDefaultConfiguration());
   scoped_refptr<Extension> extension =
       BuildExtension(ExtensionBuilder().Pass()).Build();
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTests); ++i) {
+  for (size_t i = 0; i < arraysize(kTests); ++i) {
     EXPECT_EQ(kTests[i].expect_success,
               extension_api->IsAvailable(kTests[i].permission_name,
                                          extension.get(),
                                          Feature::BLESSED_EXTENSION_CONTEXT,
                                          GURL()).is_available())
         << "Permission being tested: " << kTests[i].permission_name;
   }
 }
 
 // Tests that permissions that require manifest keys are available when those
@@ skipping 12 matching lines @@
                                          extension.get(),
                                          Feature::BLESSED_EXTENSION_CONTEXT,
                                          GURL()).is_available());
   EXPECT_FALSE(extension_api->IsAvailable("pageAction",
                                           extension.get(),
                                           Feature::BLESSED_EXTENSION_CONTEXT,
                                           GURL()).is_available());
 }
 
 }  // namespace extensions