AAPT2: Rename to match new style

Use Google3 naming style to match new
projects' and open source google projects' style.

Preferred to do this in a massive CL so as to avoid
style inconsistencies that plague legacy code bases.
This is a relatively NEW code base, may as well keep
it up to date.

Test: name/style refactor - existing tests pass
Change-Id: Ie80ecb78d46ec53efdfca2336bb57d96cbb7fb87

1 files changed, 72 insertions, 69 deletions

diff --git a/tools/aapt2/ResourceUtils_test.cpp b/tools/aapt2/ResourceUtils_test.cpp
index eb62b1b0f4fa..f9c500b42c13 100644
--- a/tools/aapt2/ResourceUtils_test.cpp
+++ b/tools/aapt2/ResourceUtils_test.cpp
@@ -15,128 +15,129 @@
  */
 
 #include "ResourceUtils.h"
+
 #include "Resource.h"
 #include "test/Test.h"
 
 namespace aapt {
 
 TEST(ResourceUtilsTest, ParseBool) {
-  EXPECT_EQ(Maybe<bool>(true), ResourceUtils::parseBool("true"));
-  EXPECT_EQ(Maybe<bool>(true), ResourceUtils::parseBool("TRUE"));
-  EXPECT_EQ(Maybe<bool>(true), ResourceUtils::parseBool("True"));
-  EXPECT_EQ(Maybe<bool>(false), ResourceUtils::parseBool("false"));
-  EXPECT_EQ(Maybe<bool>(false), ResourceUtils::parseBool("FALSE"));
-  EXPECT_EQ(Maybe<bool>(false), ResourceUtils::parseBool("False"));
+  EXPECT_EQ(Maybe<bool>(true), ResourceUtils::ParseBool("true"));
+  EXPECT_EQ(Maybe<bool>(true), ResourceUtils::ParseBool("TRUE"));
+  EXPECT_EQ(Maybe<bool>(true), ResourceUtils::ParseBool("True"));
+  EXPECT_EQ(Maybe<bool>(false), ResourceUtils::ParseBool("false"));
+  EXPECT_EQ(Maybe<bool>(false), ResourceUtils::ParseBool("FALSE"));
+  EXPECT_EQ(Maybe<bool>(false), ResourceUtils::ParseBool("False"));
 }
 
 TEST(ResourceUtilsTest, ParseResourceName) {
   ResourceNameRef actual;
-  bool actualPriv = false;
-  EXPECT_TRUE(ResourceUtils::parseResourceName("android:color/foo", &actual,
-                                               &actualPriv));
+  bool actual_priv = false;
+  EXPECT_TRUE(ResourceUtils::ParseResourceName("android:color/foo", &actual,
+                                               &actual_priv));
   EXPECT_EQ(ResourceNameRef("android", ResourceType::kColor, "foo"), actual);
-  EXPECT_FALSE(actualPriv);
+  EXPECT_FALSE(actual_priv);
 
   EXPECT_TRUE(
-      ResourceUtils::parseResourceName("color/foo", &actual, &actualPriv));
+      ResourceUtils::ParseResourceName("color/foo", &actual, &actual_priv));
   EXPECT_EQ(ResourceNameRef({}, ResourceType::kColor, "foo"), actual);
-  EXPECT_FALSE(actualPriv);
+  EXPECT_FALSE(actual_priv);
 
-  EXPECT_TRUE(ResourceUtils::parseResourceName("*android:color/foo", &actual,
-                                               &actualPriv));
+  EXPECT_TRUE(ResourceUtils::ParseResourceName("*android:color/foo", &actual,
+                                               &actual_priv));
   EXPECT_EQ(ResourceNameRef("android", ResourceType::kColor, "foo"), actual);
-  EXPECT_TRUE(actualPriv);
+  EXPECT_TRUE(actual_priv);
 
   EXPECT_FALSE(
-      ResourceUtils::parseResourceName(StringPiece(), &actual, &actualPriv));
+      ResourceUtils::ParseResourceName(StringPiece(), &actual, &actual_priv));
 }
 
 TEST(ResourceUtilsTest, ParseReferenceWithNoPackage) {
   ResourceNameRef expected({}, ResourceType::kColor, "foo");
   ResourceNameRef actual;
   bool create = false;
-  bool privateRef = false;
-  EXPECT_TRUE(ResourceUtils::parseReference("@color/foo", &actual, &create,
-                                            &privateRef));
+  bool private_ref = false;
+  EXPECT_TRUE(ResourceUtils::ParseReference("@color/foo", &actual, &create,
+                                            &private_ref));
   EXPECT_EQ(expected, actual);
   EXPECT_FALSE(create);
-  EXPECT_FALSE(privateRef);
+  EXPECT_FALSE(private_ref);
 }
 
 TEST(ResourceUtilsTest, ParseReferenceWithPackage) {
   ResourceNameRef expected("android", ResourceType::kColor, "foo");
   ResourceNameRef actual;
   bool create = false;
-  bool privateRef = false;
-  EXPECT_TRUE(ResourceUtils::parseReference("@android:color/foo", &actual,
-                                            &create, &privateRef));
+  bool private_ref = false;
+  EXPECT_TRUE(ResourceUtils::ParseReference("@android:color/foo", &actual,
+                                            &create, &private_ref));
   EXPECT_EQ(expected, actual);
   EXPECT_FALSE(create);
-  EXPECT_FALSE(privateRef);
+  EXPECT_FALSE(private_ref);
 }
 
 TEST(ResourceUtilsTest, ParseReferenceWithSurroundingWhitespace) {
   ResourceNameRef expected("android", ResourceType::kColor, "foo");
   ResourceNameRef actual;
   bool create = false;
-  bool privateRef = false;
-  EXPECT_TRUE(ResourceUtils::parseReference("\t @android:color/foo\n \n\t",
-                                            &actual, &create, &privateRef));
+  bool private_ref = false;
+  EXPECT_TRUE(ResourceUtils::ParseReference("\t @android:color/foo\n \n\t",
+                                            &actual, &create, &private_ref));
   EXPECT_EQ(expected, actual);
   EXPECT_FALSE(create);
-  EXPECT_FALSE(privateRef);
+  EXPECT_FALSE(private_ref);
 }
 
 TEST(ResourceUtilsTest, ParseAutoCreateIdReference) {
   ResourceNameRef expected("android", ResourceType::kId, "foo");
   ResourceNameRef actual;
   bool create = false;
-  bool privateRef = false;
-  EXPECT_TRUE(ResourceUtils::parseReference("@+android:id/foo", &actual,
-                                            &create, &privateRef));
+  bool private_ref = false;
+  EXPECT_TRUE(ResourceUtils::ParseReference("@+android:id/foo", &actual,
+                                            &create, &private_ref));
   EXPECT_EQ(expected, actual);
   EXPECT_TRUE(create);
-  EXPECT_FALSE(privateRef);
+  EXPECT_FALSE(private_ref);
 }
 
 TEST(ResourceUtilsTest, ParsePrivateReference) {
   ResourceNameRef expected("android", ResourceType::kId, "foo");
   ResourceNameRef actual;
   bool create = false;
-  bool privateRef = false;
-  EXPECT_TRUE(ResourceUtils::parseReference("@*android:id/foo", &actual,
-                                            &create, &privateRef));
+  bool private_ref = false;
+  EXPECT_TRUE(ResourceUtils::ParseReference("@*android:id/foo", &actual,
+                                            &create, &private_ref));
   EXPECT_EQ(expected, actual);
   EXPECT_FALSE(create);
-  EXPECT_TRUE(privateRef);
+  EXPECT_TRUE(private_ref);
 }
 
 TEST(ResourceUtilsTest, FailToParseAutoCreateNonIdReference) {
   bool create = false;
-  bool privateRef = false;
+  bool private_ref = false;
   ResourceNameRef actual;
-  EXPECT_FALSE(ResourceUtils::parseReference("@+android:color/foo", &actual,
-                                             &create, &privateRef));
+  EXPECT_FALSE(ResourceUtils::ParseReference("@+android:color/foo", &actual,
+                                             &create, &private_ref));
 }
 
 TEST(ResourceUtilsTest, ParseAttributeReferences) {
-  EXPECT_TRUE(ResourceUtils::isAttributeReference("?android"));
-  EXPECT_TRUE(ResourceUtils::isAttributeReference("?android:foo"));
-  EXPECT_TRUE(ResourceUtils::isAttributeReference("?attr/foo"));
-  EXPECT_TRUE(ResourceUtils::isAttributeReference("?android:attr/foo"));
+  EXPECT_TRUE(ResourceUtils::IsAttributeReference("?android"));
+  EXPECT_TRUE(ResourceUtils::IsAttributeReference("?android:foo"));
+  EXPECT_TRUE(ResourceUtils::IsAttributeReference("?attr/foo"));
+  EXPECT_TRUE(ResourceUtils::IsAttributeReference("?android:attr/foo"));
 }
 
 TEST(ResourceUtilsTest, FailParseIncompleteReference) {
-  EXPECT_FALSE(ResourceUtils::isAttributeReference("?style/foo"));
-  EXPECT_FALSE(ResourceUtils::isAttributeReference("?android:style/foo"));
-  EXPECT_FALSE(ResourceUtils::isAttributeReference("?android:"));
-  EXPECT_FALSE(ResourceUtils::isAttributeReference("?android:attr/"));
-  EXPECT_FALSE(ResourceUtils::isAttributeReference("?:attr/"));
-  EXPECT_FALSE(ResourceUtils::isAttributeReference("?:attr/foo"));
-  EXPECT_FALSE(ResourceUtils::isAttributeReference("?:/"));
-  EXPECT_FALSE(ResourceUtils::isAttributeReference("?:/foo"));
-  EXPECT_FALSE(ResourceUtils::isAttributeReference("?attr/"));
-  EXPECT_FALSE(ResourceUtils::isAttributeReference("?/foo"));
+  EXPECT_FALSE(ResourceUtils::IsAttributeReference("?style/foo"));
+  EXPECT_FALSE(ResourceUtils::IsAttributeReference("?android:style/foo"));
+  EXPECT_FALSE(ResourceUtils::IsAttributeReference("?android:"));
+  EXPECT_FALSE(ResourceUtils::IsAttributeReference("?android:attr/"));
+  EXPECT_FALSE(ResourceUtils::IsAttributeReference("?:attr/"));
+  EXPECT_FALSE(ResourceUtils::IsAttributeReference("?:attr/foo"));
+  EXPECT_FALSE(ResourceUtils::IsAttributeReference("?:/"));
+  EXPECT_FALSE(ResourceUtils::IsAttributeReference("?:/foo"));
+  EXPECT_FALSE(ResourceUtils::IsAttributeReference("?attr/"));
+  EXPECT_FALSE(ResourceUtils::IsAttributeReference("?/foo"));
 }
 
 TEST(ResourceUtilsTest, ParseStyleParentReference) {
@@ -144,56 +145,58 @@ TEST(ResourceUtilsTest, ParseStyleParentReference) {
                                           "foo");
   const ResourceName kStyleFooName({}, ResourceType::kStyle, "foo");
 
-  std::string errStr;
+  std::string err_str;
   Maybe<Reference> ref =
-      ResourceUtils::parseStyleParentReference("@android:style/foo", &errStr);
+      ResourceUtils::ParseStyleParentReference("@android:style/foo", &err_str);
   AAPT_ASSERT_TRUE(ref);
   EXPECT_EQ(ref.value().name.value(), kAndroidStyleFooName);
 
-  ref = ResourceUtils::parseStyleParentReference("@style/foo", &errStr);
+  ref = ResourceUtils::ParseStyleParentReference("@style/foo", &err_str);
   AAPT_ASSERT_TRUE(ref);
   EXPECT_EQ(ref.value().name.value(), kStyleFooName);
 
-  ref = ResourceUtils::parseStyleParentReference("?android:style/foo", &errStr);
+  ref =
+      ResourceUtils::ParseStyleParentReference("?android:style/foo", &err_str);
   AAPT_ASSERT_TRUE(ref);
   EXPECT_EQ(ref.value().name.value(), kAndroidStyleFooName);
 
-  ref = ResourceUtils::parseStyleParentReference("?style/foo", &errStr);
+  ref = ResourceUtils::ParseStyleParentReference("?style/foo", &err_str);
   AAPT_ASSERT_TRUE(ref);
   EXPECT_EQ(ref.value().name.value(), kStyleFooName);
 
-  ref = ResourceUtils::parseStyleParentReference("android:style/foo", &errStr);
+  ref = ResourceUtils::ParseStyleParentReference("android:style/foo", &err_str);
   AAPT_ASSERT_TRUE(ref);
   EXPECT_EQ(ref.value().name.value(), kAndroidStyleFooName);
 
-  ref = ResourceUtils::parseStyleParentReference("android:foo", &errStr);
+  ref = ResourceUtils::ParseStyleParentReference("android:foo", &err_str);
   AAPT_ASSERT_TRUE(ref);
   EXPECT_EQ(ref.value().name.value(), kAndroidStyleFooName);
 
-  ref = ResourceUtils::parseStyleParentReference("@android:foo", &errStr);
+  ref = ResourceUtils::ParseStyleParentReference("@android:foo", &err_str);
   AAPT_ASSERT_TRUE(ref);
   EXPECT_EQ(ref.value().name.value(), kAndroidStyleFooName);
 
-  ref = ResourceUtils::parseStyleParentReference("foo", &errStr);
+  ref = ResourceUtils::ParseStyleParentReference("foo", &err_str);
   AAPT_ASSERT_TRUE(ref);
   EXPECT_EQ(ref.value().name.value(), kStyleFooName);
 
-  ref = ResourceUtils::parseStyleParentReference("*android:style/foo", &errStr);
+  ref =
+      ResourceUtils::ParseStyleParentReference("*android:style/foo", &err_str);
   AAPT_ASSERT_TRUE(ref);
   EXPECT_EQ(ref.value().name.value(), kAndroidStyleFooName);
-  EXPECT_TRUE(ref.value().privateReference);
+  EXPECT_TRUE(ref.value().private_reference);
 }
 
 TEST(ResourceUtilsTest, ParseEmptyFlag) {
   std::unique_ptr<Attribute> attr =
       test::AttributeBuilder(false)
-          .setTypeMask(android::ResTable_map::TYPE_FLAGS)
-          .addItem("one", 0x01)
-          .addItem("two", 0x02)
-          .build();
+          .SetTypeMask(android::ResTable_map::TYPE_FLAGS)
+          .AddItem("one", 0x01)
+          .AddItem("two", 0x02)
+          .Build();
 
   std::unique_ptr<BinaryPrimitive> result =
-      ResourceUtils::tryParseFlagSymbol(attr.get(), "");
+      ResourceUtils::TryParseFlagSymbol(attr.get(), "");
   ASSERT_NE(nullptr, result);
   EXPECT_EQ(0u, result->value.data);
 }