Convert ARRAYSIZE_UNSAFE -> arraysize in components/.

components/policy/core/common/schema_unittest.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 "components/policy/core/common/schema.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "components/policy/core/common/schema_internal.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 392 matching lines @@
     { "Number",                      base::Value::TYPE_DOUBLE },
     { "Object",                      base::Value::TYPE_DICTIONARY },
     { "ObjectOfArray",               base::Value::TYPE_DICTIONARY },
     { "ObjectOfObject",              base::Value::TYPE_DICTIONARY },
     { "ObjectWithPatternProperties", base::Value::TYPE_DICTIONARY },
     { "String",                      base::Value::TYPE_STRING },
     { "StringWithEnums",             base::Value::TYPE_STRING },
     { "StringWithPattern",           base::Value::TYPE_STRING },
   };
   Schema::Iterator it = schema.GetPropertiesIterator();
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kExpectedProperties); ++i) {
+  for (size_t i = 0; i < arraysize(kExpectedProperties); ++i) {
     ASSERT_FALSE(it.IsAtEnd());
     EXPECT_STREQ(kExpectedProperties[i].expected_key, it.key());
     ASSERT_TRUE(it.schema().valid());
     EXPECT_EQ(kExpectedProperties[i].expected_type, it.schema().type());
     it.Advance();
   }
   EXPECT_TRUE(it.IsAtEnd());
 }
 
 TEST(SchemaTest, Lookups) {
@@ skipping 42 matching lines @@
   struct {
     const char* expected_key;
     base::Value::Type expected_type;
   } kExpectedKeys[] = {
     { "aa",     base::Value::TYPE_BOOLEAN },
     { "ab",     base::Value::TYPE_DOUBLE },
     { "aba",    base::Value::TYPE_INTEGER },
     { "abab",   base::Value::TYPE_STRING },
     { "bb",     base::Value::TYPE_NULL },
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kExpectedKeys); ++i) {
+  for (size_t i = 0; i < arraysize(kExpectedKeys); ++i) {
     Schema sub = schema.GetKnownProperty(kExpectedKeys[i].expected_key);
     ASSERT_TRUE(sub.valid());
     EXPECT_EQ(kExpectedKeys[i].expected_type, sub.type());
   }
 }
 
 TEST(SchemaTest, Wrap) {
   const internal::SchemaNode kSchemas[] = {
     { base::Value::TYPE_DICTIONARY,   0 },    //  0: root node
     { base::Value::TYPE_BOOLEAN,      -1 },   //  1
@@ skipping 65 matching lines @@
     { "Number", base::Value::TYPE_DOUBLE },
     { "String", base::Value::TYPE_STRING },
     { "List", base::Value::TYPE_LIST },
     { "IntEnum", base::Value::TYPE_INTEGER },
     { "RangedInt", base::Value::TYPE_INTEGER },
     { "StrEnum", base::Value::TYPE_STRING },
     { "StrPat", base::Value::TYPE_STRING },
   };
 
   Schema::Iterator it = schema.GetPropertiesIterator();
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kExpectedProperties); ++i) {
+  for (size_t i = 0; i < arraysize(kExpectedProperties); ++i) {
     ASSERT_FALSE(it.IsAtEnd());
     EXPECT_STREQ(kExpectedProperties[i].key, it.key());
     Schema sub = it.schema();
     ASSERT_TRUE(sub.valid());
     EXPECT_EQ(kExpectedProperties[i].type, sub.type());
 
     if (sub.type() == base::Value::TYPE_LIST) {
       Schema items = sub.GetItems();
       ASSERT_TRUE(items.valid());
       EXPECT_EQ(base::Value::TYPE_STRING, items.type());
@@ skipping 597 matching lines @@
 
   EXPECT_FALSE(ParseFails(SchemaObjectWrapper(
       "{"
       "  \"type\": \"integer\","
       "  \"minimum\": 10,"
       "  \"maximum\": 20"
       "}")));
 }
 
 }  // namespace policy