diff --git a/cmds/idmap/inspect.cpp b/cmds/idmap/inspect.cpp
index f6afc8594309a..154cb25a02a1f 100644
--- a/cmds/idmap/inspect.cpp
+++ b/cmds/idmap/inspect.cpp
@@ -2,6 +2,7 @@
 
 #include <androidfw/AssetManager.h>
 #include <androidfw/ResourceTypes.h>
+#include <utils/ByteOrder.h>
 #include <utils/String8.h>
 
 #include <fcntl.h>
diff --git a/include/androidfw/Asset.h b/include/androidfw/Asset.h
index 52c863774efb0..11709ce5f91b9 100644
--- a/include/androidfw/Asset.h
+++ b/include/androidfw/Asset.h
@@ -26,11 +26,12 @@
 
 #include <utils/Compat.h>
 #include <utils/Errors.h>
-#include <utils/FileMap.h>
 #include <utils/String8.h>
 
 namespace android {
 
+class FileMap;
+
 /*
  * Instances of this class provide read-only operations on a byte stream.
  *
diff --git a/include/androidfw/ResourceTypes.h b/include/androidfw/ResourceTypes.h
index 6349e86dae94e..08d6591e68868 100644
--- a/include/androidfw/ResourceTypes.h
+++ b/include/androidfw/ResourceTypes.h
@@ -22,7 +22,6 @@
 
 #include <androidfw/Asset.h>
 #include <androidfw/LocaleData.h>
-#include <utils/ByteOrder.h>
 #include <utils/Errors.h>
 #include <utils/String16.h>
 #include <utils/Vector.h>
diff --git a/include/androidfw/TypeWrappers.h b/include/androidfw/TypeWrappers.h
index 7bdf8af0ad4c7..4233b6bbee83b 100644
--- a/include/androidfw/TypeWrappers.h
+++ b/include/androidfw/TypeWrappers.h
@@ -18,6 +18,7 @@
 #define __TYPE_WRAPPERS_H
 
 #include <androidfw/ResourceTypes.h>
+#include <utils/ByteOrder.h>
 
 namespace android {
 
diff --git a/tools/aapt2/.clang-format b/tools/aapt2/.clang-format
index 71c5ef2fcda08..545366a9b70b0 100644
--- a/tools/aapt2/.clang-format
+++ b/tools/aapt2/.clang-format
@@ -1,3 +1,2 @@
 BasedOnStyle: Google
-ColumnLimit: 100
 
diff --git a/tools/aapt2/Android.mk b/tools/aapt2/Android.mk
index 284c7877d0546..197884dcf85ce 100644
--- a/tools/aapt2/Android.mk
+++ b/tools/aapt2/Android.mk
@@ -158,7 +158,7 @@ hostStaticLibs_windows := libz
 hostLdLibs_linux := -lz
 hostLdLibs_darwin := -lz
 
-cFlags := -Wall -Werror -Wno-unused-parameter -UNDEBUG
+cFlags := -Wall -Werror -Wno-unused-parameter
 cFlags_darwin := -D_DARWIN_UNLIMITED_STREAMS
 cFlags_windows := -Wno-maybe-uninitialized # Incorrectly marking use of Maybe.value() as error.
 cppFlags := -Wno-missing-field-initializers -fno-exceptions -fno-rtti
diff --git a/tools/aapt2/AppInfo.h b/tools/aapt2/AppInfo.h
index 2cbe117974406..1e488f70bd4d7 100644
--- a/tools/aapt2/AppInfo.h
+++ b/tools/aapt2/AppInfo.h
@@ -17,10 +17,10 @@
 #ifndef AAPT_APP_INFO_H
 #define AAPT_APP_INFO_H
 
-#include "util/Maybe.h"
-
 #include <string>
 
+#include "util/Maybe.h"
+
 namespace aapt {
 
 /**
@@ -36,17 +36,17 @@ struct AppInfo {
   /**
    * The App's minimum SDK version.
    */
-  Maybe<std::string> minSdkVersion;
+  Maybe<std::string> min_sdk_version;
 
   /**
    * The Version code of the app.
    */
-  Maybe<uint32_t> versionCode;
+  Maybe<uint32_t> version_code;
 
   /**
    * The revision code of the app.
    */
-  Maybe<uint32_t> revisionCode;
+  Maybe<uint32_t> revision_code;
 };
 
 }  // namespace aapt
diff --git a/tools/aapt2/ConfigDescription.cpp b/tools/aapt2/ConfigDescription.cpp
index 6598d63882001..289919a393739 100644
--- a/tools/aapt2/ConfigDescription.cpp
+++ b/tools/aapt2/ConfigDescription.cpp
@@ -15,22 +15,24 @@
  */
 
 #include "ConfigDescription.h"
+
+#include <string>
+#include <vector>
+
+#include "androidfw/ResourceTypes.h"
+
 #include "Locale.h"
 #include "SdkConstants.h"
 #include "util/StringPiece.h"
 #include "util/Util.h"
 
-#include <androidfw/ResourceTypes.h>
-#include <string>
-#include <vector>
-
 namespace aapt {
 
 using android::ResTable_config;
 
 static const char* kWildcardName = "any";
 
-const ConfigDescription& ConfigDescription::defaultConfig() {
+const ConfigDescription& ConfigDescription::DefaultConfig() {
   static ConfigDescription config = {};
   return config;
 }
@@ -589,169 +591,169 @@ static bool parseVersion(const char* name, ResTable_config* out) {
   return true;
 }
 
-bool ConfigDescription::parse(const StringPiece& str, ConfigDescription* out) {
-  std::vector<std::string> parts = util::splitAndLowercase(str, '-');
+bool ConfigDescription::Parse(const StringPiece& str, ConfigDescription* out) {
+  std::vector<std::string> parts = util::SplitAndLowercase(str, '-');
 
   ConfigDescription config;
-  ssize_t partsConsumed = 0;
+  ssize_t parts_consumed = 0;
   LocaleValue locale;
 
-  const auto partsEnd = parts.end();
-  auto partIter = parts.begin();
+  const auto parts_end = parts.end();
+  auto part_iter = parts.begin();
 
   if (str.size() == 0) {
     goto success;
   }
 
-  if (parseMcc(partIter->c_str(), &config)) {
-    ++partIter;
-    if (partIter == partsEnd) {
+  if (parseMcc(part_iter->c_str(), &config)) {
+    ++part_iter;
+    if (part_iter == parts_end) {
       goto success;
     }
   }
 
-  if (parseMnc(partIter->c_str(), &config)) {
-    ++partIter;
-    if (partIter == partsEnd) {
+  if (parseMnc(part_iter->c_str(), &config)) {
+    ++part_iter;
+    if (part_iter == parts_end) {
       goto success;
     }
   }
 
   // Locale spans a few '-' separators, so we let it
   // control the index.
-  partsConsumed = locale.initFromParts(partIter, partsEnd);
-  if (partsConsumed < 0) {
+  parts_consumed = locale.InitFromParts(part_iter, parts_end);
+  if (parts_consumed < 0) {
     return false;
   } else {
-    locale.writeTo(&config);
-    partIter += partsConsumed;
-    if (partIter == partsEnd) {
+    locale.WriteTo(&config);
+    part_iter += parts_consumed;
+    if (part_iter == parts_end) {
       goto success;
     }
   }
 
-  if (parseLayoutDirection(partIter->c_str(), &config)) {
-    ++partIter;
-    if (partIter == partsEnd) {
+  if (parseLayoutDirection(part_iter->c_str(), &config)) {
+    ++part_iter;
+    if (part_iter == parts_end) {
       goto success;
     }
   }
 
-  if (parseSmallestScreenWidthDp(partIter->c_str(), &config)) {
-    ++partIter;
-    if (partIter == partsEnd) {
+  if (parseSmallestScreenWidthDp(part_iter->c_str(), &config)) {
+    ++part_iter;
+    if (part_iter == parts_end) {
       goto success;
     }
   }
 
-  if (parseScreenWidthDp(partIter->c_str(), &config)) {
-    ++partIter;
-    if (partIter == partsEnd) {
+  if (parseScreenWidthDp(part_iter->c_str(), &config)) {
+    ++part_iter;
+    if (part_iter == parts_end) {
       goto success;
     }
   }
 
-  if (parseScreenHeightDp(partIter->c_str(), &config)) {
-    ++partIter;
-    if (partIter == partsEnd) {
+  if (parseScreenHeightDp(part_iter->c_str(), &config)) {
+    ++part_iter;
+    if (part_iter == parts_end) {
       goto success;
     }
   }
 
-  if (parseScreenLayoutSize(partIter->c_str(), &config)) {
-    ++partIter;
-    if (partIter == partsEnd) {
+  if (parseScreenLayoutSize(part_iter->c_str(), &config)) {
+    ++part_iter;
+    if (part_iter == parts_end) {
       goto success;
     }
   }
 
-  if (parseScreenLayoutLong(partIter->c_str(), &config)) {
-    ++partIter;
-    if (partIter == partsEnd) {
+  if (parseScreenLayoutLong(part_iter->c_str(), &config)) {
+    ++part_iter;
+    if (part_iter == parts_end) {
       goto success;
     }
   }
 
-  if (parseScreenRound(partIter->c_str(), &config)) {
-    ++partIter;
-    if (partIter == partsEnd) {
+  if (parseScreenRound(part_iter->c_str(), &config)) {
+    ++part_iter;
+    if (part_iter == parts_end) {
       goto success;
     }
   }
 
-  if (parseOrientation(partIter->c_str(), &config)) {
-    ++partIter;
-    if (partIter == partsEnd) {
+  if (parseOrientation(part_iter->c_str(), &config)) {
+    ++part_iter;
+    if (part_iter == parts_end) {
       goto success;
     }
   }
 
-  if (parseUiModeType(partIter->c_str(), &config)) {
-    ++partIter;
-    if (partIter == partsEnd) {
+  if (parseUiModeType(part_iter->c_str(), &config)) {
+    ++part_iter;
+    if (part_iter == parts_end) {
       goto success;
     }
   }
 
-  if (parseUiModeNight(partIter->c_str(), &config)) {
-    ++partIter;
-    if (partIter == partsEnd) {
+  if (parseUiModeNight(part_iter->c_str(), &config)) {
+    ++part_iter;
+    if (part_iter == parts_end) {
       goto success;
     }
   }
 
-  if (parseDensity(partIter->c_str(), &config)) {
-    ++partIter;
-    if (partIter == partsEnd) {
+  if (parseDensity(part_iter->c_str(), &config)) {
+    ++part_iter;
+    if (part_iter == parts_end) {
       goto success;
     }
   }
 
-  if (parseTouchscreen(partIter->c_str(), &config)) {
-    ++partIter;
-    if (partIter == partsEnd) {
+  if (parseTouchscreen(part_iter->c_str(), &config)) {
+    ++part_iter;
+    if (part_iter == parts_end) {
       goto success;
     }
   }
 
-  if (parseKeysHidden(partIter->c_str(), &config)) {
-    ++partIter;
-    if (partIter == partsEnd) {
+  if (parseKeysHidden(part_iter->c_str(), &config)) {
+    ++part_iter;
+    if (part_iter == parts_end) {
       goto success;
     }
   }
 
-  if (parseKeyboard(partIter->c_str(), &config)) {
-    ++partIter;
-    if (partIter == partsEnd) {
+  if (parseKeyboard(part_iter->c_str(), &config)) {
+    ++part_iter;
+    if (part_iter == parts_end) {
       goto success;
     }
   }
 
-  if (parseNavHidden(partIter->c_str(), &config)) {
-    ++partIter;
-    if (partIter == partsEnd) {
+  if (parseNavHidden(part_iter->c_str(), &config)) {
+    ++part_iter;
+    if (part_iter == parts_end) {
       goto success;
     }
   }
 
-  if (parseNavigation(partIter->c_str(), &config)) {
-    ++partIter;
-    if (partIter == partsEnd) {
+  if (parseNavigation(part_iter->c_str(), &config)) {
+    ++part_iter;
+    if (part_iter == parts_end) {
       goto success;
     }
   }
 
-  if (parseScreenSize(partIter->c_str(), &config)) {
-    ++partIter;
-    if (partIter == partsEnd) {
+  if (parseScreenSize(part_iter->c_str(), &config)) {
+    ++part_iter;
+    if (part_iter == parts_end) {
       goto success;
     }
   }
 
-  if (parseVersion(partIter->c_str(), &config)) {
-    ++partIter;
-    if (partIter == partsEnd) {
+  if (parseVersion(part_iter->c_str(), &config)) {
+    ++part_iter;
+    if (part_iter == parts_end) {
       goto success;
     }
   }
@@ -761,57 +763,57 @@ bool ConfigDescription::parse(const StringPiece& str, ConfigDescription* out) {
 
 success:
   if (out != NULL) {
-    applyVersionForCompatibility(&config);
+    ApplyVersionForCompatibility(&config);
     *out = config;
   }
   return true;
 }
 
-void ConfigDescription::applyVersionForCompatibility(
+void ConfigDescription::ApplyVersionForCompatibility(
     ConfigDescription* config) {
-  uint16_t minSdk = 0;
+  uint16_t min_sdk = 0;
   if (config->screenLayout2 & ResTable_config::MASK_SCREENROUND) {
-    minSdk = SDK_MARSHMALLOW;
+    min_sdk = SDK_MARSHMALLOW;
   } else if (config->density == ResTable_config::DENSITY_ANY) {
-    minSdk = SDK_LOLLIPOP;
+    min_sdk = SDK_LOLLIPOP;
   } else if (config->smallestScreenWidthDp !=
                  ResTable_config::SCREENWIDTH_ANY ||
              config->screenWidthDp != ResTable_config::SCREENWIDTH_ANY ||
              config->screenHeightDp != ResTable_config::SCREENHEIGHT_ANY) {
-    minSdk = SDK_HONEYCOMB_MR2;
+    min_sdk = SDK_HONEYCOMB_MR2;
   } else if ((config->uiMode & ResTable_config::MASK_UI_MODE_TYPE) !=
                  ResTable_config::UI_MODE_TYPE_ANY ||
              (config->uiMode & ResTable_config::MASK_UI_MODE_NIGHT) !=
                  ResTable_config::UI_MODE_NIGHT_ANY) {
-    minSdk = SDK_FROYO;
+    min_sdk = SDK_FROYO;
   } else if ((config->screenLayout & ResTable_config::MASK_SCREENSIZE) !=
                  ResTable_config::SCREENSIZE_ANY ||
              (config->screenLayout & ResTable_config::MASK_SCREENLONG) !=
                  ResTable_config::SCREENLONG_ANY ||
              config->density != ResTable_config::DENSITY_DEFAULT) {
-    minSdk = SDK_DONUT;
+    min_sdk = SDK_DONUT;
   }
 
-  if (minSdk > config->sdkVersion) {
-    config->sdkVersion = minSdk;
+  if (min_sdk > config->sdkVersion) {
+    config->sdkVersion = min_sdk;
   }
 }
 
-ConfigDescription ConfigDescription::copyWithoutSdkVersion() const {
+ConfigDescription ConfigDescription::CopyWithoutSdkVersion() const {
   ConfigDescription copy = *this;
   copy.sdkVersion = 0;
   return copy;
 }
 
-bool ConfigDescription::dominates(const ConfigDescription& o) const {
-  if (*this == defaultConfig() || *this == o) {
+bool ConfigDescription::Dominates(const ConfigDescription& o) const {
+  if (*this == DefaultConfig() || *this == o) {
     return true;
   }
-  return matchWithDensity(o) && !o.matchWithDensity(*this) &&
-         !isMoreSpecificThan(o) && !o.hasHigherPrecedenceThan(*this);
+  return MatchWithDensity(o) && !o.MatchWithDensity(*this) &&
+         !isMoreSpecificThan(o) && !o.HasHigherPrecedenceThan(*this);
 }
 
-bool ConfigDescription::hasHigherPrecedenceThan(
+bool ConfigDescription::HasHigherPrecedenceThan(
     const ConfigDescription& o) const {
   // The order of the following tests defines the importance of one
   // configuration parameter over another. Those tests first are more
@@ -866,7 +868,7 @@ bool ConfigDescription::hasHigherPrecedenceThan(
   return *this != o;
 }
 
-bool ConfigDescription::conflictsWith(const ConfigDescription& o) const {
+bool ConfigDescription::ConflictsWith(const ConfigDescription& o) const {
   // This method should be updated as new configuration parameters are
   // introduced (e.g. screenConfig2).
   auto pred = [](const uint32_t a, const uint32_t b) -> bool {
@@ -892,8 +894,8 @@ bool ConfigDescription::conflictsWith(const ConfigDescription& o) const {
          !pred(keyboard, o.keyboard) || !pred(navigation, o.navigation);
 }
 
-bool ConfigDescription::isCompatibleWith(const ConfigDescription& o) const {
-  return !conflictsWith(o) && !dominates(o) && !o.dominates(*this);
+bool ConfigDescription::IsCompatibleWith(const ConfigDescription& o) const {
+  return !ConflictsWith(o) && !Dominates(o) && !o.Dominates(*this);
 }
 
 }  // namespace aapt
diff --git a/tools/aapt2/ConfigDescription.h b/tools/aapt2/ConfigDescription.h
index bb54886739753..97d0f38a5af1e 100644
--- a/tools/aapt2/ConfigDescription.h
+++ b/tools/aapt2/ConfigDescription.h
@@ -17,11 +17,12 @@
 #ifndef AAPT_CONFIG_DESCRIPTION_H
 #define AAPT_CONFIG_DESCRIPTION_H
 
-#include "util/StringPiece.h"
-
-#include <androidfw/ResourceTypes.h>
 #include <ostream>
 
+#include "androidfw/ResourceTypes.h"
+
+#include "util/StringPiece.h"
+
 namespace aapt {
 
 /*
@@ -32,7 +33,7 @@ struct ConfigDescription : public android::ResTable_config {
   /**
    * Returns an immutable default config.
    */
-  static const ConfigDescription& defaultConfig();
+  static const ConfigDescription& DefaultConfig();
 
   /*
    * Parse a string of the form 'fr-sw600dp-land' and fill in the
@@ -41,14 +42,14 @@ struct ConfigDescription : public android::ResTable_config {
    * The resulting configuration has the appropriate sdkVersion defined
    * for backwards compatibility.
    */
-  static bool parse(const StringPiece& str, ConfigDescription* out = nullptr);
+  static bool Parse(const StringPiece& str, ConfigDescription* out = nullptr);
 
   /**
    * If the configuration uses an axis that was added after
    * the original Android release, make sure the SDK version
    * is set accordingly.
    */
-  static void applyVersionForCompatibility(ConfigDescription* config);
+  static void ApplyVersionForCompatibility(ConfigDescription* config);
 
   ConfigDescription();
   ConfigDescription(const android::ResTable_config& o);  // NOLINT(implicit)
@@ -59,7 +60,7 @@ struct ConfigDescription : public android::ResTable_config {
   ConfigDescription& operator=(const ConfigDescription& o);
   ConfigDescription& operator=(ConfigDescription&& o);
 
-  ConfigDescription copyWithoutSdkVersion() const;
+  ConfigDescription CopyWithoutSdkVersion() const;
 
   /**
    * A configuration X dominates another configuration Y, if X has at least the
@@ -70,14 +71,14 @@ struct ConfigDescription : public android::ResTable_config {
    * For example, the configuration 'en-w800dp' dominates 'en-rGB-w1024dp'. It
    * does not dominate 'fr', 'en-w720dp', or 'mcc001-en-w800dp'.
    */
-  bool dominates(const ConfigDescription& o) const;
+  bool Dominates(const ConfigDescription& o) const;
 
   /**
    * Returns true if this configuration defines a more important configuration
    * parameter than o. For example, "en" has higher precedence than "v23",
    * whereas "en" has the same precedence as "en-v23".
    */
-  bool hasHigherPrecedenceThan(const ConfigDescription& o) const;
+  bool HasHigherPrecedenceThan(const ConfigDescription& o) const;
 
   /**
    * A configuration conflicts with another configuration if both
@@ -85,7 +86,7 @@ struct ConfigDescription : public android::ResTable_config {
    * incompatible configuration parameter is a non-range, non-density parameter
    * that is defined in both configurations as a different, non-default value.
    */
-  bool conflictsWith(const ConfigDescription& o) const;
+  bool ConflictsWith(const ConfigDescription& o) const;
 
   /**
    * A configuration is compatible with another configuration if both
@@ -93,9 +94,9 @@ struct ConfigDescription : public android::ResTable_config {
    * unrelated by domination. For example, land-v11 conflicts with port-v21
    * but is compatible with v21 (both land-v11 and v21 would match en-land-v23).
    */
-  bool isCompatibleWith(const ConfigDescription& o) const;
+  bool IsCompatibleWith(const ConfigDescription& o) const;
 
-  bool matchWithDensity(const ConfigDescription& o) const;
+  bool MatchWithDensity(const ConfigDescription& o) const;
 
   bool operator<(const ConfigDescription& o) const;
   bool operator<=(const ConfigDescription& o) const;
@@ -141,7 +142,7 @@ inline ConfigDescription& ConfigDescription::operator=(ConfigDescription&& o) {
   return *this;
 }
 
-inline bool ConfigDescription::matchWithDensity(
+inline bool ConfigDescription::MatchWithDensity(
     const ConfigDescription& o) const {
   return match(o) && (density == 0 || density == o.density);
 }
diff --git a/tools/aapt2/ConfigDescription_test.cpp b/tools/aapt2/ConfigDescription_test.cpp
index 66b7d47761188..c331dc0f69098 100644
--- a/tools/aapt2/ConfigDescription_test.cpp
+++ b/tools/aapt2/ConfigDescription_test.cpp
@@ -15,17 +15,18 @@
  */
 
 #include "ConfigDescription.h"
+
+#include <string>
+
 #include "SdkConstants.h"
 #include "test/Test.h"
 #include "util/StringPiece.h"
 
-#include <string>
-
 namespace aapt {
 
 static ::testing::AssertionResult TestParse(
     const StringPiece& input, ConfigDescription* config = nullptr) {
-  if (ConfigDescription::parse(input, config)) {
+  if (ConfigDescription::Parse(input, config)) {
     return ::testing::AssertionSuccess() << input << " was successfully parsed";
   }
   return ::testing::AssertionFailure() << input << " could not be parsed";
diff --git a/tools/aapt2/Debug.cpp b/tools/aapt2/Debug.cpp
index 965db9ebc9c85..60b01e372d7b1 100644
--- a/tools/aapt2/Debug.cpp
+++ b/tools/aapt2/Debug.cpp
@@ -15,10 +15,6 @@
  */
 
 #include "Debug.h"
-#include "ResourceTable.h"
-#include "ResourceValues.h"
-#include "ValueVisitor.h"
-#include "util/Util.h"
 
 #include <algorithm>
 #include <iostream>
@@ -28,18 +24,25 @@
 #include <set>
 #include <vector>
 
+#include "android-base/logging.h"
+
+#include "ResourceTable.h"
+#include "ResourceValues.h"
+#include "ValueVisitor.h"
+#include "util/Util.h"
+
 namespace aapt {
 
 class PrintVisitor : public ValueVisitor {
  public:
-  using ValueVisitor::visit;
+  using ValueVisitor::Visit;
 
-  void visit(Attribute* attr) override {
+  void Visit(Attribute* attr) override {
     std::cout << "(attr) type=";
-    attr->printMask(&std::cout);
+    attr->PrintMask(&std::cout);
     static constexpr uint32_t kMask =
         android::ResTable_map::TYPE_ENUM | android::ResTable_map::TYPE_FLAGS;
-    if (attr->typeMask & kMask) {
+    if (attr->type_mask & kMask) {
       for (const auto& symbol : attr->symbols) {
         std::cout << "\n        " << symbol.symbol.name.value().entry;
         if (symbol.symbol.id) {
@@ -50,20 +53,20 @@ class PrintVisitor : public ValueVisitor {
     }
   }
 
-  void visit(Style* style) override {
+  void Visit(Style* style) override {
     std::cout << "(style)";
     if (style->parent) {
-      const Reference& parentRef = style->parent.value();
+      const Reference& parent_ref = style->parent.value();
       std::cout << " parent=";
-      if (parentRef.name) {
-        if (parentRef.privateReference) {
+      if (parent_ref.name) {
+        if (parent_ref.private_reference) {
           std::cout << "*";
         }
-        std::cout << parentRef.name.value() << " ";
+        std::cout << parent_ref.name.value() << " ";
       }
 
-      if (parentRef.id) {
-        std::cout << parentRef.id.value();
+      if (parent_ref.id) {
+        std::cout << parent_ref.id.value();
       }
     }
 
@@ -85,11 +88,11 @@ class PrintVisitor : public ValueVisitor {
     }
   }
 
-  void visit(Array* array) override { array->print(&std::cout); }
+  void Visit(Array* array) override { array->Print(&std::cout); }
 
-  void visit(Plural* plural) override { plural->print(&std::cout); }
+  void Visit(Plural* plural) override { plural->Print(&std::cout); }
 
-  void visit(Styleable* styleable) override {
+  void Visit(Styleable* styleable) override {
     std::cout << "(styleable)";
     for (const auto& attr : styleable->entries) {
       std::cout << "\n        ";
@@ -107,10 +110,10 @@ class PrintVisitor : public ValueVisitor {
     }
   }
 
-  void visitItem(Item* item) override { item->print(&std::cout); }
+  void VisitItem(Item* item) override { item->Print(&std::cout); }
 };
 
-void Debug::printTable(ResourceTable* table,
+void Debug::PrintTable(ResourceTable* table,
                        const DebugPrintTableOptions& options) {
   PrintVisitor visitor;
 
@@ -128,10 +131,10 @@ void Debug::printTable(ResourceTable* table,
       }
       std::cout << " entryCount=" << type->entries.size() << std::endl;
 
-      std::vector<const ResourceEntry*> sortedEntries;
+      std::vector<const ResourceEntry*> sorted_entries;
       for (const auto& entry : type->entries) {
         auto iter = std::lower_bound(
-            sortedEntries.begin(), sortedEntries.end(), entry.get(),
+            sorted_entries.begin(), sorted_entries.end(), entry.get(),
             [](const ResourceEntry* a, const ResourceEntry* b) -> bool {
               if (a->id && b->id) {
                 return a->id.value() < b->id.value();
@@ -141,17 +144,17 @@ void Debug::printTable(ResourceTable* table,
                 return false;
               }
             });
-        sortedEntries.insert(iter, entry.get());
+        sorted_entries.insert(iter, entry.get());
       }
 
-      for (const ResourceEntry* entry : sortedEntries) {
+      for (const ResourceEntry* entry : sorted_entries) {
         ResourceId id(package->id ? package->id.value() : uint8_t(0),
                       type->id ? type->id.value() : uint8_t(0),
                       entry->id ? entry->id.value() : uint16_t(0));
         ResourceName name(package->name, type->type, entry->name);
 
         std::cout << "    spec resource " << id << " " << name;
-        switch (entry->symbolStatus.state) {
+        switch (entry->symbol_status.state) {
           case SymbolState::kPublic:
             std::cout << " PUBLIC";
             break;
@@ -166,9 +169,9 @@ void Debug::printTable(ResourceTable* table,
 
         for (const auto& value : entry->values) {
           std::cout << "      (" << value->config << ") ";
-          value->value->accept(&visitor);
-          if (options.showSources && !value->value->getSource().path.empty()) {
-            std::cout << " src=" << value->value->getSource();
+          value->value->Accept(&visitor);
+          if (options.show_sources && !value->value->GetSource().path.empty()) {
+            std::cout << " src=" << value->value->GetSource();
           }
           std::cout << std::endl;
         }
@@ -177,35 +180,36 @@ void Debug::printTable(ResourceTable* table,
   }
 }
 
-static size_t getNodeIndex(const std::vector<ResourceName>& names,
+static size_t GetNodeIndex(const std::vector<ResourceName>& names,
                            const ResourceName& name) {
   auto iter = std::lower_bound(names.begin(), names.end(), name);
-  assert(iter != names.end() && *iter == name);
+  CHECK(iter != names.end());
+  CHECK(*iter == name);
   return std::distance(names.begin(), iter);
 }
 
-void Debug::printStyleGraph(ResourceTable* table,
-                            const ResourceName& targetStyle) {
+void Debug::PrintStyleGraph(ResourceTable* table,
+                            const ResourceName& target_style) {
   std::map<ResourceName, std::set<ResourceName>> graph;
 
-  std::queue<ResourceName> stylesToVisit;
-  stylesToVisit.push(targetStyle);
-  for (; !stylesToVisit.empty(); stylesToVisit.pop()) {
-    const ResourceName& styleName = stylesToVisit.front();
-    std::set<ResourceName>& parents = graph[styleName];
+  std::queue<ResourceName> styles_to_visit;
+  styles_to_visit.push(target_style);
+  for (; !styles_to_visit.empty(); styles_to_visit.pop()) {
+    const ResourceName& style_name = styles_to_visit.front();
+    std::set<ResourceName>& parents = graph[style_name];
     if (!parents.empty()) {
       // We've already visited this style.
       continue;
     }
 
-    Maybe<ResourceTable::SearchResult> result = table->findResource(styleName);
+    Maybe<ResourceTable::SearchResult> result = table->FindResource(style_name);
     if (result) {
       ResourceEntry* entry = result.value().entry;
       for (const auto& value : entry->values) {
-        if (Style* style = valueCast<Style>(value->value.get())) {
+        if (Style* style = ValueCast<Style>(value->value.get())) {
           if (style->parent && style->parent.value().name) {
             parents.insert(style->parent.value().name.value());
-            stylesToVisit.push(style->parent.value().name.value());
+            styles_to_visit.push(style->parent.value().name.value());
           }
         }
       }
@@ -219,24 +223,24 @@ void Debug::printStyleGraph(ResourceTable* table,
 
   std::cout << "digraph styles {\n";
   for (const auto& name : names) {
-    std::cout << "  node_" << getNodeIndex(names, name) << " [label=\"" << name
+    std::cout << "  node_" << GetNodeIndex(names, name) << " [label=\"" << name
               << "\"];\n";
   }
 
   for (const auto& entry : graph) {
-    const ResourceName& styleName = entry.first;
-    size_t styleNodeIndex = getNodeIndex(names, styleName);
+    const ResourceName& style_name = entry.first;
+    size_t style_node_index = GetNodeIndex(names, style_name);
 
-    for (const auto& parentName : entry.second) {
-      std::cout << "  node_" << styleNodeIndex << " -> "
-                << "node_" << getNodeIndex(names, parentName) << ";\n";
+    for (const auto& parent_name : entry.second) {
+      std::cout << "  node_" << style_node_index << " -> "
+                << "node_" << GetNodeIndex(names, parent_name) << ";\n";
     }
   }
 
   std::cout << "}" << std::endl;
 }
 
-void Debug::dumpHex(const void* data, size_t len) {
+void Debug::DumpHex(const void* data, size_t len) {
   const uint8_t* d = (const uint8_t*)data;
   for (size_t i = 0; i < len; i++) {
     std::cerr << std::hex << std::setfill('0') << std::setw(2) << (uint32_t)d[i]
@@ -255,55 +259,55 @@ namespace {
 
 class XmlPrinter : public xml::Visitor {
  public:
-  using xml::Visitor::visit;
+  using xml::Visitor::Visit;
 
-  void visit(xml::Element* el) override {
-    std::cerr << mPrefix;
+  void Visit(xml::Element* el) override {
+    std::cerr << prefix_;
     std::cerr << "E: ";
-    if (!el->namespaceUri.empty()) {
-      std::cerr << el->namespaceUri << ":";
+    if (!el->namespace_uri.empty()) {
+      std::cerr << el->namespace_uri << ":";
     }
-    std::cerr << el->name << " (line=" << el->lineNumber << ")\n";
+    std::cerr << el->name << " (line=" << el->line_number << ")\n";
 
     for (const xml::Attribute& attr : el->attributes) {
-      std::cerr << mPrefix << "  A: ";
-      if (!attr.namespaceUri.empty()) {
-        std::cerr << attr.namespaceUri << ":";
+      std::cerr << prefix_ << "  A: ";
+      if (!attr.namespace_uri.empty()) {
+        std::cerr << attr.namespace_uri << ":";
       }
       std::cerr << attr.name << "=" << attr.value << "\n";
     }
 
-    const size_t previousSize = mPrefix.size();
-    mPrefix += "  ";
-    xml::Visitor::visit(el);
-    mPrefix.resize(previousSize);
+    const size_t previous_size = prefix_.size();
+    prefix_ += "  ";
+    xml::Visitor::Visit(el);
+    prefix_.resize(previous_size);
   }
 
-  void visit(xml::Namespace* ns) override {
-    std::cerr << mPrefix;
-    std::cerr << "N: " << ns->namespacePrefix << "=" << ns->namespaceUri
-              << " (line=" << ns->lineNumber << ")\n";
+  void Visit(xml::Namespace* ns) override {
+    std::cerr << prefix_;
+    std::cerr << "N: " << ns->namespace_prefix << "=" << ns->namespace_uri
+              << " (line=" << ns->line_number << ")\n";
 
-    const size_t previousSize = mPrefix.size();
-    mPrefix += "  ";
-    xml::Visitor::visit(ns);
-    mPrefix.resize(previousSize);
+    const size_t previous_size = prefix_.size();
+    prefix_ += "  ";
+    xml::Visitor::Visit(ns);
+    prefix_.resize(previous_size);
   }
 
-  void visit(xml::Text* text) override {
-    std::cerr << mPrefix;
+  void Visit(xml::Text* text) override {
+    std::cerr << prefix_;
     std::cerr << "T: '" << text->text << "'\n";
   }
 
  private:
-  std::string mPrefix;
+  std::string prefix_;
 };
 
 }  // namespace
 
-void Debug::dumpXml(xml::XmlResource* doc) {
+void Debug::DumpXml(xml::XmlResource* doc) {
   XmlPrinter printer;
-  doc->root->accept(&printer);
+  doc->root->Accept(&printer);
 }
 
 }  // namespace aapt
diff --git a/tools/aapt2/Debug.h b/tools/aapt2/Debug.h
index bd92ec17d71ad..56e2e95df6cbe 100644
--- a/tools/aapt2/Debug.h
+++ b/tools/aapt2/Debug.h
@@ -17,26 +17,26 @@
 #ifndef AAPT_DEBUG_H
 #define AAPT_DEBUG_H
 
+// Include for printf-like debugging.
+#include <iostream>
+
 #include "Resource.h"
 #include "ResourceTable.h"
 #include "xml/XmlDom.h"
 
-// Include for printf-like debugging.
-#include <iostream>
-
 namespace aapt {
 
 struct DebugPrintTableOptions {
-  bool showSources = false;
+  bool show_sources = false;
 };
 
 struct Debug {
-  static void printTable(ResourceTable* table,
+  static void PrintTable(ResourceTable* table,
                          const DebugPrintTableOptions& options = {});
-  static void printStyleGraph(ResourceTable* table,
-                              const ResourceName& targetStyle);
-  static void dumpHex(const void* data, size_t len);
-  static void dumpXml(xml::XmlResource* doc);
+  static void PrintStyleGraph(ResourceTable* table,
+                              const ResourceName& target_style);
+  static void DumpHex(const void* data, size_t len);
+  static void DumpXml(xml::XmlResource* doc);
 };
 
 }  // namespace aapt
diff --git a/tools/aapt2/Diagnostics.h b/tools/aapt2/Diagnostics.h
index d39cf4c359768..5bc86a9fdbafe 100644
--- a/tools/aapt2/Diagnostics.h
+++ b/tools/aapt2/Diagnostics.h
@@ -17,15 +17,16 @@
 #ifndef AAPT_DIAGNOSTICS_H
 #define AAPT_DIAGNOSTICS_H
 
-#include "Source.h"
-#include "util/StringPiece.h"
-#include "util/Util.h"
-
-#include <android-base/macros.h>
 #include <iostream>
 #include <sstream>
 #include <string>
 
+#include "android-base/macros.h"
+
+#include "Source.h"
+#include "util/StringPiece.h"
+#include "util/Util.h"
+
 namespace aapt {
 
 struct DiagMessageActual {
@@ -34,28 +35,28 @@ struct DiagMessageActual {
 };
 
 struct DiagMessage {
- private:
-  Source mSource;
-  std::stringstream mMessage;
-
  public:
   DiagMessage() = default;
 
-  explicit DiagMessage(const StringPiece& src) : mSource(src) {}
+  explicit DiagMessage(const StringPiece& src) : source_(src) {}
 
-  explicit DiagMessage(const Source& src) : mSource(src) {}
+  explicit DiagMessage(const Source& src) : source_(src) {}
 
-  explicit DiagMessage(size_t line) : mSource(Source().withLine(line)) {}
+  explicit DiagMessage(size_t line) : source_(Source().WithLine(line)) {}
 
   template <typename T>
   DiagMessage& operator<<(const T& value) {
-    mMessage << value;
+    message_ << value;
     return *this;
   }
 
-  DiagMessageActual build() const {
-    return DiagMessageActual{mSource, mMessage.str()};
+  DiagMessageActual Build() const {
+    return DiagMessageActual{source_, message_.str()};
   }
+
+ private:
+  Source source_;
+  std::stringstream message_;
 };
 
 struct IDiagnostics {
@@ -63,21 +64,21 @@ struct IDiagnostics {
 
   enum class Level { Note, Warn, Error };
 
-  virtual void log(Level level, DiagMessageActual& actualMsg) = 0;
+  virtual void Log(Level level, DiagMessageActual& actualMsg) = 0;
 
-  virtual void error(const DiagMessage& message) {
-    DiagMessageActual actual = message.build();
-    log(Level::Error, actual);
+  virtual void Error(const DiagMessage& message) {
+    DiagMessageActual actual = message.Build();
+    Log(Level::Error, actual);
   }
 
-  virtual void warn(const DiagMessage& message) {
-    DiagMessageActual actual = message.build();
-    log(Level::Warn, actual);
+  virtual void Warn(const DiagMessage& message) {
+    DiagMessageActual actual = message.Build();
+    Log(Level::Warn, actual);
   }
 
-  virtual void note(const DiagMessage& message) {
-    DiagMessageActual actual = message.build();
-    log(Level::Note, actual);
+  virtual void Note(const DiagMessage& message) {
+    DiagMessageActual actual = message.Build();
+    Log(Level::Note, actual);
   }
 };
 
@@ -85,13 +86,13 @@ class StdErrDiagnostics : public IDiagnostics {
  public:
   StdErrDiagnostics() = default;
 
-  void log(Level level, DiagMessageActual& actualMsg) override {
+  void Log(Level level, DiagMessageActual& actual_msg) override {
     const char* tag;
 
     switch (level) {
       case Level::Error:
-        mNumErrors++;
-        if (mNumErrors > 20) {
+        num_errors_++;
+        if (num_errors_ > 20) {
           return;
         }
         tag = "error";
@@ -106,14 +107,14 @@ class StdErrDiagnostics : public IDiagnostics {
         break;
     }
 
-    if (!actualMsg.source.path.empty()) {
-      std::cerr << actualMsg.source << ": ";
+    if (!actual_msg.source.path.empty()) {
+      std::cerr << actual_msg.source << ": ";
     }
-    std::cerr << tag << ": " << actualMsg.message << "." << std::endl;
+    std::cerr << tag << ": " << actual_msg.message << "." << std::endl;
   }
 
  private:
-  size_t mNumErrors = 0;
+  size_t num_errors_ = 0;
 
   DISALLOW_COPY_AND_ASSIGN(StdErrDiagnostics);
 };
@@ -121,16 +122,16 @@ class StdErrDiagnostics : public IDiagnostics {
 class SourcePathDiagnostics : public IDiagnostics {
  public:
   SourcePathDiagnostics(const Source& src, IDiagnostics* diag)
-      : mSource(src), mDiag(diag) {}
+      : source_(src), diag_(diag) {}
 
-  void log(Level level, DiagMessageActual& actualMsg) override {
-    actualMsg.source.path = mSource.path;
-    mDiag->log(level, actualMsg);
+  void Log(Level level, DiagMessageActual& actual_msg) override {
+    actual_msg.source.path = source_.path;
+    diag_->Log(level, actual_msg);
   }
 
  private:
-  Source mSource;
-  IDiagnostics* mDiag;
+  Source source_;
+  IDiagnostics* diag_;
 
   DISALLOW_COPY_AND_ASSIGN(SourcePathDiagnostics);
 };
diff --git a/tools/aapt2/DominatorTree.cpp b/tools/aapt2/DominatorTree.cpp
index 8f6f783275590..118a385e2253a 100644
--- a/tools/aapt2/DominatorTree.cpp
+++ b/tools/aapt2/DominatorTree.cpp
@@ -15,77 +15,80 @@
  */
 
 #include "DominatorTree.h"
-#include "ConfigDescription.h"
 
 #include <algorithm>
 
+#include "android-base/logging.h"
+
+#include "ConfigDescription.h"
+
 namespace aapt {
 
 DominatorTree::DominatorTree(
     const std::vector<std::unique_ptr<ResourceConfigValue>>& configs) {
   for (const auto& config : configs) {
-    mProductRoots[config->product].tryAddChild(
+    product_roots_[config->product].TryAddChild(
         util::make_unique<Node>(config.get(), nullptr));
   }
 }
 
-void DominatorTree::accept(Visitor* visitor) {
-  for (auto& entry : mProductRoots) {
-    visitor->visitTree(entry.first, &entry.second);
+void DominatorTree::Accept(Visitor* visitor) {
+  for (auto& entry : product_roots_) {
+    visitor->VisitTree(entry.first, &entry.second);
   }
 }
 
-bool DominatorTree::Node::tryAddChild(std::unique_ptr<Node> newChild) {
-  assert(newChild->mValue && "cannot add a root or empty node as a child");
-  if (mValue && !dominates(newChild.get())) {
+bool DominatorTree::Node::TryAddChild(std::unique_ptr<Node> new_child) {
+  CHECK(new_child->value_) << "cannot add a root or empty node as a child";
+  if (value_ && !Dominates(new_child.get())) {
     // This is not the root and the child dominates us.
     return false;
   }
-  return addChild(std::move(newChild));
+  return AddChild(std::move(new_child));
 }
 
-bool DominatorTree::Node::addChild(std::unique_ptr<Node> newChild) {
-  bool hasDominatedChildren = false;
+bool DominatorTree::Node::AddChild(std::unique_ptr<Node> new_child) {
+  bool has_dominated_children = false;
   // Demote children dominated by the new config.
-  for (auto& child : mChildren) {
-    if (newChild->dominates(child.get())) {
-      child->mParent = newChild.get();
-      newChild->mChildren.push_back(std::move(child));
+  for (auto& child : children_) {
+    if (new_child->Dominates(child.get())) {
+      child->parent_ = new_child.get();
+      new_child->children_.push_back(std::move(child));
       child = {};
-      hasDominatedChildren = true;
+      has_dominated_children = true;
     }
   }
   // Remove dominated children.
-  if (hasDominatedChildren) {
-    mChildren.erase(
-        std::remove_if(mChildren.begin(), mChildren.end(),
+  if (has_dominated_children) {
+    children_.erase(
+        std::remove_if(children_.begin(), children_.end(),
                        [](const std::unique_ptr<Node>& child) -> bool {
                          return child == nullptr;
                        }),
-        mChildren.end());
+        children_.end());
   }
   // Add the new config to a child if a child dominates the new config.
-  for (auto& child : mChildren) {
-    if (child->dominates(newChild.get())) {
-      child->addChild(std::move(newChild));
+  for (auto& child : children_) {
+    if (child->Dominates(new_child.get())) {
+      child->AddChild(std::move(new_child));
       return true;
     }
   }
   // The new config is not dominated by a child, so add it here.
-  newChild->mParent = this;
-  mChildren.push_back(std::move(newChild));
+  new_child->parent_ = this;
+  children_.push_back(std::move(new_child));
   return true;
 }
 
-bool DominatorTree::Node::dominates(const Node* other) const {
+bool DominatorTree::Node::Dominates(const Node* other) const {
   // Check root node dominations.
-  if (other->isRootNode()) {
-    return isRootNode();
-  } else if (isRootNode()) {
+  if (other->is_root_node()) {
+    return is_root_node();
+  } else if (is_root_node()) {
     return true;
   }
   // Neither node is a root node; compare the configurations.
-  return mValue->config.dominates(other->mValue->config);
+  return value_->config.Dominates(other->value_->config);
 }
 
 }  // namespace aapt
diff --git a/tools/aapt2/DominatorTree.h b/tools/aapt2/DominatorTree.h
index 6d45b5d59ded0..7d50935eabfd0 100644
--- a/tools/aapt2/DominatorTree.h
+++ b/tools/aapt2/DominatorTree.h
@@ -17,13 +17,13 @@
 #ifndef AAPT_DOMINATOR_TREE_H
 #define AAPT_DOMINATOR_TREE_H
 
-#include "ResourceTable.h"
-
 #include <map>
 #include <memory>
 #include <string>
 #include <vector>
 
+#include "ResourceTable.h"
+
 namespace aapt {
 
 /**
@@ -53,67 +53,67 @@ class DominatorTree {
   class Node {
    public:
     explicit Node(ResourceConfigValue* value = nullptr, Node* parent = nullptr)
-        : mValue(value), mParent(parent) {}
+        : value_(value), parent_(parent) {}
 
-    inline ResourceConfigValue* value() const { return mValue; }
+    inline ResourceConfigValue* value() const { return value_; }
 
-    inline Node* parent() const { return mParent; }
+    inline Node* parent() const { return parent_; }
 
-    inline bool isRootNode() const { return !mValue; }
+    inline bool is_root_node() const { return !value_; }
 
     inline const std::vector<std::unique_ptr<Node>>& children() const {
-      return mChildren;
+      return children_;
     }
 
-    bool tryAddChild(std::unique_ptr<Node> newChild);
+    bool TryAddChild(std::unique_ptr<Node> new_child);
 
    private:
-    bool addChild(std::unique_ptr<Node> newChild);
-    bool dominates(const Node* other) const;
+    bool AddChild(std::unique_ptr<Node> new_child);
+    bool Dominates(const Node* other) const;
 
-    ResourceConfigValue* mValue;
-    Node* mParent;
-    std::vector<std::unique_ptr<Node>> mChildren;
+    ResourceConfigValue* value_;
+    Node* parent_;
+    std::vector<std::unique_ptr<Node>> children_;
 
     DISALLOW_COPY_AND_ASSIGN(Node);
   };
 
   struct Visitor {
     virtual ~Visitor() = default;
-    virtual void visitTree(const std::string& product, Node* root) = 0;
+    virtual void VisitTree(const std::string& product, Node* root) = 0;
   };
 
   class BottomUpVisitor : public Visitor {
    public:
     virtual ~BottomUpVisitor() = default;
 
-    void visitTree(const std::string& product, Node* root) override {
+    void VisitTree(const std::string& product, Node* root) override {
       for (auto& child : root->children()) {
-        visitNode(child.get());
+        VisitNode(child.get());
       }
     }
 
-    virtual void visitConfig(Node* node) = 0;
+    virtual void VisitConfig(Node* node) = 0;
 
    private:
-    void visitNode(Node* node) {
+    void VisitNode(Node* node) {
       for (auto& child : node->children()) {
-        visitNode(child.get());
+        VisitNode(child.get());
       }
-      visitConfig(node);
+      VisitConfig(node);
     }
   };
 
-  void accept(Visitor* visitor);
+  void Accept(Visitor* visitor);
 
-  inline const std::map<std::string, Node>& getProductRoots() const {
-    return mProductRoots;
+  inline const std::map<std::string, Node>& product_roots() const {
+    return product_roots_;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DominatorTree);
 
-  std::map<std::string, Node> mProductRoots;
+  std::map<std::string, Node> product_roots_;
 };
 
 }  // namespace aapt
diff --git a/tools/aapt2/DominatorTree_test.cpp b/tools/aapt2/DominatorTree_test.cpp
index a42d2f744ef37..e89c6beb0c57b 100644
--- a/tools/aapt2/DominatorTree_test.cpp
+++ b/tools/aapt2/DominatorTree_test.cpp
@@ -15,67 +15,68 @@
  */
 
 #include "DominatorTree.h"
-#include "test/Test.h"
-#include "util/Util.h"
 
 #include <sstream>
 #include <string>
 #include <vector>
 
+#include "test/Test.h"
+#include "util/Util.h"
+
 namespace aapt {
 
 namespace {
 
 class PrettyPrinter : public DominatorTree::Visitor {
  public:
-  explicit PrettyPrinter(const int indent = 2) : mIndent(indent) {}
+  explicit PrettyPrinter(const int indent = 2) : indent_(indent) {}
 
-  void visitTree(const std::string& product,
+  void VisitTree(const std::string& product,
                  DominatorTree::Node* root) override {
     for (auto& child : root->children()) {
-      visitNode(child.get(), 0);
+      VisitNode(child.get(), 0);
     }
   }
 
-  std::string toString(DominatorTree* tree) {
-    mBuffer.str("");
-    mBuffer.clear();
-    tree->accept(this);
-    return mBuffer.str();
+  std::string ToString(DominatorTree* tree) {
+    buffer_.str("");
+    buffer_.clear();
+    tree->Accept(this);
+    return buffer_.str();
   }
 
  private:
-  void visitConfig(const DominatorTree::Node* node, const int indent) {
-    auto configString = node->value()->config.toString();
-    mBuffer << std::string(indent, ' ')
-            << (configString.isEmpty() ? "<default>" : configString)
+  void VisitConfig(const DominatorTree::Node* node, const int indent) {
+    auto config_string = node->value()->config.toString();
+    buffer_ << std::string(indent, ' ')
+            << (config_string.isEmpty() ? "<default>" : config_string)
             << std::endl;
   }
 
-  void visitNode(const DominatorTree::Node* node, const int indent) {
-    visitConfig(node, indent);
+  void VisitNode(const DominatorTree::Node* node, const int indent) {
+    VisitConfig(node, indent);
     for (const auto& child : node->children()) {
-      visitNode(child.get(), indent + mIndent);
+      VisitNode(child.get(), indent + indent_);
     }
   }
 
-  std::stringstream mBuffer;
-  const int mIndent = 2;
+  std::stringstream buffer_;
+  const int indent_ = 2;
 };
 
 }  // namespace
 
 TEST(DominatorTreeTest, DefaultDominatesEverything) {
-  const ConfigDescription defaultConfig = {};
-  const ConfigDescription landConfig = test::parseConfigOrDie("land");
-  const ConfigDescription sw600dpLandConfig =
-      test::parseConfigOrDie("sw600dp-land-v13");
+  const ConfigDescription default_config = {};
+  const ConfigDescription land_config = test::ParseConfigOrDie("land");
+  const ConfigDescription sw600dp_land_config =
+      test::ParseConfigOrDie("sw600dp-land-v13");
 
   std::vector<std::unique_ptr<ResourceConfigValue>> configs;
-  configs.push_back(util::make_unique<ResourceConfigValue>(defaultConfig, ""));
-  configs.push_back(util::make_unique<ResourceConfigValue>(landConfig, ""));
+  configs.push_back(util::make_unique<ResourceConfigValue>(default_config, ""));
+  configs.push_back(util::make_unique<ResourceConfigValue>(land_config, ""));
   configs.push_back(
-      util::make_unique<ResourceConfigValue>(sw600dpLandConfig, ""));
+      util::make_unique<ResourceConfigValue>(sw600dp_land_config, ""));
 
   DominatorTree tree(configs);
   PrettyPrinter printer;
@@ -84,22 +85,22 @@ TEST(DominatorTreeTest, DefaultDominatesEverything) {
       "<default>\n"
       "  land\n"
       "  sw600dp-land-v13\n";
-  EXPECT_EQ(expected, printer.toString(&tree));
+  EXPECT_EQ(expected, printer.ToString(&tree));
 }
 
 TEST(DominatorTreeTest, ProductsAreDominatedSeparately) {
-  const ConfigDescription defaultConfig = {};
-  const ConfigDescription landConfig = test::parseConfigOrDie("land");
-  const ConfigDescription sw600dpLandConfig =
-      test::parseConfigOrDie("sw600dp-land-v13");
+  const ConfigDescription default_config = {};
+  const ConfigDescription land_config = test::ParseConfigOrDie("land");
+  const ConfigDescription sw600dp_land_config =
+      test::ParseConfigOrDie("sw600dp-land-v13");
 
   std::vector<std::unique_ptr<ResourceConfigValue>> configs;
-  configs.push_back(util::make_unique<ResourceConfigValue>(defaultConfig, ""));
-  configs.push_back(util::make_unique<ResourceConfigValue>(landConfig, ""));
+  configs.push_back(util::make_unique<ResourceConfigValue>(default_config, ""));
+  configs.push_back(util::make_unique<ResourceConfigValue>(land_config, ""));
   configs.push_back(
-      util::make_unique<ResourceConfigValue>(defaultConfig, "phablet"));
+      util::make_unique<ResourceConfigValue>(default_config, "phablet"));
   configs.push_back(
-      util::make_unique<ResourceConfigValue>(sw600dpLandConfig, "phablet"));
+      util::make_unique<ResourceConfigValue>(sw600dp_land_config, "phablet"));
 
   DominatorTree tree(configs);
   PrettyPrinter printer;
@@ -109,34 +110,38 @@ TEST(DominatorTreeTest, ProductsAreDominatedSeparately) {
       "  land\n"
       "<default>\n"
       "  sw600dp-land-v13\n";
-  EXPECT_EQ(expected, printer.toString(&tree));
+  EXPECT_EQ(expected, printer.ToString(&tree));
 }
 
 TEST(DominatorTreeTest, MoreSpecificConfigurationsAreDominated) {
-  const ConfigDescription defaultConfig = {};
-  const ConfigDescription enConfig = test::parseConfigOrDie("en");
-  const ConfigDescription enV21Config = test::parseConfigOrDie("en-v21");
-  const ConfigDescription ldrtlConfig = test::parseConfigOrDie("ldrtl-v4");
-  const ConfigDescription ldrtlXhdpiConfig =
-      test::parseConfigOrDie("ldrtl-xhdpi-v4");
-  const ConfigDescription sw300dpConfig = test::parseConfigOrDie("sw300dp-v13");
-  const ConfigDescription sw540dpConfig = test::parseConfigOrDie("sw540dp-v14");
-  const ConfigDescription sw600dpConfig = test::parseConfigOrDie("sw600dp-v14");
-  const ConfigDescription sw720dpConfig = test::parseConfigOrDie("sw720dp-v13");
-  const ConfigDescription v20Config = test::parseConfigOrDie("v20");
+  const ConfigDescription default_config = {};
+  const ConfigDescription en_config = test::ParseConfigOrDie("en");
+  const ConfigDescription en_v21_config = test::ParseConfigOrDie("en-v21");
+  const ConfigDescription ldrtl_config = test::ParseConfigOrDie("ldrtl-v4");
+  const ConfigDescription ldrtl_xhdpi_config =
+      test::ParseConfigOrDie("ldrtl-xhdpi-v4");
+  const ConfigDescription sw300dp_config =
+      test::ParseConfigOrDie("sw300dp-v13");
+  const ConfigDescription sw540dp_config =
+      test::ParseConfigOrDie("sw540dp-v14");
+  const ConfigDescription sw600dp_config =
+      test::ParseConfigOrDie("sw600dp-v14");
+  const ConfigDescription sw720dp_config =
+      test::ParseConfigOrDie("sw720dp-v13");
+  const ConfigDescription v20_config = test::ParseConfigOrDie("v20");
 
   std::vector<std::unique_ptr<ResourceConfigValue>> configs;
-  configs.push_back(util::make_unique<ResourceConfigValue>(defaultConfig, ""));
-  configs.push_back(util::make_unique<ResourceConfigValue>(enConfig, ""));
-  configs.push_back(util::make_unique<ResourceConfigValue>(enV21Config, ""));
-  configs.push_back(util::make_unique<ResourceConfigValue>(ldrtlConfig, ""));
+  configs.push_back(util::make_unique<ResourceConfigValue>(default_config, ""));
+  configs.push_back(util::make_unique<ResourceConfigValue>(en_config, ""));
+  configs.push_back(util::make_unique<ResourceConfigValue>(en_v21_config, ""));
+  configs.push_back(util::make_unique<ResourceConfigValue>(ldrtl_config, ""));
   configs.push_back(
-      util::make_unique<ResourceConfigValue>(ldrtlXhdpiConfig, ""));
-  configs.push_back(util::make_unique<ResourceConfigValue>(sw300dpConfig, ""));
-  configs.push_back(util::make_unique<ResourceConfigValue>(sw540dpConfig, ""));
-  configs.push_back(util::make_unique<ResourceConfigValue>(sw600dpConfig, ""));
-  configs.push_back(util::make_unique<ResourceConfigValue>(sw720dpConfig, ""));
-  configs.push_back(util::make_unique<ResourceConfigValue>(v20Config, ""));
+      util::make_unique<ResourceConfigValue>(ldrtl_xhdpi_config, ""));
+  configs.push_back(util::make_unique<ResourceConfigValue>(sw300dp_config, ""));
+  configs.push_back(util::make_unique<ResourceConfigValue>(sw540dp_config, ""));
+  configs.push_back(util::make_unique<ResourceConfigValue>(sw600dp_config, ""));
+  configs.push_back(util::make_unique<ResourceConfigValue>(sw720dp_config, ""));
+  configs.push_back(util::make_unique<ResourceConfigValue>(v20_config, ""));
 
   DominatorTree tree(configs);
   PrettyPrinter printer;
@@ -152,7 +157,7 @@ TEST(DominatorTreeTest, MoreSpecificConfigurationsAreDominated) {
       "      sw600dp-v14\n"
       "    sw720dp-v13\n"
       "  v20\n";
-  EXPECT_EQ(expected, printer.toString(&tree));
+  EXPECT_EQ(expected, printer.ToString(&tree));
 }
 
 }  // namespace aapt
diff --git a/tools/aapt2/Flags.cpp b/tools/aapt2/Flags.cpp
index cb1619657b4f9..c98cd374602fa 100644
--- a/tools/aapt2/Flags.cpp
+++ b/tools/aapt2/Flags.cpp
@@ -15,97 +15,98 @@
  */
 
 #include "Flags.h"
-#include "util/StringPiece.h"
-#include "util/Util.h"
 
 #include <iomanip>
 #include <iostream>
 #include <string>
 #include <vector>
 
+#include "util/StringPiece.h"
+#include "util/Util.h"
+
 namespace aapt {
 
-Flags& Flags::requiredFlag(const StringPiece& name,
+Flags& Flags::RequiredFlag(const StringPiece& name,
                            const StringPiece& description, std::string* value) {
   auto func = [value](const StringPiece& arg) -> bool {
-    *value = arg.toString();
+    *value = arg.ToString();
     return true;
   };
 
-  mFlags.push_back(
-      Flag{name.toString(), description.toString(), func, true, 1, false});
+  flags_.push_back(
+      Flag{name.ToString(), description.ToString(), func, true, 1, false});
   return *this;
 }
 
-Flags& Flags::requiredFlagList(const StringPiece& name,
+Flags& Flags::RequiredFlagList(const StringPiece& name,
                                const StringPiece& description,
                                std::vector<std::string>* value) {
   auto func = [value](const StringPiece& arg) -> bool {
-    value->push_back(arg.toString());
+    value->push_back(arg.ToString());
     return true;
   };
 
-  mFlags.push_back(
-      Flag{name.toString(), description.toString(), func, true, 1, false});
+  flags_.push_back(
+      Flag{name.ToString(), description.ToString(), func, true, 1, false});
   return *this;
 }
 
-Flags& Flags::optionalFlag(const StringPiece& name,
+Flags& Flags::OptionalFlag(const StringPiece& name,
                            const StringPiece& description,
                            Maybe<std::string>* value) {
   auto func = [value](const StringPiece& arg) -> bool {
-    *value = arg.toString();
+    *value = arg.ToString();
     return true;
   };
 
-  mFlags.push_back(
-      Flag{name.toString(), description.toString(), func, false, 1, false});
+  flags_.push_back(
+      Flag{name.ToString(), description.ToString(), func, false, 1, false});
   return *this;
 }
 
-Flags& Flags::optionalFlagList(const StringPiece& name,
+Flags& Flags::OptionalFlagList(const StringPiece& name,
                                const StringPiece& description,
                                std::vector<std::string>* value) {
   auto func = [value](const StringPiece& arg) -> bool {
-    value->push_back(arg.toString());
+    value->push_back(arg.ToString());
     return true;
   };
 
-  mFlags.push_back(
-      Flag{name.toString(), description.toString(), func, false, 1, false});
+  flags_.push_back(
+      Flag{name.ToString(), description.ToString(), func, false, 1, false});
   return *this;
 }
 
-Flags& Flags::optionalFlagList(const StringPiece& name,
+Flags& Flags::OptionalFlagList(const StringPiece& name,
                                const StringPiece& description,
                                std::unordered_set<std::string>* value) {
   auto func = [value](const StringPiece& arg) -> bool {
-    value->insert(arg.toString());
+    value->insert(arg.ToString());
     return true;
   };
 
-  mFlags.push_back(
-      Flag{name.toString(), description.toString(), func, false, 1, false});
+  flags_.push_back(
+      Flag{name.ToString(), description.ToString(), func, false, 1, false});
   return *this;
 }
 
-Flags& Flags::optionalSwitch(const StringPiece& name,
+Flags& Flags::OptionalSwitch(const StringPiece& name,
                              const StringPiece& description, bool* value) {
   auto func = [value](const StringPiece& arg) -> bool {
     *value = true;
     return true;
   };
 
-  mFlags.push_back(
-      Flag{name.toString(), description.toString(), func, false, 0, false});
+  flags_.push_back(
+      Flag{name.ToString(), description.ToString(), func, false, 0, false});
   return *this;
 }
 
-void Flags::usage(const StringPiece& command, std::ostream* out) {
+void Flags::Usage(const StringPiece& command, std::ostream* out) {
   constexpr size_t kWidth = 50;
 
   *out << command << " [options]";
-  for (const Flag& flag : mFlags) {
+  for (const Flag& flag : flags_) {
     if (flag.required) {
       *out << " " << flag.name << " arg";
     }
@@ -113,10 +114,10 @@ void Flags::usage(const StringPiece& command, std::ostream* out) {
 
   *out << " files...\n\nOptions:\n";
 
-  for (const Flag& flag : mFlags) {
-    std::string argLine = flag.name;
-    if (flag.numArgs > 0) {
-      argLine += " arg";
+  for (const Flag& flag : flags_) {
+    std::string argline = flag.name;
+    if (flag.num_args > 0) {
+      argline += " arg";
     }
 
     // Split the description by newlines and write out the argument (which is
@@ -124,9 +125,9 @@ void Flags::usage(const StringPiece& command, std::ostream* out) {
     // the first line) followed by the description line. This will make sure
     // that multiline
     // descriptions are still right justified and aligned.
-    for (StringPiece line : util::tokenize(flag.description, '\n')) {
-      *out << " " << std::setw(kWidth) << std::left << argLine << line << "\n";
-      argLine = " ";
+    for (StringPiece line : util::Tokenize(flag.description, '\n')) {
+      *out << " " << std::setw(kWidth) << std::left << argline << line << "\n";
+      argline = " ";
     }
   }
   *out << " " << std::setw(kWidth) << std::left << "-h"
@@ -134,29 +135,29 @@ void Flags::usage(const StringPiece& command, std::ostream* out) {
   out->flush();
 }
 
-bool Flags::parse(const StringPiece& command,
+bool Flags::Parse(const StringPiece& command,
                   const std::vector<StringPiece>& args,
-                  std::ostream* outError) {
+                  std::ostream* out_error) {
   for (size_t i = 0; i < args.size(); i++) {
     StringPiece arg = args[i];
     if (*(arg.data()) != '-') {
-      mArgs.push_back(arg.toString());
+      args_.push_back(arg.ToString());
       continue;
     }
 
     if (arg == "-h" || arg == "--help") {
-      usage(command, outError);
+      Usage(command, out_error);
       return false;
     }
 
     bool match = false;
-    for (Flag& flag : mFlags) {
+    for (Flag& flag : flags_) {
       if (arg == flag.name) {
-        if (flag.numArgs > 0) {
+        if (flag.num_args > 0) {
           i++;
           if (i >= args.size()) {
-            *outError << flag.name << " missing argument.\n\n";
-            usage(command, outError);
+            *out_error << flag.name << " missing argument.\n\n";
+            Usage(command, out_error);
             return false;
           }
           flag.action(args[i]);
@@ -170,22 +171,22 @@ bool Flags::parse(const StringPiece& command,
     }
 
     if (!match) {
-      *outError << "unknown option '" << arg << "'.\n\n";
-      usage(command, outError);
+      *out_error << "unknown option '" << arg << "'.\n\n";
+      Usage(command, out_error);
       return false;
     }
   }
 
-  for (const Flag& flag : mFlags) {
+  for (const Flag& flag : flags_) {
     if (flag.required && !flag.parsed) {
-      *outError << "missing required flag " << flag.name << "\n\n";
-      usage(command, outError);
+      *out_error << "missing required flag " << flag.name << "\n\n";
+      Usage(command, out_error);
       return false;
     }
   }
   return true;
 }
 
-const std::vector<std::string>& Flags::getArgs() { return mArgs; }
+const std::vector<std::string>& Flags::GetArgs() { return args_; }
 
 }  // namespace aapt
diff --git a/tools/aapt2/Flags.h b/tools/aapt2/Flags.h
index 4a0efdb5b3785..9feff6b4facaa 100644
--- a/tools/aapt2/Flags.h
+++ b/tools/aapt2/Flags.h
@@ -17,41 +17,41 @@
 #ifndef AAPT_FLAGS_H
 #define AAPT_FLAGS_H
 
-#include "util/Maybe.h"
-#include "util/StringPiece.h"
-
 #include <functional>
 #include <ostream>
 #include <string>
 #include <unordered_set>
 #include <vector>
 
+#include "util/Maybe.h"
+#include "util/StringPiece.h"
+
 namespace aapt {
 
 class Flags {
  public:
-  Flags& requiredFlag(const StringPiece& name, const StringPiece& description,
+  Flags& RequiredFlag(const StringPiece& name, const StringPiece& description,
                       std::string* value);
-  Flags& requiredFlagList(const StringPiece& name,
+  Flags& RequiredFlagList(const StringPiece& name,
                           const StringPiece& description,
                           std::vector<std::string>* value);
-  Flags& optionalFlag(const StringPiece& name, const StringPiece& description,
+  Flags& OptionalFlag(const StringPiece& name, const StringPiece& description,
                       Maybe<std::string>* value);
-  Flags& optionalFlagList(const StringPiece& name,
+  Flags& OptionalFlagList(const StringPiece& name,
                           const StringPiece& description,
                           std::vector<std::string>* value);
-  Flags& optionalFlagList(const StringPiece& name,
+  Flags& OptionalFlagList(const StringPiece& name,
                           const StringPiece& description,
                           std::unordered_set<std::string>* value);
-  Flags& optionalSwitch(const StringPiece& name, const StringPiece& description,
+  Flags& OptionalSwitch(const StringPiece& name, const StringPiece& description,
                         bool* value);
 
-  void usage(const StringPiece& command, std::ostream* out);
+  void Usage(const StringPiece& command, std::ostream* out);
 
-  bool parse(const StringPiece& command, const std::vector<StringPiece>& args,
+  bool Parse(const StringPiece& command, const std::vector<StringPiece>& args,
              std::ostream* outError);
 
-  const std::vector<std::string>& getArgs();
+  const std::vector<std::string>& GetArgs();
 
  private:
   struct Flag {
@@ -59,13 +59,13 @@ class Flags {
     std::string description;
     std::function<bool(const StringPiece& value)> action;
     bool required;
-    size_t numArgs;
+    size_t num_args;
 
     bool parsed;
   };
 
-  std::vector<Flag> mFlags;
-  std::vector<std::string> mArgs;
+  std::vector<Flag> flags_;
+  std::vector<std::string> args_;
 };
 
 }  // namespace aapt
diff --git a/tools/aapt2/Locale.cpp b/tools/aapt2/Locale.cpp
index a0f764175e24c..78f56c7a5b933 100644
--- a/tools/aapt2/Locale.cpp
+++ b/tools/aapt2/Locale.cpp
@@ -15,174 +15,176 @@
  */
 
 #include "Locale.h"
-#include "util/Util.h"
 
 #include <ctype.h>
+
 #include <algorithm>
 #include <string>
 #include <vector>
 
+#include "util/Util.h"
+
 namespace aapt {
 
 using android::ResTable_config;
 
-void LocaleValue::setLanguage(const char* languageChars) {
+void LocaleValue::set_language(const char* language_chars) {
   size_t i = 0;
-  while ((*languageChars) != '\0') {
-    language[i++] = ::tolower(*languageChars);
-    languageChars++;
+  while ((*language_chars) != '\0') {
+    language[i++] = ::tolower(*language_chars);
+    language_chars++;
   }
 }
 
-void LocaleValue::setRegion(const char* regionChars) {
+void LocaleValue::set_region(const char* region_chars) {
   size_t i = 0;
-  while ((*regionChars) != '\0') {
-    region[i++] = ::toupper(*regionChars);
-    regionChars++;
+  while ((*region_chars) != '\0') {
+    region[i++] = ::toupper(*region_chars);
+    region_chars++;
   }
 }
 
-void LocaleValue::setScript(const char* scriptChars) {
+void LocaleValue::set_script(const char* script_chars) {
   size_t i = 0;
-  while ((*scriptChars) != '\0') {
+  while ((*script_chars) != '\0') {
     if (i == 0) {
-      script[i++] = ::toupper(*scriptChars);
+      script[i++] = ::toupper(*script_chars);
     } else {
-      script[i++] = ::tolower(*scriptChars);
+      script[i++] = ::tolower(*script_chars);
     }
-    scriptChars++;
+    script_chars++;
   }
 }
 
-void LocaleValue::setVariant(const char* variantChars) {
+void LocaleValue::set_variant(const char* variant_chars) {
   size_t i = 0;
-  while ((*variantChars) != '\0') {
-    variant[i++] = *variantChars;
-    variantChars++;
+  while ((*variant_chars) != '\0') {
+    variant[i++] = *variant_chars;
+    variant_chars++;
   }
 }
 
-static inline bool isAlpha(const std::string& str) {
+static inline bool is_alpha(const std::string& str) {
   return std::all_of(std::begin(str), std::end(str), ::isalpha);
 }
 
-static inline bool isNumber(const std::string& str) {
+static inline bool is_number(const std::string& str) {
   return std::all_of(std::begin(str), std::end(str), ::isdigit);
 }
 
-bool LocaleValue::initFromFilterString(const StringPiece& str) {
+bool LocaleValue::InitFromFilterString(const StringPiece& str) {
   // A locale (as specified in the filter) is an underscore separated name such
   // as "en_US", "en_Latn_US", or "en_US_POSIX".
-  std::vector<std::string> parts = util::splitAndLowercase(str, '_');
+  std::vector<std::string> parts = util::SplitAndLowercase(str, '_');
 
-  const int numTags = parts.size();
+  const int num_tags = parts.size();
   bool valid = false;
-  if (numTags >= 1) {
+  if (num_tags >= 1) {
     const std::string& lang = parts[0];
-    if (isAlpha(lang) && (lang.length() == 2 || lang.length() == 3)) {
-      setLanguage(lang.c_str());
+    if (is_alpha(lang) && (lang.length() == 2 || lang.length() == 3)) {
+      set_language(lang.c_str());
       valid = true;
     }
   }
 
-  if (!valid || numTags == 1) {
+  if (!valid || num_tags == 1) {
     return valid;
   }
 
   // At this point, valid == true && numTags > 1.
   const std::string& part2 = parts[1];
-  if ((part2.length() == 2 && isAlpha(part2)) ||
-      (part2.length() == 3 && isNumber(part2))) {
-    setRegion(part2.c_str());
-  } else if (part2.length() == 4 && isAlpha(part2)) {
-    setScript(part2.c_str());
+  if ((part2.length() == 2 && is_alpha(part2)) ||
+      (part2.length() == 3 && is_number(part2))) {
+    set_region(part2.c_str());
+  } else if (part2.length() == 4 && is_alpha(part2)) {
+    set_script(part2.c_str());
   } else if (part2.length() >= 4 && part2.length() <= 8) {
-    setVariant(part2.c_str());
+    set_variant(part2.c_str());
   } else {
     valid = false;
   }
 
-  if (!valid || numTags == 2) {
+  if (!valid || num_tags == 2) {
     return valid;
   }
 
   // At this point, valid == true && numTags > 1.
   const std::string& part3 = parts[2];
-  if (((part3.length() == 2 && isAlpha(part3)) ||
-       (part3.length() == 3 && isNumber(part3))) &&
+  if (((part3.length() == 2 && is_alpha(part3)) ||
+       (part3.length() == 3 && is_number(part3))) &&
       script[0]) {
-    setRegion(part3.c_str());
+    set_region(part3.c_str());
   } else if (part3.length() >= 4 && part3.length() <= 8) {
-    setVariant(part3.c_str());
+    set_variant(part3.c_str());
   } else {
     valid = false;
   }
 
-  if (!valid || numTags == 3) {
+  if (!valid || num_tags == 3) {
     return valid;
   }
 
   const std::string& part4 = parts[3];
   if (part4.length() >= 4 && part4.length() <= 8) {
-    setVariant(part4.c_str());
+    set_variant(part4.c_str());
   } else {
     valid = false;
   }
 
-  if (!valid || numTags > 4) {
+  if (!valid || num_tags > 4) {
     return false;
   }
 
   return true;
 }
 
-ssize_t LocaleValue::initFromParts(std::vector<std::string>::iterator iter,
+ssize_t LocaleValue::InitFromParts(std::vector<std::string>::iterator iter,
                                    std::vector<std::string>::iterator end) {
-  const std::vector<std::string>::iterator startIter = iter;
+  const std::vector<std::string>::iterator start_iter = iter;
 
   std::string& part = *iter;
   if (part[0] == 'b' && part[1] == '+') {
     // This is a "modified" BCP 47 language tag. Same semantics as BCP 47 tags,
     // except that the separator is "+" and not "-".
-    std::vector<std::string> subtags = util::splitAndLowercase(part, '+');
+    std::vector<std::string> subtags = util::SplitAndLowercase(part, '+');
     subtags.erase(subtags.begin());
     if (subtags.size() == 1) {
-      setLanguage(subtags[0].c_str());
+      set_language(subtags[0].c_str());
     } else if (subtags.size() == 2) {
-      setLanguage(subtags[0].c_str());
+      set_language(subtags[0].c_str());
 
       // The second tag can either be a region, a variant or a script.
       switch (subtags[1].size()) {
         case 2:
         case 3:
-          setRegion(subtags[1].c_str());
+          set_region(subtags[1].c_str());
           break;
         case 4:
           if ('0' <= subtags[1][0] && subtags[1][0] <= '9') {
             // This is a variant: fall through
           } else {
-            setScript(subtags[1].c_str());
+            set_script(subtags[1].c_str());
             break;
           }
         case 5:
         case 6:
         case 7:
         case 8:
-          setVariant(subtags[1].c_str());
+          set_variant(subtags[1].c_str());
           break;
         default:
           return -1;
       }
     } else if (subtags.size() == 3) {
       // The language is always the first subtag.
-      setLanguage(subtags[0].c_str());
+      set_language(subtags[0].c_str());
 
       // The second subtag can either be a script or a region code.
       // If its size is 4, it's a script code, else it's a region code.
       if (subtags[1].size() == 4) {
-        setScript(subtags[1].c_str());
+        set_script(subtags[1].c_str());
       } else if (subtags[1].size() == 2 || subtags[1].size() == 3) {
-        setRegion(subtags[1].c_str());
+        set_region(subtags[1].c_str());
       } else {
         return -1;
       }
@@ -190,15 +192,15 @@ ssize_t LocaleValue::initFromParts(std::vector<std::string>::iterator iter,
       // The third tag can either be a region code (if the second tag was
       // a script), else a variant code.
       if (subtags[2].size() >= 4) {
-        setVariant(subtags[2].c_str());
+        set_variant(subtags[2].c_str());
       } else {
-        setRegion(subtags[2].c_str());
+        set_region(subtags[2].c_str());
       }
     } else if (subtags.size() == 4) {
-      setLanguage(subtags[0].c_str());
-      setScript(subtags[1].c_str());
-      setRegion(subtags[2].c_str());
-      setVariant(subtags[3].c_str());
+      set_language(subtags[0].c_str());
+      set_script(subtags[1].c_str());
+      set_region(subtags[2].c_str());
+      set_variant(subtags[3].c_str());
     } else {
       return -1;
     }
@@ -206,25 +208,25 @@ ssize_t LocaleValue::initFromParts(std::vector<std::string>::iterator iter,
     ++iter;
 
   } else {
-    if ((part.length() == 2 || part.length() == 3) && isAlpha(part) &&
+    if ((part.length() == 2 || part.length() == 3) && is_alpha(part) &&
         part != "car") {
-      setLanguage(part.c_str());
+      set_language(part.c_str());
       ++iter;
 
       if (iter != end) {
-        const std::string& regionPart = *iter;
-        if (regionPart.c_str()[0] == 'r' && regionPart.length() == 3) {
-          setRegion(regionPart.c_str() + 1);
+        const std::string& region_part = *iter;
+        if (region_part.c_str()[0] == 'r' && region_part.length() == 3) {
+          set_region(region_part.c_str() + 1);
           ++iter;
         }
       }
     }
   }
 
-  return static_cast<ssize_t>(iter - startIter);
+  return static_cast<ssize_t>(iter - start_iter);
 }
 
-void LocaleValue::initFromResTable(const ResTable_config& config) {
+void LocaleValue::InitFromResTable(const ResTable_config& config) {
   config.unpackLanguage(language);
   config.unpackRegion(region);
   if (config.localeScript[0] && !config.localeScriptWasComputed) {
@@ -236,7 +238,7 @@ void LocaleValue::initFromResTable(const ResTable_config& config) {
   }
 }
 
-void LocaleValue::writeTo(ResTable_config* out) const {
+void LocaleValue::WriteTo(ResTable_config* out) const {
   out->packLanguage(language);
   out->packRegion(region);
 
diff --git a/tools/aapt2/Locale.h b/tools/aapt2/Locale.h
index 0f7585033af72..fc6c448ac1dcd 100644
--- a/tools/aapt2/Locale.h
+++ b/tools/aapt2/Locale.h
@@ -17,12 +17,13 @@
 #ifndef AAPT_LOCALE_VALUE_H
 #define AAPT_LOCALE_VALUE_H
 
-#include "util/StringPiece.h"
-
-#include <androidfw/ResourceTypes.h>
 #include <string>
 #include <vector>
 
+#include "androidfw/ResourceTypes.h"
+
+#include "util/StringPiece.h"
+
 namespace aapt {
 
 /**
@@ -39,23 +40,23 @@ struct LocaleValue {
   /**
    * Initialize this LocaleValue from a config string.
    */
-  bool initFromFilterString(const StringPiece& config);
+  bool InitFromFilterString(const StringPiece& config);
 
   /**
    * Initialize this LocaleValue from parts of a vector.
    */
-  ssize_t initFromParts(std::vector<std::string>::iterator iter,
+  ssize_t InitFromParts(std::vector<std::string>::iterator iter,
                         std::vector<std::string>::iterator end);
 
   /**
    * Initialize this LocaleValue from a ResTable_config.
    */
-  void initFromResTable(const android::ResTable_config& config);
+  void InitFromResTable(const android::ResTable_config& config);
 
   /**
    * Set the locale in a ResTable_config from this LocaleValue.
    */
-  void writeTo(android::ResTable_config* out) const;
+  void WriteTo(android::ResTable_config* out) const;
 
   inline int compare(const LocaleValue& other) const;
 
@@ -67,10 +68,10 @@ struct LocaleValue {
   inline bool operator>(const LocaleValue& o) const;
 
  private:
-  void setLanguage(const char* language);
-  void setRegion(const char* language);
-  void setScript(const char* script);
-  void setVariant(const char* variant);
+  void set_language(const char* language);
+  void set_region(const char* language);
+  void set_script(const char* script);
+  void set_variant(const char* variant);
 };
 
 //
diff --git a/tools/aapt2/Locale_test.cpp b/tools/aapt2/Locale_test.cpp
index b82d2b9cbc0d2..68b4cae44e15b 100644
--- a/tools/aapt2/Locale_test.cpp
+++ b/tools/aapt2/Locale_test.cpp
@@ -15,18 +15,20 @@
  */
 
 #include "Locale.h"
-#include "util/Util.h"
 
-#include <gtest/gtest.h>
 #include <string>
 
+#include "gtest/gtest.h"
+
+#include "util/Util.h"
+
 namespace aapt {
 
 static ::testing::AssertionResult TestLanguage(const char* input,
                                                const char* lang) {
-  std::vector<std::string> parts = util::splitAndLowercase(input, '-');
+  std::vector<std::string> parts = util::SplitAndLowercase(input, '-');
   LocaleValue lv;
-  ssize_t count = lv.initFromParts(std::begin(parts), std::end(parts));
+  ssize_t count = lv.InitFromParts(std::begin(parts), std::end(parts));
   if (count < 0) {
     return ::testing::AssertionFailure() << " failed to parse '" << input
                                          << "'.";
@@ -51,9 +53,9 @@ static ::testing::AssertionResult TestLanguage(const char* input,
 static ::testing::AssertionResult TestLanguageRegion(const char* input,
                                                      const char* lang,
                                                      const char* region) {
-  std::vector<std::string> parts = util::splitAndLowercase(input, '-');
+  std::vector<std::string> parts = util::SplitAndLowercase(input, '-');
   LocaleValue lv;
-  ssize_t count = lv.initFromParts(std::begin(parts), std::end(parts));
+  ssize_t count = lv.InitFromParts(std::begin(parts), std::end(parts));
   if (count < 0) {
     return ::testing::AssertionFailure() << " failed to parse '" << input
                                          << "'.";
diff --git a/tools/aapt2/Main.cpp b/tools/aapt2/Main.cpp
index 8aedd44656beb..8dd176d273459 100644
--- a/tools/aapt2/Main.cpp
+++ b/tools/aapt2/Main.cpp
@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-#include "util/StringPiece.h"
-
 #include <iostream>
 #include <vector>
 
+#include "util/StringPiece.h"
+
 namespace aapt {
 
 // DO NOT UPDATE, this is more of a marketing version.
@@ -27,16 +27,16 @@ static const char* sMajorVersion = "2";
 // Update minor version whenever a feature or flag is added.
 static const char* sMinorVersion = "2";
 
-int printVersion() {
+int PrintVersion() {
   std::cerr << "Android Asset Packaging Tool (aapt) " << sMajorVersion << "."
             << sMinorVersion << std::endl;
   return 0;
 }
 
-extern int compile(const std::vector<StringPiece>& args);
-extern int link(const std::vector<StringPiece>& args);
-extern int dump(const std::vector<StringPiece>& args);
-extern int diff(const std::vector<StringPiece>& args);
+extern int Compile(const std::vector<StringPiece>& args);
+extern int Link(const std::vector<StringPiece>& args);
+extern int Dump(const std::vector<StringPiece>& args);
+extern int Diff(const std::vector<StringPiece>& args);
 
 }  // namespace aapt
 
@@ -52,15 +52,15 @@ int main(int argc, char** argv) {
 
     aapt::StringPiece command(argv[0]);
     if (command == "compile" || command == "c") {
-      return aapt::compile(args);
+      return aapt::Compile(args);
     } else if (command == "link" || command == "l") {
-      return aapt::link(args);
+      return aapt::Link(args);
     } else if (command == "dump" || command == "d") {
-      return aapt::dump(args);
+      return aapt::Dump(args);
     } else if (command == "diff") {
-      return aapt::diff(args);
+      return aapt::Diff(args);
     } else if (command == "version") {
-      return aapt::printVersion();
+      return aapt::PrintVersion();
     }
     std::cerr << "unknown command '" << command << "'\n";
   } else {
diff --git a/tools/aapt2/NameMangler.h b/tools/aapt2/NameMangler.h
index 6d244aac9716e..dba2d096dd9dd 100644
--- a/tools/aapt2/NameMangler.h
+++ b/tools/aapt2/NameMangler.h
@@ -17,12 +17,12 @@
 #ifndef AAPT_NAME_MANGLER_H
 #define AAPT_NAME_MANGLER_H
 
-#include "Resource.h"
-#include "util/Maybe.h"
-
 #include <set>
 #include <string>
 
+#include "Resource.h"
+#include "util/Maybe.h"
+
 namespace aapt {
 
 struct NameManglerPolicy {
@@ -31,37 +31,35 @@ struct NameManglerPolicy {
    * to this package are not mangled, and mangled references inherit this
    * package name.
    */
-  std::string targetPackageName;
+  std::string target_package_name;
 
   /**
    * We must know which references to mangle, and which to keep (android vs.
    * com.android.support).
    */
-  std::set<std::string> packagesToMangle;
+  std::set<std::string> packages_to_mangle;
 };
 
 class NameMangler {
- private:
-  NameManglerPolicy mPolicy;
-
  public:
-  explicit NameMangler(NameManglerPolicy policy) : mPolicy(policy) {}
+  explicit NameMangler(NameManglerPolicy policy) : policy_(policy) {}
 
-  Maybe<ResourceName> mangleName(const ResourceName& name) {
-    if (mPolicy.targetPackageName == name.package ||
-        mPolicy.packagesToMangle.count(name.package) == 0) {
+  Maybe<ResourceName> MangleName(const ResourceName& name) {
+    if (policy_.target_package_name == name.package ||
+        policy_.packages_to_mangle.count(name.package) == 0) {
       return {};
     }
 
-    std::string mangledEntryName = mangleEntry(name.package, name.entry);
-    return ResourceName(mPolicy.targetPackageName, name.type, mangledEntryName);
+    std::string mangled_entry_name = MangleEntry(name.package, name.entry);
+    return ResourceName(policy_.target_package_name, name.type,
+                        mangled_entry_name);
   }
 
-  bool shouldMangle(const std::string& package) const {
-    if (package.empty() || mPolicy.targetPackageName == package) {
+  bool ShouldMangle(const std::string& package) const {
+    if (package.empty() || policy_.target_package_name == package) {
       return false;
     }
-    return mPolicy.packagesToMangle.count(package) != 0;
+    return policy_.packages_to_mangle.count(package) != 0;
   }
 
   /**
@@ -69,7 +67,7 @@ class NameMangler {
    * The mangled name should contain symbols that are illegal to define in XML,
    * so that there will never be name mangling collisions.
    */
-  static std::string mangleEntry(const std::string& package,
+  static std::string MangleEntry(const std::string& package,
                                  const std::string& name) {
     return package + "$" + name;
   }
@@ -79,16 +77,20 @@ class NameMangler {
    * and the package in `outPackage`. Returns true if the name was unmangled or
    * false if the name was never mangled to begin with.
    */
-  static bool unmangle(std::string* outName, std::string* outPackage) {
-    size_t pivot = outName->find('$');
+  static bool Unmangle(std::string* out_name, std::string* out_package) {
+    size_t pivot = out_name->find('$');
     if (pivot == std::string::npos) {
       return false;
     }
 
-    outPackage->assign(outName->data(), pivot);
-    outName->assign(outName->data() + pivot + 1, outName->size() - (pivot + 1));
+    out_package->assign(out_name->data(), pivot);
+    out_name->assign(out_name->data() + pivot + 1,
+                     out_name->size() - (pivot + 1));
     return true;
   }
+
+ private:
+  NameManglerPolicy policy_;
 };
 
 }  // namespace aapt
diff --git a/tools/aapt2/NameMangler_test.cpp b/tools/aapt2/NameMangler_test.cpp
index b02986d8e6115..bc89b5c3fb43d 100644
--- a/tools/aapt2/NameMangler_test.cpp
+++ b/tools/aapt2/NameMangler_test.cpp
@@ -15,31 +15,32 @@
  */
 
 #include "NameMangler.h"
-#include "test/Test.h"
 
 #include <string>
 
+#include "test/Test.h"
+
 namespace aapt {
 
 TEST(NameManglerTest, MangleName) {
   std::string package = "android.appcompat";
   std::string name = "Platform.AppCompat";
 
-  std::string mangledName = NameMangler::mangleEntry(package, name);
-  EXPECT_EQ(mangledName, "android.appcompat$Platform.AppCompat");
+  std::string mangled_name = NameMangler::MangleEntry(package, name);
+  EXPECT_EQ(mangled_name, "android.appcompat$Platform.AppCompat");
 
-  std::string unmangledPackage;
-  std::string unmangledName = mangledName;
-  ASSERT_TRUE(NameMangler::unmangle(&unmangledName, &unmangledPackage));
-  EXPECT_EQ(unmangledName, "Platform.AppCompat");
-  EXPECT_EQ(unmangledPackage, "android.appcompat");
+  std::string unmangled_package;
+  std::string unmangled_name = mangled_name;
+  ASSERT_TRUE(NameMangler::Unmangle(&unmangled_name, &unmangled_package));
+  EXPECT_EQ(unmangled_name, "Platform.AppCompat");
+  EXPECT_EQ(unmangled_package, "android.appcompat");
 }
 
 TEST(NameManglerTest, IgnoreUnmangledName) {
   std::string package;
   std::string name = "foo_bar";
 
-  EXPECT_FALSE(NameMangler::unmangle(&name, &package));
+  EXPECT_FALSE(NameMangler::Unmangle(&name, &package));
   EXPECT_EQ(name, "foo_bar");
 }
 
diff --git a/tools/aapt2/Resource.cpp b/tools/aapt2/Resource.cpp
index 6805631bd2600..1d414743de71d 100644
--- a/tools/aapt2/Resource.cpp
+++ b/tools/aapt2/Resource.cpp
@@ -15,14 +15,13 @@
  */
 
 #include "Resource.h"
-#include "util/StringPiece.h"
 
 #include <map>
 #include <string>
 
 namespace aapt {
 
-StringPiece toString(ResourceType type) {
+StringPiece ToString(ResourceType type) {
   switch (type) {
     case ResourceType::kAnim:
       return "anim";
@@ -100,7 +99,7 @@ static const std::map<StringPiece, ResourceType> sResourceTypeMap{
     {"xml", ResourceType::kXml},
 };
 
-const ResourceType* parseResourceType(const StringPiece& str) {
+const ResourceType* ParseResourceType(const StringPiece& str) {
   auto iter = sResourceTypeMap.find(str);
   if (iter == std::end(sResourceTypeMap)) {
     return nullptr;
diff --git a/tools/aapt2/Resource.h b/tools/aapt2/Resource.h
index 30739db543d3d..78acb700c7c09 100644
--- a/tools/aapt2/Resource.h
+++ b/tools/aapt2/Resource.h
@@ -17,12 +17,6 @@
 #ifndef AAPT_RESOURCE_H
 #define AAPT_RESOURCE_H
 
-#include "ConfigDescription.h"
-#include "Source.h"
-#include "util/StringPiece.h"
-
-#include <utils/JenkinsHash.h>
-
 #include <iomanip>
 #include <limits>
 #include <sstream>
@@ -30,6 +24,12 @@
 #include <tuple>
 #include <vector>
 
+#include "utils/JenkinsHash.h"
+
+#include "ConfigDescription.h"
+#include "Source.h"
+#include "util/StringPiece.h"
+
 namespace aapt {
 
 /**
@@ -62,13 +62,13 @@ enum class ResourceType {
   kXml,
 };
 
-StringPiece toString(ResourceType type);
+StringPiece ToString(ResourceType type);
 
 /**
  * Returns a pointer to a valid ResourceType, or nullptr if
  * the string was invalid.
  */
-const ResourceType* parseResourceType(const StringPiece& str);
+const ResourceType* ParseResourceType(const StringPiece& str);
 
 /**
  * A resource's name. This can uniquely identify
@@ -76,16 +76,16 @@ const ResourceType* parseResourceType(const StringPiece& str);
  */
 struct ResourceName {
   std::string package;
-  ResourceType type;
+  ResourceType type = ResourceType::kRaw;
   std::string entry;
 
-  ResourceName() : type(ResourceType::kRaw) {}
+  ResourceName() = default;
   ResourceName(const StringPiece& p, ResourceType t, const StringPiece& e);
 
   int compare(const ResourceName& other) const;
 
-  bool isValid() const;
-  std::string toString() const;
+  bool is_valid() const;
+  std::string ToString() const;
 };
 
 /**
@@ -96,7 +96,7 @@ struct ResourceName {
  */
 struct ResourceNameRef {
   StringPiece package;
-  ResourceType type;
+  ResourceType type = ResourceType::kRaw;
   StringPiece entry;
 
   ResourceNameRef() = default;
@@ -108,8 +108,8 @@ struct ResourceNameRef {
   ResourceNameRef& operator=(ResourceNameRef&& rhs) = default;
   ResourceNameRef& operator=(const ResourceName& rhs);
 
-  ResourceName toResourceName() const;
-  bool isValid() const;
+  ResourceName ToResourceName() const;
+  bool is_valid() const;
 };
 
 /**
@@ -128,13 +128,13 @@ struct ResourceId {
 
   ResourceId();
   ResourceId(const ResourceId& rhs);
-  ResourceId(uint32_t resId);  // NOLINT(implicit)
+  ResourceId(uint32_t res_id);  // NOLINT(implicit)
   ResourceId(uint8_t p, uint8_t t, uint16_t e);
 
-  bool isValid() const;
-  uint8_t packageId() const;
-  uint8_t typeId() const;
-  uint16_t entryId() const;
+  bool is_valid() const;
+  uint8_t package_id() const;
+  uint8_t type_id() const;
+  uint16_t entry_id() const;
 };
 
 struct SourcedResourceName {
@@ -153,7 +153,7 @@ struct ResourceFile {
   Source source;
 
   // Exported symbols
-  std::vector<SourcedResourceName> exportedSymbols;
+  std::vector<SourcedResourceName> exported_symbols;
 };
 
 /**
@@ -196,24 +196,24 @@ inline ResourceId::ResourceId() : id(0) {}
 
 inline ResourceId::ResourceId(const ResourceId& rhs) : id(rhs.id) {}
 
-inline ResourceId::ResourceId(uint32_t resId) : id(resId) {}
+inline ResourceId::ResourceId(uint32_t res_id) : id(res_id) {}
 
 inline ResourceId::ResourceId(uint8_t p, uint8_t t, uint16_t e)
     : id((p << 24) | (t << 16) | e) {}
 
-inline bool ResourceId::isValid() const {
+inline bool ResourceId::is_valid() const {
   return (id & 0xff000000u) != 0 && (id & 0x00ff0000u) != 0;
 }
 
-inline uint8_t ResourceId::packageId() const {
+inline uint8_t ResourceId::package_id() const {
   return static_cast<uint8_t>(id >> 24);
 }
 
-inline uint8_t ResourceId::typeId() const {
+inline uint8_t ResourceId::type_id() const {
   return static_cast<uint8_t>(id >> 16);
 }
 
-inline uint16_t ResourceId::entryId() const {
+inline uint16_t ResourceId::entry_id() const {
   return static_cast<uint16_t>(id);
 }
 
@@ -234,13 +234,13 @@ inline bool operator!=(const ResourceId& lhs, const ResourceId& rhs) {
 }
 
 inline ::std::ostream& operator<<(::std::ostream& out,
-                                  const ResourceId& resId) {
-  std::ios_base::fmtflags oldFlags = out.flags();
-  char oldFill = out.fill();
+                                  const ResourceId& res_id) {
+  std::ios_base::fmtflags old_flags = out.flags();
+  char old_fill = out.fill();
   out << "0x" << std::internal << std::setfill('0') << std::setw(8) << std::hex
-      << resId.id;
-  out.flags(oldFlags);
-  out.fill(oldFill);
+      << res_id.id;
+  out.flags(old_flags);
+  out.fill(old_fill);
   return out;
 }
 
@@ -250,7 +250,7 @@ inline ::std::ostream& operator<<(::std::ostream& out,
 
 inline ::std::ostream& operator<<(::std::ostream& out,
                                   const ResourceType& val) {
-  return out << toString(val);
+  return out << ToString(val);
 }
 
 //
@@ -259,7 +259,7 @@ inline ::std::ostream& operator<<(::std::ostream& out,
 
 inline ResourceName::ResourceName(const StringPiece& p, ResourceType t,
                                   const StringPiece& e)
-    : package(p.toString()), type(t), entry(e.toString()) {}
+    : package(p.ToString()), type(t), entry(e.ToString()) {}
 
 inline int ResourceName::compare(const ResourceName& other) const {
   int cmp = package.compare(other.package);
@@ -270,7 +270,7 @@ inline int ResourceName::compare(const ResourceName& other) const {
   return cmp;
 }
 
-inline bool ResourceName::isValid() const {
+inline bool ResourceName::is_valid() const {
   return !package.empty() && !entry.empty();
 }
 
@@ -297,7 +297,7 @@ inline ::std::ostream& operator<<(::std::ostream& out,
   return out << name.type << "/" << name.entry;
 }
 
-inline std::string ResourceName::toString() const {
+inline std::string ResourceName::ToString() const {
   std::stringstream stream;
   stream << *this;
   return stream.str();
@@ -321,11 +321,11 @@ inline ResourceNameRef& ResourceNameRef::operator=(const ResourceName& rhs) {
   return *this;
 }
 
-inline ResourceName ResourceNameRef::toResourceName() const {
+inline ResourceName ResourceNameRef::ToResourceName() const {
   return ResourceName(package, type, entry);
 }
 
-inline bool ResourceNameRef::isValid() const {
+inline bool ResourceNameRef::is_valid() const {
   return !package.empty() && !entry.empty();
 }
 
diff --git a/tools/aapt2/ResourceParser.cpp b/tools/aapt2/ResourceParser.cpp
index 7d50e1d388164..b16def4025fff 100644
--- a/tools/aapt2/ResourceParser.cpp
+++ b/tools/aapt2/ResourceParser.cpp
@@ -15,6 +15,12 @@
  */
 
 #include "ResourceParser.h"
+
+#include <functional>
+#include <sstream>
+
+#include "android-base/logging.h"
+
 #include "ResourceTable.h"
 #include "ResourceUtils.h"
 #include "ResourceValues.h"
@@ -23,9 +29,6 @@
 #include "util/Util.h"
 #include "xml/XmlPullParser.h"
 
-#include <functional>
-#include <sstream>
-
 namespace aapt {
 
 constexpr const char* sXliffNamespaceUri =
@@ -35,12 +38,12 @@ constexpr const char* sXliffNamespaceUri =
  * Returns true if the element is <skip> or <eat-comment> and can be safely
  * ignored.
  */
-static bool shouldIgnoreElement(const StringPiece& ns,
+static bool ShouldIgnoreElement(const StringPiece& ns,
                                 const StringPiece& name) {
   return ns.empty() && (name == "skip" || name == "eat-comment");
 }
 
-static uint32_t parseFormatType(const StringPiece& piece) {
+static uint32_t ParseFormatType(const StringPiece& piece) {
   if (piece == "reference")
     return android::ResTable_map::TYPE_REFERENCE;
   else if (piece == "string")
@@ -64,11 +67,11 @@ static uint32_t parseFormatType(const StringPiece& piece) {
   return 0;
 }
 
-static uint32_t parseFormatAttribute(const StringPiece& str) {
+static uint32_t ParseFormatAttribute(const StringPiece& str) {
   uint32_t mask = 0;
-  for (StringPiece part : util::tokenize(str, '|')) {
-    StringPiece trimmedPart = util::trimWhitespace(part);
-    uint32_t type = parseFormatType(trimmedPart);
+  for (StringPiece part : util::Tokenize(str, '|')) {
+    StringPiece trimmed_part = util::TrimWhitespace(part);
+    uint32_t type = ParseFormatType(trimmed_part);
     if (type == 0) {
       return 0;
     }
@@ -86,45 +89,45 @@ struct ParsedResource {
   std::string product;
   Source source;
   ResourceId id;
-  Maybe<SymbolState> symbolState;
+  Maybe<SymbolState> symbol_state;
   std::string comment;
   std::unique_ptr<Value> value;
-  std::list<ParsedResource> childResources;
+  std::list<ParsedResource> child_resources;
 };
 
 // Recursively adds resources to the ResourceTable.
-static bool addResourcesToTable(ResourceTable* table, IDiagnostics* diag,
+static bool AddResourcesToTable(ResourceTable* table, IDiagnostics* diag,
                                 ParsedResource* res) {
-  StringPiece trimmedComment = util::trimWhitespace(res->comment);
-  if (trimmedComment.size() != res->comment.size()) {
+  StringPiece trimmed_comment = util::TrimWhitespace(res->comment);
+  if (trimmed_comment.size() != res->comment.size()) {
     // Only if there was a change do we re-assign.
-    res->comment = trimmedComment.toString();
+    res->comment = trimmed_comment.ToString();
   }
 
-  if (res->symbolState) {
+  if (res->symbol_state) {
     Symbol symbol;
-    symbol.state = res->symbolState.value();
+    symbol.state = res->symbol_state.value();
     symbol.source = res->source;
     symbol.comment = res->comment;
-    if (!table->setSymbolState(res->name, res->id, symbol, diag)) {
+    if (!table->SetSymbolState(res->name, res->id, symbol, diag)) {
       return false;
     }
   }
 
   if (res->value) {
     // Attach the comment, source and config to the value.
-    res->value->setComment(std::move(res->comment));
-    res->value->setSource(std::move(res->source));
+    res->value->SetComment(std::move(res->comment));
+    res->value->SetSource(std::move(res->source));
 
-    if (!table->addResource(res->name, res->id, res->config, res->product,
+    if (!table->AddResource(res->name, res->id, res->config, res->product,
                             std::move(res->value), diag)) {
       return false;
     }
   }
 
   bool error = false;
-  for (ParsedResource& child : res->childResources) {
-    error |= !addResourcesToTable(table, diag, &child);
+  for (ParsedResource& child : res->child_resources) {
+    error |= !AddResourcesToTable(table, diag, &child);
   }
   return !error;
 }
@@ -136,29 +139,29 @@ ResourceParser::ResourceParser(IDiagnostics* diag, ResourceTable* table,
                                const Source& source,
                                const ConfigDescription& config,
                                const ResourceParserOptions& options)
-    : mDiag(diag),
-      mTable(table),
-      mSource(source),
-      mConfig(config),
-      mOptions(options) {}
+    : diag_(diag),
+      table_(table),
+      source_(source),
+      config_(config),
+      options_(options) {}
 
 /**
  * Build a string from XML that converts nested elements into Span objects.
  */
-bool ResourceParser::flattenXmlSubtree(xml::XmlPullParser* parser,
-                                       std::string* outRawString,
-                                       StyleString* outStyleString) {
-  std::vector<Span> spanStack;
+bool ResourceParser::FlattenXmlSubtree(xml::XmlPullParser* parser,
+                                       std::string* out_raw_string,
+                                       StyleString* out_style_string) {
+  std::vector<Span> span_stack;
 
   bool error = false;
-  outRawString->clear();
-  outStyleString->spans.clear();
+  out_raw_string->clear();
+  out_style_string->spans.clear();
   util::StringBuilder builder;
   size_t depth = 1;
-  while (xml::XmlPullParser::isGoodEvent(parser->next())) {
-    const xml::XmlPullParser::Event event = parser->getEvent();
+  while (xml::XmlPullParser::IsGoodEvent(parser->Next())) {
+    const xml::XmlPullParser::Event event = parser->event();
     if (event == xml::XmlPullParser::Event::kEndElement) {
-      if (!parser->getElementNamespace().empty()) {
+      if (!parser->element_namespace().empty()) {
         // We already warned and skipped the start element, so just skip here
         // too
         continue;
@@ -169,150 +172,151 @@ bool ResourceParser::flattenXmlSubtree(xml::XmlPullParser* parser,
         break;
       }
 
-      spanStack.back().lastChar = builder.utf16Len() - 1;
-      outStyleString->spans.push_back(spanStack.back());
-      spanStack.pop_back();
+      span_stack.back().last_char = builder.Utf16Len() - 1;
+      out_style_string->spans.push_back(span_stack.back());
+      span_stack.pop_back();
 
     } else if (event == xml::XmlPullParser::Event::kText) {
-      outRawString->append(parser->getText());
-      builder.append(parser->getText());
+      out_raw_string->append(parser->text());
+      builder.Append(parser->text());
 
     } else if (event == xml::XmlPullParser::Event::kStartElement) {
-      if (!parser->getElementNamespace().empty()) {
-        if (parser->getElementNamespace() != sXliffNamespaceUri) {
+      if (!parser->element_namespace().empty()) {
+        if (parser->element_namespace() != sXliffNamespaceUri) {
           // Only warn if this isn't an xliff namespace.
-          mDiag->warn(DiagMessage(mSource.withLine(parser->getLineNumber()))
-                      << "skipping element '" << parser->getElementName()
+          diag_->Warn(DiagMessage(source_.WithLine(parser->line_number()))
+                      << "skipping element '" << parser->element_name()
                       << "' with unknown namespace '"
-                      << parser->getElementNamespace() << "'");
+                      << parser->element_namespace() << "'");
         }
         continue;
       }
       depth++;
 
       // Build a span object out of the nested element.
-      std::string spanName = parser->getElementName();
-      const auto endAttrIter = parser->endAttributes();
-      for (auto attrIter = parser->beginAttributes(); attrIter != endAttrIter;
-           ++attrIter) {
-        spanName += ";";
-        spanName += attrIter->name;
-        spanName += "=";
-        spanName += attrIter->value;
+      std::string span_name = parser->element_name();
+      const auto end_attr_iter = parser->end_attributes();
+      for (auto attr_iter = parser->begin_attributes();
+           attr_iter != end_attr_iter; ++attr_iter) {
+        span_name += ";";
+        span_name += attr_iter->name;
+        span_name += "=";
+        span_name += attr_iter->value;
       }
 
-      if (builder.utf16Len() > std::numeric_limits<uint32_t>::max()) {
-        mDiag->error(DiagMessage(mSource.withLine(parser->getLineNumber()))
-                     << "style string '" << builder.str() << "' is too long");
+      if (builder.Utf16Len() > std::numeric_limits<uint32_t>::max()) {
+        diag_->Error(DiagMessage(source_.WithLine(parser->line_number()))
+                     << "style string '" << builder.ToString()
+                     << "' is too long");
         error = true;
       } else {
-        spanStack.push_back(
-            Span{spanName, static_cast<uint32_t>(builder.utf16Len())});
+        span_stack.push_back(
+            Span{span_name, static_cast<uint32_t>(builder.Utf16Len())});
       }
 
     } else if (event == xml::XmlPullParser::Event::kComment) {
       // Skip
     } else {
-      assert(false);
+      LOG(FATAL) << "unhandled XML event";
     }
   }
-  assert(spanStack.empty() && "spans haven't been fully processed");
+  CHECK(span_stack.empty()) << "spans haven't been fully processed";
 
-  outStyleString->str = builder.str();
+  out_style_string->str = builder.ToString();
   return !error;
 }
 
-bool ResourceParser::parse(xml::XmlPullParser* parser) {
+bool ResourceParser::Parse(xml::XmlPullParser* parser) {
   bool error = false;
-  const size_t depth = parser->getDepth();
-  while (xml::XmlPullParser::nextChildNode(parser, depth)) {
-    if (parser->getEvent() != xml::XmlPullParser::Event::kStartElement) {
+  const size_t depth = parser->depth();
+  while (xml::XmlPullParser::NextChildNode(parser, depth)) {
+    if (parser->event() != xml::XmlPullParser::Event::kStartElement) {
       // Skip comments and text.
       continue;
     }
 
-    if (!parser->getElementNamespace().empty() ||
-        parser->getElementName() != "resources") {
-      mDiag->error(DiagMessage(mSource.withLine(parser->getLineNumber()))
+    if (!parser->element_namespace().empty() ||
+        parser->element_name() != "resources") {
+      diag_->Error(DiagMessage(source_.WithLine(parser->line_number()))
                    << "root element must be <resources>");
       return false;
     }
 
-    error |= !parseResources(parser);
+    error |= !ParseResources(parser);
     break;
   };
 
-  if (parser->getEvent() == xml::XmlPullParser::Event::kBadDocument) {
-    mDiag->error(DiagMessage(mSource.withLine(parser->getLineNumber()))
-                 << "xml parser error: " << parser->getLastError());
+  if (parser->event() == xml::XmlPullParser::Event::kBadDocument) {
+    diag_->Error(DiagMessage(source_.WithLine(parser->line_number()))
+                 << "xml parser error: " << parser->error());
     return false;
   }
   return !error;
 }
 
-bool ResourceParser::parseResources(xml::XmlPullParser* parser) {
-  std::set<ResourceName> strippedResources;
+bool ResourceParser::ParseResources(xml::XmlPullParser* parser) {
+  std::set<ResourceName> stripped_resources;
 
   bool error = false;
   std::string comment;
-  const size_t depth = parser->getDepth();
-  while (xml::XmlPullParser::nextChildNode(parser, depth)) {
-    const xml::XmlPullParser::Event event = parser->getEvent();
+  const size_t depth = parser->depth();
+  while (xml::XmlPullParser::NextChildNode(parser, depth)) {
+    const xml::XmlPullParser::Event event = parser->event();
     if (event == xml::XmlPullParser::Event::kComment) {
-      comment = parser->getComment();
+      comment = parser->comment();
       continue;
     }
 
     if (event == xml::XmlPullParser::Event::kText) {
-      if (!util::trimWhitespace(parser->getText()).empty()) {
-        mDiag->error(DiagMessage(mSource.withLine(parser->getLineNumber()))
+      if (!util::TrimWhitespace(parser->text()).empty()) {
+        diag_->Error(DiagMessage(source_.WithLine(parser->line_number()))
                      << "plain text not allowed here");
         error = true;
       }
       continue;
     }
 
-    assert(event == xml::XmlPullParser::Event::kStartElement);
+    CHECK(event == xml::XmlPullParser::Event::kStartElement);
 
-    if (!parser->getElementNamespace().empty()) {
+    if (!parser->element_namespace().empty()) {
       // Skip unknown namespace.
       continue;
     }
 
-    std::string elementName = parser->getElementName();
-    if (elementName == "skip" || elementName == "eat-comment") {
+    std::string element_name = parser->element_name();
+    if (element_name == "skip" || element_name == "eat-comment") {
       comment = "";
       continue;
     }
 
-    ParsedResource parsedResource;
-    parsedResource.config = mConfig;
-    parsedResource.source = mSource.withLine(parser->getLineNumber());
-    parsedResource.comment = std::move(comment);
+    ParsedResource parsed_resource;
+    parsed_resource.config = config_;
+    parsed_resource.source = source_.WithLine(parser->line_number());
+    parsed_resource.comment = std::move(comment);
 
     // Extract the product name if it exists.
-    if (Maybe<StringPiece> maybeProduct =
-            xml::findNonEmptyAttribute(parser, "product")) {
-      parsedResource.product = maybeProduct.value().toString();
+    if (Maybe<StringPiece> maybe_product =
+            xml::FindNonEmptyAttribute(parser, "product")) {
+      parsed_resource.product = maybe_product.value().ToString();
     }
 
     // Parse the resource regardless of product.
-    if (!parseResource(parser, &parsedResource)) {
+    if (!ParseResource(parser, &parsed_resource)) {
       error = true;
       continue;
     }
 
-    if (!addResourcesToTable(mTable, mDiag, &parsedResource)) {
+    if (!AddResourcesToTable(table_, diag_, &parsed_resource)) {
       error = true;
     }
   }
 
   // Check that we included at least one variant of each stripped resource.
-  for (const ResourceName& strippedResource : strippedResources) {
-    if (!mTable->findResource(strippedResource)) {
+  for (const ResourceName& stripped_resource : stripped_resources) {
+    if (!table_->FindResource(stripped_resource)) {
       // Failed to find the resource.
-      mDiag->error(DiagMessage(mSource)
-                   << "resource '" << strippedResource
+      diag_->Error(DiagMessage(source_)
+                   << "resource '" << stripped_resource
                    << "' "
                       "was filtered out but no product variant remains");
       error = true;
@@ -322,8 +326,8 @@ bool ResourceParser::parseResources(xml::XmlPullParser* parser) {
   return !error;
 }
 
-bool ResourceParser::parseResource(xml::XmlPullParser* parser,
-                                   ParsedResource* outResource) {
+bool ResourceParser::ParseResource(xml::XmlPullParser* parser,
+                                   ParsedResource* out_resource) {
   struct ItemTypeFormat {
     ResourceType type;
     uint32_t format;
@@ -333,7 +337,7 @@ bool ResourceParser::parseResource(xml::XmlPullParser* parser,
                                           ParsedResource*)>;
 
   static const auto elToItemMap =
-      ImmutableMap<std::string, ItemTypeFormat>::createPreSorted({
+      ImmutableMap<std::string, ItemTypeFormat>::CreatePreSorted({
           {"bool", {ResourceType::kBool, android::ResTable_map::TYPE_BOOLEAN}},
           {"color", {ResourceType::kColor, android::ResTable_map::TYPE_COLOR}},
           {"dimen",
@@ -354,48 +358,49 @@ bool ResourceParser::parseResource(xml::XmlPullParser* parser,
       });
 
   static const auto elToBagMap =
-      ImmutableMap<std::string, BagParseFunc>::createPreSorted({
-          {"add-resource", std::mem_fn(&ResourceParser::parseAddResource)},
-          {"array", std::mem_fn(&ResourceParser::parseArray)},
-          {"attr", std::mem_fn(&ResourceParser::parseAttr)},
+      ImmutableMap<std::string, BagParseFunc>::CreatePreSorted({
+          {"add-resource", std::mem_fn(&ResourceParser::ParseAddResource)},
+          {"array", std::mem_fn(&ResourceParser::ParseArray)},
+          {"attr", std::mem_fn(&ResourceParser::ParseAttr)},
           {"declare-styleable",
-           std::mem_fn(&ResourceParser::parseDeclareStyleable)},
-          {"integer-array", std::mem_fn(&ResourceParser::parseIntegerArray)},
-          {"java-symbol", std::mem_fn(&ResourceParser::parseSymbol)},
-          {"plurals", std::mem_fn(&ResourceParser::parsePlural)},
-          {"public", std::mem_fn(&ResourceParser::parsePublic)},
-          {"public-group", std::mem_fn(&ResourceParser::parsePublicGroup)},
-          {"string-array", std::mem_fn(&ResourceParser::parseStringArray)},
-          {"style", std::mem_fn(&ResourceParser::parseStyle)},
-          {"symbol", std::mem_fn(&ResourceParser::parseSymbol)},
+           std::mem_fn(&ResourceParser::ParseDeclareStyleable)},
+          {"integer-array", std::mem_fn(&ResourceParser::ParseIntegerArray)},
+          {"java-symbol", std::mem_fn(&ResourceParser::ParseSymbol)},
+          {"plurals", std::mem_fn(&ResourceParser::ParsePlural)},
+          {"public", std::mem_fn(&ResourceParser::ParsePublic)},
+          {"public-group", std::mem_fn(&ResourceParser::ParsePublicGroup)},
+          {"string-array", std::mem_fn(&ResourceParser::ParseStringArray)},
+          {"style", std::mem_fn(&ResourceParser::ParseStyle)},
+          {"symbol", std::mem_fn(&ResourceParser::ParseSymbol)},
       });
 
-  std::string resourceType = parser->getElementName();
+  std::string resource_type = parser->element_name();
 
   // The value format accepted for this resource.
-  uint32_t resourceFormat = 0u;
+  uint32_t resource_format = 0u;
 
-  if (resourceType == "item") {
+  if (resource_type == "item") {
     // Items have their type encoded in the type attribute.
-    if (Maybe<StringPiece> maybeType =
-            xml::findNonEmptyAttribute(parser, "type")) {
-      resourceType = maybeType.value().toString();
+    if (Maybe<StringPiece> maybe_type =
+            xml::FindNonEmptyAttribute(parser, "type")) {
+      resource_type = maybe_type.value().ToString();
     } else {
-      mDiag->error(DiagMessage(mSource.withLine(parser->getLineNumber()))
+      diag_->Error(DiagMessage(source_.WithLine(parser->line_number()))
                    << "<item> must have a 'type' attribute");
       return false;
     }
 
-    if (Maybe<StringPiece> maybeFormat =
-            xml::findNonEmptyAttribute(parser, "format")) {
+    if (Maybe<StringPiece> maybe_format =
+            xml::FindNonEmptyAttribute(parser, "format")) {
       // An explicit format for this resource was specified. The resource will
       // retain
       // its type in its name, but the accepted value for this type is
       // overridden.
-      resourceFormat = parseFormatType(maybeFormat.value());
-      if (!resourceFormat) {
-        mDiag->error(DiagMessage(outResource->source)
-                     << "'" << maybeFormat.value() << "' is an invalid format");
+      resource_format = ParseFormatType(maybe_format.value());
+      if (!resource_format) {
+        diag_->Error(DiagMessage(out_resource->source)
+                     << "'" << maybe_format.value()
+                     << "' is an invalid format");
         return false;
       }
     }
@@ -403,65 +408,65 @@ bool ResourceParser::parseResource(xml::XmlPullParser* parser,
 
   // Get the name of the resource. This will be checked later, because not all
   // XML elements require a name.
-  Maybe<StringPiece> maybeName = xml::findNonEmptyAttribute(parser, "name");
+  Maybe<StringPiece> maybe_name = xml::FindNonEmptyAttribute(parser, "name");
 
-  if (resourceType == "id") {
-    if (!maybeName) {
-      mDiag->error(DiagMessage(outResource->source)
-                   << "<" << parser->getElementName()
+  if (resource_type == "id") {
+    if (!maybe_name) {
+      diag_->Error(DiagMessage(out_resource->source)
+                   << "<" << parser->element_name()
                    << "> missing 'name' attribute");
       return false;
     }
 
-    outResource->name.type = ResourceType::kId;
-    outResource->name.entry = maybeName.value().toString();
-    outResource->value = util::make_unique<Id>();
+    out_resource->name.type = ResourceType::kId;
+    out_resource->name.entry = maybe_name.value().ToString();
+    out_resource->value = util::make_unique<Id>();
     return true;
   }
 
-  const auto itemIter = elToItemMap.find(resourceType);
-  if (itemIter != elToItemMap.end()) {
+  const auto item_iter = elToItemMap.find(resource_type);
+  if (item_iter != elToItemMap.end()) {
     // This is an item, record its type and format and start parsing.
 
-    if (!maybeName) {
-      mDiag->error(DiagMessage(outResource->source)
-                   << "<" << parser->getElementName()
+    if (!maybe_name) {
+      diag_->Error(DiagMessage(out_resource->source)
+                   << "<" << parser->element_name()
                    << "> missing 'name' attribute");
       return false;
     }
 
-    outResource->name.type = itemIter->second.type;
-    outResource->name.entry = maybeName.value().toString();
+    out_resource->name.type = item_iter->second.type;
+    out_resource->name.entry = maybe_name.value().ToString();
 
     // Only use the implicit format for this type if it wasn't overridden.
-    if (!resourceFormat) {
-      resourceFormat = itemIter->second.format;
+    if (!resource_format) {
+      resource_format = item_iter->second.format;
     }
 
-    if (!parseItem(parser, outResource, resourceFormat)) {
+    if (!ParseItem(parser, out_resource, resource_format)) {
       return false;
     }
     return true;
   }
 
   // This might be a bag or something.
-  const auto bagIter = elToBagMap.find(resourceType);
-  if (bagIter != elToBagMap.end()) {
+  const auto bag_iter = elToBagMap.find(resource_type);
+  if (bag_iter != elToBagMap.end()) {
     // Ensure we have a name (unless this is a <public-group>).
-    if (resourceType != "public-group") {
-      if (!maybeName) {
-        mDiag->error(DiagMessage(outResource->source)
-                     << "<" << parser->getElementName()
+    if (resource_type != "public-group") {
+      if (!maybe_name) {
+        diag_->Error(DiagMessage(out_resource->source)
+                     << "<" << parser->element_name()
                      << "> missing 'name' attribute");
         return false;
       }
 
-      outResource->name.entry = maybeName.value().toString();
+      out_resource->name.entry = maybe_name.value().ToString();
     }
 
     // Call the associated parse method. The type will be filled in by the
     // parse func.
-    if (!bagIter->second(this, parser, outResource)) {
+    if (!bag_iter->second(this, parser, out_resource)) {
       return false;
     }
     return true;
@@ -469,44 +474,44 @@ bool ResourceParser::parseResource(xml::XmlPullParser* parser,
 
   // Try parsing the elementName (or type) as a resource. These shall only be
   // resources like 'layout' or 'xml' and they can only be references.
-  const ResourceType* parsedType = parseResourceType(resourceType);
-  if (parsedType) {
-    if (!maybeName) {
-      mDiag->error(DiagMessage(outResource->source)
-                   << "<" << parser->getElementName()
+  const ResourceType* parsed_type = ParseResourceType(resource_type);
+  if (parsed_type) {
+    if (!maybe_name) {
+      diag_->Error(DiagMessage(out_resource->source)
+                   << "<" << parser->element_name()
                    << "> missing 'name' attribute");
       return false;
     }
 
-    outResource->name.type = *parsedType;
-    outResource->name.entry = maybeName.value().toString();
-    outResource->value =
-        parseXml(parser, android::ResTable_map::TYPE_REFERENCE, kNoRawString);
-    if (!outResource->value) {
-      mDiag->error(DiagMessage(outResource->source)
-                   << "invalid value for type '" << *parsedType
+    out_resource->name.type = *parsed_type;
+    out_resource->name.entry = maybe_name.value().ToString();
+    out_resource->value =
+        ParseXml(parser, android::ResTable_map::TYPE_REFERENCE, kNoRawString);
+    if (!out_resource->value) {
+      diag_->Error(DiagMessage(out_resource->source)
+                   << "invalid value for type '" << *parsed_type
                    << "'. Expected a reference");
       return false;
     }
     return true;
   }
 
-  mDiag->warn(DiagMessage(outResource->source)
-              << "unknown resource type '" << parser->getElementName() << "'");
+  diag_->Warn(DiagMessage(out_resource->source)
+              << "unknown resource type '" << parser->element_name() << "'");
   return false;
 }
 
-bool ResourceParser::parseItem(xml::XmlPullParser* parser,
-                               ParsedResource* outResource,
+bool ResourceParser::ParseItem(xml::XmlPullParser* parser,
+                               ParsedResource* out_resource,
                                const uint32_t format) {
   if (format == android::ResTable_map::TYPE_STRING) {
-    return parseString(parser, outResource);
+    return ParseString(parser, out_resource);
   }
 
-  outResource->value = parseXml(parser, format, kNoRawString);
-  if (!outResource->value) {
-    mDiag->error(DiagMessage(outResource->source) << "invalid "
-                                                  << outResource->name.type);
+  out_resource->value = ParseXml(parser, format, kNoRawString);
+  if (!out_resource->value) {
+    diag_->Error(DiagMessage(out_resource->source) << "invalid "
+                                                   << out_resource->name.type);
     return false;
   }
   return true;
@@ -519,362 +524,364 @@ bool ResourceParser::parseItem(xml::XmlPullParser* parser,
  * an Item. If allowRawValue is false, nullptr is returned in this
  * case.
  */
-std::unique_ptr<Item> ResourceParser::parseXml(xml::XmlPullParser* parser,
-                                               const uint32_t typeMask,
-                                               const bool allowRawValue) {
-  const size_t beginXmlLine = parser->getLineNumber();
+std::unique_ptr<Item> ResourceParser::ParseXml(xml::XmlPullParser* parser,
+                                               const uint32_t type_mask,
+                                               const bool allow_raw_value) {
+  const size_t begin_xml_line = parser->line_number();
 
-  std::string rawValue;
-  StyleString styleString;
-  if (!flattenXmlSubtree(parser, &rawValue, &styleString)) {
+  std::string raw_value;
+  StyleString style_string;
+  if (!FlattenXmlSubtree(parser, &raw_value, &style_string)) {
     return {};
   }
 
-  if (!styleString.spans.empty()) {
+  if (!style_string.spans.empty()) {
     // This can only be a StyledString.
-    return util::make_unique<StyledString>(mTable->stringPool.makeRef(
-        styleString,
-        StringPool::Context(StringPool::Context::kStylePriority, mConfig)));
+    return util::make_unique<StyledString>(table_->string_pool.MakeRef(
+        style_string,
+        StringPool::Context(StringPool::Context::kStylePriority, config_)));
   }
 
-  auto onCreateReference = [&](const ResourceName& name) {
+  auto on_create_reference = [&](const ResourceName& name) {
     // name.package can be empty here, as it will assume the package name of the
     // table.
     std::unique_ptr<Id> id = util::make_unique<Id>();
-    id->setSource(mSource.withLine(beginXmlLine));
-    mTable->addResource(name, {}, {}, std::move(id), mDiag);
+    id->SetSource(source_.WithLine(begin_xml_line));
+    table_->AddResource(name, {}, {}, std::move(id), diag_);
   };
 
   // Process the raw value.
-  std::unique_ptr<Item> processedItem = ResourceUtils::tryParseItemForAttribute(
-      rawValue, typeMask, onCreateReference);
-  if (processedItem) {
+  std::unique_ptr<Item> processed_item =
+      ResourceUtils::TryParseItemForAttribute(raw_value, type_mask,
+                                              on_create_reference);
+  if (processed_item) {
     // Fix up the reference.
-    if (Reference* ref = valueCast<Reference>(processedItem.get())) {
-      transformReferenceFromNamespace(parser, "", ref);
+    if (Reference* ref = ValueCast<Reference>(processed_item.get())) {
+      TransformReferenceFromNamespace(parser, "", ref);
     }
-    return processedItem;
+    return processed_item;
   }
 
   // Try making a regular string.
-  if (typeMask & android::ResTable_map::TYPE_STRING) {
+  if (type_mask & android::ResTable_map::TYPE_STRING) {
     // Use the trimmed, escaped string.
-    return util::make_unique<String>(mTable->stringPool.makeRef(
-        styleString.str, StringPool::Context(mConfig)));
+    return util::make_unique<String>(table_->string_pool.MakeRef(
+        style_string.str, StringPool::Context(config_)));
   }
 
-  if (allowRawValue) {
+  if (allow_raw_value) {
     // We can't parse this so return a RawString if we are allowed.
     return util::make_unique<RawString>(
-        mTable->stringPool.makeRef(rawValue, StringPool::Context(mConfig)));
+        table_->string_pool.MakeRef(raw_value, StringPool::Context(config_)));
   }
   return {};
 }
 
-bool ResourceParser::parseString(xml::XmlPullParser* parser,
-                                 ParsedResource* outResource) {
+bool ResourceParser::ParseString(xml::XmlPullParser* parser,
+                                 ParsedResource* out_resource) {
   bool formatted = true;
-  if (Maybe<StringPiece> formattedAttr =
-          xml::findAttribute(parser, "formatted")) {
-    Maybe<bool> maybeFormatted =
-        ResourceUtils::parseBool(formattedAttr.value());
-    if (!maybeFormatted) {
-      mDiag->error(DiagMessage(outResource->source)
+  if (Maybe<StringPiece> formatted_attr =
+          xml::FindAttribute(parser, "formatted")) {
+    Maybe<bool> maybe_formatted =
+        ResourceUtils::ParseBool(formatted_attr.value());
+    if (!maybe_formatted) {
+      diag_->Error(DiagMessage(out_resource->source)
                    << "invalid value for 'formatted'. Must be a boolean");
       return false;
     }
-    formatted = maybeFormatted.value();
+    formatted = maybe_formatted.value();
   }
 
-  bool translateable = mOptions.translatable;
-  if (Maybe<StringPiece> translateableAttr =
-          xml::findAttribute(parser, "translatable")) {
-    Maybe<bool> maybeTranslateable =
-        ResourceUtils::parseBool(translateableAttr.value());
-    if (!maybeTranslateable) {
-      mDiag->error(DiagMessage(outResource->source)
+  bool translateable = options_.translatable;
+  if (Maybe<StringPiece> translateable_attr =
+          xml::FindAttribute(parser, "translatable")) {
+    Maybe<bool> maybe_translateable =
+        ResourceUtils::ParseBool(translateable_attr.value());
+    if (!maybe_translateable) {
+      diag_->Error(DiagMessage(out_resource->source)
                    << "invalid value for 'translatable'. Must be a boolean");
       return false;
     }
-    translateable = maybeTranslateable.value();
+    translateable = maybe_translateable.value();
   }
 
-  outResource->value =
-      parseXml(parser, android::ResTable_map::TYPE_STRING, kNoRawString);
-  if (!outResource->value) {
-    mDiag->error(DiagMessage(outResource->source) << "not a valid string");
+  out_resource->value =
+      ParseXml(parser, android::ResTable_map::TYPE_STRING, kNoRawString);
+  if (!out_resource->value) {
+    diag_->Error(DiagMessage(out_resource->source) << "not a valid string");
     return false;
   }
 
-  if (String* stringValue = valueCast<String>(outResource->value.get())) {
-    stringValue->setTranslateable(translateable);
+  if (String* string_value = ValueCast<String>(out_resource->value.get())) {
+    string_value->SetTranslateable(translateable);
 
     if (formatted && translateable) {
-      if (!util::verifyJavaStringFormat(*stringValue->value)) {
-        DiagMessage msg(outResource->source);
+      if (!util::VerifyJavaStringFormat(*string_value->value)) {
+        DiagMessage msg(out_resource->source);
         msg << "multiple substitutions specified in non-positional format; "
                "did you mean to add the formatted=\"false\" attribute?";
-        if (mOptions.errorOnPositionalArguments) {
-          mDiag->error(msg);
+        if (options_.error_on_positional_arguments) {
+          diag_->Error(msg);
           return false;
         }
 
-        mDiag->warn(msg);
+        diag_->Warn(msg);
       }
     }
 
-  } else if (StyledString* stringValue =
-                 valueCast<StyledString>(outResource->value.get())) {
-    stringValue->setTranslateable(translateable);
+  } else if (StyledString* string_value =
+                 ValueCast<StyledString>(out_resource->value.get())) {
+    string_value->SetTranslateable(translateable);
   }
   return true;
 }
 
-bool ResourceParser::parsePublic(xml::XmlPullParser* parser,
-                                 ParsedResource* outResource) {
-  Maybe<StringPiece> maybeType = xml::findNonEmptyAttribute(parser, "type");
-  if (!maybeType) {
-    mDiag->error(DiagMessage(outResource->source)
+bool ResourceParser::ParsePublic(xml::XmlPullParser* parser,
+                                 ParsedResource* out_resource) {
+  Maybe<StringPiece> maybe_type = xml::FindNonEmptyAttribute(parser, "type");
+  if (!maybe_type) {
+    diag_->Error(DiagMessage(out_resource->source)
                  << "<public> must have a 'type' attribute");
     return false;
   }
 
-  const ResourceType* parsedType = parseResourceType(maybeType.value());
-  if (!parsedType) {
-    mDiag->error(DiagMessage(outResource->source) << "invalid resource type '"
-                                                  << maybeType.value()
-                                                  << "' in <public>");
+  const ResourceType* parsed_type = ParseResourceType(maybe_type.value());
+  if (!parsed_type) {
+    diag_->Error(DiagMessage(out_resource->source) << "invalid resource type '"
+                                                   << maybe_type.value()
+                                                   << "' in <public>");
     return false;
   }
 
-  outResource->name.type = *parsedType;
+  out_resource->name.type = *parsed_type;
 
-  if (Maybe<StringPiece> maybeIdStr =
-          xml::findNonEmptyAttribute(parser, "id")) {
-    Maybe<ResourceId> maybeId =
-        ResourceUtils::parseResourceId(maybeIdStr.value());
-    if (!maybeId) {
-      mDiag->error(DiagMessage(outResource->source) << "invalid resource ID '"
-                                                    << maybeId.value()
-                                                    << "' in <public>");
+  if (Maybe<StringPiece> maybe_id_str =
+          xml::FindNonEmptyAttribute(parser, "id")) {
+    Maybe<ResourceId> maybe_id =
+        ResourceUtils::ParseResourceId(maybe_id_str.value());
+    if (!maybe_id) {
+      diag_->Error(DiagMessage(out_resource->source) << "invalid resource ID '"
+                                                     << maybe_id.value()
+                                                     << "' in <public>");
       return false;
     }
-    outResource->id = maybeId.value();
+    out_resource->id = maybe_id.value();
   }
 
-  if (*parsedType == ResourceType::kId) {
+  if (*parsed_type == ResourceType::kId) {
     // An ID marked as public is also the definition of an ID.
-    outResource->value = util::make_unique<Id>();
+    out_resource->value = util::make_unique<Id>();
   }
 
-  outResource->symbolState = SymbolState::kPublic;
+  out_resource->symbol_state = SymbolState::kPublic;
   return true;
 }
 
-bool ResourceParser::parsePublicGroup(xml::XmlPullParser* parser,
-                                      ParsedResource* outResource) {
-  Maybe<StringPiece> maybeType = xml::findNonEmptyAttribute(parser, "type");
-  if (!maybeType) {
-    mDiag->error(DiagMessage(outResource->source)
+bool ResourceParser::ParsePublicGroup(xml::XmlPullParser* parser,
+                                      ParsedResource* out_resource) {
+  Maybe<StringPiece> maybe_type = xml::FindNonEmptyAttribute(parser, "type");
+  if (!maybe_type) {
+    diag_->Error(DiagMessage(out_resource->source)
                  << "<public-group> must have a 'type' attribute");
     return false;
   }
 
-  const ResourceType* parsedType = parseResourceType(maybeType.value());
-  if (!parsedType) {
-    mDiag->error(DiagMessage(outResource->source) << "invalid resource type '"
-                                                  << maybeType.value()
-                                                  << "' in <public-group>");
+  const ResourceType* parsed_type = ParseResourceType(maybe_type.value());
+  if (!parsed_type) {
+    diag_->Error(DiagMessage(out_resource->source) << "invalid resource type '"
+                                                   << maybe_type.value()
+                                                   << "' in <public-group>");
     return false;
   }
 
-  Maybe<StringPiece> maybeIdStr =
-      xml::findNonEmptyAttribute(parser, "first-id");
-  if (!maybeIdStr) {
-    mDiag->error(DiagMessage(outResource->source)
+  Maybe<StringPiece> maybe_id_str =
+      xml::FindNonEmptyAttribute(parser, "first-id");
+  if (!maybe_id_str) {
+    diag_->Error(DiagMessage(out_resource->source)
                  << "<public-group> must have a 'first-id' attribute");
     return false;
   }
 
-  Maybe<ResourceId> maybeId =
-      ResourceUtils::parseResourceId(maybeIdStr.value());
-  if (!maybeId) {
-    mDiag->error(DiagMessage(outResource->source) << "invalid resource ID '"
-                                                  << maybeIdStr.value()
-                                                  << "' in <public-group>");
+  Maybe<ResourceId> maybe_id =
+      ResourceUtils::ParseResourceId(maybe_id_str.value());
+  if (!maybe_id) {
+    diag_->Error(DiagMessage(out_resource->source) << "invalid resource ID '"
+                                                   << maybe_id_str.value()
+                                                   << "' in <public-group>");
     return false;
   }
 
-  ResourceId nextId = maybeId.value();
+  ResourceId next_id = maybe_id.value();
 
   std::string comment;
   bool error = false;
-  const size_t depth = parser->getDepth();
-  while (xml::XmlPullParser::nextChildNode(parser, depth)) {
-    if (parser->getEvent() == xml::XmlPullParser::Event::kComment) {
-      comment = util::trimWhitespace(parser->getComment()).toString();
+  const size_t depth = parser->depth();
+  while (xml::XmlPullParser::NextChildNode(parser, depth)) {
+    if (parser->event() == xml::XmlPullParser::Event::kComment) {
+      comment = util::TrimWhitespace(parser->comment()).ToString();
       continue;
-    } else if (parser->getEvent() != xml::XmlPullParser::Event::kStartElement) {
+    } else if (parser->event() != xml::XmlPullParser::Event::kStartElement) {
       // Skip text.
       continue;
     }
 
-    const Source itemSource = mSource.withLine(parser->getLineNumber());
-    const std::string& elementNamespace = parser->getElementNamespace();
-    const std::string& elementName = parser->getElementName();
-    if (elementNamespace.empty() && elementName == "public") {
-      Maybe<StringPiece> maybeName = xml::findNonEmptyAttribute(parser, "name");
-      if (!maybeName) {
-        mDiag->error(DiagMessage(itemSource)
+    const Source item_source = source_.WithLine(parser->line_number());
+    const std::string& element_namespace = parser->element_namespace();
+    const std::string& element_name = parser->element_name();
+    if (element_namespace.empty() && element_name == "public") {
+      Maybe<StringPiece> maybe_name =
+          xml::FindNonEmptyAttribute(parser, "name");
+      if (!maybe_name) {
+        diag_->Error(DiagMessage(item_source)
                      << "<public> must have a 'name' attribute");
         error = true;
         continue;
       }
 
-      if (xml::findNonEmptyAttribute(parser, "id")) {
-        mDiag->error(DiagMessage(itemSource)
+      if (xml::FindNonEmptyAttribute(parser, "id")) {
+        diag_->Error(DiagMessage(item_source)
                      << "'id' is ignored within <public-group>");
         error = true;
         continue;
       }
 
-      if (xml::findNonEmptyAttribute(parser, "type")) {
-        mDiag->error(DiagMessage(itemSource)
+      if (xml::FindNonEmptyAttribute(parser, "type")) {
+        diag_->Error(DiagMessage(item_source)
                      << "'type' is ignored within <public-group>");
         error = true;
         continue;
       }
 
-      ParsedResource childResource;
-      childResource.name.type = *parsedType;
-      childResource.name.entry = maybeName.value().toString();
-      childResource.id = nextId;
-      childResource.comment = std::move(comment);
-      childResource.source = itemSource;
-      childResource.symbolState = SymbolState::kPublic;
-      outResource->childResources.push_back(std::move(childResource));
+      ParsedResource child_resource;
+      child_resource.name.type = *parsed_type;
+      child_resource.name.entry = maybe_name.value().ToString();
+      child_resource.id = next_id;
+      child_resource.comment = std::move(comment);
+      child_resource.source = item_source;
+      child_resource.symbol_state = SymbolState::kPublic;
+      out_resource->child_resources.push_back(std::move(child_resource));
 
-      nextId.id += 1;
+      next_id.id += 1;
 
-    } else if (!shouldIgnoreElement(elementNamespace, elementName)) {
-      mDiag->error(DiagMessage(itemSource) << ":" << elementName << ">");
+    } else if (!ShouldIgnoreElement(element_namespace, element_name)) {
+      diag_->Error(DiagMessage(item_source) << ":" << element_name << ">");
       error = true;
     }
   }
   return !error;
 }
 
-bool ResourceParser::parseSymbolImpl(xml::XmlPullParser* parser,
-                                     ParsedResource* outResource) {
-  Maybe<StringPiece> maybeType = xml::findNonEmptyAttribute(parser, "type");
-  if (!maybeType) {
-    mDiag->error(DiagMessage(outResource->source)
-                 << "<" << parser->getElementName()
+bool ResourceParser::ParseSymbolImpl(xml::XmlPullParser* parser,
+                                     ParsedResource* out_resource) {
+  Maybe<StringPiece> maybe_type = xml::FindNonEmptyAttribute(parser, "type");
+  if (!maybe_type) {
+    diag_->Error(DiagMessage(out_resource->source)
+                 << "<" << parser->element_name()
                  << "> must have a 'type' attribute");
     return false;
   }
 
-  const ResourceType* parsedType = parseResourceType(maybeType.value());
-  if (!parsedType) {
-    mDiag->error(DiagMessage(outResource->source)
-                 << "invalid resource type '" << maybeType.value() << "' in <"
-                 << parser->getElementName() << ">");
+  const ResourceType* parsed_type = ParseResourceType(maybe_type.value());
+  if (!parsed_type) {
+    diag_->Error(DiagMessage(out_resource->source)
+                 << "invalid resource type '" << maybe_type.value() << "' in <"
+                 << parser->element_name() << ">");
     return false;
   }
 
-  outResource->name.type = *parsedType;
+  out_resource->name.type = *parsed_type;
   return true;
 }
 
-bool ResourceParser::parseSymbol(xml::XmlPullParser* parser,
-                                 ParsedResource* outResource) {
-  if (parseSymbolImpl(parser, outResource)) {
-    outResource->symbolState = SymbolState::kPrivate;
+bool ResourceParser::ParseSymbol(xml::XmlPullParser* parser,
+                                 ParsedResource* out_resource) {
+  if (ParseSymbolImpl(parser, out_resource)) {
+    out_resource->symbol_state = SymbolState::kPrivate;
     return true;
   }
   return false;
 }
 
-bool ResourceParser::parseAddResource(xml::XmlPullParser* parser,
-                                      ParsedResource* outResource) {
-  if (parseSymbolImpl(parser, outResource)) {
-    outResource->symbolState = SymbolState::kUndefined;
+bool ResourceParser::ParseAddResource(xml::XmlPullParser* parser,
+                                      ParsedResource* out_resource) {
+  if (ParseSymbolImpl(parser, out_resource)) {
+    out_resource->symbol_state = SymbolState::kUndefined;
     return true;
   }
   return false;
 }
 
-bool ResourceParser::parseAttr(xml::XmlPullParser* parser,
-                               ParsedResource* outResource) {
-  return parseAttrImpl(parser, outResource, false);
+bool ResourceParser::ParseAttr(xml::XmlPullParser* parser,
+                               ParsedResource* out_resource) {
+  return ParseAttrImpl(parser, out_resource, false);
 }
 
-bool ResourceParser::parseAttrImpl(xml::XmlPullParser* parser,
-                                   ParsedResource* outResource, bool weak) {
-  outResource->name.type = ResourceType::kAttr;
+bool ResourceParser::ParseAttrImpl(xml::XmlPullParser* parser,
+                                   ParsedResource* out_resource, bool weak) {
+  out_resource->name.type = ResourceType::kAttr;
 
   // Attributes only end up in default configuration.
-  if (outResource->config != ConfigDescription::defaultConfig()) {
-    mDiag->warn(DiagMessage(outResource->source)
-                << "ignoring configuration '" << outResource->config
-                << "' for attribute " << outResource->name);
-    outResource->config = ConfigDescription::defaultConfig();
+  if (out_resource->config != ConfigDescription::DefaultConfig()) {
+    diag_->Warn(DiagMessage(out_resource->source)
+                << "ignoring configuration '" << out_resource->config
+                << "' for attribute " << out_resource->name);
+    out_resource->config = ConfigDescription::DefaultConfig();
   }
 
-  uint32_t typeMask = 0;
+  uint32_t type_mask = 0;
 
-  Maybe<StringPiece> maybeFormat = xml::findAttribute(parser, "format");
-  if (maybeFormat) {
-    typeMask = parseFormatAttribute(maybeFormat.value());
-    if (typeMask == 0) {
-      mDiag->error(DiagMessage(mSource.withLine(parser->getLineNumber()))
-                   << "invalid attribute format '" << maybeFormat.value()
+  Maybe<StringPiece> maybe_format = xml::FindAttribute(parser, "format");
+  if (maybe_format) {
+    type_mask = ParseFormatAttribute(maybe_format.value());
+    if (type_mask == 0) {
+      diag_->Error(DiagMessage(source_.WithLine(parser->line_number()))
+                   << "invalid attribute format '" << maybe_format.value()
                    << "'");
       return false;
     }
   }
 
-  Maybe<int32_t> maybeMin, maybeMax;
+  Maybe<int32_t> maybe_min, maybe_max;
 
-  if (Maybe<StringPiece> maybeMinStr = xml::findAttribute(parser, "min")) {
-    StringPiece minStr = util::trimWhitespace(maybeMinStr.value());
-    if (!minStr.empty()) {
-      std::u16string minStr16 = util::utf8ToUtf16(minStr);
+  if (Maybe<StringPiece> maybe_min_str = xml::FindAttribute(parser, "min")) {
+    StringPiece min_str = util::TrimWhitespace(maybe_min_str.value());
+    if (!min_str.empty()) {
+      std::u16string min_str16 = util::Utf8ToUtf16(min_str);
       android::Res_value value;
-      if (android::ResTable::stringToInt(minStr16.data(), minStr16.size(),
+      if (android::ResTable::stringToInt(min_str16.data(), min_str16.size(),
                                          &value)) {
-        maybeMin = static_cast<int32_t>(value.data);
+        maybe_min = static_cast<int32_t>(value.data);
       }
     }
 
-    if (!maybeMin) {
-      mDiag->error(DiagMessage(mSource.withLine(parser->getLineNumber()))
-                   << "invalid 'min' value '" << minStr << "'");
+    if (!maybe_min) {
+      diag_->Error(DiagMessage(source_.WithLine(parser->line_number()))
+                   << "invalid 'min' value '" << min_str << "'");
       return false;
     }
   }
 
-  if (Maybe<StringPiece> maybeMaxStr = xml::findAttribute(parser, "max")) {
-    StringPiece maxStr = util::trimWhitespace(maybeMaxStr.value());
-    if (!maxStr.empty()) {
-      std::u16string maxStr16 = util::utf8ToUtf16(maxStr);
+  if (Maybe<StringPiece> maybe_max_str = xml::FindAttribute(parser, "max")) {
+    StringPiece max_str = util::TrimWhitespace(maybe_max_str.value());
+    if (!max_str.empty()) {
+      std::u16string max_str16 = util::Utf8ToUtf16(max_str);
       android::Res_value value;
-      if (android::ResTable::stringToInt(maxStr16.data(), maxStr16.size(),
+      if (android::ResTable::stringToInt(max_str16.data(), max_str16.size(),
                                          &value)) {
-        maybeMax = static_cast<int32_t>(value.data);
+        maybe_max = static_cast<int32_t>(value.data);
       }
     }
 
-    if (!maybeMax) {
-      mDiag->error(DiagMessage(mSource.withLine(parser->getLineNumber()))
-                   << "invalid 'max' value '" << maxStr << "'");
+    if (!maybe_max) {
+      diag_->Error(DiagMessage(source_.WithLine(parser->line_number()))
+                   << "invalid 'max' value '" << max_str << "'");
       return false;
     }
   }
 
-  if ((maybeMin || maybeMax) &&
-      (typeMask & android::ResTable_map::TYPE_INTEGER) == 0) {
-    mDiag->error(DiagMessage(mSource.withLine(parser->getLineNumber()))
+  if ((maybe_min || maybe_max) &&
+      (type_mask & android::ResTable_map::TYPE_INTEGER) == 0) {
+    diag_->Error(DiagMessage(source_.WithLine(parser->line_number()))
                  << "'min' and 'max' can only be used when format='integer'");
     return false;
   }
@@ -889,68 +896,68 @@ bool ResourceParser::parseAttrImpl(xml::XmlPullParser* parser,
 
   std::string comment;
   bool error = false;
-  const size_t depth = parser->getDepth();
-  while (xml::XmlPullParser::nextChildNode(parser, depth)) {
-    if (parser->getEvent() == xml::XmlPullParser::Event::kComment) {
-      comment = util::trimWhitespace(parser->getComment()).toString();
+  const size_t depth = parser->depth();
+  while (xml::XmlPullParser::NextChildNode(parser, depth)) {
+    if (parser->event() == xml::XmlPullParser::Event::kComment) {
+      comment = util::TrimWhitespace(parser->comment()).ToString();
       continue;
-    } else if (parser->getEvent() != xml::XmlPullParser::Event::kStartElement) {
+    } else if (parser->event() != xml::XmlPullParser::Event::kStartElement) {
       // Skip text.
       continue;
     }
 
-    const Source itemSource = mSource.withLine(parser->getLineNumber());
-    const std::string& elementNamespace = parser->getElementNamespace();
-    const std::string& elementName = parser->getElementName();
-    if (elementNamespace.empty() &&
-        (elementName == "flag" || elementName == "enum")) {
-      if (elementName == "enum") {
-        if (typeMask & android::ResTable_map::TYPE_FLAGS) {
-          mDiag->error(DiagMessage(itemSource)
+    const Source item_source = source_.WithLine(parser->line_number());
+    const std::string& element_namespace = parser->element_namespace();
+    const std::string& element_name = parser->element_name();
+    if (element_namespace.empty() &&
+        (element_name == "flag" || element_name == "enum")) {
+      if (element_name == "enum") {
+        if (type_mask & android::ResTable_map::TYPE_FLAGS) {
+          diag_->Error(DiagMessage(item_source)
                        << "can not define an <enum>; already defined a <flag>");
           error = true;
           continue;
         }
-        typeMask |= android::ResTable_map::TYPE_ENUM;
+        type_mask |= android::ResTable_map::TYPE_ENUM;
 
-      } else if (elementName == "flag") {
-        if (typeMask & android::ResTable_map::TYPE_ENUM) {
-          mDiag->error(DiagMessage(itemSource)
+      } else if (element_name == "flag") {
+        if (type_mask & android::ResTable_map::TYPE_ENUM) {
+          diag_->Error(DiagMessage(item_source)
                        << "can not define a <flag>; already defined an <enum>");
           error = true;
           continue;
         }
-        typeMask |= android::ResTable_map::TYPE_FLAGS;
+        type_mask |= android::ResTable_map::TYPE_FLAGS;
       }
 
       if (Maybe<Attribute::Symbol> s =
-              parseEnumOrFlagItem(parser, elementName)) {
+              ParseEnumOrFlagItem(parser, element_name)) {
         Attribute::Symbol& symbol = s.value();
-        ParsedResource childResource;
-        childResource.name = symbol.symbol.name.value();
-        childResource.source = itemSource;
-        childResource.value = util::make_unique<Id>();
-        outResource->childResources.push_back(std::move(childResource));
+        ParsedResource child_resource;
+        child_resource.name = symbol.symbol.name.value();
+        child_resource.source = item_source;
+        child_resource.value = util::make_unique<Id>();
+        out_resource->child_resources.push_back(std::move(child_resource));
 
-        symbol.symbol.setComment(std::move(comment));
-        symbol.symbol.setSource(itemSource);
+        symbol.symbol.SetComment(std::move(comment));
+        symbol.symbol.SetSource(item_source);
 
-        auto insertResult = items.insert(std::move(symbol));
-        if (!insertResult.second) {
-          const Attribute::Symbol& existingSymbol = *insertResult.first;
-          mDiag->error(DiagMessage(itemSource)
+        auto insert_result = items.insert(std::move(symbol));
+        if (!insert_result.second) {
+          const Attribute::Symbol& existing_symbol = *insert_result.first;
+          diag_->Error(DiagMessage(item_source)
                        << "duplicate symbol '"
-                       << existingSymbol.symbol.name.value().entry << "'");
+                       << existing_symbol.symbol.name.value().entry << "'");
 
-          mDiag->note(DiagMessage(existingSymbol.symbol.getSource())
+          diag_->Note(DiagMessage(existing_symbol.symbol.GetSource())
                       << "first defined here");
           error = true;
         }
       } else {
         error = true;
       }
-    } else if (!shouldIgnoreElement(elementNamespace, elementName)) {
-      mDiag->error(DiagMessage(itemSource) << ":" << elementName << ">");
+    } else if (!ShouldIgnoreElement(element_namespace, element_name)) {
+      diag_->Error(DiagMessage(item_source) << ":" << element_name << ">");
       error = true;
     }
 
@@ -963,134 +970,134 @@ bool ResourceParser::parseAttrImpl(xml::XmlPullParser* parser,
 
   std::unique_ptr<Attribute> attr = util::make_unique<Attribute>(weak);
   attr->symbols = std::vector<Attribute::Symbol>(items.begin(), items.end());
-  attr->typeMask =
-      typeMask ? typeMask : uint32_t(android::ResTable_map::TYPE_ANY);
-  if (maybeMin) {
-    attr->minInt = maybeMin.value();
+  attr->type_mask =
+      type_mask ? type_mask : uint32_t(android::ResTable_map::TYPE_ANY);
+  if (maybe_min) {
+    attr->min_int = maybe_min.value();
   }
 
-  if (maybeMax) {
-    attr->maxInt = maybeMax.value();
+  if (maybe_max) {
+    attr->max_int = maybe_max.value();
   }
-  outResource->value = std::move(attr);
+  out_resource->value = std::move(attr);
   return true;
 }
 
-Maybe<Attribute::Symbol> ResourceParser::parseEnumOrFlagItem(
+Maybe<Attribute::Symbol> ResourceParser::ParseEnumOrFlagItem(
     xml::XmlPullParser* parser, const StringPiece& tag) {
-  const Source source = mSource.withLine(parser->getLineNumber());
+  const Source source = source_.WithLine(parser->line_number());
 
-  Maybe<StringPiece> maybeName = xml::findNonEmptyAttribute(parser, "name");
-  if (!maybeName) {
-    mDiag->error(DiagMessage(source) << "no attribute 'name' found for tag <"
+  Maybe<StringPiece> maybe_name = xml::FindNonEmptyAttribute(parser, "name");
+  if (!maybe_name) {
+    diag_->Error(DiagMessage(source) << "no attribute 'name' found for tag <"
                                      << tag << ">");
     return {};
   }
 
-  Maybe<StringPiece> maybeValue = xml::findNonEmptyAttribute(parser, "value");
-  if (!maybeValue) {
-    mDiag->error(DiagMessage(source) << "no attribute 'value' found for tag <"
+  Maybe<StringPiece> maybe_value = xml::FindNonEmptyAttribute(parser, "value");
+  if (!maybe_value) {
+    diag_->Error(DiagMessage(source) << "no attribute 'value' found for tag <"
                                      << tag << ">");
     return {};
   }
 
-  std::u16string value16 = util::utf8ToUtf16(maybeValue.value());
+  std::u16string value16 = util::Utf8ToUtf16(maybe_value.value());
   android::Res_value val;
   if (!android::ResTable::stringToInt(value16.data(), value16.size(), &val)) {
-    mDiag->error(DiagMessage(source) << "invalid value '" << maybeValue.value()
+    diag_->Error(DiagMessage(source) << "invalid value '" << maybe_value.value()
                                      << "' for <" << tag
                                      << ">; must be an integer");
     return {};
   }
 
   return Attribute::Symbol{
-      Reference(ResourceNameRef({}, ResourceType::kId, maybeName.value())),
+      Reference(ResourceNameRef({}, ResourceType::kId, maybe_name.value())),
       val.data};
 }
 
-bool ResourceParser::parseStyleItem(xml::XmlPullParser* parser, Style* style) {
-  const Source source = mSource.withLine(parser->getLineNumber());
+bool ResourceParser::ParseStyleItem(xml::XmlPullParser* parser, Style* style) {
+  const Source source = source_.WithLine(parser->line_number());
 
-  Maybe<StringPiece> maybeName = xml::findNonEmptyAttribute(parser, "name");
-  if (!maybeName) {
-    mDiag->error(DiagMessage(source) << "<item> must have a 'name' attribute");
+  Maybe<StringPiece> maybe_name = xml::FindNonEmptyAttribute(parser, "name");
+  if (!maybe_name) {
+    diag_->Error(DiagMessage(source) << "<item> must have a 'name' attribute");
     return false;
   }
 
-  Maybe<Reference> maybeKey =
-      ResourceUtils::parseXmlAttributeName(maybeName.value());
-  if (!maybeKey) {
-    mDiag->error(DiagMessage(source) << "invalid attribute name '"
-                                     << maybeName.value() << "'");
+  Maybe<Reference> maybe_key =
+      ResourceUtils::ParseXmlAttributeName(maybe_name.value());
+  if (!maybe_key) {
+    diag_->Error(DiagMessage(source) << "invalid attribute name '"
+                                     << maybe_name.value() << "'");
     return false;
   }
 
-  transformReferenceFromNamespace(parser, "", &maybeKey.value());
-  maybeKey.value().setSource(source);
+  TransformReferenceFromNamespace(parser, "", &maybe_key.value());
+  maybe_key.value().SetSource(source);
 
-  std::unique_ptr<Item> value = parseXml(parser, 0, kAllowRawString);
+  std::unique_ptr<Item> value = ParseXml(parser, 0, kAllowRawString);
   if (!value) {
-    mDiag->error(DiagMessage(source) << "could not parse style item");
+    diag_->Error(DiagMessage(source) << "could not parse style item");
     return false;
   }
 
   style->entries.push_back(
-      Style::Entry{std::move(maybeKey.value()), std::move(value)});
+      Style::Entry{std::move(maybe_key.value()), std::move(value)});
   return true;
 }
 
-bool ResourceParser::parseStyle(xml::XmlPullParser* parser,
-                                ParsedResource* outResource) {
-  outResource->name.type = ResourceType::kStyle;
+bool ResourceParser::ParseStyle(xml::XmlPullParser* parser,
+                                ParsedResource* out_resource) {
+  out_resource->name.type = ResourceType::kStyle;
 
   std::unique_ptr<Style> style = util::make_unique<Style>();
 
-  Maybe<StringPiece> maybeParent = xml::findAttribute(parser, "parent");
-  if (maybeParent) {
+  Maybe<StringPiece> maybe_parent = xml::FindAttribute(parser, "parent");
+  if (maybe_parent) {
     // If the parent is empty, we don't have a parent, but we also don't infer
     // either.
-    if (!maybeParent.value().empty()) {
-      std::string errStr;
-      style->parent = ResourceUtils::parseStyleParentReference(
-          maybeParent.value(), &errStr);
+    if (!maybe_parent.value().empty()) {
+      std::string err_str;
+      style->parent = ResourceUtils::ParseStyleParentReference(
+          maybe_parent.value(), &err_str);
       if (!style->parent) {
-        mDiag->error(DiagMessage(outResource->source) << errStr);
+        diag_->Error(DiagMessage(out_resource->source) << err_str);
         return false;
       }
 
       // Transform the namespace prefix to the actual package name, and mark the
       // reference as
       // private if appropriate.
-      transformReferenceFromNamespace(parser, "", &style->parent.value());
+      TransformReferenceFromNamespace(parser, "", &style->parent.value());
     }
 
   } else {
     // No parent was specified, so try inferring it from the style name.
-    std::string styleName = outResource->name.entry;
-    size_t pos = styleName.find_last_of(u'.');
+    std::string style_name = out_resource->name.entry;
+    size_t pos = style_name.find_last_of(u'.');
     if (pos != std::string::npos) {
-      style->parentInferred = true;
+      style->parent_inferred = true;
       style->parent = Reference(
-          ResourceName({}, ResourceType::kStyle, styleName.substr(0, pos)));
+          ResourceName({}, ResourceType::kStyle, style_name.substr(0, pos)));
     }
   }
 
   bool error = false;
-  const size_t depth = parser->getDepth();
-  while (xml::XmlPullParser::nextChildNode(parser, depth)) {
-    if (parser->getEvent() != xml::XmlPullParser::Event::kStartElement) {
+  const size_t depth = parser->depth();
+  while (xml::XmlPullParser::NextChildNode(parser, depth)) {
+    if (parser->event() != xml::XmlPullParser::Event::kStartElement) {
       // Skip text and comments.
       continue;
     }
 
-    const std::string& elementNamespace = parser->getElementNamespace();
-    const std::string& elementName = parser->getElementName();
-    if (elementNamespace == "" && elementName == "item") {
-      error |= !parseStyleItem(parser, style.get());
+    const std::string& element_namespace = parser->element_namespace();
+    const std::string& element_name = parser->element_name();
+    if (element_namespace == "" && element_name == "item") {
+      error |= !ParseStyleItem(parser, style.get());
 
-    } else if (!shouldIgnoreElement(elementNamespace, elementName)) {
-      mDiag->error(DiagMessage(mSource.withLine(parser->getLineNumber()))
-                   << ":" << elementName << ">");
+    } else if (!ShouldIgnoreElement(element_namespace, element_name)) {
+      diag_->Error(DiagMessage(source_.WithLine(parser->line_number()))
+                   << ":" << element_name << ">");
       error = true;
     }
   }
@@ -1099,73 +1106,73 @@ bool ResourceParser::parseStyle(xml::XmlPullParser* parser,
     return false;
   }
 
-  outResource->value = std::move(style);
+  out_resource->value = std::move(style);
   return true;
 }
 
-bool ResourceParser::parseArray(xml::XmlPullParser* parser,
-                                ParsedResource* outResource) {
-  return parseArrayImpl(parser, outResource, android::ResTable_map::TYPE_ANY);
+bool ResourceParser::ParseArray(xml::XmlPullParser* parser,
+                                ParsedResource* out_resource) {
+  return ParseArrayImpl(parser, out_resource, android::ResTable_map::TYPE_ANY);
 }
 
-bool ResourceParser::parseIntegerArray(xml::XmlPullParser* parser,
-                                       ParsedResource* outResource) {
-  return parseArrayImpl(parser, outResource,
+bool ResourceParser::ParseIntegerArray(xml::XmlPullParser* parser,
+                                       ParsedResource* out_resource) {
+  return ParseArrayImpl(parser, out_resource,
                         android::ResTable_map::TYPE_INTEGER);
 }
 
-bool ResourceParser::parseStringArray(xml::XmlPullParser* parser,
-                                      ParsedResource* outResource) {
-  return parseArrayImpl(parser, outResource,
+bool ResourceParser::ParseStringArray(xml::XmlPullParser* parser,
+                                      ParsedResource* out_resource) {
+  return ParseArrayImpl(parser, out_resource,
                         android::ResTable_map::TYPE_STRING);
 }
 
-bool ResourceParser::parseArrayImpl(xml::XmlPullParser* parser,
-                                    ParsedResource* outResource,
+bool ResourceParser::ParseArrayImpl(xml::XmlPullParser* parser,
+                                    ParsedResource* out_resource,
                                     const uint32_t typeMask) {
-  outResource->name.type = ResourceType::kArray;
+  out_resource->name.type = ResourceType::kArray;
 
   std::unique_ptr<Array> array = util::make_unique<Array>();
 
-  bool translateable = mOptions.translatable;
-  if (Maybe<StringPiece> translateableAttr =
-          xml::findAttribute(parser, "translatable")) {
-    Maybe<bool> maybeTranslateable =
-        ResourceUtils::parseBool(translateableAttr.value());
-    if (!maybeTranslateable) {
-      mDiag->error(DiagMessage(outResource->source)
+  bool translateable = options_.translatable;
+  if (Maybe<StringPiece> translateable_attr =
+          xml::FindAttribute(parser, "translatable")) {
+    Maybe<bool> maybe_translateable =
+        ResourceUtils::ParseBool(translateable_attr.value());
+    if (!maybe_translateable) {
+      diag_->Error(DiagMessage(out_resource->source)
                    << "invalid value for 'translatable'. Must be a boolean");
       return false;
     }
-    translateable = maybeTranslateable.value();
+    translateable = maybe_translateable.value();
   }
-  array->setTranslateable(translateable);
+  array->SetTranslateable(translateable);
 
   bool error = false;
-  const size_t depth = parser->getDepth();
-  while (xml::XmlPullParser::nextChildNode(parser, depth)) {
-    if (parser->getEvent() != xml::XmlPullParser::Event::kStartElement) {
+  const size_t depth = parser->depth();
+  while (xml::XmlPullParser::NextChildNode(parser, depth)) {
+    if (parser->event() != xml::XmlPullParser::Event::kStartElement) {
       // Skip text and comments.
       continue;
     }
 
-    const Source itemSource = mSource.withLine(parser->getLineNumber());
-    const std::string& elementNamespace = parser->getElementNamespace();
-    const std::string& elementName = parser->getElementName();
-    if (elementNamespace.empty() && elementName == "item") {
-      std::unique_ptr<Item> item = parseXml(parser, typeMask, kNoRawString);
+    const Source item_source = source_.WithLine(parser->line_number());
+    const std::string& element_namespace = parser->element_namespace();
+    const std::string& element_name = parser->element_name();
+    if (element_namespace.empty() && element_name == "item") {
+      std::unique_ptr<Item> item = ParseXml(parser, typeMask, kNoRawString);
       if (!item) {
-        mDiag->error(DiagMessage(itemSource) << "could not parse array item");
+        diag_->Error(DiagMessage(item_source) << "could not parse array item");
         error = true;
         continue;
       }
-      item->setSource(itemSource);
+      item->SetSource(item_source);
       array->items.emplace_back(std::move(item));
 
-    } else if (!shouldIgnoreElement(elementNamespace, elementName)) {
-      mDiag->error(DiagMessage(mSource.withLine(parser->getLineNumber()))
-                   << "unknown tag <" << elementNamespace << ":" << elementName
-                   << ">");
+    } else if (!ShouldIgnoreElement(element_namespace, element_name)) {
+      diag_->Error(DiagMessage(source_.WithLine(parser->line_number()))
+                   << "unknown tag <" << element_namespace << ":"
+                   << element_name << ">");
       error = true;
     }
   }
@@ -1174,77 +1181,78 @@ bool ResourceParser::parseArrayImpl(xml::XmlPullParser* parser,
     return false;
   }
 
-  outResource->value = std::move(array);
+  out_resource->value = std::move(array);
   return true;
 }
 
-bool ResourceParser::parsePlural(xml::XmlPullParser* parser,
-                                 ParsedResource* outResource) {
-  outResource->name.type = ResourceType::kPlurals;
+bool ResourceParser::ParsePlural(xml::XmlPullParser* parser,
+                                 ParsedResource* out_resource) {
+  out_resource->name.type = ResourceType::kPlurals;
 
   std::unique_ptr<Plural> plural = util::make_unique<Plural>();
 
   bool error = false;
-  const size_t depth = parser->getDepth();
-  while (xml::XmlPullParser::nextChildNode(parser, depth)) {
-    if (parser->getEvent() != xml::XmlPullParser::Event::kStartElement) {
+  const size_t depth = parser->depth();
+  while (xml::XmlPullParser::NextChildNode(parser, depth)) {
+    if (parser->event() != xml::XmlPullParser::Event::kStartElement) {
       // Skip text and comments.
       continue;
     }
 
-    const Source itemSource = mSource.withLine(parser->getLineNumber());
-    const std::string& elementNamespace = parser->getElementNamespace();
-    const std::string& elementName = parser->getElementName();
-    if (elementNamespace.empty() && elementName == "item") {
-      Maybe<StringPiece> maybeQuantity =
-          xml::findNonEmptyAttribute(parser, "quantity");
-      if (!maybeQuantity) {
-        mDiag->error(DiagMessage(itemSource)
+    const Source item_source = source_.WithLine(parser->line_number());
+    const std::string& element_namespace = parser->element_namespace();
+    const std::string& element_name = parser->element_name();
+    if (element_namespace.empty() && element_name == "item") {
+      Maybe<StringPiece> maybe_quantity =
+          xml::FindNonEmptyAttribute(parser, "quantity");
+      if (!maybe_quantity) {
+        diag_->Error(DiagMessage(item_source)
                      << "<item> in <plurals> requires attribute "
                      << "'quantity'");
         error = true;
         continue;
       }
 
-      StringPiece trimmedQuantity = util::trimWhitespace(maybeQuantity.value());
+      StringPiece trimmed_quantity =
+          util::TrimWhitespace(maybe_quantity.value());
       size_t index = 0;
-      if (trimmedQuantity == "zero") {
+      if (trimmed_quantity == "zero") {
         index = Plural::Zero;
-      } else if (trimmedQuantity == "one") {
+      } else if (trimmed_quantity == "one") {
         index = Plural::One;
-      } else if (trimmedQuantity == "two") {
+      } else if (trimmed_quantity == "two") {
         index = Plural::Two;
-      } else if (trimmedQuantity == "few") {
+      } else if (trimmed_quantity == "few") {
         index = Plural::Few;
-      } else if (trimmedQuantity == "many") {
+      } else if (trimmed_quantity == "many") {
         index = Plural::Many;
-      } else if (trimmedQuantity == "other") {
+      } else if (trimmed_quantity == "other") {
         index = Plural::Other;
       } else {
-        mDiag->error(DiagMessage(itemSource)
+        diag_->Error(DiagMessage(item_source)
                      << "<item> in <plural> has invalid value '"
-                     << trimmedQuantity << "' for attribute 'quantity'");
+                     << trimmed_quantity << "' for attribute 'quantity'");
         error = true;
         continue;
       }
 
       if (plural->values[index]) {
-        mDiag->error(DiagMessage(itemSource) << "duplicate quantity '"
-                                             << trimmedQuantity << "'");
+        diag_->Error(DiagMessage(item_source) << "duplicate quantity '"
+                                              << trimmed_quantity << "'");
         error = true;
         continue;
       }
 
-      if (!(plural->values[index] = parseXml(
+      if (!(plural->values[index] = ParseXml(
                 parser, android::ResTable_map::TYPE_STRING, kNoRawString))) {
         error = true;
       }
-      plural->values[index]->setSource(itemSource);
+      plural->values[index]->SetSource(item_source);
 
-    } else if (!shouldIgnoreElement(elementNamespace, elementName)) {
-      mDiag->error(DiagMessage(itemSource)
-                   << "unknown tag <" << elementNamespace << ":" << elementName
-                   << ">");
+    } else if (!ShouldIgnoreElement(element_namespace, element_name)) {
+      diag_->Error(DiagMessage(item_source) << "unknown tag <"
+                                            << element_namespace << ":"
+                                            << element_name << ">");
       error = true;
     }
   }
@@ -1253,47 +1261,48 @@ bool ResourceParser::parsePlural(xml::XmlPullParser* parser,
     return false;
   }
 
-  outResource->value = std::move(plural);
+  out_resource->value = std::move(plural);
   return true;
 }
 
-bool ResourceParser::parseDeclareStyleable(xml::XmlPullParser* parser,
-                                           ParsedResource* outResource) {
-  outResource->name.type = ResourceType::kStyleable;
+bool ResourceParser::ParseDeclareStyleable(xml::XmlPullParser* parser,
+                                           ParsedResource* out_resource) {
+  out_resource->name.type = ResourceType::kStyleable;
 
   // Declare-styleable is kPrivate by default, because it technically only
   // exists in R.java.
-  outResource->symbolState = SymbolState::kPublic;
+  out_resource->symbol_state = SymbolState::kPublic;
 
   // Declare-styleable only ends up in default config;
-  if (outResource->config != ConfigDescription::defaultConfig()) {
-    mDiag->warn(DiagMessage(outResource->source)
-                << "ignoring configuration '" << outResource->config
-                << "' for styleable " << outResource->name.entry);
-    outResource->config = ConfigDescription::defaultConfig();
+  if (out_resource->config != ConfigDescription::DefaultConfig()) {
+    diag_->Warn(DiagMessage(out_resource->source)
+                << "ignoring configuration '" << out_resource->config
+                << "' for styleable " << out_resource->name.entry);
+    out_resource->config = ConfigDescription::DefaultConfig();
   }
 
   std::unique_ptr<Styleable> styleable = util::make_unique<Styleable>();
 
   std::string comment;
   bool error = false;
-  const size_t depth = parser->getDepth();
-  while (xml::XmlPullParser::nextChildNode(parser, depth)) {
-    if (parser->getEvent() == xml::XmlPullParser::Event::kComment) {
-      comment = util::trimWhitespace(parser->getComment()).toString();
+  const size_t depth = parser->depth();
+  while (xml::XmlPullParser::NextChildNode(parser, depth)) {
+    if (parser->event() == xml::XmlPullParser::Event::kComment) {
+      comment = util::TrimWhitespace(parser->comment()).ToString();
       continue;
-    } else if (parser->getEvent() != xml::XmlPullParser::Event::kStartElement) {
+    } else if (parser->event() != xml::XmlPullParser::Event::kStartElement) {
       // Ignore text.
       continue;
     }
 
-    const Source itemSource = mSource.withLine(parser->getLineNumber());
-    const std::string& elementNamespace = parser->getElementNamespace();
-    const std::string& elementName = parser->getElementName();
-    if (elementNamespace.empty() && elementName == "attr") {
-      Maybe<StringPiece> maybeName = xml::findNonEmptyAttribute(parser, "name");
-      if (!maybeName) {
-        mDiag->error(DiagMessage(itemSource)
+    const Source item_source = source_.WithLine(parser->line_number());
+    const std::string& element_namespace = parser->element_namespace();
+    const std::string& element_name = parser->element_name();
+    if (element_namespace.empty() && element_name == "attr") {
+      Maybe<StringPiece> maybe_name =
+          xml::FindNonEmptyAttribute(parser, "name");
+      if (!maybe_name) {
+        diag_->Error(DiagMessage(item_source)
                      << "<attr> tag must have a 'name' attribute");
         error = true;
         continue;
@@ -1302,40 +1311,40 @@ bool ResourceParser::parseDeclareStyleable(xml::XmlPullParser* parser,
       // If this is a declaration, the package name may be in the name. Separate
       // these out.
       // Eg. <attr name="android:text" />
-      Maybe<Reference> maybeRef =
-          ResourceUtils::parseXmlAttributeName(maybeName.value());
-      if (!maybeRef) {
-        mDiag->error(DiagMessage(itemSource) << "<attr> tag has invalid name '"
-                                             << maybeName.value() << "'");
+      Maybe<Reference> maybe_ref =
+          ResourceUtils::ParseXmlAttributeName(maybe_name.value());
+      if (!maybe_ref) {
+        diag_->Error(DiagMessage(item_source) << "<attr> tag has invalid name '"
+                                              << maybe_name.value() << "'");
         error = true;
         continue;
       }
 
-      Reference& childRef = maybeRef.value();
-      xml::transformReferenceFromNamespace(parser, "", &childRef);
+      Reference& child_ref = maybe_ref.value();
+      xml::TransformReferenceFromNamespace(parser, "", &child_ref);
 
       // Create the ParsedResource that will add the attribute to the table.
-      ParsedResource childResource;
-      childResource.name = childRef.name.value();
-      childResource.source = itemSource;
-      childResource.comment = std::move(comment);
+      ParsedResource child_resource;
+      child_resource.name = child_ref.name.value();
+      child_resource.source = item_source;
+      child_resource.comment = std::move(comment);
 
-      if (!parseAttrImpl(parser, &childResource, true)) {
+      if (!ParseAttrImpl(parser, &child_resource, true)) {
         error = true;
         continue;
       }
 
       // Create the reference to this attribute.
-      childRef.setComment(childResource.comment);
-      childRef.setSource(itemSource);
-      styleable->entries.push_back(std::move(childRef));
+      child_ref.SetComment(child_resource.comment);
+      child_ref.SetSource(item_source);
+      styleable->entries.push_back(std::move(child_ref));
 
-      outResource->childResources.push_back(std::move(childResource));
+      out_resource->child_resources.push_back(std::move(child_resource));
 
-    } else if (!shouldIgnoreElement(elementNamespace, elementName)) {
-      mDiag->error(DiagMessage(itemSource)
-                   << "unknown tag <" << elementNamespace << ":" << elementName
-                   << ">");
+    } else if (!ShouldIgnoreElement(element_namespace, element_name)) {
+      diag_->Error(DiagMessage(item_source) << "unknown tag <"
+                                            << element_namespace << ":"
+                                            << element_name << ">");
       error = true;
     }
 
@@ -1346,7 +1355,7 @@ bool ResourceParser::parseDeclareStyleable(xml::XmlPullParser* parser,
     return false;
   }
 
-  outResource->value = std::move(styleable);
+  out_resource->value = std::move(styleable);
   return true;
 }
 
diff --git a/tools/aapt2/ResourceParser.h b/tools/aapt2/ResourceParser.h
index 644ed4923c3a9..11b1e5b787ca0 100644
--- a/tools/aapt2/ResourceParser.h
+++ b/tools/aapt2/ResourceParser.h
@@ -17,6 +17,10 @@
 #ifndef AAPT_RESOURCE_PARSER_H
 #define AAPT_RESOURCE_PARSER_H
 
+#include <memory>
+
+#include "android-base/macros.h"
+
 #include "ConfigDescription.h"
 #include "Diagnostics.h"
 #include "ResourceTable.h"
@@ -26,8 +30,6 @@
 #include "util/StringPiece.h"
 #include "xml/XmlPullParser.h"
 
-#include <memory>
-
 namespace aapt {
 
 struct ParsedResource;
@@ -42,7 +44,7 @@ struct ResourceParserOptions {
    * Whether positional arguments in formatted strings are treated as errors or
    * warnings.
    */
-  bool errorOnPositionalArguments = true;
+  bool error_on_positional_arguments = true;
 };
 
 /*
@@ -53,70 +55,71 @@ class ResourceParser {
   ResourceParser(IDiagnostics* diag, ResourceTable* table, const Source& source,
                  const ConfigDescription& config,
                  const ResourceParserOptions& options = {});
-
-  ResourceParser(const ResourceParser&) = delete;  // No copy.
-
-  bool parse(xml::XmlPullParser* parser);
+  bool Parse(xml::XmlPullParser* parser);
 
  private:
+  DISALLOW_COPY_AND_ASSIGN(ResourceParser);
+
   /*
    * Parses the XML subtree as a StyleString (flattened XML representation for
    * strings
-   * with formatting). If successful, `outStyleString`
-   * contains the escaped and whitespace trimmed text, while `outRawString`
+   * with formatting). If successful, `out_style_string`
+   * contains the escaped and whitespace trimmed text, while `out_raw_string`
    * contains the unescaped text. Returns true on success.
    */
-  bool flattenXmlSubtree(xml::XmlPullParser* parser, std::string* outRawString,
-                         StyleString* outStyleString);
+  bool FlattenXmlSubtree(xml::XmlPullParser* parser,
+                         std::string* out_raw_string,
+                         StyleString* out_style_string);
 
   /*
    * Parses the XML subtree and returns an Item.
-   * The type of Item that can be parsed is denoted by the `typeMask`.
-   * If `allowRawValue` is true and the subtree can not be parsed as a regular
+   * The type of Item that can be parsed is denoted by the `type_mask`.
+   * If `allow_raw_value` is true and the subtree can not be parsed as a regular
    * Item, then a
    * RawString is returned. Otherwise this returns false;
    */
-  std::unique_ptr<Item> parseXml(xml::XmlPullParser* parser,
-                                 const uint32_t typeMask,
-                                 const bool allowRawValue);
+  std::unique_ptr<Item> ParseXml(xml::XmlPullParser* parser,
+                                 const uint32_t type_mask,
+                                 const bool allow_raw_value);
 
-  bool parseResources(xml::XmlPullParser* parser);
-  bool parseResource(xml::XmlPullParser* parser, ParsedResource* outResource);
+  bool ParseResources(xml::XmlPullParser* parser);
+  bool ParseResource(xml::XmlPullParser* parser, ParsedResource* out_resource);
 
-  bool parseItem(xml::XmlPullParser* parser, ParsedResource* outResource,
+  bool ParseItem(xml::XmlPullParser* parser, ParsedResource* out_resource,
                  uint32_t format);
-  bool parseString(xml::XmlPullParser* parser, ParsedResource* outResource);
+  bool ParseString(xml::XmlPullParser* parser, ParsedResource* out_resource);
 
-  bool parsePublic(xml::XmlPullParser* parser, ParsedResource* outResource);
-  bool parsePublicGroup(xml::XmlPullParser* parser,
-                        ParsedResource* outResource);
-  bool parseSymbolImpl(xml::XmlPullParser* parser, ParsedResource* outResource);
-  bool parseSymbol(xml::XmlPullParser* parser, ParsedResource* outResource);
-  bool parseAddResource(xml::XmlPullParser* parser,
-                        ParsedResource* outResource);
-  bool parseAttr(xml::XmlPullParser* parser, ParsedResource* outResource);
-  bool parseAttrImpl(xml::XmlPullParser* parser, ParsedResource* outResource,
+  bool ParsePublic(xml::XmlPullParser* parser, ParsedResource* out_resource);
+  bool ParsePublicGroup(xml::XmlPullParser* parser,
+                        ParsedResource* out_resource);
+  bool ParseSymbolImpl(xml::XmlPullParser* parser,
+                       ParsedResource* out_resource);
+  bool ParseSymbol(xml::XmlPullParser* parser, ParsedResource* out_resource);
+  bool ParseAddResource(xml::XmlPullParser* parser,
+                        ParsedResource* out_resource);
+  bool ParseAttr(xml::XmlPullParser* parser, ParsedResource* out_resource);
+  bool ParseAttrImpl(xml::XmlPullParser* parser, ParsedResource* out_resource,
                      bool weak);
-  Maybe<Attribute::Symbol> parseEnumOrFlagItem(xml::XmlPullParser* parser,
+  Maybe<Attribute::Symbol> ParseEnumOrFlagItem(xml::XmlPullParser* parser,
                                                const StringPiece& tag);
-  bool parseStyle(xml::XmlPullParser* parser, ParsedResource* outResource);
-  bool parseStyleItem(xml::XmlPullParser* parser, Style* style);
-  bool parseDeclareStyleable(xml::XmlPullParser* parser,
-                             ParsedResource* outResource);
-  bool parseArray(xml::XmlPullParser* parser, ParsedResource* outResource);
-  bool parseIntegerArray(xml::XmlPullParser* parser,
-                         ParsedResource* outResource);
-  bool parseStringArray(xml::XmlPullParser* parser,
-                        ParsedResource* outResource);
-  bool parseArrayImpl(xml::XmlPullParser* parser, ParsedResource* outResource,
+  bool ParseStyle(xml::XmlPullParser* parser, ParsedResource* out_resource);
+  bool ParseStyleItem(xml::XmlPullParser* parser, Style* style);
+  bool ParseDeclareStyleable(xml::XmlPullParser* parser,
+                             ParsedResource* out_resource);
+  bool ParseArray(xml::XmlPullParser* parser, ParsedResource* out_resource);
+  bool ParseIntegerArray(xml::XmlPullParser* parser,
+                         ParsedResource* out_resource);
+  bool ParseStringArray(xml::XmlPullParser* parser,
+                        ParsedResource* out_resource);
+  bool ParseArrayImpl(xml::XmlPullParser* parser, ParsedResource* out_resource,
                       uint32_t typeMask);
-  bool parsePlural(xml::XmlPullParser* parser, ParsedResource* outResource);
+  bool ParsePlural(xml::XmlPullParser* parser, ParsedResource* out_resource);
 
-  IDiagnostics* mDiag;
-  ResourceTable* mTable;
-  Source mSource;
-  ConfigDescription mConfig;
-  ResourceParserOptions mOptions;
+  IDiagnostics* diag_;
+  ResourceTable* table_;
+  Source source_;
+  ConfigDescription config_;
+  ResourceParserOptions options_;
 };
 
 }  // namespace aapt
diff --git a/tools/aapt2/ResourceParser_test.cpp b/tools/aapt2/ResourceParser_test.cpp
index b6d57c0f7b9bf..2463911445e7f 100644
--- a/tools/aapt2/ResourceParser_test.cpp
+++ b/tools/aapt2/ResourceParser_test.cpp
@@ -15,79 +15,82 @@
  */
 
 #include "ResourceParser.h"
+
+#include <sstream>
+#include <string>
+
 #include "ResourceTable.h"
 #include "ResourceUtils.h"
 #include "ResourceValues.h"
 #include "test/Test.h"
 #include "xml/XmlPullParser.h"
 
-#include <sstream>
-#include <string>
-
 namespace aapt {
 
 constexpr const char* kXmlPreamble =
     "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n";
 
 TEST(ResourceParserSingleTest, FailToParseWithNoRootResourcesElement) {
-  std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
+  std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
   std::stringstream input(kXmlPreamble);
   input << "<attr name=\"foo\"/>" << std::endl;
   ResourceTable table;
-  ResourceParser parser(context->getDiagnostics(), &table, Source{"test"}, {});
-  xml::XmlPullParser xmlParser(input);
-  ASSERT_FALSE(parser.parse(&xmlParser));
+  ResourceParser parser(context->GetDiagnostics(), &table, Source{"test"}, {});
+  xml::XmlPullParser xml_parser(input);
+  ASSERT_FALSE(parser.Parse(&xml_parser));
 }
 
-struct ResourceParserTest : public ::testing::Test {
-  ResourceTable mTable;
-  std::unique_ptr<IAaptContext> mContext;
+class ResourceParserTest : public ::testing::Test {
+ public:
+  void SetUp() override { context_ = test::ContextBuilder().Build(); }
 
-  void SetUp() override { mContext = test::ContextBuilder().build(); }
-
-  ::testing::AssertionResult testParse(const StringPiece& str) {
-    return testParse(str, ConfigDescription{});
+  ::testing::AssertionResult TestParse(const StringPiece& str) {
+    return TestParse(str, ConfigDescription{});
   }
 
-  ::testing::AssertionResult testParse(const StringPiece& str,
+  ::testing::AssertionResult TestParse(const StringPiece& str,
                                        const ConfigDescription& config) {
     std::stringstream input(kXmlPreamble);
     input << "<resources>\n" << str << "\n</resources>" << std::endl;
     ResourceParserOptions parserOptions;
-    ResourceParser parser(mContext->getDiagnostics(), &mTable, Source{"test"},
+    ResourceParser parser(context_->GetDiagnostics(), &table_, Source{"test"},
                           config, parserOptions);
     xml::XmlPullParser xmlParser(input);
-    if (parser.parse(&xmlParser)) {
+    if (parser.Parse(&xmlParser)) {
       return ::testing::AssertionSuccess();
     }
     return ::testing::AssertionFailure();
   }
+
+ protected:
+  ResourceTable table_;
+  std::unique_ptr<IAaptContext> context_;
 };
 
 TEST_F(ResourceParserTest, ParseQuotedString) {
   std::string input = "<string name=\"foo\">   \"  hey there \" </string>";
-  ASSERT_TRUE(testParse(input));
+  ASSERT_TRUE(TestParse(input));
 
-  String* str = test::getValue<String>(&mTable, "string/foo");
+  String* str = test::GetValue<String>(&table_, "string/foo");
   ASSERT_NE(nullptr, str);
   EXPECT_EQ(std::string("  hey there "), *str->value);
 }
 
 TEST_F(ResourceParserTest, ParseEscapedString) {
   std::string input = "<string name=\"foo\">\\?123</string>";
-  ASSERT_TRUE(testParse(input));
+  ASSERT_TRUE(TestParse(input));
 
-  String* str = test::getValue<String>(&mTable, "string/foo");
+  String* str = test::GetValue<String>(&table_, "string/foo");
   ASSERT_NE(nullptr, str);
   EXPECT_EQ(std::string("?123"), *str->value);
 }
 
 TEST_F(ResourceParserTest, ParseFormattedString) {
   std::string input = "<string name=\"foo\">%d %s</string>";
-  ASSERT_FALSE(testParse(input));
+  ASSERT_FALSE(TestParse(input));
 
   input = "<string name=\"foo\">%1$d %2$s</string>";
-  ASSERT_TRUE(testParse(input));
+  ASSERT_TRUE(TestParse(input));
 }
 
 TEST_F(ResourceParserTest, ParseStyledString) {
@@ -96,32 +99,32 @@ TEST_F(ResourceParserTest, ParseStyledString) {
   // use UTF-16 length and not UTF-18 length.
   std::string input =
       "<string name=\"foo\">This is my aunt\u2019s <b>string</b></string>";
-  ASSERT_TRUE(testParse(input));
+  ASSERT_TRUE(TestParse(input));
 
-  StyledString* str = test::getValue<StyledString>(&mTable, "string/foo");
+  StyledString* str = test::GetValue<StyledString>(&table_, "string/foo");
   ASSERT_NE(nullptr, str);
 
-  const std::string expectedStr = "This is my aunt\u2019s string";
-  EXPECT_EQ(expectedStr, *str->value->str);
+  const std::string expected_str = "This is my aunt\u2019s string";
+  EXPECT_EQ(expected_str, *str->value->str);
   EXPECT_EQ(1u, str->value->spans.size());
 
   EXPECT_EQ(std::string("b"), *str->value->spans[0].name);
-  EXPECT_EQ(17u, str->value->spans[0].firstChar);
-  EXPECT_EQ(23u, str->value->spans[0].lastChar);
+  EXPECT_EQ(17u, str->value->spans[0].first_char);
+  EXPECT_EQ(23u, str->value->spans[0].last_char);
 }
 
 TEST_F(ResourceParserTest, ParseStringWithWhitespace) {
   std::string input = "<string name=\"foo\">  This is what  I think  </string>";
-  ASSERT_TRUE(testParse(input));
+  ASSERT_TRUE(TestParse(input));
 
-  String* str = test::getValue<String>(&mTable, "string/foo");
+  String* str = test::GetValue<String>(&table_, "string/foo");
   ASSERT_NE(nullptr, str);
   EXPECT_EQ(std::string("This is what I think"), *str->value);
 
   input = "<string name=\"foo2\">\"  This is what  I think  \"</string>";
-  ASSERT_TRUE(testParse(input));
+  ASSERT_TRUE(TestParse(input));
 
-  str = test::getValue<String>(&mTable, "string/foo2");
+  str = test::GetValue<String>(&table_, "string/foo2");
   ASSERT_NE(nullptr, str);
   EXPECT_EQ(std::string("  This is what  I think  "), *str->value);
 }
@@ -131,16 +134,16 @@ TEST_F(ResourceParserTest, IgnoreXliffTags) {
       "<string name=\"foo\" \n"
       "        xmlns:xliff=\"urn:oasis:names:tc:xliff:document:1.2\">\n"
       "  There are <xliff:g id=\"count\">%1$d</xliff:g> apples</string>";
-  ASSERT_TRUE(testParse(input));
+  ASSERT_TRUE(TestParse(input));
 
-  String* str = test::getValue<String>(&mTable, "string/foo");
+  String* str = test::GetValue<String>(&table_, "string/foo");
   ASSERT_NE(nullptr, str);
   EXPECT_EQ(StringPiece("There are %1$d apples"), StringPiece(*str->value));
 }
 
 TEST_F(ResourceParserTest, ParseNull) {
   std::string input = "<integer name=\"foo\">@null</integer>";
-  ASSERT_TRUE(testParse(input));
+  ASSERT_TRUE(TestParse(input));
 
   // The Android runtime treats a value of android::Res_value::TYPE_NULL as
   // a non-existing value, and this causes problems in styles when trying to
@@ -149,7 +152,7 @@ TEST_F(ResourceParserTest, ParseNull) {
   // android::Res_value::TYPE_REFERENCE
   // with a data value of 0.
   BinaryPrimitive* integer =
-      test::getValue<BinaryPrimitive>(&mTable, "integer/foo");
+      test::GetValue<BinaryPrimitive>(&table_, "integer/foo");
   ASSERT_NE(nullptr, integer);
   EXPECT_EQ(uint16_t(android::Res_value::TYPE_REFERENCE),
             integer->value.dataType);
@@ -158,10 +161,10 @@ TEST_F(ResourceParserTest, ParseNull) {
 
 TEST_F(ResourceParserTest, ParseEmpty) {
   std::string input = "<integer name=\"foo\">@empty</integer>";
-  ASSERT_TRUE(testParse(input));
+  ASSERT_TRUE(TestParse(input));
 
   BinaryPrimitive* integer =
-      test::getValue<BinaryPrimitive>(&mTable, "integer/foo");
+      test::GetValue<BinaryPrimitive>(&table_, "integer/foo");
   ASSERT_NE(nullptr, integer);
   EXPECT_EQ(uint16_t(android::Res_value::TYPE_NULL), integer->value.dataType);
   EXPECT_EQ(uint32_t(android::Res_value::DATA_NULL_EMPTY), integer->value.data);
@@ -171,15 +174,15 @@ TEST_F(ResourceParserTest, ParseAttr) {
   std::string input =
       "<attr name=\"foo\" format=\"string\"/>\n"
       "<attr name=\"bar\"/>";
-  ASSERT_TRUE(testParse(input));
+  ASSERT_TRUE(TestParse(input));
 
-  Attribute* attr = test::getValue<Attribute>(&mTable, "attr/foo");
+  Attribute* attr = test::GetValue<Attribute>(&table_, "attr/foo");
   ASSERT_NE(nullptr, attr);
-  EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_STRING), attr->typeMask);
+  EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_STRING), attr->type_mask);
 
-  attr = test::getValue<Attribute>(&mTable, "attr/bar");
+  attr = test::GetValue<Attribute>(&table_, "attr/bar");
   ASSERT_NE(nullptr, attr);
-  EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_ANY), attr->typeMask);
+  EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_ANY), attr->type_mask);
 }
 
 // Old AAPT allowed attributes to be defined under different configurations, but
@@ -188,42 +191,42 @@ TEST_F(ResourceParserTest, ParseAttr) {
 // behavior.
 TEST_F(ResourceParserTest,
        ParseAttrAndDeclareStyleableUnderConfigButRecordAsNoConfig) {
-  const ConfigDescription watchConfig = test::parseConfigOrDie("watch");
+  const ConfigDescription watch_config = test::ParseConfigOrDie("watch");
   std::string input = R"EOF(
         <attr name="foo" />
         <declare-styleable name="bar">
           <attr name="baz" />
         </declare-styleable>)EOF";
-  ASSERT_TRUE(testParse(input, watchConfig));
+  ASSERT_TRUE(TestParse(input, watch_config));
 
-  EXPECT_EQ(nullptr, test::getValueForConfig<Attribute>(&mTable, "attr/foo",
-                                                        watchConfig));
-  EXPECT_EQ(nullptr, test::getValueForConfig<Attribute>(&mTable, "attr/baz",
-                                                        watchConfig));
-  EXPECT_EQ(nullptr, test::getValueForConfig<Styleable>(
-                         &mTable, "styleable/bar", watchConfig));
+  EXPECT_EQ(nullptr, test::GetValueForConfig<Attribute>(&table_, "attr/foo",
+                                                        watch_config));
+  EXPECT_EQ(nullptr, test::GetValueForConfig<Attribute>(&table_, "attr/baz",
+                                                        watch_config));
+  EXPECT_EQ(nullptr, test::GetValueForConfig<Styleable>(
+                         &table_, "styleable/bar", watch_config));
 
-  EXPECT_NE(nullptr, test::getValue<Attribute>(&mTable, "attr/foo"));
-  EXPECT_NE(nullptr, test::getValue<Attribute>(&mTable, "attr/baz"));
-  EXPECT_NE(nullptr, test::getValue<Styleable>(&mTable, "styleable/bar"));
+  EXPECT_NE(nullptr, test::GetValue<Attribute>(&table_, "attr/foo"));
+  EXPECT_NE(nullptr, test::GetValue<Attribute>(&table_, "attr/baz"));
+  EXPECT_NE(nullptr, test::GetValue<Styleable>(&table_, "styleable/bar"));
 }
 
 TEST_F(ResourceParserTest, ParseAttrWithMinMax) {
   std::string input =
       "<attr name=\"foo\" min=\"10\" max=\"23\" format=\"integer\"/>";
-  ASSERT_TRUE(testParse(input));
+  ASSERT_TRUE(TestParse(input));
 
-  Attribute* attr = test::getValue<Attribute>(&mTable, "attr/foo");
+  Attribute* attr = test::GetValue<Attribute>(&table_, "attr/foo");
   ASSERT_NE(nullptr, attr);
-  EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_INTEGER), attr->typeMask);
-  EXPECT_EQ(10, attr->minInt);
-  EXPECT_EQ(23, attr->maxInt);
+  EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_INTEGER), attr->type_mask);
+  EXPECT_EQ(10, attr->min_int);
+  EXPECT_EQ(23, attr->max_int);
 }
 
 TEST_F(ResourceParserTest, FailParseAttrWithMinMaxButNotInteger) {
   std::string input =
       "<attr name=\"foo\" min=\"10\" max=\"23\" format=\"string\"/>";
-  ASSERT_FALSE(testParse(input));
+  ASSERT_FALSE(TestParse(input));
 }
 
 TEST_F(ResourceParserTest, ParseUseAndDeclOfAttr) {
@@ -232,11 +235,11 @@ TEST_F(ResourceParserTest, ParseUseAndDeclOfAttr) {
       "  <attr name=\"foo\" />\n"
       "</declare-styleable>\n"
       "<attr name=\"foo\" format=\"string\"/>";
-  ASSERT_TRUE(testParse(input));
+  ASSERT_TRUE(TestParse(input));
 
-  Attribute* attr = test::getValue<Attribute>(&mTable, "attr/foo");
+  Attribute* attr = test::GetValue<Attribute>(&table_, "attr/foo");
   ASSERT_NE(nullptr, attr);
-  EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_STRING), attr->typeMask);
+  EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_STRING), attr->type_mask);
 }
 
 TEST_F(ResourceParserTest, ParseDoubleUseOfAttr) {
@@ -247,11 +250,11 @@ TEST_F(ResourceParserTest, ParseDoubleUseOfAttr) {
       "<declare-styleable name=\"Window\">\n"
       "  <attr name=\"foo\" format=\"boolean\"/>\n"
       "</declare-styleable>";
-  ASSERT_TRUE(testParse(input));
+  ASSERT_TRUE(TestParse(input));
 
-  Attribute* attr = test::getValue<Attribute>(&mTable, "attr/foo");
+  Attribute* attr = test::GetValue<Attribute>(&table_, "attr/foo");
   ASSERT_NE(nullptr, attr);
-  EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_BOOLEAN), attr->typeMask);
+  EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_BOOLEAN), attr->type_mask);
 }
 
 TEST_F(ResourceParserTest, ParseEnumAttr) {
@@ -261,24 +264,24 @@ TEST_F(ResourceParserTest, ParseEnumAttr) {
       "  <enum name=\"bat\" value=\"1\"/>\n"
       "  <enum name=\"baz\" value=\"2\"/>\n"
       "</attr>";
-  ASSERT_TRUE(testParse(input));
+  ASSERT_TRUE(TestParse(input));
 
-  Attribute* enumAttr = test::getValue<Attribute>(&mTable, "attr/foo");
-  ASSERT_NE(enumAttr, nullptr);
-  EXPECT_EQ(enumAttr->typeMask, android::ResTable_map::TYPE_ENUM);
-  ASSERT_EQ(enumAttr->symbols.size(), 3u);
+  Attribute* enum_attr = test::GetValue<Attribute>(&table_, "attr/foo");
+  ASSERT_NE(enum_attr, nullptr);
+  EXPECT_EQ(enum_attr->type_mask, android::ResTable_map::TYPE_ENUM);
+  ASSERT_EQ(enum_attr->symbols.size(), 3u);
 
-  AAPT_ASSERT_TRUE(enumAttr->symbols[0].symbol.name);
-  EXPECT_EQ(enumAttr->symbols[0].symbol.name.value().entry, "bar");
-  EXPECT_EQ(enumAttr->symbols[0].value, 0u);
+  AAPT_ASSERT_TRUE(enum_attr->symbols[0].symbol.name);
+  EXPECT_EQ(enum_attr->symbols[0].symbol.name.value().entry, "bar");
+  EXPECT_EQ(enum_attr->symbols[0].value, 0u);
 
-  AAPT_ASSERT_TRUE(enumAttr->symbols[1].symbol.name);
-  EXPECT_EQ(enumAttr->symbols[1].symbol.name.value().entry, "bat");
-  EXPECT_EQ(enumAttr->symbols[1].value, 1u);
+  AAPT_ASSERT_TRUE(enum_attr->symbols[1].symbol.name);
+  EXPECT_EQ(enum_attr->symbols[1].symbol.name.value().entry, "bat");
+  EXPECT_EQ(enum_attr->symbols[1].value, 1u);
 
-  AAPT_ASSERT_TRUE(enumAttr->symbols[2].symbol.name);
-  EXPECT_EQ(enumAttr->symbols[2].symbol.name.value().entry, "baz");
-  EXPECT_EQ(enumAttr->symbols[2].value, 2u);
+  AAPT_ASSERT_TRUE(enum_attr->symbols[2].symbol.name);
+  EXPECT_EQ(enum_attr->symbols[2].symbol.name.value().entry, "baz");
+  EXPECT_EQ(enum_attr->symbols[2].value, 2u);
 }
 
 TEST_F(ResourceParserTest, ParseFlagAttr) {
@@ -288,29 +291,29 @@ TEST_F(ResourceParserTest, ParseFlagAttr) {
       "  <flag name=\"bat\" value=\"1\"/>\n"
       "  <flag name=\"baz\" value=\"2\"/>\n"
       "</attr>";
-  ASSERT_TRUE(testParse(input));
+  ASSERT_TRUE(TestParse(input));
 
-  Attribute* flagAttr = test::getValue<Attribute>(&mTable, "attr/foo");
-  ASSERT_NE(nullptr, flagAttr);
-  EXPECT_EQ(flagAttr->typeMask, android::ResTable_map::TYPE_FLAGS);
-  ASSERT_EQ(flagAttr->symbols.size(), 3u);
+  Attribute* flag_attr = test::GetValue<Attribute>(&table_, "attr/foo");
+  ASSERT_NE(nullptr, flag_attr);
+  EXPECT_EQ(flag_attr->type_mask, android::ResTable_map::TYPE_FLAGS);
+  ASSERT_EQ(flag_attr->symbols.size(), 3u);
 
-  AAPT_ASSERT_TRUE(flagAttr->symbols[0].symbol.name);
-  EXPECT_EQ(flagAttr->symbols[0].symbol.name.value().entry, "bar");
-  EXPECT_EQ(flagAttr->symbols[0].value, 0u);
+  AAPT_ASSERT_TRUE(flag_attr->symbols[0].symbol.name);
+  EXPECT_EQ(flag_attr->symbols[0].symbol.name.value().entry, "bar");
+  EXPECT_EQ(flag_attr->symbols[0].value, 0u);
 
-  AAPT_ASSERT_TRUE(flagAttr->symbols[1].symbol.name);
-  EXPECT_EQ(flagAttr->symbols[1].symbol.name.value().entry, "bat");
-  EXPECT_EQ(flagAttr->symbols[1].value, 1u);
+  AAPT_ASSERT_TRUE(flag_attr->symbols[1].symbol.name);
+  EXPECT_EQ(flag_attr->symbols[1].symbol.name.value().entry, "bat");
+  EXPECT_EQ(flag_attr->symbols[1].value, 1u);
 
-  AAPT_ASSERT_TRUE(flagAttr->symbols[2].symbol.name);
-  EXPECT_EQ(flagAttr->symbols[2].symbol.name.value().entry, "baz");
-  EXPECT_EQ(flagAttr->symbols[2].value, 2u);
+  AAPT_ASSERT_TRUE(flag_attr->symbols[2].symbol.name);
+  EXPECT_EQ(flag_attr->symbols[2].symbol.name.value().entry, "baz");
+  EXPECT_EQ(flag_attr->symbols[2].value, 2u);
 
-  std::unique_ptr<BinaryPrimitive> flagValue =
-      ResourceUtils::tryParseFlagSymbol(flagAttr, "baz|bat");
-  ASSERT_NE(nullptr, flagValue);
-  EXPECT_EQ(flagValue->value.data, 1u | 2u);
+  std::unique_ptr<BinaryPrimitive> flag_value =
+      ResourceUtils::TryParseFlagSymbol(flag_attr, "baz|bat");
+  ASSERT_NE(nullptr, flag_value);
+  EXPECT_EQ(flag_value->value.data, 1u | 2u);
 }
 
 TEST_F(ResourceParserTest, FailToParseEnumAttrWithNonUniqueKeys) {
@@ -320,7 +323,7 @@ TEST_F(ResourceParserTest, FailToParseEnumAttrWithNonUniqueKeys) {
       "  <enum name=\"bat\" value=\"1\"/>\n"
       "  <enum name=\"bat\" value=\"2\"/>\n"
       "</attr>";
-  ASSERT_FALSE(testParse(input));
+  ASSERT_FALSE(TestParse(input));
 }
 
 TEST_F(ResourceParserTest, ParseStyle) {
@@ -330,38 +333,38 @@ TEST_F(ResourceParserTest, ParseStyle) {
       "  <item name=\"bat\">@string/hey</item>\n"
       "  <item name=\"baz\"><b>hey</b></item>\n"
       "</style>";
-  ASSERT_TRUE(testParse(input));
+  ASSERT_TRUE(TestParse(input));
 
-  Style* style = test::getValue<Style>(&mTable, "style/foo");
+  Style* style = test::GetValue<Style>(&table_, "style/foo");
   ASSERT_NE(nullptr, style);
   AAPT_ASSERT_TRUE(style->parent);
   AAPT_ASSERT_TRUE(style->parent.value().name);
-  EXPECT_EQ(test::parseNameOrDie("style/fu"),
+  EXPECT_EQ(test::ParseNameOrDie("style/fu"),
             style->parent.value().name.value());
   ASSERT_EQ(3u, style->entries.size());
 
   AAPT_ASSERT_TRUE(style->entries[0].key.name);
-  EXPECT_EQ(test::parseNameOrDie("attr/bar"),
+  EXPECT_EQ(test::ParseNameOrDie("attr/bar"),
             style->entries[0].key.name.value());
 
   AAPT_ASSERT_TRUE(style->entries[1].key.name);
-  EXPECT_EQ(test::parseNameOrDie("attr/bat"),
+  EXPECT_EQ(test::ParseNameOrDie("attr/bat"),
             style->entries[1].key.name.value());
 
   AAPT_ASSERT_TRUE(style->entries[2].key.name);
-  EXPECT_EQ(test::parseNameOrDie("attr/baz"),
+  EXPECT_EQ(test::ParseNameOrDie("attr/baz"),
             style->entries[2].key.name.value());
 }
 
 TEST_F(ResourceParserTest, ParseStyleWithShorthandParent) {
   std::string input = "<style name=\"foo\" parent=\"com.app:Theme\"/>";
-  ASSERT_TRUE(testParse(input));
+  ASSERT_TRUE(TestParse(input));
 
-  Style* style = test::getValue<Style>(&mTable, "style/foo");
+  Style* style = test::GetValue<Style>(&table_, "style/foo");
   ASSERT_NE(nullptr, style);
   AAPT_ASSERT_TRUE(style->parent);
   AAPT_ASSERT_TRUE(style->parent.value().name);
-  EXPECT_EQ(test::parseNameOrDie("com.app:style/Theme"),
+  EXPECT_EQ(test::ParseNameOrDie("com.app:style/Theme"),
             style->parent.value().name.value());
 }
 
@@ -369,13 +372,13 @@ TEST_F(ResourceParserTest, ParseStyleWithPackageAliasedParent) {
   std::string input =
       "<style xmlns:app=\"http://schemas.android.com/apk/res/android\"\n"
       "       name=\"foo\" parent=\"app:Theme\"/>";
-  ASSERT_TRUE(testParse(input));
+  ASSERT_TRUE(TestParse(input));
 
-  Style* style = test::getValue<Style>(&mTable, "style/foo");
+  Style* style = test::GetValue<Style>(&table_, "style/foo");
   ASSERT_NE(nullptr, style);
   AAPT_ASSERT_TRUE(style->parent);
   AAPT_ASSERT_TRUE(style->parent.value().name);
-  EXPECT_EQ(test::parseNameOrDie("android:style/Theme"),
+  EXPECT_EQ(test::ParseNameOrDie("android:style/Theme"),
             style->parent.value().name.value());
 }
 
@@ -385,55 +388,55 @@ TEST_F(ResourceParserTest, ParseStyleWithPackageAliasedItems) {
       "name=\"foo\">\n"
       "  <item name=\"app:bar\">0</item>\n"
       "</style>";
-  ASSERT_TRUE(testParse(input));
+  ASSERT_TRUE(TestParse(input));
 
-  Style* style = test::getValue<Style>(&mTable, "style/foo");
+  Style* style = test::GetValue<Style>(&table_, "style/foo");
   ASSERT_NE(nullptr, style);
   ASSERT_EQ(1u, style->entries.size());
-  EXPECT_EQ(test::parseNameOrDie("android:attr/bar"),
+  EXPECT_EQ(test::ParseNameOrDie("android:attr/bar"),
             style->entries[0].key.name.value());
 }
 
 TEST_F(ResourceParserTest, ParseStyleWithInferredParent) {
   std::string input = "<style name=\"foo.bar\"/>";
-  ASSERT_TRUE(testParse(input));
+  ASSERT_TRUE(TestParse(input));
 
-  Style* style = test::getValue<Style>(&mTable, "style/foo.bar");
+  Style* style = test::GetValue<Style>(&table_, "style/foo.bar");
   ASSERT_NE(nullptr, style);
   AAPT_ASSERT_TRUE(style->parent);
   AAPT_ASSERT_TRUE(style->parent.value().name);
   EXPECT_EQ(style->parent.value().name.value(),
-            test::parseNameOrDie("style/foo"));
-  EXPECT_TRUE(style->parentInferred);
+            test::ParseNameOrDie("style/foo"));
+  EXPECT_TRUE(style->parent_inferred);
 }
 
 TEST_F(ResourceParserTest,
        ParseStyleWithInferredParentOverridenByEmptyParentAttribute) {
   std::string input = "<style name=\"foo.bar\" parent=\"\"/>";
-  ASSERT_TRUE(testParse(input));
+  ASSERT_TRUE(TestParse(input));
 
-  Style* style = test::getValue<Style>(&mTable, "style/foo.bar");
+  Style* style = test::GetValue<Style>(&table_, "style/foo.bar");
   ASSERT_NE(nullptr, style);
   AAPT_EXPECT_FALSE(style->parent);
-  EXPECT_FALSE(style->parentInferred);
+  EXPECT_FALSE(style->parent_inferred);
 }
 
 TEST_F(ResourceParserTest, ParseStyleWithPrivateParentReference) {
   std::string input =
       R"EOF(<style name="foo" parent="*android:style/bar" />)EOF";
-  ASSERT_TRUE(testParse(input));
+  ASSERT_TRUE(TestParse(input));
 
-  Style* style = test::getValue<Style>(&mTable, "style/foo");
+  Style* style = test::GetValue<Style>(&table_, "style/foo");
   ASSERT_NE(nullptr, style);
   AAPT_ASSERT_TRUE(style->parent);
-  EXPECT_TRUE(style->parent.value().privateReference);
+  EXPECT_TRUE(style->parent.value().private_reference);
 }
 
 TEST_F(ResourceParserTest, ParseAutoGeneratedIdReference) {
   std::string input = "<string name=\"foo\">@+id/bar</string>";
-  ASSERT_TRUE(testParse(input));
+  ASSERT_TRUE(TestParse(input));
 
-  Id* id = test::getValue<Id>(&mTable, "id/bar");
+  Id* id = test::GetValue<Id>(&table_, "id/bar");
   ASSERT_NE(id, nullptr);
 }
 
@@ -446,35 +449,35 @@ TEST_F(ResourceParserTest, ParseAttributesDeclareStyleable) {
       "    <enum name=\"foo\" value=\"1\"/>\n"
       "  </attr>\n"
       "</declare-styleable>";
-  ASSERT_TRUE(testParse(input));
+  ASSERT_TRUE(TestParse(input));
 
   Maybe<ResourceTable::SearchResult> result =
-      mTable.findResource(test::parseNameOrDie("styleable/foo"));
+      table_.FindResource(test::ParseNameOrDie("styleable/foo"));
   AAPT_ASSERT_TRUE(result);
-  EXPECT_EQ(SymbolState::kPublic, result.value().entry->symbolStatus.state);
+  EXPECT_EQ(SymbolState::kPublic, result.value().entry->symbol_status.state);
 
-  Attribute* attr = test::getValue<Attribute>(&mTable, "attr/bar");
+  Attribute* attr = test::GetValue<Attribute>(&table_, "attr/bar");
   ASSERT_NE(attr, nullptr);
-  EXPECT_TRUE(attr->isWeak());
+  EXPECT_TRUE(attr->IsWeak());
 
-  attr = test::getValue<Attribute>(&mTable, "attr/bat");
+  attr = test::GetValue<Attribute>(&table_, "attr/bat");
   ASSERT_NE(attr, nullptr);
-  EXPECT_TRUE(attr->isWeak());
+  EXPECT_TRUE(attr->IsWeak());
 
-  attr = test::getValue<Attribute>(&mTable, "attr/baz");
+  attr = test::GetValue<Attribute>(&table_, "attr/baz");
   ASSERT_NE(attr, nullptr);
-  EXPECT_TRUE(attr->isWeak());
+  EXPECT_TRUE(attr->IsWeak());
   EXPECT_EQ(1u, attr->symbols.size());
 
-  EXPECT_NE(nullptr, test::getValue<Id>(&mTable, "id/foo"));
+  EXPECT_NE(nullptr, test::GetValue<Id>(&table_, "id/foo"));
 
-  Styleable* styleable = test::getValue<Styleable>(&mTable, "styleable/foo");
+  Styleable* styleable = test::GetValue<Styleable>(&table_, "styleable/foo");
   ASSERT_NE(styleable, nullptr);
   ASSERT_EQ(3u, styleable->entries.size());
 
-  EXPECT_EQ(test::parseNameOrDie("attr/bar"),
+  EXPECT_EQ(test::ParseNameOrDie("attr/bar"),
             styleable->entries[0].name.value());
-  EXPECT_EQ(test::parseNameOrDie("attr/bat"),
+  EXPECT_EQ(test::ParseNameOrDie("attr/bat"),
             styleable->entries[1].name.value());
 }
 
@@ -485,16 +488,16 @@ TEST_F(ResourceParserTest, ParsePrivateAttributesDeclareStyleable) {
       "  <attr name=\"*android:bar\" />\n"
       "  <attr name=\"privAndroid:bat\" />\n"
       "</declare-styleable>";
-  ASSERT_TRUE(testParse(input));
-  Styleable* styleable = test::getValue<Styleable>(&mTable, "styleable/foo");
+  ASSERT_TRUE(TestParse(input));
+  Styleable* styleable = test::GetValue<Styleable>(&table_, "styleable/foo");
   ASSERT_NE(nullptr, styleable);
   ASSERT_EQ(2u, styleable->entries.size());
 
-  EXPECT_TRUE(styleable->entries[0].privateReference);
+  EXPECT_TRUE(styleable->entries[0].private_reference);
   AAPT_ASSERT_TRUE(styleable->entries[0].name);
   EXPECT_EQ(std::string("android"), styleable->entries[0].name.value().package);
 
-  EXPECT_TRUE(styleable->entries[1].privateReference);
+  EXPECT_TRUE(styleable->entries[1].private_reference);
   AAPT_ASSERT_TRUE(styleable->entries[1].name);
   EXPECT_EQ(std::string("android"), styleable->entries[1].name.value().package);
 }
@@ -506,15 +509,15 @@ TEST_F(ResourceParserTest, ParseArray) {
       "  <item>hey</item>\n"
       "  <item>23</item>\n"
       "</array>";
-  ASSERT_TRUE(testParse(input));
+  ASSERT_TRUE(TestParse(input));
 
-  Array* array = test::getValue<Array>(&mTable, "array/foo");
+  Array* array = test::GetValue<Array>(&table_, "array/foo");
   ASSERT_NE(array, nullptr);
   ASSERT_EQ(3u, array->items.size());
 
-  EXPECT_NE(nullptr, valueCast<Reference>(array->items[0].get()));
-  EXPECT_NE(nullptr, valueCast<String>(array->items[1].get()));
-  EXPECT_NE(nullptr, valueCast<BinaryPrimitive>(array->items[2].get()));
+  EXPECT_NE(nullptr, ValueCast<Reference>(array->items[0].get()));
+  EXPECT_NE(nullptr, ValueCast<String>(array->items[1].get()));
+  EXPECT_NE(nullptr, ValueCast<BinaryPrimitive>(array->items[2].get()));
 }
 
 TEST_F(ResourceParserTest, ParseStringArray) {
@@ -522,8 +525,8 @@ TEST_F(ResourceParserTest, ParseStringArray) {
       "<string-array name=\"foo\">\n"
       "  <item>\"Werk\"</item>\n"
       "</string-array>\n";
-  ASSERT_TRUE(testParse(input));
-  EXPECT_NE(nullptr, test::getValue<Array>(&mTable, "array/foo"));
+  ASSERT_TRUE(TestParse(input));
+  EXPECT_NE(nullptr, test::GetValue<Array>(&table_, "array/foo"));
 }
 
 TEST_F(ResourceParserTest, ParsePlural) {
@@ -532,18 +535,18 @@ TEST_F(ResourceParserTest, ParsePlural) {
       "  <item quantity=\"other\">apples</item>\n"
       "  <item quantity=\"one\">apple</item>\n"
       "</plurals>";
-  ASSERT_TRUE(testParse(input));
+  ASSERT_TRUE(TestParse(input));
 }
 
 TEST_F(ResourceParserTest, ParseCommentsWithResource) {
   std::string input =
       "<!--This is a comment-->\n"
       "<string name=\"foo\">Hi</string>";
-  ASSERT_TRUE(testParse(input));
+  ASSERT_TRUE(TestParse(input));
 
-  String* value = test::getValue<String>(&mTable, "string/foo");
+  String* value = test::GetValue<String>(&table_, "string/foo");
   ASSERT_NE(nullptr, value);
-  EXPECT_EQ(value->getComment(), "This is a comment");
+  EXPECT_EQ(value->GetComment(), "This is a comment");
 }
 
 TEST_F(ResourceParserTest, DoNotCombineMultipleComments) {
@@ -552,11 +555,11 @@ TEST_F(ResourceParserTest, DoNotCombineMultipleComments) {
       "<!--Two-->\n"
       "<string name=\"foo\">Hi</string>";
 
-  ASSERT_TRUE(testParse(input));
+  ASSERT_TRUE(TestParse(input));
 
-  String* value = test::getValue<String>(&mTable, "string/foo");
+  String* value = test::GetValue<String>(&table_, "string/foo");
   ASSERT_NE(nullptr, value);
-  EXPECT_EQ(value->getComment(), "Two");
+  EXPECT_EQ(value->GetComment(), "Two");
 }
 
 TEST_F(ResourceParserTest, IgnoreCommentBeforeEndTag) {
@@ -567,11 +570,11 @@ TEST_F(ResourceParserTest, IgnoreCommentBeforeEndTag) {
       "<!--Two-->\n"
       "</string>";
 
-  ASSERT_TRUE(testParse(input));
+  ASSERT_TRUE(TestParse(input));
 
-  String* value = test::getValue<String>(&mTable, "string/foo");
+  String* value = test::GetValue<String>(&table_, "string/foo");
   ASSERT_NE(nullptr, value);
-  EXPECT_EQ(value->getComment(), "One");
+  EXPECT_EQ(value->GetComment(), "One");
 }
 
 TEST_F(ResourceParserTest, ParseNestedComments) {
@@ -588,21 +591,21 @@ TEST_F(ResourceParserTest, ParseNestedComments) {
           <!-- The very first -->
           <enum name="one" value="1" />
         </attr>)EOF";
-  ASSERT_TRUE(testParse(input));
+  ASSERT_TRUE(TestParse(input));
 
-  Styleable* styleable = test::getValue<Styleable>(&mTable, "styleable/foo");
+  Styleable* styleable = test::GetValue<Styleable>(&table_, "styleable/foo");
   ASSERT_NE(nullptr, styleable);
   ASSERT_EQ(1u, styleable->entries.size());
 
   EXPECT_EQ(StringPiece("The name of the bar"),
-            styleable->entries.front().getComment());
+            styleable->entries.front().GetComment());
 
-  Attribute* attr = test::getValue<Attribute>(&mTable, "attr/foo");
+  Attribute* attr = test::GetValue<Attribute>(&table_, "attr/foo");
   ASSERT_NE(nullptr, attr);
   ASSERT_EQ(1u, attr->symbols.size());
 
   EXPECT_EQ(StringPiece("The very first"),
-            attr->symbols.front().symbol.getComment());
+            attr->symbols.front().symbol.GetComment());
 }
 
 /*
@@ -611,9 +614,9 @@ TEST_F(ResourceParserTest, ParseNestedComments) {
  */
 TEST_F(ResourceParserTest, ParsePublicIdAsDefinition) {
   std::string input = "<public type=\"id\" name=\"foo\"/>";
-  ASSERT_TRUE(testParse(input));
+  ASSERT_TRUE(TestParse(input));
 
-  Id* id = test::getValue<Id>(&mTable, "id/foo");
+  Id* id = test::GetValue<Id>(&table_, "id/foo");
   ASSERT_NE(nullptr, id);
 }
 
@@ -626,26 +629,26 @@ TEST_F(ResourceParserTest, KeepAllProducts) {
         <string name="bit" product="phablet">hoot</string>
         <string name="bot" product="default">yes</string>
     )EOF";
-  ASSERT_TRUE(testParse(input));
+  ASSERT_TRUE(TestParse(input));
 
-  EXPECT_NE(nullptr, test::getValueForConfigAndProduct<String>(
-                         &mTable, "string/foo",
-                         ConfigDescription::defaultConfig(), "phone"));
-  EXPECT_NE(nullptr, test::getValueForConfigAndProduct<String>(
-                         &mTable, "string/foo",
-                         ConfigDescription::defaultConfig(), "no-sdcard"));
+  EXPECT_NE(nullptr, test::GetValueForConfigAndProduct<String>(
+                         &table_, "string/foo",
+                         ConfigDescription::DefaultConfig(), "phone"));
+  EXPECT_NE(nullptr, test::GetValueForConfigAndProduct<String>(
+                         &table_, "string/foo",
+                         ConfigDescription::DefaultConfig(), "no-sdcard"));
   EXPECT_NE(nullptr,
-            test::getValueForConfigAndProduct<String>(
-                &mTable, "string/bar", ConfigDescription::defaultConfig(), ""));
+            test::GetValueForConfigAndProduct<String>(
+                &table_, "string/bar", ConfigDescription::DefaultConfig(), ""));
   EXPECT_NE(nullptr,
-            test::getValueForConfigAndProduct<String>(
-                &mTable, "string/baz", ConfigDescription::defaultConfig(), ""));
-  EXPECT_NE(nullptr, test::getValueForConfigAndProduct<String>(
-                         &mTable, "string/bit",
-                         ConfigDescription::defaultConfig(), "phablet"));
-  EXPECT_NE(nullptr, test::getValueForConfigAndProduct<String>(
-                         &mTable, "string/bot",
-                         ConfigDescription::defaultConfig(), "default"));
+            test::GetValueForConfigAndProduct<String>(
+                &table_, "string/baz", ConfigDescription::DefaultConfig(), ""));
+  EXPECT_NE(nullptr, test::GetValueForConfigAndProduct<String>(
+                         &table_, "string/bit",
+                         ConfigDescription::DefaultConfig(), "phablet"));
+  EXPECT_NE(nullptr, test::GetValueForConfigAndProduct<String>(
+                         &table_, "string/bot",
+                         ConfigDescription::DefaultConfig(), "default"));
 }
 
 TEST_F(ResourceParserTest, AutoIncrementIdsInPublicGroup) {
@@ -654,61 +657,61 @@ TEST_F(ResourceParserTest, AutoIncrementIdsInPublicGroup) {
       <public name="foo" />
       <public name="bar" />
     </public-group>)EOF";
-  ASSERT_TRUE(testParse(input));
+  ASSERT_TRUE(TestParse(input));
 
   Maybe<ResourceTable::SearchResult> result =
-      mTable.findResource(test::parseNameOrDie("attr/foo"));
+      table_.FindResource(test::ParseNameOrDie("attr/foo"));
   AAPT_ASSERT_TRUE(result);
 
   AAPT_ASSERT_TRUE(result.value().package->id);
   AAPT_ASSERT_TRUE(result.value().type->id);
   AAPT_ASSERT_TRUE(result.value().entry->id);
-  ResourceId actualId(result.value().package->id.value(),
-                      result.value().type->id.value(),
-                      result.value().entry->id.value());
-  EXPECT_EQ(ResourceId(0x01010040), actualId);
+  ResourceId actual_id(result.value().package->id.value(),
+                       result.value().type->id.value(),
+                       result.value().entry->id.value());
+  EXPECT_EQ(ResourceId(0x01010040), actual_id);
 
-  result = mTable.findResource(test::parseNameOrDie("attr/bar"));
+  result = table_.FindResource(test::ParseNameOrDie("attr/bar"));
   AAPT_ASSERT_TRUE(result);
 
   AAPT_ASSERT_TRUE(result.value().package->id);
   AAPT_ASSERT_TRUE(result.value().type->id);
   AAPT_ASSERT_TRUE(result.value().entry->id);
-  actualId = ResourceId(result.value().package->id.value(),
-                        result.value().type->id.value(),
-                        result.value().entry->id.value());
-  EXPECT_EQ(ResourceId(0x01010041), actualId);
+  actual_id = ResourceId(result.value().package->id.value(),
+                         result.value().type->id.value(),
+                         result.value().entry->id.value());
+  EXPECT_EQ(ResourceId(0x01010041), actual_id);
 }
 
 TEST_F(ResourceParserTest, ExternalTypesShouldOnlyBeReferences) {
   std::string input =
       R"EOF(<item type="layout" name="foo">@layout/bar</item>)EOF";
-  ASSERT_TRUE(testParse(input));
+  ASSERT_TRUE(TestParse(input));
 
   input = R"EOF(<item type="layout" name="bar">"this is a string"</item>)EOF";
-  ASSERT_FALSE(testParse(input));
+  ASSERT_FALSE(TestParse(input));
 }
 
 TEST_F(ResourceParserTest,
        AddResourcesElementShouldAddEntryWithUndefinedSymbol) {
   std::string input = R"EOF(<add-resource name="bar" type="string" />)EOF";
-  ASSERT_TRUE(testParse(input));
+  ASSERT_TRUE(TestParse(input));
 
   Maybe<ResourceTable::SearchResult> result =
-      mTable.findResource(test::parseNameOrDie("string/bar"));
+      table_.FindResource(test::ParseNameOrDie("string/bar"));
   AAPT_ASSERT_TRUE(result);
   const ResourceEntry* entry = result.value().entry;
   ASSERT_NE(nullptr, entry);
-  EXPECT_EQ(SymbolState::kUndefined, entry->symbolStatus.state);
+  EXPECT_EQ(SymbolState::kUndefined, entry->symbol_status.state);
 }
 
 TEST_F(ResourceParserTest, ParseItemElementWithFormat) {
   std::string input =
       R"EOF(<item name="foo" type="integer" format="float">0.3</item>)EOF";
-  ASSERT_TRUE(testParse(input));
+  ASSERT_TRUE(TestParse(input));
 
   BinaryPrimitive* val =
-      test::getValue<BinaryPrimitive>(&mTable, "integer/foo");
+      test::GetValue<BinaryPrimitive>(&table_, "integer/foo");
   ASSERT_NE(nullptr, val);
 
   EXPECT_EQ(uint32_t(android::Res_value::TYPE_FLOAT), val->value.dataType);
diff --git a/tools/aapt2/ResourceTable.cpp b/tools/aapt2/ResourceTable.cpp
index c52c91c0832f1..4e6a50ae149b1 100644
--- a/tools/aapt2/ResourceTable.cpp
+++ b/tools/aapt2/ResourceTable.cpp
@@ -21,6 +21,7 @@
 #include "ValueVisitor.h"
 #include "util/Util.h"
 
+#include <android-base/logging.h>
 #include <androidfw/ResourceTypes.h>
 #include <algorithm>
 #include <memory>
@@ -29,28 +30,29 @@
 
 namespace aapt {
 
-static bool lessThanType(const std::unique_ptr<ResourceTableType>& lhs,
-                         ResourceType rhs) {
+static bool less_than_type(const std::unique_ptr<ResourceTableType>& lhs,
+                           ResourceType rhs) {
   return lhs->type < rhs;
 }
 
 template <typename T>
-static bool lessThanStructWithName(const std::unique_ptr<T>& lhs,
-                                   const StringPiece& rhs) {
+static bool less_than_struct_with_name(const std::unique_ptr<T>& lhs,
+                                       const StringPiece& rhs) {
   return lhs->name.compare(0, lhs->name.size(), rhs.data(), rhs.size()) < 0;
 }
 
-ResourceTablePackage* ResourceTable::findPackage(const StringPiece& name) {
+ResourceTablePackage* ResourceTable::FindPackage(const StringPiece& name) {
   const auto last = packages.end();
-  auto iter = std::lower_bound(packages.begin(), last, name,
-                               lessThanStructWithName<ResourceTablePackage>);
+  auto iter =
+      std::lower_bound(packages.begin(), last, name,
+                       less_than_struct_with_name<ResourceTablePackage>);
   if (iter != last && name == (*iter)->name) {
     return iter->get();
   }
   return nullptr;
 }
 
-ResourceTablePackage* ResourceTable::findPackageById(uint8_t id) {
+ResourceTablePackage* ResourceTable::FindPackageById(uint8_t id) {
   for (auto& package : packages) {
     if (package->id && package->id.value() == id) {
       return package.get();
@@ -59,9 +61,9 @@ ResourceTablePackage* ResourceTable::findPackageById(uint8_t id) {
   return nullptr;
 }
 
-ResourceTablePackage* ResourceTable::createPackage(const StringPiece& name,
+ResourceTablePackage* ResourceTable::CreatePackage(const StringPiece& name,
                                                    Maybe<uint8_t> id) {
-  ResourceTablePackage* package = findOrCreatePackage(name);
+  ResourceTablePackage* package = FindOrCreatePackage(name);
   if (id && !package->id) {
     package->id = id;
     return package;
@@ -73,61 +75,62 @@ ResourceTablePackage* ResourceTable::createPackage(const StringPiece& name,
   return package;
 }
 
-ResourceTablePackage* ResourceTable::findOrCreatePackage(
+ResourceTablePackage* ResourceTable::FindOrCreatePackage(
     const StringPiece& name) {
   const auto last = packages.end();
-  auto iter = std::lower_bound(packages.begin(), last, name,
-                               lessThanStructWithName<ResourceTablePackage>);
+  auto iter =
+      std::lower_bound(packages.begin(), last, name,
+                       less_than_struct_with_name<ResourceTablePackage>);
   if (iter != last && name == (*iter)->name) {
     return iter->get();
   }
 
-  std::unique_ptr<ResourceTablePackage> newPackage =
+  std::unique_ptr<ResourceTablePackage> new_package =
       util::make_unique<ResourceTablePackage>();
-  newPackage->name = name.toString();
-  return packages.emplace(iter, std::move(newPackage))->get();
+  new_package->name = name.ToString();
+  return packages.emplace(iter, std::move(new_package))->get();
 }
 
-ResourceTableType* ResourceTablePackage::findType(ResourceType type) {
+ResourceTableType* ResourceTablePackage::FindType(ResourceType type) {
   const auto last = types.end();
-  auto iter = std::lower_bound(types.begin(), last, type, lessThanType);
+  auto iter = std::lower_bound(types.begin(), last, type, less_than_type);
   if (iter != last && (*iter)->type == type) {
     return iter->get();
   }
   return nullptr;
 }
 
-ResourceTableType* ResourceTablePackage::findOrCreateType(ResourceType type) {
+ResourceTableType* ResourceTablePackage::FindOrCreateType(ResourceType type) {
   const auto last = types.end();
-  auto iter = std::lower_bound(types.begin(), last, type, lessThanType);
+  auto iter = std::lower_bound(types.begin(), last, type, less_than_type);
   if (iter != last && (*iter)->type == type) {
     return iter->get();
   }
   return types.emplace(iter, new ResourceTableType(type))->get();
 }
 
-ResourceEntry* ResourceTableType::findEntry(const StringPiece& name) {
+ResourceEntry* ResourceTableType::FindEntry(const StringPiece& name) {
   const auto last = entries.end();
   auto iter = std::lower_bound(entries.begin(), last, name,
-                               lessThanStructWithName<ResourceEntry>);
+                               less_than_struct_with_name<ResourceEntry>);
   if (iter != last && name == (*iter)->name) {
     return iter->get();
   }
   return nullptr;
 }
 
-ResourceEntry* ResourceTableType::findOrCreateEntry(const StringPiece& name) {
+ResourceEntry* ResourceTableType::FindOrCreateEntry(const StringPiece& name) {
   auto last = entries.end();
   auto iter = std::lower_bound(entries.begin(), last, name,
-                               lessThanStructWithName<ResourceEntry>);
+                               less_than_struct_with_name<ResourceEntry>);
   if (iter != last && name == (*iter)->name) {
     return iter->get();
   }
   return entries.emplace(iter, new ResourceEntry(name))->get();
 }
 
-ResourceConfigValue* ResourceEntry::findValue(const ConfigDescription& config) {
-  return findValue(config, StringPiece());
+ResourceConfigValue* ResourceEntry::FindValue(const ConfigDescription& config) {
+  return FindValue(config, StringPiece());
 }
 
 struct ConfigKey {
@@ -144,7 +147,7 @@ bool ltConfigKeyRef(const std::unique_ptr<ResourceConfigValue>& lhs,
   return cmp < 0;
 }
 
-ResourceConfigValue* ResourceEntry::findValue(const ConfigDescription& config,
+ResourceConfigValue* ResourceEntry::FindValue(const ConfigDescription& config,
                                               const StringPiece& product) {
   auto iter = std::lower_bound(values.begin(), values.end(),
                                ConfigKey{&config, product}, ltConfigKeyRef);
@@ -157,7 +160,7 @@ ResourceConfigValue* ResourceEntry::findValue(const ConfigDescription& config,
   return nullptr;
 }
 
-ResourceConfigValue* ResourceEntry::findOrCreateValue(
+ResourceConfigValue* ResourceEntry::FindOrCreateValue(
     const ConfigDescription& config, const StringPiece& product) {
   auto iter = std::lower_bound(values.begin(), values.end(),
                                ConfigKey{&config, product}, ltConfigKeyRef);
@@ -197,7 +200,7 @@ std::vector<ResourceConfigValue*> ResourceEntry::findAllValues(
   return results;
 }
 
-std::vector<ResourceConfigValue*> ResourceEntry::findValuesIf(
+std::vector<ResourceConfigValue*> ResourceEntry::FindValuesIf(
     const std::function<bool(ResourceConfigValue*)>& f) {
   std::vector<ResourceConfigValue*> results;
   for (auto& configValue : values) {
@@ -232,16 +235,16 @@ std::vector<ResourceConfigValue*> ResourceEntry::findValuesIf(
  * format for there to be
  * no error.
  */
-ResourceTable::CollisionResult ResourceTable::resolveValueCollision(
+ResourceTable::CollisionResult ResourceTable::ResolveValueCollision(
     Value* existing, Value* incoming) {
-  Attribute* existingAttr = valueCast<Attribute>(existing);
-  Attribute* incomingAttr = valueCast<Attribute>(incoming);
-  if (!incomingAttr) {
-    if (incoming->isWeak()) {
+  Attribute* existing_attr = ValueCast<Attribute>(existing);
+  Attribute* incoming_attr = ValueCast<Attribute>(incoming);
+  if (!incoming_attr) {
+    if (incoming->IsWeak()) {
       // We're trying to add a weak resource but a resource
       // already exists. Keep the existing.
       return CollisionResult::kKeepOriginal;
-    } else if (existing->isWeak()) {
+    } else if (existing->IsWeak()) {
       // Override the weak resource with the new strong resource.
       return CollisionResult::kTakeNew;
     }
@@ -250,8 +253,8 @@ ResourceTable::CollisionResult ResourceTable::resolveValueCollision(
     return CollisionResult::kConflict;
   }
 
-  if (!existingAttr) {
-    if (existing->isWeak()) {
+  if (!existing_attr) {
+    if (existing->IsWeak()) {
       // The existing value is not an attribute and it is weak,
       // so take the incoming attribute value.
       return CollisionResult::kTakeNew;
@@ -261,7 +264,7 @@ ResourceTable::CollisionResult ResourceTable::resolveValueCollision(
     return CollisionResult::kConflict;
   }
 
-  assert(incomingAttr && existingAttr);
+  CHECK(incoming_attr != nullptr && existing_attr != nullptr);
 
   //
   // Attribute specific handling. At this point we know both
@@ -269,22 +272,22 @@ ResourceTable::CollisionResult ResourceTable::resolveValueCollision(
   // attributes all-over, we do special handling to see
   // which definition sticks.
   //
-  if (existingAttr->typeMask == incomingAttr->typeMask) {
+  if (existing_attr->type_mask == incoming_attr->type_mask) {
     // The two attributes are both DECLs, but they are plain attributes
     // with the same formats.
     // Keep the strongest one.
-    return existingAttr->isWeak() ? CollisionResult::kTakeNew
-                                  : CollisionResult::kKeepOriginal;
+    return existing_attr->IsWeak() ? CollisionResult::kTakeNew
+                                   : CollisionResult::kKeepOriginal;
   }
 
-  if (existingAttr->isWeak() &&
-      existingAttr->typeMask == android::ResTable_map::TYPE_ANY) {
+  if (existing_attr->IsWeak() &&
+      existing_attr->type_mask == android::ResTable_map::TYPE_ANY) {
     // Any incoming attribute is better than this.
     return CollisionResult::kTakeNew;
   }
 
-  if (incomingAttr->isWeak() &&
-      incomingAttr->typeMask == android::ResTable_map::TYPE_ANY) {
+  if (incoming_attr->IsWeak() &&
+      incoming_attr->type_mask == android::ResTable_map::TYPE_ANY) {
     // The incoming attribute may be a USE instead of a DECL.
     // Keep the existing attribute.
     return CollisionResult::kKeepOriginal;
@@ -295,138 +298,139 @@ ResourceTable::CollisionResult ResourceTable::resolveValueCollision(
 static constexpr const char* kValidNameChars = "._-";
 static constexpr const char* kValidNameMangledChars = "._-$";
 
-bool ResourceTable::addResource(const ResourceNameRef& name,
+bool ResourceTable::AddResource(const ResourceNameRef& name,
                                 const ConfigDescription& config,
                                 const StringPiece& product,
                                 std::unique_ptr<Value> value,
                                 IDiagnostics* diag) {
-  return addResourceImpl(name, {}, config, product, std::move(value),
-                         kValidNameChars, resolveValueCollision, diag);
+  return AddResourceImpl(name, {}, config, product, std::move(value),
+                         kValidNameChars, ResolveValueCollision, diag);
 }
 
-bool ResourceTable::addResource(const ResourceNameRef& name,
-                                const ResourceId& resId,
+bool ResourceTable::AddResource(const ResourceNameRef& name,
+                                const ResourceId& res_id,
                                 const ConfigDescription& config,
                                 const StringPiece& product,
                                 std::unique_ptr<Value> value,
                                 IDiagnostics* diag) {
-  return addResourceImpl(name, resId, config, product, std::move(value),
-                         kValidNameChars, resolveValueCollision, diag);
+  return AddResourceImpl(name, res_id, config, product, std::move(value),
+                         kValidNameChars, ResolveValueCollision, diag);
 }
 
-bool ResourceTable::addFileReference(const ResourceNameRef& name,
+bool ResourceTable::AddFileReference(const ResourceNameRef& name,
                                      const ConfigDescription& config,
                                      const Source& source,
                                      const StringPiece& path,
                                      IDiagnostics* diag) {
-  return addFileReferenceImpl(name, config, source, path, nullptr,
+  return AddFileReferenceImpl(name, config, source, path, nullptr,
                               kValidNameChars, diag);
 }
 
-bool ResourceTable::addFileReferenceAllowMangled(
+bool ResourceTable::AddFileReferenceAllowMangled(
     const ResourceNameRef& name, const ConfigDescription& config,
     const Source& source, const StringPiece& path, io::IFile* file,
     IDiagnostics* diag) {
-  return addFileReferenceImpl(name, config, source, path, file,
+  return AddFileReferenceImpl(name, config, source, path, file,
                               kValidNameMangledChars, diag);
 }
 
-bool ResourceTable::addFileReferenceImpl(
+bool ResourceTable::AddFileReferenceImpl(
     const ResourceNameRef& name, const ConfigDescription& config,
     const Source& source, const StringPiece& path, io::IFile* file,
-    const char* validChars, IDiagnostics* diag) {
+    const char* valid_chars, IDiagnostics* diag) {
   std::unique_ptr<FileReference> fileRef =
-      util::make_unique<FileReference>(stringPool.makeRef(path));
-  fileRef->setSource(source);
+      util::make_unique<FileReference>(string_pool.MakeRef(path));
+  fileRef->SetSource(source);
   fileRef->file = file;
-  return addResourceImpl(name, ResourceId{}, config, StringPiece{},
-                         std::move(fileRef), validChars, resolveValueCollision,
+  return AddResourceImpl(name, ResourceId{}, config, StringPiece{},
+                         std::move(fileRef), valid_chars, ResolveValueCollision,
                          diag);
 }
 
-bool ResourceTable::addResourceAllowMangled(const ResourceNameRef& name,
+bool ResourceTable::AddResourceAllowMangled(const ResourceNameRef& name,
                                             const ConfigDescription& config,
                                             const StringPiece& product,
                                             std::unique_ptr<Value> value,
                                             IDiagnostics* diag) {
-  return addResourceImpl(name, ResourceId{}, config, product, std::move(value),
-                         kValidNameMangledChars, resolveValueCollision, diag);
+  return AddResourceImpl(name, ResourceId{}, config, product, std::move(value),
+                         kValidNameMangledChars, ResolveValueCollision, diag);
 }
 
-bool ResourceTable::addResourceAllowMangled(const ResourceNameRef& name,
+bool ResourceTable::AddResourceAllowMangled(const ResourceNameRef& name,
                                             const ResourceId& id,
                                             const ConfigDescription& config,
                                             const StringPiece& product,
                                             std::unique_ptr<Value> value,
                                             IDiagnostics* diag) {
-  return addResourceImpl(name, id, config, product, std::move(value),
-                         kValidNameMangledChars, resolveValueCollision, diag);
+  return AddResourceImpl(name, id, config, product, std::move(value),
+                         kValidNameMangledChars, ResolveValueCollision, diag);
 }
 
-bool ResourceTable::addResourceImpl(
-    const ResourceNameRef& name, const ResourceId& resId,
+bool ResourceTable::AddResourceImpl(
+    const ResourceNameRef& name, const ResourceId& res_id,
     const ConfigDescription& config, const StringPiece& product,
-    std::unique_ptr<Value> value, const char* validChars,
+    std::unique_ptr<Value> value, const char* valid_chars,
     const CollisionResolverFunc& conflictResolver, IDiagnostics* diag) {
-  assert(value && "value can't be nullptr");
-  assert(diag && "diagnostics can't be nullptr");
+  CHECK(value != nullptr);
+  CHECK(diag != nullptr);
 
-  auto badCharIter =
-      util::findNonAlphaNumericAndNotInSet(name.entry, validChars);
-  if (badCharIter != name.entry.end()) {
-    diag->error(DiagMessage(value->getSource())
+  auto bad_char_iter =
+      util::FindNonAlphaNumericAndNotInSet(name.entry, valid_chars);
+  if (bad_char_iter != name.entry.end()) {
+    diag->Error(DiagMessage(value->GetSource())
                 << "resource '" << name << "' has invalid entry name '"
                 << name.entry << "'. Invalid character '"
-                << StringPiece(badCharIter, 1) << "'");
+                << StringPiece(bad_char_iter, 1) << "'");
     return false;
   }
 
-  ResourceTablePackage* package = findOrCreatePackage(name.package);
-  if (resId.isValid() && package->id &&
-      package->id.value() != resId.packageId()) {
-    diag->error(DiagMessage(value->getSource())
-                << "trying to add resource '" << name << "' with ID " << resId
+  ResourceTablePackage* package = FindOrCreatePackage(name.package);
+  if (res_id.is_valid() && package->id &&
+      package->id.value() != res_id.package_id()) {
+    diag->Error(DiagMessage(value->GetSource())
+                << "trying to add resource '" << name << "' with ID " << res_id
                 << " but package '" << package->name << "' already has ID "
                 << std::hex << (int)package->id.value() << std::dec);
     return false;
   }
 
-  ResourceTableType* type = package->findOrCreateType(name.type);
-  if (resId.isValid() && type->id && type->id.value() != resId.typeId()) {
-    diag->error(DiagMessage(value->getSource())
-                << "trying to add resource '" << name << "' with ID " << resId
+  ResourceTableType* type = package->FindOrCreateType(name.type);
+  if (res_id.is_valid() && type->id && type->id.value() != res_id.type_id()) {
+    diag->Error(DiagMessage(value->GetSource())
+                << "trying to add resource '" << name << "' with ID " << res_id
                 << " but type '" << type->type << "' already has ID "
                 << std::hex << (int)type->id.value() << std::dec);
     return false;
   }
 
-  ResourceEntry* entry = type->findOrCreateEntry(name.entry);
-  if (resId.isValid() && entry->id && entry->id.value() != resId.entryId()) {
-    diag->error(DiagMessage(value->getSource())
-                << "trying to add resource '" << name << "' with ID " << resId
+  ResourceEntry* entry = type->FindOrCreateEntry(name.entry);
+  if (res_id.is_valid() && entry->id &&
+      entry->id.value() != res_id.entry_id()) {
+    diag->Error(DiagMessage(value->GetSource())
+                << "trying to add resource '" << name << "' with ID " << res_id
                 << " but resource already has ID "
                 << ResourceId(package->id.value(), type->id.value(),
                               entry->id.value()));
     return false;
   }
 
-  ResourceConfigValue* configValue = entry->findOrCreateValue(config, product);
-  if (!configValue->value) {
+  ResourceConfigValue* config_value = entry->FindOrCreateValue(config, product);
+  if (!config_value->value) {
     // Resource does not exist, add it now.
-    configValue->value = std::move(value);
+    config_value->value = std::move(value);
 
   } else {
-    switch (conflictResolver(configValue->value.get(), value.get())) {
+    switch (conflictResolver(config_value->value.get(), value.get())) {
       case CollisionResult::kTakeNew:
         // Take the incoming value.
-        configValue->value = std::move(value);
+        config_value->value = std::move(value);
         break;
 
       case CollisionResult::kConflict:
-        diag->error(DiagMessage(value->getSource())
+        diag->Error(DiagMessage(value->GetSource())
                     << "duplicate value for resource '" << name << "' "
                     << "with config '" << config << "'");
-        diag->error(DiagMessage(configValue->value->getSource())
+        diag->Error(DiagMessage(config_value->value->GetSource())
                     << "resource previously defined here");
         return false;
 
@@ -435,113 +439,114 @@ bool ResourceTable::addResourceImpl(
     }
   }
 
-  if (resId.isValid()) {
-    package->id = resId.packageId();
-    type->id = resId.typeId();
-    entry->id = resId.entryId();
+  if (res_id.is_valid()) {
+    package->id = res_id.package_id();
+    type->id = res_id.type_id();
+    entry->id = res_id.entry_id();
   }
   return true;
 }
 
-bool ResourceTable::setSymbolState(const ResourceNameRef& name,
-                                   const ResourceId& resId,
+bool ResourceTable::SetSymbolState(const ResourceNameRef& name,
+                                   const ResourceId& res_id,
                                    const Symbol& symbol, IDiagnostics* diag) {
-  return setSymbolStateImpl(name, resId, symbol, kValidNameChars, diag);
+  return SetSymbolStateImpl(name, res_id, symbol, kValidNameChars, diag);
 }
 
-bool ResourceTable::setSymbolStateAllowMangled(const ResourceNameRef& name,
-                                               const ResourceId& resId,
+bool ResourceTable::SetSymbolStateAllowMangled(const ResourceNameRef& name,
+                                               const ResourceId& res_id,
                                                const Symbol& symbol,
                                                IDiagnostics* diag) {
-  return setSymbolStateImpl(name, resId, symbol, kValidNameMangledChars, diag);
+  return SetSymbolStateImpl(name, res_id, symbol, kValidNameMangledChars, diag);
 }
 
-bool ResourceTable::setSymbolStateImpl(const ResourceNameRef& name,
-                                       const ResourceId& resId,
+bool ResourceTable::SetSymbolStateImpl(const ResourceNameRef& name,
+                                       const ResourceId& res_id,
                                        const Symbol& symbol,
-                                       const char* validChars,
+                                       const char* valid_chars,
                                        IDiagnostics* diag) {
-  assert(diag && "diagnostics can't be nullptr");
+  CHECK(diag != nullptr);
 
-  auto badCharIter =
-      util::findNonAlphaNumericAndNotInSet(name.entry, validChars);
-  if (badCharIter != name.entry.end()) {
-    diag->error(DiagMessage(symbol.source)
+  auto bad_char_iter =
+      util::FindNonAlphaNumericAndNotInSet(name.entry, valid_chars);
+  if (bad_char_iter != name.entry.end()) {
+    diag->Error(DiagMessage(symbol.source)
                 << "resource '" << name << "' has invalid entry name '"
                 << name.entry << "'. Invalid character '"
-                << StringPiece(badCharIter, 1) << "'");
+                << StringPiece(bad_char_iter, 1) << "'");
     return false;
   }
 
-  ResourceTablePackage* package = findOrCreatePackage(name.package);
-  if (resId.isValid() && package->id &&
-      package->id.value() != resId.packageId()) {
-    diag->error(DiagMessage(symbol.source)
-                << "trying to add resource '" << name << "' with ID " << resId
+  ResourceTablePackage* package = FindOrCreatePackage(name.package);
+  if (res_id.is_valid() && package->id &&
+      package->id.value() != res_id.package_id()) {
+    diag->Error(DiagMessage(symbol.source)
+                << "trying to add resource '" << name << "' with ID " << res_id
                 << " but package '" << package->name << "' already has ID "
                 << std::hex << (int)package->id.value() << std::dec);
     return false;
   }
 
-  ResourceTableType* type = package->findOrCreateType(name.type);
-  if (resId.isValid() && type->id && type->id.value() != resId.typeId()) {
-    diag->error(DiagMessage(symbol.source)
-                << "trying to add resource '" << name << "' with ID " << resId
+  ResourceTableType* type = package->FindOrCreateType(name.type);
+  if (res_id.is_valid() && type->id && type->id.value() != res_id.type_id()) {
+    diag->Error(DiagMessage(symbol.source)
+                << "trying to add resource '" << name << "' with ID " << res_id
                 << " but type '" << type->type << "' already has ID "
                 << std::hex << (int)type->id.value() << std::dec);
     return false;
   }
 
-  ResourceEntry* entry = type->findOrCreateEntry(name.entry);
-  if (resId.isValid() && entry->id && entry->id.value() != resId.entryId()) {
-    diag->error(DiagMessage(symbol.source)
-                << "trying to add resource '" << name << "' with ID " << resId
+  ResourceEntry* entry = type->FindOrCreateEntry(name.entry);
+  if (res_id.is_valid() && entry->id &&
+      entry->id.value() != res_id.entry_id()) {
+    diag->Error(DiagMessage(symbol.source)
+                << "trying to add resource '" << name << "' with ID " << res_id
                 << " but resource already has ID "
                 << ResourceId(package->id.value(), type->id.value(),
                               entry->id.value()));
     return false;
   }
 
-  if (resId.isValid()) {
-    package->id = resId.packageId();
-    type->id = resId.typeId();
-    entry->id = resId.entryId();
+  if (res_id.is_valid()) {
+    package->id = res_id.package_id();
+    type->id = res_id.type_id();
+    entry->id = res_id.entry_id();
   }
 
   // Only mark the type state as public, it doesn't care about being private.
   if (symbol.state == SymbolState::kPublic) {
-    type->symbolStatus.state = SymbolState::kPublic;
+    type->symbol_status.state = SymbolState::kPublic;
   }
 
   if (symbol.state == SymbolState::kUndefined &&
-      entry->symbolStatus.state != SymbolState::kUndefined) {
+      entry->symbol_status.state != SymbolState::kUndefined) {
     // We can't undefine a symbol (remove its visibility). Ignore.
     return true;
   }
 
   if (symbol.state == SymbolState::kPrivate &&
-      entry->symbolStatus.state == SymbolState::kPublic) {
+      entry->symbol_status.state == SymbolState::kPublic) {
     // We can't downgrade public to private. Ignore.
     return true;
   }
 
-  entry->symbolStatus = std::move(symbol);
+  entry->symbol_status = std::move(symbol);
   return true;
 }
 
-Maybe<ResourceTable::SearchResult> ResourceTable::findResource(
+Maybe<ResourceTable::SearchResult> ResourceTable::FindResource(
     const ResourceNameRef& name) {
-  ResourceTablePackage* package = findPackage(name.package);
+  ResourceTablePackage* package = FindPackage(name.package);
   if (!package) {
     return {};
   }
 
-  ResourceTableType* type = package->findType(name.type);
+  ResourceTableType* type = package->FindType(name.type);
   if (!type) {
     return {};
   }
 
-  ResourceEntry* entry = type->findEntry(name.entry);
+  ResourceEntry* entry = type->FindEntry(name.entry);
   if (!entry) {
     return {};
   }
diff --git a/tools/aapt2/ResourceTable.h b/tools/aapt2/ResourceTable.h
index ebaad41eac6e1..a0c3217df6104 100644
--- a/tools/aapt2/ResourceTable.h
+++ b/tools/aapt2/ResourceTable.h
@@ -70,7 +70,7 @@ class ResourceConfigValue {
 
   ResourceConfigValue(const ConfigDescription& config,
                       const StringPiece& product)
-      : config(config), product(product.toString()) {}
+      : config(config), product(product.ToString()) {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ResourceConfigValue);
@@ -98,23 +98,23 @@ class ResourceEntry {
    * Whether this resource is public (and must maintain the same entry ID across
    * builds).
    */
-  Symbol symbolStatus;
+  Symbol symbol_status;
 
   /**
    * The resource's values for each configuration.
    */
   std::vector<std::unique_ptr<ResourceConfigValue>> values;
 
-  explicit ResourceEntry(const StringPiece& name) : name(name.toString()) {}
+  explicit ResourceEntry(const StringPiece& name) : name(name.ToString()) {}
 
-  ResourceConfigValue* findValue(const ConfigDescription& config);
-  ResourceConfigValue* findValue(const ConfigDescription& config,
+  ResourceConfigValue* FindValue(const ConfigDescription& config);
+  ResourceConfigValue* FindValue(const ConfigDescription& config,
                                  const StringPiece& product);
-  ResourceConfigValue* findOrCreateValue(const ConfigDescription& config,
+  ResourceConfigValue* FindOrCreateValue(const ConfigDescription& config,
                                          const StringPiece& product);
   std::vector<ResourceConfigValue*> findAllValues(
       const ConfigDescription& config);
-  std::vector<ResourceConfigValue*> findValuesIf(
+  std::vector<ResourceConfigValue*> FindValuesIf(
       const std::function<bool(ResourceConfigValue*)>& f);
 
  private:
@@ -141,7 +141,7 @@ class ResourceTableType {
    * Whether this type is public (and must maintain the same
    * type ID across builds).
    */
-  Symbol symbolStatus;
+  Symbol symbol_status;
 
   /**
    * List of resources for this type.
@@ -150,8 +150,8 @@ class ResourceTableType {
 
   explicit ResourceTableType(const ResourceType type) : type(type) {}
 
-  ResourceEntry* findEntry(const StringPiece& name);
-  ResourceEntry* findOrCreateEntry(const StringPiece& name);
+  ResourceEntry* FindEntry(const StringPiece& name);
+  ResourceEntry* FindOrCreateEntry(const StringPiece& name);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ResourceTableType);
@@ -168,8 +168,8 @@ class ResourceTablePackage {
   std::vector<std::unique_ptr<ResourceTableType>> types;
 
   ResourceTablePackage() = default;
-  ResourceTableType* findType(ResourceType type);
-  ResourceTableType* findOrCreateType(const ResourceType type);
+  ResourceTableType* FindType(ResourceType type);
+  ResourceTableType* FindOrCreateType(const ResourceType type);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ResourceTablePackage);
@@ -191,53 +191,53 @@ class ResourceTable {
    * When a collision of resources occurs, this method decides which value to
    * keep.
    */
-  static CollisionResult resolveValueCollision(Value* existing,
+  static CollisionResult ResolveValueCollision(Value* existing,
                                                Value* incoming);
 
-  bool addResource(const ResourceNameRef& name, const ConfigDescription& config,
+  bool AddResource(const ResourceNameRef& name, const ConfigDescription& config,
                    const StringPiece& product, std::unique_ptr<Value> value,
                    IDiagnostics* diag);
 
-  bool addResource(const ResourceNameRef& name, const ResourceId& resId,
+  bool AddResource(const ResourceNameRef& name, const ResourceId& res_id,
                    const ConfigDescription& config, const StringPiece& product,
                    std::unique_ptr<Value> value, IDiagnostics* diag);
 
-  bool addFileReference(const ResourceNameRef& name,
+  bool AddFileReference(const ResourceNameRef& name,
                         const ConfigDescription& config, const Source& source,
                         const StringPiece& path, IDiagnostics* diag);
 
-  bool addFileReferenceAllowMangled(const ResourceNameRef& name,
+  bool AddFileReferenceAllowMangled(const ResourceNameRef& name,
                                     const ConfigDescription& config,
                                     const Source& source,
                                     const StringPiece& path, io::IFile* file,
                                     IDiagnostics* diag);
 
   /**
-   * Same as addResource, but doesn't verify the validity of the name. This is
+   * Same as AddResource, but doesn't verify the validity of the name. This is
    * used
    * when loading resources from an existing binary resource table that may have
    * mangled
    * names.
    */
-  bool addResourceAllowMangled(const ResourceNameRef& name,
+  bool AddResourceAllowMangled(const ResourceNameRef& name,
                                const ConfigDescription& config,
                                const StringPiece& product,
                                std::unique_ptr<Value> value,
                                IDiagnostics* diag);
 
-  bool addResourceAllowMangled(const ResourceNameRef& name,
+  bool AddResourceAllowMangled(const ResourceNameRef& name,
                                const ResourceId& id,
                                const ConfigDescription& config,
                                const StringPiece& product,
                                std::unique_ptr<Value> value,
                                IDiagnostics* diag);
 
-  bool setSymbolState(const ResourceNameRef& name, const ResourceId& resId,
+  bool SetSymbolState(const ResourceNameRef& name, const ResourceId& res_id,
                       const Symbol& symbol, IDiagnostics* diag);
 
-  bool setSymbolStateAllowMangled(const ResourceNameRef& name,
-                                  const ResourceId& resId, const Symbol& symbol,
-                                  IDiagnostics* diag);
+  bool SetSymbolStateAllowMangled(const ResourceNameRef& name,
+                                  const ResourceId& res_id,
+                                  const Symbol& symbol, IDiagnostics* diag);
 
   struct SearchResult {
     ResourceTablePackage* package;
@@ -245,21 +245,21 @@ class ResourceTable {
     ResourceEntry* entry;
   };
 
-  Maybe<SearchResult> findResource(const ResourceNameRef& name);
+  Maybe<SearchResult> FindResource(const ResourceNameRef& name);
 
   /**
    * The string pool used by this resource table. Values that reference strings
    * must use
    * this pool to create their strings.
    *
-   * NOTE: `stringPool` must come before `packages` so that it is destroyed
+   * NOTE: `string_pool` must come before `packages` so that it is destroyed
    * after.
-   * When `string pool` references are destroyed (as they will be when
+   * When `string_pool` references are destroyed (as they will be when
    * `packages`
    * is destroyed), they decrement a refCount, which would cause invalid
    * memory access if the pool was already destroyed.
    */
-  StringPool stringPool;
+  StringPool string_pool;
 
   /**
    * The list of packages in this table, sorted alphabetically by package name.
@@ -273,31 +273,31 @@ class ResourceTable {
    * represent the
    * 'current' package before it is known to the ResourceTable.
    */
-  ResourceTablePackage* findPackage(const StringPiece& name);
+  ResourceTablePackage* FindPackage(const StringPiece& name);
 
-  ResourceTablePackage* findPackageById(uint8_t id);
+  ResourceTablePackage* FindPackageById(uint8_t id);
 
-  ResourceTablePackage* createPackage(const StringPiece& name,
+  ResourceTablePackage* CreatePackage(const StringPiece& name,
                                       Maybe<uint8_t> id = {});
 
  private:
-  ResourceTablePackage* findOrCreatePackage(const StringPiece& name);
+  ResourceTablePackage* FindOrCreatePackage(const StringPiece& name);
 
-  bool addResourceImpl(const ResourceNameRef& name, const ResourceId& resId,
+  bool AddResourceImpl(const ResourceNameRef& name, const ResourceId& res_id,
                        const ConfigDescription& config,
                        const StringPiece& product, std::unique_ptr<Value> value,
-                       const char* validChars,
-                       const CollisionResolverFunc& conflictResolver,
+                       const char* valid_chars,
+                       const CollisionResolverFunc& conflict_resolver,
                        IDiagnostics* diag);
 
-  bool addFileReferenceImpl(const ResourceNameRef& name,
+  bool AddFileReferenceImpl(const ResourceNameRef& name,
                             const ConfigDescription& config,
                             const Source& source, const StringPiece& path,
-                            io::IFile* file, const char* validChars,
+                            io::IFile* file, const char* valid_chars,
                             IDiagnostics* diag);
 
-  bool setSymbolStateImpl(const ResourceNameRef& name, const ResourceId& resId,
-                          const Symbol& symbol, const char* validChars,
+  bool SetSymbolStateImpl(const ResourceNameRef& name, const ResourceId& res_id,
+                          const Symbol& symbol, const char* valid_chars,
                           IDiagnostics* diag);
 
   DISALLOW_COPY_AND_ASSIGN(ResourceTable);
diff --git a/tools/aapt2/ResourceTable_test.cpp b/tools/aapt2/ResourceTable_test.cpp
index a64ad3eb639ad..cb3699a00f755 100644
--- a/tools/aapt2/ResourceTable_test.cpp
+++ b/tools/aapt2/ResourceTable_test.cpp
@@ -29,108 +29,108 @@ namespace aapt {
 TEST(ResourceTableTest, FailToAddResourceWithBadName) {
   ResourceTable table;
 
-  EXPECT_FALSE(table.addResource(
-      test::parseNameOrDie("android:id/hey,there"), ConfigDescription{}, "",
-      test::ValueBuilder<Id>().setSource("test.xml", 21u).build(),
-      test::getDiagnostics()));
+  EXPECT_FALSE(table.AddResource(
+      test::ParseNameOrDie("android:id/hey,there"), ConfigDescription{}, "",
+      test::ValueBuilder<Id>().SetSource("test.xml", 21u).Build(),
+      test::GetDiagnostics()));
 
-  EXPECT_FALSE(table.addResource(
-      test::parseNameOrDie("android:id/hey:there"), ConfigDescription{}, "",
-      test::ValueBuilder<Id>().setSource("test.xml", 21u).build(),
-      test::getDiagnostics()));
+  EXPECT_FALSE(table.AddResource(
+      test::ParseNameOrDie("android:id/hey:there"), ConfigDescription{}, "",
+      test::ValueBuilder<Id>().SetSource("test.xml", 21u).Build(),
+      test::GetDiagnostics()));
 }
 
 TEST(ResourceTableTest, AddOneResource) {
   ResourceTable table;
 
-  EXPECT_TRUE(table.addResource(
-      test::parseNameOrDie("android:attr/id"), ConfigDescription{}, "",
-      test::ValueBuilder<Id>().setSource("test/path/file.xml", 23u).build(),
-      test::getDiagnostics()));
+  EXPECT_TRUE(table.AddResource(
+      test::ParseNameOrDie("android:attr/id"), ConfigDescription{}, "",
+      test::ValueBuilder<Id>().SetSource("test/path/file.xml", 23u).Build(),
+      test::GetDiagnostics()));
 
-  ASSERT_NE(nullptr, test::getValue<Id>(&table, "android:attr/id"));
+  ASSERT_NE(nullptr, test::GetValue<Id>(&table, "android:attr/id"));
 }
 
 TEST(ResourceTableTest, AddMultipleResources) {
   ResourceTable table;
 
   ConfigDescription config;
-  ConfigDescription languageConfig;
-  memcpy(languageConfig.language, "pl", sizeof(languageConfig.language));
+  ConfigDescription language_config;
+  memcpy(language_config.language, "pl", sizeof(language_config.language));
 
-  EXPECT_TRUE(table.addResource(
-      test::parseNameOrDie("android:attr/layout_width"), config, "",
-      test::ValueBuilder<Id>().setSource("test/path/file.xml", 10u).build(),
-      test::getDiagnostics()));
+  EXPECT_TRUE(table.AddResource(
+      test::ParseNameOrDie("android:attr/layout_width"), config, "",
+      test::ValueBuilder<Id>().SetSource("test/path/file.xml", 10u).Build(),
+      test::GetDiagnostics()));
 
-  EXPECT_TRUE(table.addResource(
-      test::parseNameOrDie("android:attr/id"), config, "",
-      test::ValueBuilder<Id>().setSource("test/path/file.xml", 12u).build(),
-      test::getDiagnostics()));
+  EXPECT_TRUE(table.AddResource(
+      test::ParseNameOrDie("android:attr/id"), config, "",
+      test::ValueBuilder<Id>().SetSource("test/path/file.xml", 12u).Build(),
+      test::GetDiagnostics()));
 
-  EXPECT_TRUE(table.addResource(
-      test::parseNameOrDie("android:string/ok"), config, "",
-      test::ValueBuilder<Id>().setSource("test/path/file.xml", 14u).build(),
-      test::getDiagnostics()));
+  EXPECT_TRUE(table.AddResource(
+      test::ParseNameOrDie("android:string/ok"), config, "",
+      test::ValueBuilder<Id>().SetSource("test/path/file.xml", 14u).Build(),
+      test::GetDiagnostics()));
 
-  EXPECT_TRUE(table.addResource(
-      test::parseNameOrDie("android:string/ok"), languageConfig, "",
+  EXPECT_TRUE(table.AddResource(
+      test::ParseNameOrDie("android:string/ok"), language_config, "",
       test::ValueBuilder<BinaryPrimitive>(android::Res_value{})
-          .setSource("test/path/file.xml", 20u)
-          .build(),
-      test::getDiagnostics()));
+          .SetSource("test/path/file.xml", 20u)
+          .Build(),
+      test::GetDiagnostics()));
 
-  ASSERT_NE(nullptr, test::getValue<Id>(&table, "android:attr/layout_width"));
-  ASSERT_NE(nullptr, test::getValue<Id>(&table, "android:attr/id"));
-  ASSERT_NE(nullptr, test::getValue<Id>(&table, "android:string/ok"));
-  ASSERT_NE(nullptr, test::getValueForConfig<BinaryPrimitive>(
-                         &table, "android:string/ok", languageConfig));
+  ASSERT_NE(nullptr, test::GetValue<Id>(&table, "android:attr/layout_width"));
+  ASSERT_NE(nullptr, test::GetValue<Id>(&table, "android:attr/id"));
+  ASSERT_NE(nullptr, test::GetValue<Id>(&table, "android:string/ok"));
+  ASSERT_NE(nullptr, test::GetValueForConfig<BinaryPrimitive>(
+                         &table, "android:string/ok", language_config));
 }
 
 TEST(ResourceTableTest, OverrideWeakResourceValue) {
   ResourceTable table;
 
-  ASSERT_TRUE(table.addResource(
-      test::parseNameOrDie("android:attr/foo"), ConfigDescription{}, "",
-      util::make_unique<Attribute>(true), test::getDiagnostics()));
+  ASSERT_TRUE(table.AddResource(
+      test::ParseNameOrDie("android:attr/foo"), ConfigDescription{}, "",
+      util::make_unique<Attribute>(true), test::GetDiagnostics()));
 
-  Attribute* attr = test::getValue<Attribute>(&table, "android:attr/foo");
+  Attribute* attr = test::GetValue<Attribute>(&table, "android:attr/foo");
   ASSERT_NE(nullptr, attr);
-  EXPECT_TRUE(attr->isWeak());
+  EXPECT_TRUE(attr->IsWeak());
 
-  ASSERT_TRUE(table.addResource(
-      test::parseNameOrDie("android:attr/foo"), ConfigDescription{}, "",
-      util::make_unique<Attribute>(false), test::getDiagnostics()));
+  ASSERT_TRUE(table.AddResource(
+      test::ParseNameOrDie("android:attr/foo"), ConfigDescription{}, "",
+      util::make_unique<Attribute>(false), test::GetDiagnostics()));
 
-  attr = test::getValue<Attribute>(&table, "android:attr/foo");
+  attr = test::GetValue<Attribute>(&table, "android:attr/foo");
   ASSERT_NE(nullptr, attr);
-  EXPECT_FALSE(attr->isWeak());
+  EXPECT_FALSE(attr->IsWeak());
 }
 
 TEST(ResourceTableTest, ProductVaryingValues) {
   ResourceTable table;
 
-  EXPECT_TRUE(table.addResource(test::parseNameOrDie("android:string/foo"),
-                                test::parseConfigOrDie("land"), "tablet",
+  EXPECT_TRUE(table.AddResource(test::ParseNameOrDie("android:string/foo"),
+                                test::ParseConfigOrDie("land"), "tablet",
                                 util::make_unique<Id>(),
-                                test::getDiagnostics()));
-  EXPECT_TRUE(table.addResource(test::parseNameOrDie("android:string/foo"),
-                                test::parseConfigOrDie("land"), "phone",
+                                test::GetDiagnostics()));
+  EXPECT_TRUE(table.AddResource(test::ParseNameOrDie("android:string/foo"),
+                                test::ParseConfigOrDie("land"), "phone",
                                 util::make_unique<Id>(),
-                                test::getDiagnostics()));
+                                test::GetDiagnostics()));
 
-  EXPECT_NE(nullptr, test::getValueForConfigAndProduct<Id>(
+  EXPECT_NE(nullptr, test::GetValueForConfigAndProduct<Id>(
                          &table, "android:string/foo",
-                         test::parseConfigOrDie("land"), "tablet"));
-  EXPECT_NE(nullptr, test::getValueForConfigAndProduct<Id>(
+                         test::ParseConfigOrDie("land"), "tablet"));
+  EXPECT_NE(nullptr, test::GetValueForConfigAndProduct<Id>(
                          &table, "android:string/foo",
-                         test::parseConfigOrDie("land"), "phone"));
+                         test::ParseConfigOrDie("land"), "phone"));
 
   Maybe<ResourceTable::SearchResult> sr =
-      table.findResource(test::parseNameOrDie("android:string/foo"));
+      table.FindResource(test::ParseNameOrDie("android:string/foo"));
   AAPT_ASSERT_TRUE(sr);
   std::vector<ResourceConfigValue*> values =
-      sr.value().entry->findAllValues(test::parseConfigOrDie("land"));
+      sr.value().entry->findAllValues(test::ParseConfigOrDie("land"));
   ASSERT_EQ(2u, values.size());
   EXPECT_EQ(std::string("phone"), values[0]->product);
   EXPECT_EQ(std::string("tablet"), values[1]->product);
diff --git a/tools/aapt2/ResourceUtils.cpp b/tools/aapt2/ResourceUtils.cpp
index b41be4bab0b8f..fce9b338d7268 100644
--- a/tools/aapt2/ResourceUtils.cpp
+++ b/tools/aapt2/ResourceUtils.cpp
@@ -15,34 +15,36 @@
  */
 
 #include "ResourceUtils.h"
+
+#include <sstream>
+
+#include "androidfw/ResourceTypes.h"
+
 #include "NameMangler.h"
 #include "SdkConstants.h"
 #include "flatten/ResourceTypeExtensions.h"
 #include "util/Files.h"
 #include "util/Util.h"
 
-#include <androidfw/ResourceTypes.h>
-#include <sstream>
-
 namespace aapt {
 namespace ResourceUtils {
 
-Maybe<ResourceName> toResourceName(
-    const android::ResTable::resource_name& nameIn) {
-  ResourceName nameOut;
-  if (!nameIn.package) {
+Maybe<ResourceName> ToResourceName(
+    const android::ResTable::resource_name& name_in) {
+  ResourceName name_out;
+  if (!name_in.package) {
     return {};
   }
 
-  nameOut.package =
-      util::utf16ToUtf8(StringPiece16(nameIn.package, nameIn.packageLen));
+  name_out.package =
+      util::Utf16ToUtf8(StringPiece16(name_in.package, name_in.packageLen));
 
   const ResourceType* type;
-  if (nameIn.type) {
-    type = parseResourceType(
-        util::utf16ToUtf8(StringPiece16(nameIn.type, nameIn.typeLen)));
-  } else if (nameIn.type8) {
-    type = parseResourceType(StringPiece(nameIn.type8, nameIn.typeLen));
+  if (name_in.type) {
+    type = ParseResourceType(
+        util::Utf16ToUtf8(StringPiece16(name_in.type, name_in.typeLen)));
+  } else if (name_in.type8) {
+    type = ParseResourceType(StringPiece(name_in.type8, name_in.typeLen));
   } else {
     return {};
   }
@@ -51,46 +53,46 @@ Maybe<ResourceName> toResourceName(
     return {};
   }
 
-  nameOut.type = *type;
+  name_out.type = *type;
 
-  if (nameIn.name) {
-    nameOut.entry =
-        util::utf16ToUtf8(StringPiece16(nameIn.name, nameIn.nameLen));
-  } else if (nameIn.name8) {
-    nameOut.entry = StringPiece(nameIn.name8, nameIn.nameLen).toString();
+  if (name_in.name) {
+    name_out.entry =
+        util::Utf16ToUtf8(StringPiece16(name_in.name, name_in.nameLen));
+  } else if (name_in.name8) {
+    name_out.entry = StringPiece(name_in.name8, name_in.nameLen).ToString();
   } else {
     return {};
   }
-  return nameOut;
+  return name_out;
 }
 
-bool extractResourceName(const StringPiece& str, StringPiece* outPackage,
-                         StringPiece* outType, StringPiece* outEntry) {
-  bool hasPackageSeparator = false;
-  bool hasTypeSeparator = false;
+bool ExtractResourceName(const StringPiece& str, StringPiece* out_package,
+                         StringPiece* out_type, StringPiece* out_entry) {
+  bool has_package_separator = false;
+  bool has_type_separator = false;
   const char* start = str.data();
   const char* end = start + str.size();
   const char* current = start;
   while (current != end) {
-    if (outType->size() == 0 && *current == '/') {
-      hasTypeSeparator = true;
-      outType->assign(start, current - start);
+    if (out_type->size() == 0 && *current == '/') {
+      has_type_separator = true;
+      out_type->assign(start, current - start);
       start = current + 1;
-    } else if (outPackage->size() == 0 && *current == ':') {
-      hasPackageSeparator = true;
-      outPackage->assign(start, current - start);
+    } else if (out_package->size() == 0 && *current == ':') {
+      has_package_separator = true;
+      out_package->assign(start, current - start);
       start = current + 1;
     }
     current++;
   }
-  outEntry->assign(start, end - start);
+  out_entry->assign(start, end - start);
 
-  return !(hasPackageSeparator && outPackage->empty()) &&
-         !(hasTypeSeparator && outType->empty());
+  return !(has_package_separator && out_package->empty()) &&
+         !(has_type_separator && out_type->empty());
 }
 
-bool parseResourceName(const StringPiece& str, ResourceNameRef* outRef,
-                       bool* outPrivate) {
+bool ParseResourceName(const StringPiece& str, ResourceNameRef* out_ref,
+                       bool* out_private) {
   if (str.empty()) {
     return false;
   }
@@ -105,13 +107,13 @@ bool parseResourceName(const StringPiece& str, ResourceNameRef* outRef,
   StringPiece package;
   StringPiece type;
   StringPiece entry;
-  if (!extractResourceName(str.substr(offset, str.size() - offset), &package,
+  if (!ExtractResourceName(str.substr(offset, str.size() - offset), &package,
                            &type, &entry)) {
     return false;
   }
 
-  const ResourceType* parsedType = parseResourceType(type);
-  if (!parsedType) {
+  const ResourceType* parsed_type = ParseResourceType(type);
+  if (!parsed_type) {
     return false;
   }
 
@@ -119,37 +121,37 @@ bool parseResourceName(const StringPiece& str, ResourceNameRef* outRef,
     return false;
   }
 
-  if (outRef) {
-    outRef->package = package;
-    outRef->type = *parsedType;
-    outRef->entry = entry;
+  if (out_ref) {
+    out_ref->package = package;
+    out_ref->type = *parsed_type;
+    out_ref->entry = entry;
   }
 
-  if (outPrivate) {
-    *outPrivate = priv;
+  if (out_private) {
+    *out_private = priv;
   }
   return true;
 }
 
-bool parseReference(const StringPiece& str, ResourceNameRef* outRef,
-                    bool* outCreate, bool* outPrivate) {
-  StringPiece trimmedStr(util::trimWhitespace(str));
-  if (trimmedStr.empty()) {
+bool ParseReference(const StringPiece& str, ResourceNameRef* out_ref,
+                    bool* out_create, bool* out_private) {
+  StringPiece trimmed_str(util::TrimWhitespace(str));
+  if (trimmed_str.empty()) {
     return false;
   }
 
   bool create = false;
   bool priv = false;
-  if (trimmedStr.data()[0] == '@') {
+  if (trimmed_str.data()[0] == '@') {
     size_t offset = 1;
-    if (trimmedStr.data()[1] == '+') {
+    if (trimmed_str.data()[1] == '+') {
       create = true;
       offset += 1;
     }
 
     ResourceNameRef name;
-    if (!parseResourceName(
-            trimmedStr.substr(offset, trimmedStr.size() - offset), &name,
+    if (!ParseResourceName(
+            trimmed_str.substr(offset, trimmed_str.size() - offset), &name,
             &priv)) {
       return false;
     }
@@ -162,37 +164,37 @@ bool parseReference(const StringPiece& str, ResourceNameRef* outRef,
       return false;
     }
 
-    if (outRef) {
-      *outRef = name;
+    if (out_ref) {
+      *out_ref = name;
     }
 
-    if (outCreate) {
-      *outCreate = create;
+    if (out_create) {
+      *out_create = create;
     }
 
-    if (outPrivate) {
-      *outPrivate = priv;
+    if (out_private) {
+      *out_private = priv;
     }
     return true;
   }
   return false;
 }
 
-bool isReference(const StringPiece& str) {
-  return parseReference(str, nullptr, nullptr, nullptr);
+bool IsReference(const StringPiece& str) {
+  return ParseReference(str, nullptr, nullptr, nullptr);
 }
 
-bool parseAttributeReference(const StringPiece& str, ResourceNameRef* outRef) {
-  StringPiece trimmedStr(util::trimWhitespace(str));
-  if (trimmedStr.empty()) {
+bool ParseAttributeReference(const StringPiece& str, ResourceNameRef* out_ref) {
+  StringPiece trimmed_str(util::TrimWhitespace(str));
+  if (trimmed_str.empty()) {
     return false;
   }
 
-  if (*trimmedStr.data() == '?') {
+  if (*trimmed_str.data() == '?') {
     StringPiece package;
     StringPiece type;
     StringPiece entry;
-    if (!extractResourceName(trimmedStr.substr(1, trimmedStr.size() - 1),
+    if (!ExtractResourceName(trimmed_str.substr(1, trimmed_str.size() - 1),
                              &package, &type, &entry)) {
       return false;
     }
@@ -205,18 +207,18 @@ bool parseAttributeReference(const StringPiece& str, ResourceNameRef* outRef) {
       return false;
     }
 
-    if (outRef) {
-      outRef->package = package;
-      outRef->type = ResourceType::kAttr;
-      outRef->entry = entry;
+    if (out_ref) {
+      out_ref->package = package;
+      out_ref->type = ResourceType::kAttr;
+      out_ref->entry = entry;
     }
     return true;
   }
   return false;
 }
 
-bool isAttributeReference(const StringPiece& str) {
-  return parseAttributeReference(str, nullptr);
+bool IsAttributeReference(const StringPiece& str) {
+  return ParseAttributeReference(str, nullptr);
 }
 
 /*
@@ -227,65 +229,65 @@ bool isAttributeReference(const StringPiece& str) {
  * <[*]package>:[style/]<entry>
  * [[*]package:style/]<entry>
  */
-Maybe<Reference> parseStyleParentReference(const StringPiece& str,
-                                           std::string* outError) {
+Maybe<Reference> ParseStyleParentReference(const StringPiece& str,
+                                           std::string* out_error) {
   if (str.empty()) {
     return {};
   }
 
   StringPiece name = str;
 
-  bool hasLeadingIdentifiers = false;
-  bool privateRef = false;
+  bool has_leading_identifiers = false;
+  bool private_ref = false;
 
   // Skip over these identifiers. A style's parent is a normal reference.
   if (name.data()[0] == '@' || name.data()[0] == '?') {
-    hasLeadingIdentifiers = true;
+    has_leading_identifiers = true;
     name = name.substr(1, name.size() - 1);
   }
 
   if (name.data()[0] == '*') {
-    privateRef = true;
+    private_ref = true;
     name = name.substr(1, name.size() - 1);
   }
 
   ResourceNameRef ref;
   ref.type = ResourceType::kStyle;
 
-  StringPiece typeStr;
-  extractResourceName(name, &ref.package, &typeStr, &ref.entry);
-  if (!typeStr.empty()) {
+  StringPiece type_str;
+  ExtractResourceName(name, &ref.package, &type_str, &ref.entry);
+  if (!type_str.empty()) {
     // If we have a type, make sure it is a Style.
-    const ResourceType* parsedType = parseResourceType(typeStr);
-    if (!parsedType || *parsedType != ResourceType::kStyle) {
+    const ResourceType* parsed_type = ParseResourceType(type_str);
+    if (!parsed_type || *parsed_type != ResourceType::kStyle) {
       std::stringstream err;
-      err << "invalid resource type '" << typeStr << "' for parent of style";
-      *outError = err.str();
+      err << "invalid resource type '" << type_str << "' for parent of style";
+      *out_error = err.str();
       return {};
     }
   }
 
-  if (!hasLeadingIdentifiers && ref.package.empty() && !typeStr.empty()) {
+  if (!has_leading_identifiers && ref.package.empty() && !type_str.empty()) {
     std::stringstream err;
     err << "invalid parent reference '" << str << "'";
-    *outError = err.str();
+    *out_error = err.str();
     return {};
   }
 
   Reference result(ref);
-  result.privateReference = privateRef;
+  result.private_reference = private_ref;
   return result;
 }
 
-Maybe<Reference> parseXmlAttributeName(const StringPiece& str) {
-  StringPiece trimmedStr = util::trimWhitespace(str);
-  const char* start = trimmedStr.data();
-  const char* const end = start + trimmedStr.size();
+Maybe<Reference> ParseXmlAttributeName(const StringPiece& str) {
+  StringPiece trimmed_str = util::TrimWhitespace(str);
+  const char* start = trimmed_str.data();
+  const char* const end = start + trimmed_str.size();
   const char* p = start;
 
   Reference ref;
   if (p != end && *p == '*') {
-    ref.privateReference = true;
+    ref.private_reference = true;
     start++;
     p++;
   }
@@ -302,38 +304,38 @@ Maybe<Reference> parseXmlAttributeName(const StringPiece& str) {
   }
 
   ref.name =
-      ResourceName(package.toString(), ResourceType::kAttr,
-                   name.empty() ? trimmedStr.toString() : name.toString());
+      ResourceName(package.ToString(), ResourceType::kAttr,
+                   name.empty() ? trimmed_str.ToString() : name.ToString());
   return Maybe<Reference>(std::move(ref));
 }
 
-std::unique_ptr<Reference> tryParseReference(const StringPiece& str,
-                                             bool* outCreate) {
+std::unique_ptr<Reference> TryParseReference(const StringPiece& str,
+                                             bool* out_create) {
   ResourceNameRef ref;
-  bool privateRef = false;
-  if (parseReference(str, &ref, outCreate, &privateRef)) {
+  bool private_ref = false;
+  if (ParseReference(str, &ref, out_create, &private_ref)) {
     std::unique_ptr<Reference> value = util::make_unique<Reference>(ref);
-    value->privateReference = privateRef;
+    value->private_reference = private_ref;
     return value;
   }
 
-  if (parseAttributeReference(str, &ref)) {
-    if (outCreate) {
-      *outCreate = false;
+  if (ParseAttributeReference(str, &ref)) {
+    if (out_create) {
+      *out_create = false;
     }
     return util::make_unique<Reference>(ref, Reference::Type::kAttribute);
   }
   return {};
 }
 
-std::unique_ptr<BinaryPrimitive> tryParseNullOrEmpty(const StringPiece& str) {
-  StringPiece trimmedStr(util::trimWhitespace(str));
+std::unique_ptr<BinaryPrimitive> TryParseNullOrEmpty(const StringPiece& str) {
+  StringPiece trimmed_str(util::TrimWhitespace(str));
   android::Res_value value = {};
-  if (trimmedStr == "@null") {
+  if (trimmed_str == "@null") {
     // TYPE_NULL with data set to 0 is interpreted by the runtime as an error.
     // Instead we set the data type to TYPE_REFERENCE with a value of 0.
     value.dataType = android::Res_value::TYPE_REFERENCE;
-  } else if (trimmedStr == "@empty") {
+  } else if (trimmed_str == "@empty") {
     // TYPE_NULL with value of DATA_NULL_EMPTY is handled fine by the runtime.
     value.dataType = android::Res_value::TYPE_NULL;
     value.data = android::Res_value::DATA_NULL_EMPTY;
@@ -343,14 +345,14 @@ std::unique_ptr<BinaryPrimitive> tryParseNullOrEmpty(const StringPiece& str) {
   return util::make_unique<BinaryPrimitive>(value);
 }
 
-std::unique_ptr<BinaryPrimitive> tryParseEnumSymbol(const Attribute* enumAttr,
+std::unique_ptr<BinaryPrimitive> TryParseEnumSymbol(const Attribute* enum_attr,
                                                     const StringPiece& str) {
-  StringPiece trimmedStr(util::trimWhitespace(str));
-  for (const Attribute::Symbol& symbol : enumAttr->symbols) {
+  StringPiece trimmed_str(util::TrimWhitespace(str));
+  for (const Attribute::Symbol& symbol : enum_attr->symbols) {
     // Enum symbols are stored as @package:id/symbol resources,
     // so we need to match against the 'entry' part of the identifier.
-    const ResourceName& enumSymbolResourceName = symbol.symbol.name.value();
-    if (trimmedStr == enumSymbolResourceName.entry) {
+    const ResourceName& enum_symbol_resource_name = symbol.symbol.name.value();
+    if (trimmed_str == enum_symbol_resource_name.entry) {
       android::Res_value value = {};
       value.dataType = android::Res_value::TYPE_INT_DEC;
       value.data = symbol.value;
@@ -360,40 +362,41 @@ std::unique_ptr<BinaryPrimitive> tryParseEnumSymbol(const Attribute* enumAttr,
   return {};
 }
 
-std::unique_ptr<BinaryPrimitive> tryParseFlagSymbol(const Attribute* flagAttr,
+std::unique_ptr<BinaryPrimitive> TryParseFlagSymbol(const Attribute* flag_attr,
                                                     const StringPiece& str) {
   android::Res_value flags = {};
   flags.dataType = android::Res_value::TYPE_INT_HEX;
   flags.data = 0u;
 
-  if (util::trimWhitespace(str).empty()) {
+  if (util::TrimWhitespace(str).empty()) {
     // Empty string is a valid flag (0).
     return util::make_unique<BinaryPrimitive>(flags);
   }
 
-  for (StringPiece part : util::tokenize(str, '|')) {
-    StringPiece trimmedPart = util::trimWhitespace(part);
+  for (StringPiece part : util::Tokenize(str, '|')) {
+    StringPiece trimmed_part = util::TrimWhitespace(part);
 
-    bool flagSet = false;
-    for (const Attribute::Symbol& symbol : flagAttr->symbols) {
+    bool flag_set = false;
+    for (const Attribute::Symbol& symbol : flag_attr->symbols) {
       // Flag symbols are stored as @package:id/symbol resources,
       // so we need to match against the 'entry' part of the identifier.
-      const ResourceName& flagSymbolResourceName = symbol.symbol.name.value();
-      if (trimmedPart == flagSymbolResourceName.entry) {
+      const ResourceName& flag_symbol_resource_name =
+          symbol.symbol.name.value();
+      if (trimmed_part == flag_symbol_resource_name.entry) {
         flags.data |= symbol.value;
-        flagSet = true;
+        flag_set = true;
         break;
       }
     }
 
-    if (!flagSet) {
+    if (!flag_set) {
       return {};
     }
   }
   return util::make_unique<BinaryPrimitive>(flags);
 }
 
-static uint32_t parseHex(char c, bool* outError) {
+static uint32_t ParseHex(char c, bool* out_error) {
   if (c >= '0' && c <= '9') {
     return c - '0';
   } else if (c >= 'a' && c <= 'f') {
@@ -401,15 +404,15 @@ static uint32_t parseHex(char c, bool* outError) {
   } else if (c >= 'A' && c <= 'F') {
     return c - 'A' + 0xa;
   } else {
-    *outError = true;
+    *out_error = true;
     return 0xffffffffu;
   }
 }
 
-std::unique_ptr<BinaryPrimitive> tryParseColor(const StringPiece& str) {
-  StringPiece colorStr(util::trimWhitespace(str));
-  const char* start = colorStr.data();
-  const size_t len = colorStr.size();
+std::unique_ptr<BinaryPrimitive> TryParseColor(const StringPiece& str) {
+  StringPiece color_str(util::TrimWhitespace(str));
+  const char* start = color_str.data();
+  const size_t len = color_str.size();
   if (len == 0 || start[0] != '#') {
     return {};
   }
@@ -419,41 +422,41 @@ std::unique_ptr<BinaryPrimitive> tryParseColor(const StringPiece& str) {
   if (len == 4) {
     value.dataType = android::Res_value::TYPE_INT_COLOR_RGB4;
     value.data = 0xff000000u;
-    value.data |= parseHex(start[1], &error) << 20;
-    value.data |= parseHex(start[1], &error) << 16;
-    value.data |= parseHex(start[2], &error) << 12;
-    value.data |= parseHex(start[2], &error) << 8;
-    value.data |= parseHex(start[3], &error) << 4;
-    value.data |= parseHex(start[3], &error);
+    value.data |= ParseHex(start[1], &error) << 20;
+    value.data |= ParseHex(start[1], &error) << 16;
+    value.data |= ParseHex(start[2], &error) << 12;
+    value.data |= ParseHex(start[2], &error) << 8;
+    value.data |= ParseHex(start[3], &error) << 4;
+    value.data |= ParseHex(start[3], &error);
   } else if (len == 5) {
     value.dataType = android::Res_value::TYPE_INT_COLOR_ARGB4;
-    value.data |= parseHex(start[1], &error) << 28;
-    value.data |= parseHex(start[1], &error) << 24;
-    value.data |= parseHex(start[2], &error) << 20;
-    value.data |= parseHex(start[2], &error) << 16;
-    value.data |= parseHex(start[3], &error) << 12;
-    value.data |= parseHex(start[3], &error) << 8;
-    value.data |= parseHex(start[4], &error) << 4;
-    value.data |= parseHex(start[4], &error);
+    value.data |= ParseHex(start[1], &error) << 28;
+    value.data |= ParseHex(start[1], &error) << 24;
+    value.data |= ParseHex(start[2], &error) << 20;
+    value.data |= ParseHex(start[2], &error) << 16;
+    value.data |= ParseHex(start[3], &error) << 12;
+    value.data |= ParseHex(start[3], &error) << 8;
+    value.data |= ParseHex(start[4], &error) << 4;
+    value.data |= ParseHex(start[4], &error);
   } else if (len == 7) {
     value.dataType = android::Res_value::TYPE_INT_COLOR_RGB8;
     value.data = 0xff000000u;
-    value.data |= parseHex(start[1], &error) << 20;
-    value.data |= parseHex(start[2], &error) << 16;
-    value.data |= parseHex(start[3], &error) << 12;
-    value.data |= parseHex(start[4], &error) << 8;
-    value.data |= parseHex(start[5], &error) << 4;
-    value.data |= parseHex(start[6], &error);
+    value.data |= ParseHex(start[1], &error) << 20;
+    value.data |= ParseHex(start[2], &error) << 16;
+    value.data |= ParseHex(start[3], &error) << 12;
+    value.data |= ParseHex(start[4], &error) << 8;
+    value.data |= ParseHex(start[5], &error) << 4;
+    value.data |= ParseHex(start[6], &error);
   } else if (len == 9) {
     value.dataType = android::Res_value::TYPE_INT_COLOR_ARGB8;
-    value.data |= parseHex(start[1], &error) << 28;
-    value.data |= parseHex(start[2], &error) << 24;
-    value.data |= parseHex(start[3], &error) << 20;
-    value.data |= parseHex(start[4], &error) << 16;
-    value.data |= parseHex(start[5], &error) << 12;
-    value.data |= parseHex(start[6], &error) << 8;
-    value.data |= parseHex(start[7], &error) << 4;
-    value.data |= parseHex(start[8], &error);
+    value.data |= ParseHex(start[1], &error) << 28;
+    value.data |= ParseHex(start[2], &error) << 24;
+    value.data |= ParseHex(start[3], &error) << 20;
+    value.data |= ParseHex(start[4], &error) << 16;
+    value.data |= ParseHex(start[5], &error) << 12;
+    value.data |= ParseHex(start[6], &error) << 8;
+    value.data |= ParseHex(start[7], &error) << 4;
+    value.data |= ParseHex(start[8], &error);
   } else {
     return {};
   }
@@ -461,19 +464,19 @@ std::unique_ptr<BinaryPrimitive> tryParseColor(const StringPiece& str) {
                : util::make_unique<BinaryPrimitive>(value);
 }
 
-Maybe<bool> parseBool(const StringPiece& str) {
-  StringPiece trimmedStr(util::trimWhitespace(str));
-  if (trimmedStr == "true" || trimmedStr == "TRUE" || trimmedStr == "True") {
+Maybe<bool> ParseBool(const StringPiece& str) {
+  StringPiece trimmed_str(util::TrimWhitespace(str));
+  if (trimmed_str == "true" || trimmed_str == "TRUE" || trimmed_str == "True") {
     return Maybe<bool>(true);
-  } else if (trimmedStr == "false" || trimmedStr == "FALSE" ||
-             trimmedStr == "False") {
+  } else if (trimmed_str == "false" || trimmed_str == "FALSE" ||
+             trimmed_str == "False") {
     return Maybe<bool>(false);
   }
   return {};
 }
 
-Maybe<uint32_t> parseInt(const StringPiece& str) {
-  std::u16string str16 = util::utf8ToUtf16(str);
+Maybe<uint32_t> ParseInt(const StringPiece& str) {
+  std::u16string str16 = util::Utf8ToUtf16(str);
   android::Res_value value;
   if (android::ResTable::stringToInt(str16.data(), str16.size(), &value)) {
     return value.data;
@@ -481,15 +484,15 @@ Maybe<uint32_t> parseInt(const StringPiece& str) {
   return {};
 }
 
-Maybe<ResourceId> parseResourceId(const StringPiece& str) {
-  StringPiece trimmedStr(util::trimWhitespace(str));
+Maybe<ResourceId> ParseResourceId(const StringPiece& str) {
+  StringPiece trimmed_str(util::TrimWhitespace(str));
 
-  std::u16string str16 = util::utf8ToUtf16(trimmedStr);
+  std::u16string str16 = util::Utf8ToUtf16(trimmed_str);
   android::Res_value value;
   if (android::ResTable::stringToInt(str16.data(), str16.size(), &value)) {
     if (value.dataType == android::Res_value::TYPE_INT_HEX) {
       ResourceId id(value.data);
-      if (id.isValid()) {
+      if (id.is_valid()) {
         return id;
       }
     }
@@ -497,29 +500,29 @@ Maybe<ResourceId> parseResourceId(const StringPiece& str) {
   return {};
 }
 
-Maybe<int> parseSdkVersion(const StringPiece& str) {
-  StringPiece trimmedStr(util::trimWhitespace(str));
+Maybe<int> ParseSdkVersion(const StringPiece& str) {
+  StringPiece trimmed_str(util::TrimWhitespace(str));
 
-  std::u16string str16 = util::utf8ToUtf16(trimmedStr);
+  std::u16string str16 = util::Utf8ToUtf16(trimmed_str);
   android::Res_value value;
   if (android::ResTable::stringToInt(str16.data(), str16.size(), &value)) {
     return static_cast<int>(value.data);
   }
 
   // Try parsing the code name.
-  std::pair<StringPiece, int> entry = getDevelopmentSdkCodeNameAndVersion();
-  if (entry.first == trimmedStr) {
+  std::pair<StringPiece, int> entry = GetDevelopmentSdkCodeNameAndVersion();
+  if (entry.first == trimmed_str) {
     return entry.second;
   }
   return {};
 }
 
-std::unique_ptr<BinaryPrimitive> tryParseBool(const StringPiece& str) {
-  if (Maybe<bool> maybeResult = parseBool(str)) {
+std::unique_ptr<BinaryPrimitive> TryParseBool(const StringPiece& str) {
+  if (Maybe<bool> maybe_result = ParseBool(str)) {
     android::Res_value value = {};
     value.dataType = android::Res_value::TYPE_INT_BOOLEAN;
 
-    if (maybeResult.value()) {
+    if (maybe_result.value()) {
       value.data = 0xffffffffu;
     } else {
       value.data = 0;
@@ -529,8 +532,8 @@ std::unique_ptr<BinaryPrimitive> tryParseBool(const StringPiece& str) {
   return {};
 }
 
-std::unique_ptr<BinaryPrimitive> tryParseInt(const StringPiece& str) {
-  std::u16string str16 = util::utf8ToUtf16(str);
+std::unique_ptr<BinaryPrimitive> TryParseInt(const StringPiece& str) {
+  std::u16string str16 = util::Utf8ToUtf16(str);
   android::Res_value value;
   if (!android::ResTable::stringToInt(str16.data(), str16.size(), &value)) {
     return {};
@@ -538,8 +541,8 @@ std::unique_ptr<BinaryPrimitive> tryParseInt(const StringPiece& str) {
   return util::make_unique<BinaryPrimitive>(value);
 }
 
-std::unique_ptr<BinaryPrimitive> tryParseFloat(const StringPiece& str) {
-  std::u16string str16 = util::utf8ToUtf16(str);
+std::unique_ptr<BinaryPrimitive> TryParseFloat(const StringPiece& str) {
+  std::u16string str16 = util::Utf8ToUtf16(str);
   android::Res_value value;
   if (!android::ResTable::stringToFloat(str16.data(), str16.size(), &value)) {
     return {};
@@ -547,7 +550,7 @@ std::unique_ptr<BinaryPrimitive> tryParseFloat(const StringPiece& str) {
   return util::make_unique<BinaryPrimitive>(value);
 }
 
-uint32_t androidTypeToAttributeTypeMask(uint16_t type) {
+uint32_t AndroidTypeToAttributeTypeMask(uint16_t type) {
   switch (type) {
     case android::Res_value::TYPE_NULL:
     case android::Res_value::TYPE_REFERENCE:
@@ -587,57 +590,57 @@ uint32_t androidTypeToAttributeTypeMask(uint16_t type) {
   };
 }
 
-std::unique_ptr<Item> tryParseItemForAttribute(
-    const StringPiece& value, uint32_t typeMask,
-    const std::function<void(const ResourceName&)>& onCreateReference) {
-  std::unique_ptr<BinaryPrimitive> nullOrEmpty = tryParseNullOrEmpty(value);
-  if (nullOrEmpty) {
-    return std::move(nullOrEmpty);
+std::unique_ptr<Item> TryParseItemForAttribute(
+    const StringPiece& value, uint32_t type_mask,
+    const std::function<void(const ResourceName&)>& on_create_reference) {
+  std::unique_ptr<BinaryPrimitive> null_or_empty = TryParseNullOrEmpty(value);
+  if (null_or_empty) {
+    return std::move(null_or_empty);
   }
 
   bool create = false;
-  std::unique_ptr<Reference> reference = tryParseReference(value, &create);
+  std::unique_ptr<Reference> reference = TryParseReference(value, &create);
   if (reference) {
-    if (create && onCreateReference) {
-      onCreateReference(reference->name.value());
+    if (create && on_create_reference) {
+      on_create_reference(reference->name.value());
     }
     return std::move(reference);
   }
 
-  if (typeMask & android::ResTable_map::TYPE_COLOR) {
+  if (type_mask & android::ResTable_map::TYPE_COLOR) {
     // Try parsing this as a color.
-    std::unique_ptr<BinaryPrimitive> color = tryParseColor(value);
+    std::unique_ptr<BinaryPrimitive> color = TryParseColor(value);
     if (color) {
       return std::move(color);
     }
   }
 
-  if (typeMask & android::ResTable_map::TYPE_BOOLEAN) {
+  if (type_mask & android::ResTable_map::TYPE_BOOLEAN) {
     // Try parsing this as a boolean.
-    std::unique_ptr<BinaryPrimitive> boolean = tryParseBool(value);
+    std::unique_ptr<BinaryPrimitive> boolean = TryParseBool(value);
     if (boolean) {
       return std::move(boolean);
     }
   }
 
-  if (typeMask & android::ResTable_map::TYPE_INTEGER) {
+  if (type_mask & android::ResTable_map::TYPE_INTEGER) {
     // Try parsing this as an integer.
-    std::unique_ptr<BinaryPrimitive> integer = tryParseInt(value);
+    std::unique_ptr<BinaryPrimitive> integer = TryParseInt(value);
     if (integer) {
       return std::move(integer);
     }
   }
 
-  const uint32_t floatMask = android::ResTable_map::TYPE_FLOAT |
-                             android::ResTable_map::TYPE_DIMENSION |
-                             android::ResTable_map::TYPE_FRACTION;
-  if (typeMask & floatMask) {
+  const uint32_t float_mask = android::ResTable_map::TYPE_FLOAT |
+                              android::ResTable_map::TYPE_DIMENSION |
+                              android::ResTable_map::TYPE_FRACTION;
+  if (type_mask & float_mask) {
     // Try parsing this as a float.
-    std::unique_ptr<BinaryPrimitive> floatingPoint = tryParseFloat(value);
-    if (floatingPoint) {
-      if (typeMask &
-          androidTypeToAttributeTypeMask(floatingPoint->value.dataType)) {
-        return std::move(floatingPoint);
+    std::unique_ptr<BinaryPrimitive> floating_point = TryParseFloat(value);
+    if (floating_point) {
+      if (type_mask &
+          AndroidTypeToAttributeTypeMask(floating_point->value.dataType)) {
+        return std::move(floating_point);
       }
     }
   }
@@ -648,49 +651,49 @@ std::unique_ptr<Item> tryParseItemForAttribute(
  * We successively try to parse the string as a resource type that the Attribute
  * allows.
  */
-std::unique_ptr<Item> tryParseItemForAttribute(
+std::unique_ptr<Item> TryParseItemForAttribute(
     const StringPiece& str, const Attribute* attr,
-    const std::function<void(const ResourceName&)>& onCreateReference) {
-  const uint32_t typeMask = attr->typeMask;
+    const std::function<void(const ResourceName&)>& on_create_reference) {
+  const uint32_t type_mask = attr->type_mask;
   std::unique_ptr<Item> value =
-      tryParseItemForAttribute(str, typeMask, onCreateReference);
+      TryParseItemForAttribute(str, type_mask, on_create_reference);
   if (value) {
     return value;
   }
 
-  if (typeMask & android::ResTable_map::TYPE_ENUM) {
+  if (type_mask & android::ResTable_map::TYPE_ENUM) {
     // Try parsing this as an enum.
-    std::unique_ptr<BinaryPrimitive> enumValue = tryParseEnumSymbol(attr, str);
-    if (enumValue) {
-      return std::move(enumValue);
+    std::unique_ptr<BinaryPrimitive> enum_value = TryParseEnumSymbol(attr, str);
+    if (enum_value) {
+      return std::move(enum_value);
     }
   }
 
-  if (typeMask & android::ResTable_map::TYPE_FLAGS) {
+  if (type_mask & android::ResTable_map::TYPE_FLAGS) {
     // Try parsing this as a flag.
-    std::unique_ptr<BinaryPrimitive> flagValue = tryParseFlagSymbol(attr, str);
-    if (flagValue) {
-      return std::move(flagValue);
+    std::unique_ptr<BinaryPrimitive> flag_value = TryParseFlagSymbol(attr, str);
+    if (flag_value) {
+      return std::move(flag_value);
     }
   }
   return {};
 }
 
-std::string buildResourceFileName(const ResourceFile& resFile,
+std::string BuildResourceFileName(const ResourceFile& res_file,
                                   const NameMangler* mangler) {
   std::stringstream out;
-  out << "res/" << resFile.name.type;
-  if (resFile.config != ConfigDescription{}) {
-    out << "-" << resFile.config;
+  out << "res/" << res_file.name.type;
+  if (res_file.config != ConfigDescription{}) {
+    out << "-" << res_file.config;
   }
   out << "/";
 
-  if (mangler && mangler->shouldMangle(resFile.name.package)) {
-    out << NameMangler::mangleEntry(resFile.name.package, resFile.name.entry);
+  if (mangler && mangler->ShouldMangle(res_file.name.package)) {
+    out << NameMangler::MangleEntry(res_file.name.package, res_file.name.entry);
   } else {
-    out << resFile.name.entry;
+    out << res_file.name.entry;
   }
-  out << file::getExtension(resFile.source.path);
+  out << file::GetExtension(res_file.source.path);
   return out.str();
 }
 
diff --git a/tools/aapt2/ResourceUtils.h b/tools/aapt2/ResourceUtils.h
index cebe47cee3a7c..9766f6a7b2faa 100644
--- a/tools/aapt2/ResourceUtils.h
+++ b/tools/aapt2/ResourceUtils.h
@@ -17,14 +17,14 @@
 #ifndef AAPT_RESOURCEUTILS_H
 #define AAPT_RESOURCEUTILS_H
 
+#include <functional>
+#include <memory>
+
 #include "NameMangler.h"
 #include "Resource.h"
 #include "ResourceValues.h"
 #include "util/StringPiece.h"
 
-#include <functional>
-#include <memory>
-
 namespace aapt {
 namespace ResourceUtils {
 
@@ -37,76 +37,75 @@ namespace ResourceUtils {
  * individual extracted piece to verify that the pieces are valid.
  * Returns false if there was no package but a ':' was present.
  */
-bool extractResourceName(const StringPiece& str, StringPiece* outPackage,
-                         StringPiece* outType, StringPiece* outEntry);
+bool ExtractResourceName(const StringPiece& str, StringPiece* out_package,
+                         StringPiece* out_type, StringPiece* out_entry);
 
 /**
  * Returns true if the string was parsed as a resource name
  * ([*][package:]type/name), with
- * `outResource` set to the parsed resource name and `outPrivate` set to true if
- * a '*' prefix
- * was present.
+ * `out_resource` set to the parsed resource name and `out_private` set to true
+ * if a '*' prefix was present.
  */
-bool parseResourceName(const StringPiece& str, ResourceNameRef* outResource,
-                       bool* outPrivate = nullptr);
+bool ParseResourceName(const StringPiece& str, ResourceNameRef* out_resource,
+                       bool* out_private = nullptr);
 
 /*
  * Returns true if the string was parsed as a reference
  * (@[+][package:]type/name), with
- * `outReference` set to the parsed reference.
+ * `out_reference` set to the parsed reference.
  *
- * If '+' was present in the reference, `outCreate` is set to true.
- * If '*' was present in the reference, `outPrivate` is set to true.
+ * If '+' was present in the reference, `out_create` is set to true.
+ * If '*' was present in the reference, `out_private` is set to true.
  */
-bool parseReference(const StringPiece& str, ResourceNameRef* outReference,
-                    bool* outCreate = nullptr, bool* outPrivate = nullptr);
+bool ParseReference(const StringPiece& str, ResourceNameRef* out_reference,
+                    bool* out_create = nullptr, bool* out_private = nullptr);
 
 /*
  * Returns true if the string is in the form of a resource reference
  * (@[+][package:]type/name).
  */
-bool isReference(const StringPiece& str);
+bool IsReference(const StringPiece& str);
 
 /*
  * Returns true if the string was parsed as an attribute reference
  * (?[package:][type/]name),
- * with `outReference` set to the parsed reference.
+ * with `out_reference` set to the parsed reference.
  */
-bool parseAttributeReference(const StringPiece& str,
-                             ResourceNameRef* outReference);
+bool ParseAttributeReference(const StringPiece& str,
+                             ResourceNameRef* out_reference);
 
 /**
  * Returns true if the string is in the form of an attribute
  * reference(?[package:][type/]name).
  */
-bool isAttributeReference(const StringPiece& str);
+bool IsAttributeReference(const StringPiece& str);
 
 /**
  * Convert an android::ResTable::resource_name to an aapt::ResourceName struct.
  */
-Maybe<ResourceName> toResourceName(
+Maybe<ResourceName> ToResourceName(
     const android::ResTable::resource_name& name);
 
 /**
  * Returns a boolean value if the string is equal to TRUE, true, True, FALSE,
  * false, or False.
  */
-Maybe<bool> parseBool(const StringPiece& str);
+Maybe<bool> ParseBool(const StringPiece& str);
 
 /**
  * Returns a uint32_t if the string is an integer.
  */
-Maybe<uint32_t> parseInt(const StringPiece& str);
+Maybe<uint32_t> ParseInt(const StringPiece& str);
 
 /**
  * Returns an ID if it the string represented a valid ID.
  */
-Maybe<ResourceId> parseResourceId(const StringPiece& str);
+Maybe<ResourceId> ParseResourceId(const StringPiece& str);
 
 /**
  * Parses an SDK version, which can be an integer, or a letter from A-Z.
  */
-Maybe<int> parseSdkVersion(const StringPiece& str);
+Maybe<int> ParseSdkVersion(const StringPiece& str);
 
 /*
  * Returns a Reference, or None Maybe instance if the string `str` was parsed as
@@ -119,8 +118,8 @@ Maybe<int> parseSdkVersion(const StringPiece& str);
  * ?[package:]style/<entry> or
  * <package>:[style/]<entry>
  */
-Maybe<Reference> parseStyleParentReference(const StringPiece& str,
-                                           std::string* outError);
+Maybe<Reference> ParseStyleParentReference(const StringPiece& str,
+                                           std::string* out_error);
 
 /*
  * Returns a Reference if the string `str` was parsed as a valid XML attribute
@@ -129,7 +128,7 @@ Maybe<Reference> parseStyleParentReference(const StringPiece& str,
  *
  * package:entry
  */
-Maybe<Reference> parseXmlAttributeName(const StringPiece& str);
+Maybe<Reference> ParseXmlAttributeName(const StringPiece& str);
 
 /*
  * Returns a Reference object if the string was parsed as a resource or
@@ -138,73 +137,68 @@ Maybe<Reference> parseXmlAttributeName(const StringPiece& str);
  * if
  * the '+' was present in the string.
  */
-std::unique_ptr<Reference> tryParseReference(const StringPiece& str,
-                                             bool* outCreate = nullptr);
+std::unique_ptr<Reference> TryParseReference(const StringPiece& str,
+                                             bool* out_create = nullptr);
 
 /*
  * Returns a BinaryPrimitve object representing @null or @empty if the string
- * was parsed
- * as one.
+ * was parsed as one.
  */
-std::unique_ptr<BinaryPrimitive> tryParseNullOrEmpty(const StringPiece& str);
+std::unique_ptr<BinaryPrimitive> TryParseNullOrEmpty(const StringPiece& str);
 
 /*
  * Returns a BinaryPrimitve object representing a color if the string was parsed
  * as one.
  */
-std::unique_ptr<BinaryPrimitive> tryParseColor(const StringPiece& str);
+std::unique_ptr<BinaryPrimitive> TryParseColor(const StringPiece& str);
 
 /*
  * Returns a BinaryPrimitve object representing a boolean if the string was
- * parsed
- * as one.
+ * parsed as one.
  */
-std::unique_ptr<BinaryPrimitive> tryParseBool(const StringPiece& str);
+std::unique_ptr<BinaryPrimitive> TryParseBool(const StringPiece& str);
 
 /*
  * Returns a BinaryPrimitve object representing an integer if the string was
- * parsed
- * as one.
+ * parsed as one.
  */
-std::unique_ptr<BinaryPrimitive> tryParseInt(const StringPiece& str);
+std::unique_ptr<BinaryPrimitive> TryParseInt(const StringPiece& str);
 
 /*
  * Returns a BinaryPrimitve object representing a floating point number
  * (float, dimension, etc) if the string was parsed as one.
  */
-std::unique_ptr<BinaryPrimitive> tryParseFloat(const StringPiece& str);
+std::unique_ptr<BinaryPrimitive> TryParseFloat(const StringPiece& str);
 
 /*
  * Returns a BinaryPrimitve object representing an enum symbol if the string was
- * parsed
- * as one.
+ * parsed as one.
  */
-std::unique_ptr<BinaryPrimitive> tryParseEnumSymbol(const Attribute* enumAttr,
+std::unique_ptr<BinaryPrimitive> TryParseEnumSymbol(const Attribute* enum_attr,
                                                     const StringPiece& str);
 
 /*
  * Returns a BinaryPrimitve object representing a flag symbol if the string was
- * parsed
- * as one.
+ * parsed as one.
  */
-std::unique_ptr<BinaryPrimitive> tryParseFlagSymbol(const Attribute* enumAttr,
+std::unique_ptr<BinaryPrimitive> TryParseFlagSymbol(const Attribute* enum_attr,
                                                     const StringPiece& str);
 /*
  * Try to convert a string to an Item for the given attribute. The attribute
  * will
  * restrict what values the string can be converted to.
- * The callback function onCreateReference is called when the parsed item is a
+ * The callback function on_create_reference is called when the parsed item is a
  * reference to an ID that must be created (@+id/foo).
  */
-std::unique_ptr<Item> tryParseItemForAttribute(
+std::unique_ptr<Item> TryParseItemForAttribute(
     const StringPiece& value, const Attribute* attr,
-    const std::function<void(const ResourceName&)>& onCreateReference = {});
+    const std::function<void(const ResourceName&)>& on_create_reference = {});
 
-std::unique_ptr<Item> tryParseItemForAttribute(
-    const StringPiece& value, uint32_t typeMask,
-    const std::function<void(const ResourceName&)>& onCreateReference = {});
+std::unique_ptr<Item> TryParseItemForAttribute(
+    const StringPiece& value, uint32_t type_mask,
+    const std::function<void(const ResourceName&)>& on_create_reference = {});
 
-uint32_t androidTypeToAttributeTypeMask(uint16_t type);
+uint32_t AndroidTypeToAttributeTypeMask(uint16_t type);
 
 /**
  * Returns a string path suitable for use within an APK. The path will look
@@ -216,8 +210,8 @@ uint32_t androidTypeToAttributeTypeMask(uint16_t type);
  * the package
  * requires mangling.
  */
-std::string buildResourceFileName(const ResourceFile& resFile,
-                                  const NameMangler* mangler);
+std::string BuildResourceFileName(const ResourceFile& res_file,
+                                  const NameMangler* mangler = nullptr);
 
 }  // namespace ResourceUtils
 }  // namespace aapt
diff --git a/tools/aapt2/ResourceUtils_test.cpp b/tools/aapt2/ResourceUtils_test.cpp
index eb62b1b0f4fa3..f9c500b42c136 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);
 }
diff --git a/tools/aapt2/ResourceValues.cpp b/tools/aapt2/ResourceValues.cpp
index 60590b6026b5f..7956ad826acdd 100644
--- a/tools/aapt2/ResourceValues.cpp
+++ b/tools/aapt2/ResourceValues.cpp
@@ -15,94 +15,95 @@
  */
 
 #include "ResourceValues.h"
+
+#include <algorithm>
+#include <limits>
+#include <set>
+
+#include "androidfw/ResourceTypes.h"
+
 #include "Resource.h"
 #include "ResourceUtils.h"
 #include "ValueVisitor.h"
 #include "util/Util.h"
 
-#include <androidfw/ResourceTypes.h>
-#include <algorithm>
-#include <limits>
-#include <set>
-
 namespace aapt {
 
 template <typename Derived>
-void BaseValue<Derived>::accept(RawValueVisitor* visitor) {
-  visitor->visit(static_cast<Derived*>(this));
+void BaseValue<Derived>::Accept(RawValueVisitor* visitor) {
+  visitor->Visit(static_cast<Derived*>(this));
 }
 
 template <typename Derived>
-void BaseItem<Derived>::accept(RawValueVisitor* visitor) {
-  visitor->visit(static_cast<Derived*>(this));
+void BaseItem<Derived>::Accept(RawValueVisitor* visitor) {
+  visitor->Visit(static_cast<Derived*>(this));
 }
 
 RawString::RawString(const StringPool::Ref& ref) : value(ref) {}
 
-bool RawString::equals(const Value* value) const {
-  const RawString* other = valueCast<RawString>(value);
+bool RawString::Equals(const Value* value) const {
+  const RawString* other = ValueCast<RawString>(value);
   if (!other) {
     return false;
   }
   return *this->value == *other->value;
 }
 
-RawString* RawString::clone(StringPool* newPool) const {
-  RawString* rs = new RawString(newPool->makeRef(*value));
-  rs->mComment = mComment;
-  rs->mSource = mSource;
+RawString* RawString::Clone(StringPool* new_pool) const {
+  RawString* rs = new RawString(new_pool->MakeRef(*value));
+  rs->comment_ = comment_;
+  rs->source_ = source_;
   return rs;
 }
 
-bool RawString::flatten(android::Res_value* outValue) const {
-  outValue->dataType = android::Res_value::TYPE_STRING;
-  outValue->data =
-      util::hostToDevice32(static_cast<uint32_t>(value.getIndex()));
+bool RawString::Flatten(android::Res_value* out_value) const {
+  out_value->dataType = android::Res_value::TYPE_STRING;
+  out_value->data = util::HostToDevice32(static_cast<uint32_t>(value.index()));
   return true;
 }
 
-void RawString::print(std::ostream* out) const {
+void RawString::Print(std::ostream* out) const {
   *out << "(raw string) " << *value;
 }
 
-Reference::Reference() : referenceType(Type::kResource) {}
+Reference::Reference() : reference_type(Type::kResource) {}
 
 Reference::Reference(const ResourceNameRef& n, Type t)
-    : name(n.toResourceName()), referenceType(t) {}
+    : name(n.ToResourceName()), reference_type(t) {}
 
 Reference::Reference(const ResourceId& i, Type type)
-    : id(i), referenceType(type) {}
+    : id(i), reference_type(type) {}
 
 Reference::Reference(const ResourceNameRef& n, const ResourceId& i)
-    : name(n.toResourceName()), id(i), referenceType(Type::kResource) {}
+    : name(n.ToResourceName()), id(i), reference_type(Type::kResource) {}
 
-bool Reference::equals(const Value* value) const {
-  const Reference* other = valueCast<Reference>(value);
+bool Reference::Equals(const Value* value) const {
+  const Reference* other = ValueCast<Reference>(value);
   if (!other) {
     return false;
   }
-  return referenceType == other->referenceType &&
-         privateReference == other->privateReference && id == other->id &&
+  return reference_type == other->reference_type &&
+         private_reference == other->private_reference && id == other->id &&
          name == other->name;
 }
 
-bool Reference::flatten(android::Res_value* outValue) const {
-  outValue->dataType = (referenceType == Reference::Type::kResource)
-                           ? android::Res_value::TYPE_REFERENCE
-                           : android::Res_value::TYPE_ATTRIBUTE;
-  outValue->data = util::hostToDevice32(id ? id.value().id : 0);
+bool Reference::Flatten(android::Res_value* out_value) const {
+  out_value->dataType = (reference_type == Reference::Type::kResource)
+                            ? android::Res_value::TYPE_REFERENCE
+                            : android::Res_value::TYPE_ATTRIBUTE;
+  out_value->data = util::HostToDevice32(id ? id.value().id : 0);
   return true;
 }
 
-Reference* Reference::clone(StringPool* /*newPool*/) const {
+Reference* Reference::Clone(StringPool* /*new_pool*/) const {
   return new Reference(*this);
 }
 
-void Reference::print(std::ostream* out) const {
+void Reference::Print(std::ostream* out) const {
   *out << "(reference) ";
-  if (referenceType == Reference::Type::kResource) {
+  if (reference_type == Reference::Type::kResource) {
     *out << "@";
-    if (privateReference) {
+    if (private_reference) {
       *out << "*";
     }
   } else {
@@ -118,128 +119,127 @@ void Reference::print(std::ostream* out) const {
   }
 }
 
-bool Id::equals(const Value* value) const {
-  return valueCast<Id>(value) != nullptr;
+bool Id::Equals(const Value* value) const {
+  return ValueCast<Id>(value) != nullptr;
 }
 
-bool Id::flatten(android::Res_value* out) const {
+bool Id::Flatten(android::Res_value* out) const {
   out->dataType = android::Res_value::TYPE_INT_BOOLEAN;
-  out->data = util::hostToDevice32(0);
+  out->data = util::HostToDevice32(0);
   return true;
 }
 
-Id* Id::clone(StringPool* /*newPool*/) const { return new Id(*this); }
+Id* Id::Clone(StringPool* /*new_pool*/) const { return new Id(*this); }
 
-void Id::print(std::ostream* out) const { *out << "(id)"; }
+void Id::Print(std::ostream* out) const { *out << "(id)"; }
 
 String::String(const StringPool::Ref& ref) : value(ref) {}
 
-bool String::equals(const Value* value) const {
-  const String* other = valueCast<String>(value);
+bool String::Equals(const Value* value) const {
+  const String* other = ValueCast<String>(value);
   if (!other) {
     return false;
   }
   return *this->value == *other->value;
 }
 
-bool String::flatten(android::Res_value* outValue) const {
+bool String::Flatten(android::Res_value* out_value) const {
   // Verify that our StringPool index is within encode-able limits.
-  if (value.getIndex() > std::numeric_limits<uint32_t>::max()) {
+  if (value.index() > std::numeric_limits<uint32_t>::max()) {
     return false;
   }
 
-  outValue->dataType = android::Res_value::TYPE_STRING;
-  outValue->data =
-      util::hostToDevice32(static_cast<uint32_t>(value.getIndex()));
+  out_value->dataType = android::Res_value::TYPE_STRING;
+  out_value->data = util::HostToDevice32(static_cast<uint32_t>(value.index()));
   return true;
 }
 
-String* String::clone(StringPool* newPool) const {
-  String* str = new String(newPool->makeRef(*value));
-  str->mComment = mComment;
-  str->mSource = mSource;
+String* String::Clone(StringPool* new_pool) const {
+  String* str = new String(new_pool->MakeRef(*value));
+  str->comment_ = comment_;
+  str->source_ = source_;
   return str;
 }
 
-void String::print(std::ostream* out) const {
+void String::Print(std::ostream* out) const {
   *out << "(string) \"" << *value << "\"";
 }
 
 StyledString::StyledString(const StringPool::StyleRef& ref) : value(ref) {}
 
-bool StyledString::equals(const Value* value) const {
-  const StyledString* other = valueCast<StyledString>(value);
+bool StyledString::Equals(const Value* value) const {
+  const StyledString* other = ValueCast<StyledString>(value);
   if (!other) {
     return false;
   }
 
   if (*this->value->str == *other->value->str) {
-    const std::vector<StringPool::Span>& spansA = this->value->spans;
-    const std::vector<StringPool::Span>& spansB = other->value->spans;
+    const std::vector<StringPool::Span>& spans_a = this->value->spans;
+    const std::vector<StringPool::Span>& spans_b = other->value->spans;
     return std::equal(
-        spansA.begin(), spansA.end(), spansB.begin(),
+        spans_a.begin(), spans_a.end(), spans_b.begin(),
         [](const StringPool::Span& a, const StringPool::Span& b) -> bool {
-          return *a.name == *b.name && a.firstChar == b.firstChar &&
-                 a.lastChar == b.lastChar;
+          return *a.name == *b.name && a.first_char == b.first_char &&
+                 a.last_char == b.last_char;
         });
   }
   return false;
 }
 
-bool StyledString::flatten(android::Res_value* outValue) const {
-  if (value.getIndex() > std::numeric_limits<uint32_t>::max()) {
+bool StyledString::Flatten(android::Res_value* out_value) const {
+  if (value.index() > std::numeric_limits<uint32_t>::max()) {
     return false;
   }
 
-  outValue->dataType = android::Res_value::TYPE_STRING;
-  outValue->data =
-      util::hostToDevice32(static_cast<uint32_t>(value.getIndex()));
+  out_value->dataType = android::Res_value::TYPE_STRING;
+  out_value->data = util::HostToDevice32(static_cast<uint32_t>(value.index()));
   return true;
 }
 
-StyledString* StyledString::clone(StringPool* newPool) const {
-  StyledString* str = new StyledString(newPool->makeRef(value));
-  str->mComment = mComment;
-  str->mSource = mSource;
+StyledString* StyledString::Clone(StringPool* new_pool) const {
+  StyledString* str = new StyledString(new_pool->MakeRef(value));
+  str->comment_ = comment_;
+  str->source_ = source_;
   return str;
 }
 
-void StyledString::print(std::ostream* out) const {
+void StyledString::Print(std::ostream* out) const {
   *out << "(styled string) \"" << *value->str << "\"";
   for (const StringPool::Span& span : value->spans) {
-    *out << " " << *span.name << ":" << span.firstChar << "," << span.lastChar;
+    *out << " " << *span.name << ":" << span.first_char << ","
+         << span.last_char;
   }
 }
 
 FileReference::FileReference(const StringPool::Ref& _path) : path(_path) {}
 
-bool FileReference::equals(const Value* value) const {
-  const FileReference* other = valueCast<FileReference>(value);
+bool FileReference::Equals(const Value* value) const {
+  const FileReference* other = ValueCast<FileReference>(value);
   if (!other) {
     return false;
   }
   return *path == *other->path;
 }
 
-bool FileReference::flatten(android::Res_value* outValue) const {
-  if (path.getIndex() > std::numeric_limits<uint32_t>::max()) {
+bool FileReference::Flatten(android::Res_value* out_value) const {
+  if (path.index() > std::numeric_limits<uint32_t>::max()) {
     return false;
   }
 
-  outValue->dataType = android::Res_value::TYPE_STRING;
-  outValue->data = util::hostToDevice32(static_cast<uint32_t>(path.getIndex()));
+  out_value->dataType = android::Res_value::TYPE_STRING;
+  out_value->data = util::HostToDevice32(static_cast<uint32_t>(path.index()));
   return true;
 }
 
-FileReference* FileReference::clone(StringPool* newPool) const {
-  FileReference* fr = new FileReference(newPool->makeRef(*path));
+FileReference* FileReference::Clone(StringPool* new_pool) const {
+  FileReference* fr = new FileReference(new_pool->MakeRef(*path));
   fr->file = file;
-  fr->mComment = mComment;
-  fr->mSource = mSource;
+  fr->comment_ = comment_;
+  fr->source_ = source_;
   return fr;
 }
 
-void FileReference::print(std::ostream* out) const {
+void FileReference::Print(std::ostream* out) const {
   *out << "(file) " << *path;
 }
 
@@ -250,8 +250,8 @@ BinaryPrimitive::BinaryPrimitive(uint8_t dataType, uint32_t data) {
   value.data = data;
 }
 
-bool BinaryPrimitive::equals(const Value* value) const {
-  const BinaryPrimitive* other = valueCast<BinaryPrimitive>(value);
+bool BinaryPrimitive::Equals(const Value* value) const {
+  const BinaryPrimitive* other = ValueCast<BinaryPrimitive>(value);
   if (!other) {
     return false;
   }
@@ -259,17 +259,17 @@ bool BinaryPrimitive::equals(const Value* value) const {
          this->value.data == other->value.data;
 }
 
-bool BinaryPrimitive::flatten(android::Res_value* outValue) const {
-  outValue->dataType = value.dataType;
-  outValue->data = util::hostToDevice32(value.data);
+bool BinaryPrimitive::Flatten(android::Res_value* out_value) const {
+  out_value->dataType = value.dataType;
+  out_value->data = util::HostToDevice32(value.data);
   return true;
 }
 
-BinaryPrimitive* BinaryPrimitive::clone(StringPool* /*newPool*/) const {
+BinaryPrimitive* BinaryPrimitive::Clone(StringPool* /*new_pool*/) const {
   return new BinaryPrimitive(*this);
 }
 
-void BinaryPrimitive::print(std::ostream* out) const {
+void BinaryPrimitive::Print(std::ostream* out) const {
   switch (value.dataType) {
     case android::Res_value::TYPE_NULL:
       *out << "(null)";
@@ -297,10 +297,10 @@ void BinaryPrimitive::print(std::ostream* out) const {
 }
 
 Attribute::Attribute(bool w, uint32_t t)
-    : typeMask(t),
-      minInt(std::numeric_limits<int32_t>::min()),
-      maxInt(std::numeric_limits<int32_t>::max()) {
-  mWeak = w;
+    : type_mask(t),
+      min_int(std::numeric_limits<int32_t>::min()),
+      max_int(std::numeric_limits<int32_t>::max()) {
+  weak_ = w;
 }
 
 template <typename T>
@@ -308,8 +308,8 @@ T* addPointer(T& val) {
   return &val;
 }
 
-bool Attribute::equals(const Value* value) const {
-  const Attribute* other = valueCast<Attribute>(value);
+bool Attribute::Equals(const Value* value) const {
+  const Attribute* other = ValueCast<Attribute>(value);
   if (!other) {
     return false;
   }
@@ -318,46 +318,46 @@ bool Attribute::equals(const Value* value) const {
     return false;
   }
 
-  if (typeMask != other->typeMask || minInt != other->minInt ||
-      maxInt != other->maxInt) {
+  if (type_mask != other->type_mask || min_int != other->min_int ||
+      max_int != other->max_int) {
     return false;
   }
 
-  std::vector<const Symbol*> sortedA;
-  std::transform(symbols.begin(), symbols.end(), std::back_inserter(sortedA),
+  std::vector<const Symbol*> sorted_a;
+  std::transform(symbols.begin(), symbols.end(), std::back_inserter(sorted_a),
                  addPointer<const Symbol>);
-  std::sort(sortedA.begin(), sortedA.end(),
+  std::sort(sorted_a.begin(), sorted_a.end(),
             [](const Symbol* a, const Symbol* b) -> bool {
               return a->symbol.name < b->symbol.name;
             });
 
-  std::vector<const Symbol*> sortedB;
+  std::vector<const Symbol*> sorted_b;
   std::transform(other->symbols.begin(), other->symbols.end(),
-                 std::back_inserter(sortedB), addPointer<const Symbol>);
-  std::sort(sortedB.begin(), sortedB.end(),
+                 std::back_inserter(sorted_b), addPointer<const Symbol>);
+  std::sort(sorted_b.begin(), sorted_b.end(),
             [](const Symbol* a, const Symbol* b) -> bool {
               return a->symbol.name < b->symbol.name;
             });
 
-  return std::equal(sortedA.begin(), sortedA.end(), sortedB.begin(),
+  return std::equal(sorted_a.begin(), sorted_a.end(), sorted_b.begin(),
                     [](const Symbol* a, const Symbol* b) -> bool {
-                      return a->symbol.equals(&b->symbol) &&
+                      return a->symbol.Equals(&b->symbol) &&
                              a->value == b->value;
                     });
 }
 
-Attribute* Attribute::clone(StringPool* /*newPool*/) const {
+Attribute* Attribute::Clone(StringPool* /*new_pool*/) const {
   return new Attribute(*this);
 }
 
-void Attribute::printMask(std::ostream* out) const {
-  if (typeMask == android::ResTable_map::TYPE_ANY) {
+void Attribute::PrintMask(std::ostream* out) const {
+  if (type_mask == android::ResTable_map::TYPE_ANY) {
     *out << "any";
     return;
   }
 
   bool set = false;
-  if ((typeMask & android::ResTable_map::TYPE_REFERENCE) != 0) {
+  if ((type_mask & android::ResTable_map::TYPE_REFERENCE) != 0) {
     if (!set) {
       set = true;
     } else {
@@ -366,7 +366,7 @@ void Attribute::printMask(std::ostream* out) const {
     *out << "reference";
   }
 
-  if ((typeMask & android::ResTable_map::TYPE_STRING) != 0) {
+  if ((type_mask & android::ResTable_map::TYPE_STRING) != 0) {
     if (!set) {
       set = true;
     } else {
@@ -375,7 +375,7 @@ void Attribute::printMask(std::ostream* out) const {
     *out << "string";
   }
 
-  if ((typeMask & android::ResTable_map::TYPE_INTEGER) != 0) {
+  if ((type_mask & android::ResTable_map::TYPE_INTEGER) != 0) {
     if (!set) {
       set = true;
     } else {
@@ -384,7 +384,7 @@ void Attribute::printMask(std::ostream* out) const {
     *out << "integer";
   }
 
-  if ((typeMask & android::ResTable_map::TYPE_BOOLEAN) != 0) {
+  if ((type_mask & android::ResTable_map::TYPE_BOOLEAN) != 0) {
     if (!set) {
       set = true;
     } else {
@@ -393,7 +393,7 @@ void Attribute::printMask(std::ostream* out) const {
     *out << "boolean";
   }
 
-  if ((typeMask & android::ResTable_map::TYPE_COLOR) != 0) {
+  if ((type_mask & android::ResTable_map::TYPE_COLOR) != 0) {
     if (!set) {
       set = true;
     } else {
@@ -402,7 +402,7 @@ void Attribute::printMask(std::ostream* out) const {
     *out << "color";
   }
 
-  if ((typeMask & android::ResTable_map::TYPE_FLOAT) != 0) {
+  if ((type_mask & android::ResTable_map::TYPE_FLOAT) != 0) {
     if (!set) {
       set = true;
     } else {
@@ -411,7 +411,7 @@ void Attribute::printMask(std::ostream* out) const {
     *out << "float";
   }
 
-  if ((typeMask & android::ResTable_map::TYPE_DIMENSION) != 0) {
+  if ((type_mask & android::ResTable_map::TYPE_DIMENSION) != 0) {
     if (!set) {
       set = true;
     } else {
@@ -420,7 +420,7 @@ void Attribute::printMask(std::ostream* out) const {
     *out << "dimension";
   }
 
-  if ((typeMask & android::ResTable_map::TYPE_FRACTION) != 0) {
+  if ((type_mask & android::ResTable_map::TYPE_FRACTION) != 0) {
     if (!set) {
       set = true;
     } else {
@@ -429,7 +429,7 @@ void Attribute::printMask(std::ostream* out) const {
     *out << "fraction";
   }
 
-  if ((typeMask & android::ResTable_map::TYPE_ENUM) != 0) {
+  if ((type_mask & android::ResTable_map::TYPE_ENUM) != 0) {
     if (!set) {
       set = true;
     } else {
@@ -438,7 +438,7 @@ void Attribute::printMask(std::ostream* out) const {
     *out << "enum";
   }
 
-  if ((typeMask & android::ResTable_map::TYPE_FLAGS) != 0) {
+  if ((type_mask & android::ResTable_map::TYPE_FLAGS) != 0) {
     if (!set) {
       set = true;
     } else {
@@ -448,96 +448,96 @@ void Attribute::printMask(std::ostream* out) const {
   }
 }
 
-void Attribute::print(std::ostream* out) const {
+void Attribute::Print(std::ostream* out) const {
   *out << "(attr) ";
-  printMask(out);
+  PrintMask(out);
 
   if (!symbols.empty()) {
-    *out << " [" << util::joiner(symbols, ", ") << "]";
+    *out << " [" << util::Joiner(symbols, ", ") << "]";
   }
 
-  if (minInt != std::numeric_limits<int32_t>::min()) {
-    *out << " min=" << minInt;
+  if (min_int != std::numeric_limits<int32_t>::min()) {
+    *out << " min=" << min_int;
   }
 
-  if (maxInt != std::numeric_limits<int32_t>::max()) {
-    *out << " max=" << maxInt;
+  if (max_int != std::numeric_limits<int32_t>::max()) {
+    *out << " max=" << max_int;
   }
 
-  if (isWeak()) {
+  if (IsWeak()) {
     *out << " [weak]";
   }
 }
 
-static void buildAttributeMismatchMessage(DiagMessage* msg,
+static void BuildAttributeMismatchMessage(DiagMessage* msg,
                                           const Attribute* attr,
                                           const Item* value) {
   *msg << "expected";
-  if (attr->typeMask & android::ResTable_map::TYPE_BOOLEAN) {
+  if (attr->type_mask & android::ResTable_map::TYPE_BOOLEAN) {
     *msg << " boolean";
   }
 
-  if (attr->typeMask & android::ResTable_map::TYPE_COLOR) {
+  if (attr->type_mask & android::ResTable_map::TYPE_COLOR) {
     *msg << " color";
   }
 
-  if (attr->typeMask & android::ResTable_map::TYPE_DIMENSION) {
+  if (attr->type_mask & android::ResTable_map::TYPE_DIMENSION) {
     *msg << " dimension";
   }
 
-  if (attr->typeMask & android::ResTable_map::TYPE_ENUM) {
+  if (attr->type_mask & android::ResTable_map::TYPE_ENUM) {
     *msg << " enum";
   }
 
-  if (attr->typeMask & android::ResTable_map::TYPE_FLAGS) {
+  if (attr->type_mask & android::ResTable_map::TYPE_FLAGS) {
     *msg << " flags";
   }
 
-  if (attr->typeMask & android::ResTable_map::TYPE_FLOAT) {
+  if (attr->type_mask & android::ResTable_map::TYPE_FLOAT) {
     *msg << " float";
   }
 
-  if (attr->typeMask & android::ResTable_map::TYPE_FRACTION) {
+  if (attr->type_mask & android::ResTable_map::TYPE_FRACTION) {
     *msg << " fraction";
   }
 
-  if (attr->typeMask & android::ResTable_map::TYPE_INTEGER) {
+  if (attr->type_mask & android::ResTable_map::TYPE_INTEGER) {
     *msg << " integer";
   }
 
-  if (attr->typeMask & android::ResTable_map::TYPE_REFERENCE) {
+  if (attr->type_mask & android::ResTable_map::TYPE_REFERENCE) {
     *msg << " reference";
   }
 
-  if (attr->typeMask & android::ResTable_map::TYPE_STRING) {
+  if (attr->type_mask & android::ResTable_map::TYPE_STRING) {
     *msg << " string";
   }
 
   *msg << " but got " << *value;
 }
 
-bool Attribute::matches(const Item* item, DiagMessage* outMsg) const {
+bool Attribute::Matches(const Item* item, DiagMessage* out_msg) const {
   android::Res_value val = {};
-  item->flatten(&val);
+  item->Flatten(&val);
 
   // Always allow references.
-  const uint32_t mask = typeMask | android::ResTable_map::TYPE_REFERENCE;
-  if (!(mask & ResourceUtils::androidTypeToAttributeTypeMask(val.dataType))) {
-    if (outMsg) {
-      buildAttributeMismatchMessage(outMsg, this, item);
+  const uint32_t mask = type_mask | android::ResTable_map::TYPE_REFERENCE;
+  if (!(mask & ResourceUtils::AndroidTypeToAttributeTypeMask(val.dataType))) {
+    if (out_msg) {
+      BuildAttributeMismatchMessage(out_msg, this, item);
     }
     return false;
 
-  } else if (ResourceUtils::androidTypeToAttributeTypeMask(val.dataType) &
+  } else if (ResourceUtils::AndroidTypeToAttributeTypeMask(val.dataType) &
              android::ResTable_map::TYPE_INTEGER) {
-    if (static_cast<int32_t>(util::deviceToHost32(val.data)) < minInt) {
-      if (outMsg) {
-        *outMsg << *item << " is less than minimum integer " << minInt;
+    if (static_cast<int32_t>(util::DeviceToHost32(val.data)) < min_int) {
+      if (out_msg) {
+        *out_msg << *item << " is less than minimum integer " << min_int;
       }
       return false;
-    } else if (static_cast<int32_t>(util::deviceToHost32(val.data)) > maxInt) {
-      if (outMsg) {
-        *outMsg << *item << " is greater than maximum integer " << maxInt;
+    } else if (static_cast<int32_t>(util::DeviceToHost32(val.data)) > max_int) {
+      if (out_msg) {
+        *out_msg << *item << " is greater than maximum integer " << max_int;
       }
       return false;
     }
@@ -545,14 +545,14 @@ bool Attribute::matches(const Item* item, DiagMessage* outMsg) const {
   return true;
 }
 
-bool Style::equals(const Value* value) const {
-  const Style* other = valueCast<Style>(value);
+bool Style::Equals(const Value* value) const {
+  const Style* other = ValueCast<Style>(value);
   if (!other) {
     return false;
   }
   if (bool(parent) != bool(other->parent) ||
       (parent && other->parent &&
-       !parent.value().equals(&other->parent.value()))) {
+       !parent.value().Equals(&other->parent.value()))) {
     return false;
   }
 
@@ -560,51 +560,51 @@ bool Style::equals(const Value* value) const {
     return false;
   }
 
-  std::vector<const Entry*> sortedA;
-  std::transform(entries.begin(), entries.end(), std::back_inserter(sortedA),
+  std::vector<const Entry*> sorted_a;
+  std::transform(entries.begin(), entries.end(), std::back_inserter(sorted_a),
                  addPointer<const Entry>);
-  std::sort(sortedA.begin(), sortedA.end(),
+  std::sort(sorted_a.begin(), sorted_a.end(),
             [](const Entry* a, const Entry* b) -> bool {
               return a->key.name < b->key.name;
             });
 
-  std::vector<const Entry*> sortedB;
+  std::vector<const Entry*> sorted_b;
   std::transform(other->entries.begin(), other->entries.end(),
-                 std::back_inserter(sortedB), addPointer<const Entry>);
-  std::sort(sortedB.begin(), sortedB.end(),
+                 std::back_inserter(sorted_b), addPointer<const Entry>);
+  std::sort(sorted_b.begin(), sorted_b.end(),
             [](const Entry* a, const Entry* b) -> bool {
               return a->key.name < b->key.name;
             });
 
-  return std::equal(sortedA.begin(), sortedA.end(), sortedB.begin(),
+  return std::equal(sorted_a.begin(), sorted_a.end(), sorted_b.begin(),
                     [](const Entry* a, const Entry* b) -> bool {
-                      return a->key.equals(&b->key) &&
-                             a->value->equals(b->value.get());
+                      return a->key.Equals(&b->key) &&
+                             a->value->Equals(b->value.get());
                     });
 }
 
-Style* Style::clone(StringPool* newPool) const {
+Style* Style::Clone(StringPool* new_pool) const {
   Style* style = new Style();
   style->parent = parent;
-  style->parentInferred = parentInferred;
-  style->mComment = mComment;
-  style->mSource = mSource;
+  style->parent_inferred = parent_inferred;
+  style->comment_ = comment_;
+  style->source_ = source_;
   for (auto& entry : entries) {
     style->entries.push_back(
-        Entry{entry.key, std::unique_ptr<Item>(entry.value->clone(newPool))});
+        Entry{entry.key, std::unique_ptr<Item>(entry.value->Clone(new_pool))});
   }
   return style;
 }
 
-void Style::print(std::ostream* out) const {
+void Style::Print(std::ostream* out) const {
   *out << "(style) ";
   if (parent && parent.value().name) {
-    if (parent.value().privateReference) {
+    if (parent.value().private_reference) {
       *out << "*";
     }
     *out << parent.value().name.value();
   }
-  *out << " [" << util::joiner(entries, ", ") << "]";
+  *out << " [" << util::Joiner(entries, ", ") << "]";
 }
 
 static ::std::ostream& operator<<(::std::ostream& out,
@@ -617,12 +617,12 @@ static ::std::ostream& operator<<(::std::ostream& out,
     out << "???";
   }
   out << " = ";
-  value.value->print(&out);
+  value.value->Print(&out);
   return out;
 }
 
-bool Array::equals(const Value* value) const {
-  const Array* other = valueCast<Array>(value);
+bool Array::Equals(const Value* value) const {
+  const Array* other = ValueCast<Array>(value);
   if (!other) {
     return false;
   }
@@ -634,26 +634,26 @@ bool Array::equals(const Value* value) const {
   return std::equal(items.begin(), items.end(), other->items.begin(),
                     [](const std::unique_ptr<Item>& a,
                        const std::unique_ptr<Item>& b) -> bool {
-                      return a->equals(b.get());
+                      return a->Equals(b.get());
                     });
 }
 
-Array* Array::clone(StringPool* newPool) const {
+Array* Array::Clone(StringPool* new_pool) const {
   Array* array = new Array();
-  array->mComment = mComment;
-  array->mSource = mSource;
+  array->comment_ = comment_;
+  array->source_ = source_;
   for (auto& item : items) {
-    array->items.emplace_back(std::unique_ptr<Item>(item->clone(newPool)));
+    array->items.emplace_back(std::unique_ptr<Item>(item->Clone(new_pool)));
   }
   return array;
 }
 
-void Array::print(std::ostream* out) const {
-  *out << "(array) [" << util::joiner(items, ", ") << "]";
+void Array::Print(std::ostream* out) const {
+  *out << "(array) [" << util::Joiner(items, ", ") << "]";
 }
 
-bool Plural::equals(const Value* value) const {
-  const Plural* other = valueCast<Plural>(value);
+bool Plural::Equals(const Value* value) const {
+  const Plural* other = ValueCast<Plural>(value);
   if (!other) {
     return false;
   }
@@ -668,24 +668,24 @@ bool Plural::equals(const Value* value) const {
                       if (bool(a) != bool(b)) {
                         return false;
                       }
-                      return bool(a) == bool(b) || a->equals(b.get());
+                      return bool(a) == bool(b) || a->Equals(b.get());
                     });
 }
 
-Plural* Plural::clone(StringPool* newPool) const {
+Plural* Plural::Clone(StringPool* new_pool) const {
   Plural* p = new Plural();
-  p->mComment = mComment;
-  p->mSource = mSource;
+  p->comment_ = comment_;
+  p->source_ = source_;
   const size_t count = values.size();
   for (size_t i = 0; i < count; i++) {
     if (values[i]) {
-      p->values[i] = std::unique_ptr<Item>(values[i]->clone(newPool));
+      p->values[i] = std::unique_ptr<Item>(values[i]->Clone(new_pool));
     }
   }
   return p;
 }
 
-void Plural::print(std::ostream* out) const {
+void Plural::Print(std::ostream* out) const {
   *out << "(plural)";
   if (values[Zero]) {
     *out << " zero=" << *values[Zero];
@@ -713,8 +713,8 @@ static ::std::ostream& operator<<(::std::ostream& out,
   return out << *item;
 }
 
-bool Styleable::equals(const Value* value) const {
-  const Styleable* other = valueCast<Styleable>(value);
+bool Styleable::Equals(const Value* value) const {
+  const Styleable* other = ValueCast<Styleable>(value);
   if (!other) {
     return false;
   }
@@ -725,21 +725,21 @@ bool Styleable::equals(const Value* value) const {
 
   return std::equal(entries.begin(), entries.end(), other->entries.begin(),
                     [](const Reference& a, const Reference& b) -> bool {
-                      return a.equals(&b);
+                      return a.Equals(&b);
                     });
 }
 
-Styleable* Styleable::clone(StringPool* /*newPool*/) const {
+Styleable* Styleable::Clone(StringPool* /*new_pool*/) const {
   return new Styleable(*this);
 }
 
-void Styleable::print(std::ostream* out) const {
+void Styleable::Print(std::ostream* out) const {
   *out << "(styleable) "
-       << " [" << util::joiner(entries, ", ") << "]";
+       << " [" << util::Joiner(entries, ", ") << "]";
 }
 
 bool operator<(const Reference& a, const Reference& b) {
-  int cmp = a.name.valueOrDefault({}).compare(b.name.valueOrDefault({}));
+  int cmp = a.name.value_or_default({}).compare(b.name.value_or_default({}));
   if (cmp != 0) return cmp < 0;
   return a.id < b.id;
 }
@@ -758,7 +758,7 @@ struct NameOnlyComparator {
   }
 };
 
-void Styleable::mergeWith(Styleable* other) {
+void Styleable::MergeWith(Styleable* other) {
   // Compare only names, because some References may already have their IDs
   // assigned
   // (framework IDs that don't change).
diff --git a/tools/aapt2/ResourceValues.h b/tools/aapt2/ResourceValues.h
index a28ffe5aff0f6..ea73615e372a4 100644
--- a/tools/aapt2/ResourceValues.h
+++ b/tools/aapt2/ResourceValues.h
@@ -17,17 +17,18 @@
 #ifndef AAPT_RESOURCE_VALUES_H
 #define AAPT_RESOURCE_VALUES_H
 
+#include <array>
+#include <ostream>
+#include <vector>
+
+#include "androidfw/ResourceTypes.h"
+
 #include "Diagnostics.h"
 #include "Resource.h"
 #include "StringPool.h"
 #include "io/File.h"
 #include "util/Maybe.h"
 
-#include <androidfw/ResourceTypes.h>
-#include <array>
-#include <ostream>
-#include <vector>
-
 namespace aapt {
 
 struct RawValueVisitor;
@@ -46,58 +47,59 @@ struct Value {
    * Whether this value is weak and can be overridden without
    * warning or error. Default is false.
    */
-  bool isWeak() const { return mWeak; }
+  bool IsWeak() const { return weak_; }
 
-  void setWeak(bool val) { mWeak = val; }
+  void SetWeak(bool val) { weak_ = val; }
 
   // Whether the value is marked as translateable.
   // This does not persist when flattened.
   // It is only used during compilation phase.
-  void setTranslateable(bool val) { mTranslateable = val; }
+  void SetTranslateable(bool val) { translateable_ = val; }
 
   // Default true.
-  bool isTranslateable() const { return mTranslateable; }
+  bool IsTranslateable() const { return translateable_; }
 
   /**
    * Returns the source where this value was defined.
    */
-  const Source& getSource() const { return mSource; }
+  const Source& GetSource() const { return source_; }
 
-  void setSource(const Source& source) { mSource = source; }
+  void SetSource(const Source& source) { source_ = source; }
 
-  void setSource(Source&& source) { mSource = std::move(source); }
+  void SetSource(Source&& source) { source_ = std::move(source); }
 
   /**
    * Returns the comment that was associated with this resource.
    */
-  const std::string& getComment() const { return mComment; }
+  const std::string& GetComment() const { return comment_; }
 
-  void setComment(const StringPiece& str) { mComment = str.toString(); }
+  void SetComment(const StringPiece& str) { comment_ = str.ToString(); }
 
-  void setComment(std::string&& str) { mComment = std::move(str); }
+  void SetComment(std::string&& str) { comment_ = std::move(str); }
 
-  virtual bool equals(const Value* value) const = 0;
+  virtual bool Equals(const Value* value) const = 0;
 
   /**
    * Calls the appropriate overload of ValueVisitor.
    */
-  virtual void accept(RawValueVisitor* visitor) = 0;
+  virtual void Accept(RawValueVisitor* visitor) = 0;
 
   /**
-   * Clone the value.
+   * Clone the value. new_pool is the new StringPool that
+   * any resources with strings should use when copying their string.
    */
-  virtual Value* clone(StringPool* newPool) const = 0;
+  virtual Value* Clone(StringPool* new_pool) const = 0;
 
   /**
    * Human readable printout of this value.
    */
-  virtual void print(std::ostream* out) const = 0;
+  virtual void Print(std::ostream* out) const = 0;
 
  protected:
-  Source mSource;
-  std::string mComment;
-  bool mWeak = false;
-  bool mTranslateable = true;
+  Source source_;
+  std::string comment_;
+  bool weak_ = false;
+  bool translateable_ = true;
 };
 
 /**
@@ -105,7 +107,7 @@ struct Value {
  */
 template <typename Derived>
 struct BaseValue : public Value {
-  void accept(RawValueVisitor* visitor) override;
+  void Accept(RawValueVisitor* visitor) override;
 };
 
 /**
@@ -115,14 +117,14 @@ struct Item : public Value {
   /**
    * Clone the Item.
    */
-  virtual Item* clone(StringPool* newPool) const override = 0;
+  virtual Item* Clone(StringPool* new_pool) const override = 0;
 
   /**
    * Fills in an android::Res_value structure with this Item's binary
    * representation.
    * Returns false if an error occurred.
    */
-  virtual bool flatten(android::Res_value* outValue) const = 0;
+  virtual bool Flatten(android::Res_value* out_value) const = 0;
 };
 
 /**
@@ -130,7 +132,7 @@ struct Item : public Value {
  */
 template <typename Derived>
 struct BaseItem : public Item {
-  void accept(RawValueVisitor* visitor) override;
+  void Accept(RawValueVisitor* visitor) override;
 };
 
 /**
@@ -149,18 +151,18 @@ struct Reference : public BaseItem<Reference> {
 
   Maybe<ResourceName> name;
   Maybe<ResourceId> id;
-  Reference::Type referenceType;
-  bool privateReference = false;
+  Reference::Type reference_type;
+  bool private_reference = false;
 
   Reference();
   explicit Reference(const ResourceNameRef& n, Type type = Type::kResource);
   explicit Reference(const ResourceId& i, Type type = Type::kResource);
-  explicit Reference(const ResourceNameRef& n, const ResourceId& i);
+  Reference(const ResourceNameRef& n, const ResourceId& i);
 
-  bool equals(const Value* value) const override;
-  bool flatten(android::Res_value* outValue) const override;
-  Reference* clone(StringPool* newPool) const override;
-  void print(std::ostream* out) const override;
+  bool Equals(const Value* value) const override;
+  bool Flatten(android::Res_value* out_value) const override;
+  Reference* Clone(StringPool* new_pool) const override;
+  void Print(std::ostream* out) const override;
 };
 
 bool operator<(const Reference&, const Reference&);
@@ -170,11 +172,11 @@ bool operator==(const Reference&, const Reference&);
  * An ID resource. Has no real value, just a place holder.
  */
 struct Id : public BaseItem<Id> {
-  Id() { mWeak = true; }
-  bool equals(const Value* value) const override;
-  bool flatten(android::Res_value* out) const override;
-  Id* clone(StringPool* newPool) const override;
-  void print(std::ostream* out) const override;
+  Id() { weak_ = true; }
+  bool Equals(const Value* value) const override;
+  bool Flatten(android::Res_value* out) const override;
+  Id* Clone(StringPool* new_pool) const override;
+  void Print(std::ostream* out) const override;
 };
 
 /**
@@ -187,10 +189,10 @@ struct RawString : public BaseItem<RawString> {
 
   explicit RawString(const StringPool::Ref& ref);
 
-  bool equals(const Value* value) const override;
-  bool flatten(android::Res_value* outValue) const override;
-  RawString* clone(StringPool* newPool) const override;
-  void print(std::ostream* out) const override;
+  bool Equals(const Value* value) const override;
+  bool Flatten(android::Res_value* out_value) const override;
+  RawString* Clone(StringPool* new_pool) const override;
+  void Print(std::ostream* out) const override;
 };
 
 struct String : public BaseItem<String> {
@@ -198,10 +200,10 @@ struct String : public BaseItem<String> {
 
   explicit String(const StringPool::Ref& ref);
 
-  bool equals(const Value* value) const override;
-  bool flatten(android::Res_value* outValue) const override;
-  String* clone(StringPool* newPool) const override;
-  void print(std::ostream* out) const override;
+  bool Equals(const Value* value) const override;
+  bool Flatten(android::Res_value* out_value) const override;
+  String* Clone(StringPool* new_pool) const override;
+  void Print(std::ostream* out) const override;
 };
 
 struct StyledString : public BaseItem<StyledString> {
@@ -209,10 +211,10 @@ struct StyledString : public BaseItem<StyledString> {
 
   explicit StyledString(const StringPool::StyleRef& ref);
 
-  bool equals(const Value* value) const override;
-  bool flatten(android::Res_value* outValue) const override;
-  StyledString* clone(StringPool* newPool) const override;
-  void print(std::ostream* out) const override;
+  bool Equals(const Value* value) const override;
+  bool Flatten(android::Res_value* out_value) const override;
+  StyledString* Clone(StringPool* new_pool) const override;
+  void Print(std::ostream* out) const override;
 };
 
 struct FileReference : public BaseItem<FileReference> {
@@ -226,10 +228,10 @@ struct FileReference : public BaseItem<FileReference> {
   FileReference() = default;
   explicit FileReference(const StringPool::Ref& path);
 
-  bool equals(const Value* value) const override;
-  bool flatten(android::Res_value* outValue) const override;
-  FileReference* clone(StringPool* newPool) const override;
-  void print(std::ostream* out) const override;
+  bool Equals(const Value* value) const override;
+  bool Flatten(android::Res_value* out_value) const override;
+  FileReference* Clone(StringPool* new_pool) const override;
+  void Print(std::ostream* out) const override;
 };
 
 /**
@@ -242,10 +244,10 @@ struct BinaryPrimitive : public BaseItem<BinaryPrimitive> {
   explicit BinaryPrimitive(const android::Res_value& val);
   BinaryPrimitive(uint8_t dataType, uint32_t data);
 
-  bool equals(const Value* value) const override;
-  bool flatten(android::Res_value* outValue) const override;
-  BinaryPrimitive* clone(StringPool* newPool) const override;
-  void print(std::ostream* out) const override;
+  bool Equals(const Value* value) const override;
+  bool Flatten(android::Res_value* out_value) const override;
+  BinaryPrimitive* Clone(StringPool* new_pool) const override;
+  void Print(std::ostream* out) const override;
 };
 
 struct Attribute : public BaseValue<Attribute> {
@@ -254,18 +256,18 @@ struct Attribute : public BaseValue<Attribute> {
     uint32_t value;
   };
 
-  uint32_t typeMask;
-  int32_t minInt;
-  int32_t maxInt;
+  uint32_t type_mask;
+  int32_t min_int;
+  int32_t max_int;
   std::vector<Symbol> symbols;
 
   explicit Attribute(bool w, uint32_t t = 0u);
 
-  bool equals(const Value* value) const override;
-  Attribute* clone(StringPool* newPool) const override;
-  void printMask(std::ostream* out) const;
-  void print(std::ostream* out) const override;
-  bool matches(const Item* item, DiagMessage* outMsg) const;
+  bool Equals(const Value* value) const override;
+  Attribute* Clone(StringPool* new_pool) const override;
+  void PrintMask(std::ostream* out) const;
+  void Print(std::ostream* out) const override;
+  bool Matches(const Item* item, DiagMessage* out_msg) const;
 };
 
 struct Style : public BaseValue<Style> {
@@ -280,21 +282,21 @@ struct Style : public BaseValue<Style> {
    * If set to true, the parent was auto inferred from the
    * style's name.
    */
-  bool parentInferred = false;
+  bool parent_inferred = false;
 
   std::vector<Entry> entries;
 
-  bool equals(const Value* value) const override;
-  Style* clone(StringPool* newPool) const override;
-  void print(std::ostream* out) const override;
+  bool Equals(const Value* value) const override;
+  Style* Clone(StringPool* new_pool) const override;
+  void Print(std::ostream* out) const override;
 };
 
 struct Array : public BaseValue<Array> {
   std::vector<std::unique_ptr<Item>> items;
 
-  bool equals(const Value* value) const override;
-  Array* clone(StringPool* newPool) const override;
-  void print(std::ostream* out) const override;
+  bool Equals(const Value* value) const override;
+  Array* Clone(StringPool* new_pool) const override;
+  void Print(std::ostream* out) const override;
 };
 
 struct Plural : public BaseValue<Plural> {
@@ -302,25 +304,25 @@ struct Plural : public BaseValue<Plural> {
 
   std::array<std::unique_ptr<Item>, Count> values;
 
-  bool equals(const Value* value) const override;
-  Plural* clone(StringPool* newPool) const override;
-  void print(std::ostream* out) const override;
+  bool Equals(const Value* value) const override;
+  Plural* Clone(StringPool* new_pool) const override;
+  void Print(std::ostream* out) const override;
 };
 
 struct Styleable : public BaseValue<Styleable> {
   std::vector<Reference> entries;
 
-  bool equals(const Value* value) const override;
-  Styleable* clone(StringPool* newPool) const override;
-  void print(std::ostream* out) const override;
-  void mergeWith(Styleable* styleable);
+  bool Equals(const Value* value) const override;
+  Styleable* Clone(StringPool* newPool) const override;
+  void Print(std::ostream* out) const override;
+  void MergeWith(Styleable* styleable);
 };
 
 /**
  * Stream operator for printing Value objects.
  */
 inline ::std::ostream& operator<<(::std::ostream& out, const Value& value) {
-  value.print(&out);
+  value.Print(&out);
   return out;
 }
 
diff --git a/tools/aapt2/Resource_test.cpp b/tools/aapt2/Resource_test.cpp
index 4b6b122f984e2..720ab91c57408 100644
--- a/tools/aapt2/Resource_test.cpp
+++ b/tools/aapt2/Resource_test.cpp
@@ -15,100 +15,101 @@
  */
 
 #include "Resource.h"
+
 #include "test/Test.h"
 
 namespace aapt {
 
 TEST(ResourceTypeTest, ParseResourceTypes) {
-  const ResourceType* type = parseResourceType("anim");
+  const ResourceType* type = ParseResourceType("anim");
   ASSERT_NE(type, nullptr);
   EXPECT_EQ(*type, ResourceType::kAnim);
 
-  type = parseResourceType("animator");
+  type = ParseResourceType("animator");
   ASSERT_NE(type, nullptr);
   EXPECT_EQ(*type, ResourceType::kAnimator);
 
-  type = parseResourceType("array");
+  type = ParseResourceType("array");
   ASSERT_NE(type, nullptr);
   EXPECT_EQ(*type, ResourceType::kArray);
 
-  type = parseResourceType("attr");
+  type = ParseResourceType("attr");
   ASSERT_NE(type, nullptr);
   EXPECT_EQ(*type, ResourceType::kAttr);
 
-  type = parseResourceType("^attr-private");
+  type = ParseResourceType("^attr-private");
   ASSERT_NE(type, nullptr);
   EXPECT_EQ(*type, ResourceType::kAttrPrivate);
 
-  type = parseResourceType("bool");
+  type = ParseResourceType("bool");
   ASSERT_NE(type, nullptr);
   EXPECT_EQ(*type, ResourceType::kBool);
 
-  type = parseResourceType("color");
+  type = ParseResourceType("color");
   ASSERT_NE(type, nullptr);
   EXPECT_EQ(*type, ResourceType::kColor);
 
-  type = parseResourceType("dimen");
+  type = ParseResourceType("dimen");
   ASSERT_NE(type, nullptr);
   EXPECT_EQ(*type, ResourceType::kDimen);
 
-  type = parseResourceType("drawable");
+  type = ParseResourceType("drawable");
   ASSERT_NE(type, nullptr);
   EXPECT_EQ(*type, ResourceType::kDrawable);
 
-  type = parseResourceType("fraction");
+  type = ParseResourceType("fraction");
   ASSERT_NE(type, nullptr);
   EXPECT_EQ(*type, ResourceType::kFraction);
 
-  type = parseResourceType("id");
+  type = ParseResourceType("id");
   ASSERT_NE(type, nullptr);
   EXPECT_EQ(*type, ResourceType::kId);
 
-  type = parseResourceType("integer");
+  type = ParseResourceType("integer");
   ASSERT_NE(type, nullptr);
   EXPECT_EQ(*type, ResourceType::kInteger);
 
-  type = parseResourceType("interpolator");
+  type = ParseResourceType("interpolator");
   ASSERT_NE(type, nullptr);
   EXPECT_EQ(*type, ResourceType::kInterpolator);
 
-  type = parseResourceType("layout");
+  type = ParseResourceType("layout");
   ASSERT_NE(type, nullptr);
   EXPECT_EQ(*type, ResourceType::kLayout);
 
-  type = parseResourceType("menu");
+  type = ParseResourceType("menu");
   ASSERT_NE(type, nullptr);
   EXPECT_EQ(*type, ResourceType::kMenu);
 
-  type = parseResourceType("mipmap");
+  type = ParseResourceType("mipmap");
   ASSERT_NE(type, nullptr);
   EXPECT_EQ(*type, ResourceType::kMipmap);
 
-  type = parseResourceType("plurals");
+  type = ParseResourceType("plurals");
   ASSERT_NE(type, nullptr);
   EXPECT_EQ(*type, ResourceType::kPlurals);
 
-  type = parseResourceType("raw");
+  type = ParseResourceType("raw");
   ASSERT_NE(type, nullptr);
   EXPECT_EQ(*type, ResourceType::kRaw);
 
-  type = parseResourceType("string");
+  type = ParseResourceType("string");
   ASSERT_NE(type, nullptr);
   EXPECT_EQ(*type, ResourceType::kString);
 
-  type = parseResourceType("style");
+  type = ParseResourceType("style");
   ASSERT_NE(type, nullptr);
   EXPECT_EQ(*type, ResourceType::kStyle);
 
-  type = parseResourceType("transition");
+  type = ParseResourceType("transition");
   ASSERT_NE(type, nullptr);
   EXPECT_EQ(*type, ResourceType::kTransition);
 
-  type = parseResourceType("xml");
+  type = ParseResourceType("xml");
   ASSERT_NE(type, nullptr);
   EXPECT_EQ(*type, ResourceType::kXml);
 
-  type = parseResourceType("blahaha");
+  type = ParseResourceType("blahaha");
   EXPECT_EQ(type, nullptr);
 }
 
diff --git a/tools/aapt2/SdkConstants.cpp b/tools/aapt2/SdkConstants.cpp
index 75375da334586..c7f920ac6c581 100644
--- a/tools/aapt2/SdkConstants.cpp
+++ b/tools/aapt2/SdkConstants.cpp
@@ -48,17 +48,17 @@ static const std::vector<std::pair<uint16_t, size_t>> sAttrIdMap = {
     {0x04ce, SDK_LOLLIPOP},
 };
 
-static bool lessEntryId(const std::pair<uint16_t, size_t>& p,
+static bool less_entry_id(const std::pair<uint16_t, size_t>& p,
                         uint16_t entryId) {
   return p.first < entryId;
 }
 
-size_t findAttributeSdkLevel(const ResourceId& id) {
-  if (id.packageId() != 0x01 && id.typeId() != 0x01) {
+size_t FindAttributeSdkLevel(const ResourceId& id) {
+  if (id.package_id() != 0x01 && id.type_id() != 0x01) {
     return 0;
   }
   auto iter = std::lower_bound(sAttrIdMap.begin(), sAttrIdMap.end(),
-                               id.entryId(), lessEntryId);
+                               id.entry_id(), less_entry_id);
   if (iter == sAttrIdMap.end()) {
     return SDK_LOLLIPOP_MR1;
   }
@@ -727,7 +727,7 @@ static const std::unordered_map<std::string, size_t> sAttrMap = {
     {"windowActivityTransitions", 21},
     {"colorEdgeEffect", 21}};
 
-size_t findAttributeSdkLevel(const ResourceName& name) {
+size_t FindAttributeSdkLevel(const ResourceName& name) {
   if (name.package != "android" && name.type != ResourceType::kAttr) {
     return 0;
   }
@@ -739,7 +739,7 @@ size_t findAttributeSdkLevel(const ResourceName& name) {
   return SDK_LOLLIPOP_MR1;
 }
 
-std::pair<StringPiece, int> getDevelopmentSdkCodeNameAndVersion() {
+std::pair<StringPiece, int> GetDevelopmentSdkCodeNameAndVersion() {
   return std::make_pair(StringPiece(sDevelopmentSdkCodeName),
                         sDevelopmentSdkLevel);
 }
diff --git a/tools/aapt2/SdkConstants.h b/tools/aapt2/SdkConstants.h
index bd17fe4996187..9b38ecbeae990 100644
--- a/tools/aapt2/SdkConstants.h
+++ b/tools/aapt2/SdkConstants.h
@@ -17,10 +17,10 @@
 #ifndef AAPT_SDK_CONSTANTS_H
 #define AAPT_SDK_CONSTANTS_H
 
-#include "Resource.h"
-
 #include <utility>
 
+#include "Resource.h"
+
 namespace aapt {
 
 enum {
@@ -47,9 +47,9 @@ enum {
   SDK_MARSHMALLOW = 23,
 };
 
-size_t findAttributeSdkLevel(const ResourceId& id);
-size_t findAttributeSdkLevel(const ResourceName& name);
-std::pair<StringPiece, int> getDevelopmentSdkCodeNameAndVersion();
+size_t FindAttributeSdkLevel(const ResourceId& id);
+size_t FindAttributeSdkLevel(const ResourceName& name);
+std::pair<StringPiece, int> GetDevelopmentSdkCodeNameAndVersion();
 
 }  // namespace aapt
 
diff --git a/tools/aapt2/SdkConstants_test.cpp b/tools/aapt2/SdkConstants_test.cpp
index 3b70acb7c6106..716d922fb5a06 100644
--- a/tools/aapt2/SdkConstants_test.cpp
+++ b/tools/aapt2/SdkConstants_test.cpp
@@ -16,23 +16,23 @@
 
 #include "SdkConstants.h"
 
-#include <gtest/gtest.h>
+#include "gtest/gtest.h"
 
 namespace aapt {
 
 TEST(SdkConstantsTest, FirstAttributeIsSdk1) {
-  EXPECT_EQ(1u, findAttributeSdkLevel(ResourceId(0x01010000)));
+  EXPECT_EQ(1u, FindAttributeSdkLevel(ResourceId(0x01010000)));
 }
 
 TEST(SdkConstantsTest, AllAttributesAfterLollipopAreLollipopMR1) {
-  EXPECT_EQ(SDK_LOLLIPOP, findAttributeSdkLevel(ResourceId(0x010103f7)));
-  EXPECT_EQ(SDK_LOLLIPOP, findAttributeSdkLevel(ResourceId(0x010104ce)));
+  EXPECT_EQ(SDK_LOLLIPOP, FindAttributeSdkLevel(ResourceId(0x010103f7)));
+  EXPECT_EQ(SDK_LOLLIPOP, FindAttributeSdkLevel(ResourceId(0x010104ce)));
 
-  EXPECT_EQ(SDK_LOLLIPOP_MR1, findAttributeSdkLevel(ResourceId(0x010104cf)));
-  EXPECT_EQ(SDK_LOLLIPOP_MR1, findAttributeSdkLevel(ResourceId(0x010104d8)));
+  EXPECT_EQ(SDK_LOLLIPOP_MR1, FindAttributeSdkLevel(ResourceId(0x010104cf)));
+  EXPECT_EQ(SDK_LOLLIPOP_MR1, FindAttributeSdkLevel(ResourceId(0x010104d8)));
 
-  EXPECT_EQ(SDK_LOLLIPOP_MR1, findAttributeSdkLevel(ResourceId(0x010104d9)));
-  EXPECT_EQ(SDK_LOLLIPOP_MR1, findAttributeSdkLevel(ResourceId(0x0101ffff)));
+  EXPECT_EQ(SDK_LOLLIPOP_MR1, FindAttributeSdkLevel(ResourceId(0x010104d9)));
+  EXPECT_EQ(SDK_LOLLIPOP_MR1, FindAttributeSdkLevel(ResourceId(0x0101ffff)));
 }
 
 }  // namespace aapt
diff --git a/tools/aapt2/Source.h b/tools/aapt2/Source.h
index 422b36112660a..459a8e603b6b0 100644
--- a/tools/aapt2/Source.h
+++ b/tools/aapt2/Source.h
@@ -17,12 +17,12 @@
 #ifndef AAPT_SOURCE_H
 #define AAPT_SOURCE_H
 
-#include "util/Maybe.h"
-#include "util/StringPiece.h"
-
 #include <ostream>
 #include <string>
 
+#include "util/Maybe.h"
+#include "util/StringPiece.h"
+
 namespace aapt {
 
 /**
@@ -36,13 +36,13 @@ struct Source {
   Source() = default;
 
   inline Source(const StringPiece& path)
-      : path(path.toString()) {  // NOLINT(implicit)
+      : path(path.ToString()) {  // NOLINT(implicit)
   }
 
   inline Source(const StringPiece& path, size_t line)
-      : path(path.toString()), line(line) {}
+      : path(path.ToString()), line(line) {}
 
-  inline Source withLine(size_t line) const { return Source(path, line); }
+  inline Source WithLine(size_t line) const { return Source(path, line); }
 };
 
 //
diff --git a/tools/aapt2/StringPool.cpp b/tools/aapt2/StringPool.cpp
index a167a6aec8022..30328299bb84a 100644
--- a/tools/aapt2/StringPool.cpp
+++ b/tools/aapt2/StringPool.cpp
@@ -15,263 +15,266 @@
  */
 
 #include "StringPool.h"
-#include "util/BigBuffer.h"
-#include "util/StringPiece.h"
-#include "util/Util.h"
 
-#include <androidfw/ResourceTypes.h>
 #include <algorithm>
 #include <memory>
 #include <string>
 
+#include "android-base/logging.h"
+#include "androidfw/ResourceTypes.h"
+
+#include "util/BigBuffer.h"
+#include "util/StringPiece.h"
+#include "util/Util.h"
+
 namespace aapt {
 
-StringPool::Ref::Ref() : mEntry(nullptr) {}
+StringPool::Ref::Ref() : entry_(nullptr) {}
 
-StringPool::Ref::Ref(const StringPool::Ref& rhs) : mEntry(rhs.mEntry) {
-  if (mEntry != nullptr) {
-    mEntry->ref++;
+StringPool::Ref::Ref(const StringPool::Ref& rhs) : entry_(rhs.entry_) {
+  if (entry_ != nullptr) {
+    entry_->ref_++;
   }
 }
 
-StringPool::Ref::Ref(StringPool::Entry* entry) : mEntry(entry) {
-  if (mEntry != nullptr) {
-    mEntry->ref++;
+StringPool::Ref::Ref(StringPool::Entry* entry) : entry_(entry) {
+  if (entry_ != nullptr) {
+    entry_->ref_++;
   }
 }
 
 StringPool::Ref::~Ref() {
-  if (mEntry != nullptr) {
-    mEntry->ref--;
+  if (entry_ != nullptr) {
+    entry_->ref_--;
   }
 }
 
 StringPool::Ref& StringPool::Ref::operator=(const StringPool::Ref& rhs) {
-  if (rhs.mEntry != nullptr) {
-    rhs.mEntry->ref++;
+  if (rhs.entry_ != nullptr) {
+    rhs.entry_->ref_++;
   }
 
-  if (mEntry != nullptr) {
-    mEntry->ref--;
+  if (entry_ != nullptr) {
+    entry_->ref_--;
   }
-  mEntry = rhs.mEntry;
+  entry_ = rhs.entry_;
   return *this;
 }
 
 const std::string* StringPool::Ref::operator->() const {
-  return &mEntry->value;
+  return &entry_->value;
 }
 
-const std::string& StringPool::Ref::operator*() const { return mEntry->value; }
+const std::string& StringPool::Ref::operator*() const { return entry_->value; }
 
-size_t StringPool::Ref::getIndex() const { return mEntry->index; }
+size_t StringPool::Ref::index() const { return entry_->index; }
 
-const StringPool::Context& StringPool::Ref::getContext() const {
-  return mEntry->context;
+const StringPool::Context& StringPool::Ref::GetContext() const {
+  return entry_->context;
 }
 
-StringPool::StyleRef::StyleRef() : mEntry(nullptr) {}
+StringPool::StyleRef::StyleRef() : entry_(nullptr) {}
 
 StringPool::StyleRef::StyleRef(const StringPool::StyleRef& rhs)
-    : mEntry(rhs.mEntry) {
-  if (mEntry != nullptr) {
-    mEntry->ref++;
+    : entry_(rhs.entry_) {
+  if (entry_ != nullptr) {
+    entry_->ref_++;
   }
 }
 
-StringPool::StyleRef::StyleRef(StringPool::StyleEntry* entry) : mEntry(entry) {
-  if (mEntry != nullptr) {
-    mEntry->ref++;
+StringPool::StyleRef::StyleRef(StringPool::StyleEntry* entry) : entry_(entry) {
+  if (entry_ != nullptr) {
+    entry_->ref_++;
   }
 }
 
 StringPool::StyleRef::~StyleRef() {
-  if (mEntry != nullptr) {
-    mEntry->ref--;
+  if (entry_ != nullptr) {
+    entry_->ref_--;
   }
 }
 
 StringPool::StyleRef& StringPool::StyleRef::operator=(
     const StringPool::StyleRef& rhs) {
-  if (rhs.mEntry != nullptr) {
-    rhs.mEntry->ref++;
+  if (rhs.entry_ != nullptr) {
+    rhs.entry_->ref_++;
   }
 
-  if (mEntry != nullptr) {
-    mEntry->ref--;
+  if (entry_ != nullptr) {
+    entry_->ref_--;
   }
-  mEntry = rhs.mEntry;
+  entry_ = rhs.entry_;
   return *this;
 }
 
 const StringPool::StyleEntry* StringPool::StyleRef::operator->() const {
-  return mEntry;
+  return entry_;
 }
 
 const StringPool::StyleEntry& StringPool::StyleRef::operator*() const {
-  return *mEntry;
+  return *entry_;
 }
 
-size_t StringPool::StyleRef::getIndex() const { return mEntry->str.getIndex(); }
+size_t StringPool::StyleRef::index() const { return entry_->str.index(); }
 
-const StringPool::Context& StringPool::StyleRef::getContext() const {
-  return mEntry->str.getContext();
+const StringPool::Context& StringPool::StyleRef::GetContext() const {
+  return entry_->str.GetContext();
 }
 
-StringPool::Ref StringPool::makeRef(const StringPiece& str) {
-  return makeRefImpl(str, Context{}, true);
+StringPool::Ref StringPool::MakeRef(const StringPiece& str) {
+  return MakeRefImpl(str, Context{}, true);
 }
 
-StringPool::Ref StringPool::makeRef(const StringPiece& str,
+StringPool::Ref StringPool::MakeRef(const StringPiece& str,
                                     const Context& context) {
-  return makeRefImpl(str, context, true);
+  return MakeRefImpl(str, context, true);
 }
 
-StringPool::Ref StringPool::makeRefImpl(const StringPiece& str,
+StringPool::Ref StringPool::MakeRefImpl(const StringPiece& str,
                                         const Context& context, bool unique) {
   if (unique) {
-    auto iter = mIndexedStrings.find(str);
-    if (iter != std::end(mIndexedStrings)) {
+    auto iter = indexed_strings_.find(str);
+    if (iter != std::end(indexed_strings_)) {
       return Ref(iter->second);
     }
   }
 
   Entry* entry = new Entry();
-  entry->value = str.toString();
+  entry->value = str.ToString();
   entry->context = context;
-  entry->index = mStrings.size();
-  entry->ref = 0;
-  mStrings.emplace_back(entry);
-  mIndexedStrings.insert(std::make_pair(StringPiece(entry->value), entry));
+  entry->index = strings_.size();
+  entry->ref_ = 0;
+  strings_.emplace_back(entry);
+  indexed_strings_.insert(std::make_pair(StringPiece(entry->value), entry));
   return Ref(entry);
 }
 
-StringPool::StyleRef StringPool::makeRef(const StyleString& str) {
-  return makeRef(str, Context{});
+StringPool::StyleRef StringPool::MakeRef(const StyleString& str) {
+  return MakeRef(str, Context{});
 }
 
-StringPool::StyleRef StringPool::makeRef(const StyleString& str,
+StringPool::StyleRef StringPool::MakeRef(const StyleString& str,
                                          const Context& context) {
   Entry* entry = new Entry();
   entry->value = str.str;
   entry->context = context;
-  entry->index = mStrings.size();
-  entry->ref = 0;
-  mStrings.emplace_back(entry);
-  mIndexedStrings.insert(std::make_pair(StringPiece(entry->value), entry));
+  entry->index = strings_.size();
+  entry->ref_ = 0;
+  strings_.emplace_back(entry);
+  indexed_strings_.insert(std::make_pair(StringPiece(entry->value), entry));
 
-  StyleEntry* styleEntry = new StyleEntry();
-  styleEntry->str = Ref(entry);
+  StyleEntry* style_entry = new StyleEntry();
+  style_entry->str = Ref(entry);
   for (const aapt::Span& span : str.spans) {
-    styleEntry->spans.emplace_back(
-        Span{makeRef(span.name), span.firstChar, span.lastChar});
+    style_entry->spans.emplace_back(
+        Span{MakeRef(span.name), span.first_char, span.last_char});
   }
-  styleEntry->ref = 0;
-  mStyles.emplace_back(styleEntry);
-  return StyleRef(styleEntry);
+  style_entry->ref_ = 0;
+  styles_.emplace_back(style_entry);
+  return StyleRef(style_entry);
 }
 
-StringPool::StyleRef StringPool::makeRef(const StyleRef& ref) {
+StringPool::StyleRef StringPool::MakeRef(const StyleRef& ref) {
   Entry* entry = new Entry();
-  entry->value = *ref.mEntry->str;
-  entry->context = ref.mEntry->str.mEntry->context;
-  entry->index = mStrings.size();
-  entry->ref = 0;
-  mStrings.emplace_back(entry);
-  mIndexedStrings.insert(std::make_pair(StringPiece(entry->value), entry));
+  entry->value = *ref.entry_->str;
+  entry->context = ref.entry_->str.entry_->context;
+  entry->index = strings_.size();
+  entry->ref_ = 0;
+  strings_.emplace_back(entry);
+  indexed_strings_.insert(std::make_pair(StringPiece(entry->value), entry));
 
-  StyleEntry* styleEntry = new StyleEntry();
-  styleEntry->str = Ref(entry);
-  for (const Span& span : ref.mEntry->spans) {
-    styleEntry->spans.emplace_back(
-        Span{makeRef(*span.name), span.firstChar, span.lastChar});
+  StyleEntry* style_entry = new StyleEntry();
+  style_entry->str = Ref(entry);
+  for (const Span& span : ref.entry_->spans) {
+    style_entry->spans.emplace_back(
+        Span{MakeRef(*span.name), span.first_char, span.last_char});
   }
-  styleEntry->ref = 0;
-  mStyles.emplace_back(styleEntry);
-  return StyleRef(styleEntry);
+  style_entry->ref_ = 0;
+  styles_.emplace_back(style_entry);
+  return StyleRef(style_entry);
 }
 
-void StringPool::merge(StringPool&& pool) {
-  mIndexedStrings.insert(pool.mIndexedStrings.begin(),
-                         pool.mIndexedStrings.end());
-  pool.mIndexedStrings.clear();
-  std::move(pool.mStrings.begin(), pool.mStrings.end(),
-            std::back_inserter(mStrings));
-  pool.mStrings.clear();
-  std::move(pool.mStyles.begin(), pool.mStyles.end(),
-            std::back_inserter(mStyles));
-  pool.mStyles.clear();
+void StringPool::Merge(StringPool&& pool) {
+  indexed_strings_.insert(pool.indexed_strings_.begin(),
+                          pool.indexed_strings_.end());
+  pool.indexed_strings_.clear();
+  std::move(pool.strings_.begin(), pool.strings_.end(),
+            std::back_inserter(strings_));
+  pool.strings_.clear();
+  std::move(pool.styles_.begin(), pool.styles_.end(),
+            std::back_inserter(styles_));
+  pool.styles_.clear();
 
   // Assign the indices.
-  const size_t len = mStrings.size();
+  const size_t len = strings_.size();
   for (size_t index = 0; index < len; index++) {
-    mStrings[index]->index = index;
+    strings_[index]->index = index;
   }
 }
 
-void StringPool::hintWillAdd(size_t stringCount, size_t styleCount) {
-  mStrings.reserve(mStrings.size() + stringCount);
-  mStyles.reserve(mStyles.size() + styleCount);
+void StringPool::HintWillAdd(size_t stringCount, size_t styleCount) {
+  strings_.reserve(strings_.size() + stringCount);
+  styles_.reserve(styles_.size() + styleCount);
 }
 
-void StringPool::prune() {
-  const auto iterEnd = std::end(mIndexedStrings);
-  auto indexIter = std::begin(mIndexedStrings);
-  while (indexIter != iterEnd) {
-    if (indexIter->second->ref <= 0) {
-      indexIter = mIndexedStrings.erase(indexIter);
+void StringPool::Prune() {
+  const auto iter_end = indexed_strings_.end();
+  auto index_iter = indexed_strings_.begin();
+  while (index_iter != iter_end) {
+    if (index_iter->second->ref_ <= 0) {
+      index_iter = indexed_strings_.erase(index_iter);
     } else {
-      ++indexIter;
+      ++index_iter;
     }
   }
 
-  auto endIter2 =
-      std::remove_if(std::begin(mStrings), std::end(mStrings),
+  auto end_iter2 =
+      std::remove_if(strings_.begin(), strings_.end(),
                      [](const std::unique_ptr<Entry>& entry) -> bool {
-                       return entry->ref <= 0;
+                       return entry->ref_ <= 0;
                      });
 
-  auto endIter3 =
-      std::remove_if(std::begin(mStyles), std::end(mStyles),
+  auto end_iter3 =
+      std::remove_if(styles_.begin(), styles_.end(),
                      [](const std::unique_ptr<StyleEntry>& entry) -> bool {
-                       return entry->ref <= 0;
+                       return entry->ref_ <= 0;
                      });
 
   // Remove the entries at the end or else we'll be accessing
   // a deleted string from the StyleEntry.
-  mStrings.erase(endIter2, std::end(mStrings));
-  mStyles.erase(endIter3, std::end(mStyles));
+  strings_.erase(end_iter2, strings_.end());
+  styles_.erase(end_iter3, styles_.end());
 
   // Reassign the indices.
-  const size_t len = mStrings.size();
+  const size_t len = strings_.size();
   for (size_t index = 0; index < len; index++) {
-    mStrings[index]->index = index;
+    strings_[index]->index = index;
   }
 }
 
-void StringPool::sort(
+void StringPool::Sort(
     const std::function<bool(const Entry&, const Entry&)>& cmp) {
   std::sort(
-      std::begin(mStrings), std::end(mStrings),
+      strings_.begin(), strings_.end(),
       [&cmp](const std::unique_ptr<Entry>& a,
              const std::unique_ptr<Entry>& b) -> bool { return cmp(*a, *b); });
 
   // Assign the indices.
-  const size_t len = mStrings.size();
+  const size_t len = strings_.size();
   for (size_t index = 0; index < len; index++) {
-    mStrings[index]->index = index;
+    strings_[index]->index = index;
   }
 
   // Reorder the styles.
-  std::sort(std::begin(mStyles), std::end(mStyles),
+  std::sort(styles_.begin(), styles_.end(),
             [](const std::unique_ptr<StyleEntry>& lhs,
                const std::unique_ptr<StyleEntry>& rhs) -> bool {
-              return lhs->str.getIndex() < rhs->str.getIndex();
+              return lhs->str.index() < rhs->str.index();
             });
 }
 
 template <typename T>
-static T* encodeLength(T* data, size_t length) {
+static T* EncodeLength(T* data, size_t length) {
   static_assert(std::is_integral<T>::value, "wat.");
 
   constexpr size_t kMask = 1 << ((sizeof(T) * 8) - 1);
@@ -284,7 +287,7 @@ static T* encodeLength(T* data, size_t length) {
 }
 
 template <typename T>
-static size_t encodedLengthUnits(size_t length) {
+static size_t EncodedLengthUnits(size_t length) {
   static_assert(std::is_integral<T>::value, "wat.");
 
   constexpr size_t kMask = 1 << ((sizeof(T) * 8) - 1);
@@ -292,10 +295,10 @@ static size_t encodedLengthUnits(size_t length) {
   return length > kMaxSize ? 2 : 1;
 }
 
-bool StringPool::flatten(BigBuffer* out, const StringPool& pool, bool utf8) {
-  const size_t startIndex = out->size();
+bool StringPool::Flatten(BigBuffer* out, const StringPool& pool, bool utf8) {
+  const size_t start_index = out->size();
   android::ResStringPool_header* header =
-      out->nextBlock<android::ResStringPool_header>();
+      out->NextBlock<android::ResStringPool_header>();
   header->header.type = android::RES_STRING_POOL_TYPE;
   header->header.headerSize = sizeof(*header);
   header->stringCount = pool.size();
@@ -304,92 +307,90 @@ bool StringPool::flatten(BigBuffer* out, const StringPool& pool, bool utf8) {
   }
 
   uint32_t* indices =
-      pool.size() != 0 ? out->nextBlock<uint32_t>(pool.size()) : nullptr;
+      pool.size() != 0 ? out->NextBlock<uint32_t>(pool.size()) : nullptr;
 
-  uint32_t* styleIndices = nullptr;
-  if (!pool.mStyles.empty()) {
-    header->styleCount = pool.mStyles.back()->str.getIndex() + 1;
-    styleIndices = out->nextBlock<uint32_t>(header->styleCount);
+  uint32_t* style_indices = nullptr;
+  if (!pool.styles_.empty()) {
+    header->styleCount = pool.styles_.back()->str.index() + 1;
+    style_indices = out->NextBlock<uint32_t>(header->styleCount);
   }
 
-  const size_t beforeStringsIndex = out->size();
-  header->stringsStart = beforeStringsIndex - startIndex;
+  const size_t before_strings_index = out->size();
+  header->stringsStart = before_strings_index - start_index;
 
   for (const auto& entry : pool) {
-    *indices = out->size() - beforeStringsIndex;
+    *indices = out->size() - before_strings_index;
     indices++;
 
     if (utf8) {
       const std::string& encoded = entry->value;
-      const ssize_t utf16Length = utf8_to_utf16_length(
+      const ssize_t utf16_length = utf8_to_utf16_length(
           reinterpret_cast<const uint8_t*>(entry->value.data()),
           entry->value.size());
-      assert(utf16Length >= 0);
+      CHECK(utf16_length >= 0);
 
-      const size_t totalSize = encodedLengthUnits<char>(utf16Length) +
-                               encodedLengthUnits<char>(encoded.length()) +
-                               encoded.size() + 1;
+      const size_t total_size = EncodedLengthUnits<char>(utf16_length) +
+                                EncodedLengthUnits<char>(encoded.length()) +
+                                encoded.size() + 1;
 
-      char* data = out->nextBlock<char>(totalSize);
+      char* data = out->NextBlock<char>(total_size);
 
       // First encode the UTF16 string length.
-      data = encodeLength(data, utf16Length);
+      data = EncodeLength(data, utf16_length);
 
       // Now encode the size of the real UTF8 string.
-      data = encodeLength(data, encoded.length());
+      data = EncodeLength(data, encoded.length());
       strncpy(data, encoded.data(), encoded.size());
 
     } else {
-      const std::u16string encoded = util::utf8ToUtf16(entry->value);
-      const ssize_t utf16Length = encoded.size();
+      const std::u16string encoded = util::Utf8ToUtf16(entry->value);
+      const ssize_t utf16_length = encoded.size();
 
       // Total number of 16-bit words to write.
-      const size_t totalSize =
-          encodedLengthUnits<char16_t>(utf16Length) + encoded.size() + 1;
+      const size_t total_size =
+          EncodedLengthUnits<char16_t>(utf16_length) + encoded.size() + 1;
 
-      char16_t* data = out->nextBlock<char16_t>(totalSize);
+      char16_t* data = out->NextBlock<char16_t>(total_size);
 
       // Encode the actual UTF16 string length.
-      data = encodeLength(data, utf16Length);
-      const size_t byteLength = encoded.size() * sizeof(char16_t);
+      data = EncodeLength(data, utf16_length);
+      const size_t byte_length = encoded.size() * sizeof(char16_t);
 
       // NOTE: For some reason, strncpy16(data, entry->value.data(),
-      // entry->value.size())
-      // truncates the string.
-      memcpy(data, encoded.data(), byteLength);
+      // entry->value.size()) truncates the string.
+      memcpy(data, encoded.data(), byte_length);
 
       // The null-terminating character is already here due to the block of data
-      // being set
-      // to 0s on allocation.
+      // being set to 0s on allocation.
     }
   }
 
-  out->align4();
+  out->Align4();
 
-  if (!pool.mStyles.empty()) {
-    const size_t beforeStylesIndex = out->size();
-    header->stylesStart = beforeStylesIndex - startIndex;
+  if (!pool.styles_.empty()) {
+    const size_t before_styles_index = out->size();
+    header->stylesStart = before_styles_index - start_index;
 
-    size_t currentIndex = 0;
-    for (const auto& entry : pool.mStyles) {
-      while (entry->str.getIndex() > currentIndex) {
-        styleIndices[currentIndex++] = out->size() - beforeStylesIndex;
+    size_t current_index = 0;
+    for (const auto& entry : pool.styles_) {
+      while (entry->str.index() > current_index) {
+        style_indices[current_index++] = out->size() - before_styles_index;
 
-        uint32_t* spanOffset = out->nextBlock<uint32_t>();
-        *spanOffset = android::ResStringPool_span::END;
+        uint32_t* span_offset = out->NextBlock<uint32_t>();
+        *span_offset = android::ResStringPool_span::END;
       }
-      styleIndices[currentIndex++] = out->size() - beforeStylesIndex;
+      style_indices[current_index++] = out->size() - before_styles_index;
 
       android::ResStringPool_span* span =
-          out->nextBlock<android::ResStringPool_span>(entry->spans.size());
+          out->NextBlock<android::ResStringPool_span>(entry->spans.size());
       for (const auto& s : entry->spans) {
-        span->name.index = s.name.getIndex();
-        span->firstChar = s.firstChar;
-        span->lastChar = s.lastChar;
+        span->name.index = s.name.index();
+        span->firstChar = s.first_char;
+        span->lastChar = s.last_char;
         span++;
       }
 
-      uint32_t* spanEnd = out->nextBlock<uint32_t>();
+      uint32_t* spanEnd = out->NextBlock<uint32_t>();
       *spanEnd = android::ResStringPool_span::END;
     }
 
@@ -397,22 +398,22 @@ bool StringPool::flatten(BigBuffer* out, const StringPool& pool, bool utf8) {
     // ResStringPool_span structure worth of 0xFFFFFFFF at the end
     // of the style block, so fill in the remaining 2 32bit words
     // with 0xFFFFFFFF.
-    const size_t paddingLength = sizeof(android::ResStringPool_span) -
-                                 sizeof(android::ResStringPool_span::name);
-    uint8_t* padding = out->nextBlock<uint8_t>(paddingLength);
-    memset(padding, 0xff, paddingLength);
-    out->align4();
+    const size_t padding_length = sizeof(android::ResStringPool_span) -
+                                  sizeof(android::ResStringPool_span::name);
+    uint8_t* padding = out->NextBlock<uint8_t>(padding_length);
+    memset(padding, 0xff, padding_length);
+    out->Align4();
   }
-  header->header.size = out->size() - startIndex;
+  header->header.size = out->size() - start_index;
   return true;
 }
 
-bool StringPool::flattenUtf8(BigBuffer* out, const StringPool& pool) {
-  return flatten(out, pool, true);
+bool StringPool::FlattenUtf8(BigBuffer* out, const StringPool& pool) {
+  return Flatten(out, pool, true);
 }
 
-bool StringPool::flattenUtf16(BigBuffer* out, const StringPool& pool) {
-  return flatten(out, pool, false);
+bool StringPool::FlattenUtf16(BigBuffer* out, const StringPool& pool) {
+  return Flatten(out, pool, false);
 }
 
 }  // namespace aapt
diff --git a/tools/aapt2/StringPool.h b/tools/aapt2/StringPool.h
index 6e0d646cae125..a4f556ca52e48 100644
--- a/tools/aapt2/StringPool.h
+++ b/tools/aapt2/StringPool.h
@@ -17,22 +17,22 @@
 #ifndef AAPT_STRING_POOL_H
 #define AAPT_STRING_POOL_H
 
-#include "ConfigDescription.h"
-#include "util/BigBuffer.h"
-#include "util/StringPiece.h"
-
 #include <functional>
 #include <memory>
 #include <string>
 #include <unordered_map>
 #include <vector>
 
+#include "ConfigDescription.h"
+#include "util/BigBuffer.h"
+#include "util/StringPiece.h"
+
 namespace aapt {
 
 struct Span {
   std::string name;
-  uint32_t firstChar;
-  uint32_t lastChar;
+  uint32_t first_char;
+  uint32_t last_char;
 };
 
 struct StyleString {
@@ -72,15 +72,15 @@ class StringPool {
     const std::string* operator->() const;
     const std::string& operator*() const;
 
-    size_t getIndex() const;
-    const Context& getContext() const;
+    size_t index() const;
+    const Context& GetContext() const;
 
    private:
     friend class StringPool;
 
     explicit Ref(Entry* entry);
 
-    Entry* mEntry;
+    Entry* entry_;
   };
 
   class StyleEntry;
@@ -95,15 +95,15 @@ class StringPool {
     const StyleEntry* operator->() const;
     const StyleEntry& operator*() const;
 
-    size_t getIndex() const;
-    const Context& getContext() const;
+    size_t index() const;
+    const Context& GetContext() const;
 
    private:
     friend class StringPool;
 
     explicit StyleRef(StyleEntry* entry);
 
-    StyleEntry* mEntry;
+    StyleEntry* entry_;
   };
 
   class Entry {
@@ -116,13 +116,13 @@ class StringPool {
     friend class StringPool;
     friend class Ref;
 
-    int ref;
+    int ref_;
   };
 
   struct Span {
     Ref name;
-    uint32_t firstChar;
-    uint32_t lastChar;
+    uint32_t first_char;
+    uint32_t last_char;
   };
 
   class StyleEntry {
@@ -134,13 +134,13 @@ class StringPool {
     friend class StringPool;
     friend class StyleRef;
 
-    int ref;
+    int ref_;
   };
 
   using const_iterator = std::vector<std::unique_ptr<Entry>>::const_iterator;
 
-  static bool flattenUtf8(BigBuffer* out, const StringPool& pool);
-  static bool flattenUtf16(BigBuffer* out, const StringPool& pool);
+  static bool FlattenUtf8(BigBuffer* out, const StringPool& pool);
+  static bool FlattenUtf16(BigBuffer* out, const StringPool& pool);
 
   StringPool() = default;
   StringPool(const StringPool&) = delete;
@@ -149,84 +149,84 @@ class StringPool {
    * Adds a string to the pool, unless it already exists. Returns
    * a reference to the string in the pool.
    */
-  Ref makeRef(const StringPiece& str);
+  Ref MakeRef(const StringPiece& str);
 
   /**
    * Adds a string to the pool, unless it already exists, with a context
    * object that can be used when sorting the string pool. Returns
    * a reference to the string in the pool.
    */
-  Ref makeRef(const StringPiece& str, const Context& context);
+  Ref MakeRef(const StringPiece& str, const Context& context);
 
   /**
    * Adds a style to the string pool and returns a reference to it.
    */
-  StyleRef makeRef(const StyleString& str);
+  StyleRef MakeRef(const StyleString& str);
 
   /**
    * Adds a style to the string pool with a context object that
    * can be used when sorting the string pool. Returns a reference
    * to the style in the string pool.
    */
-  StyleRef makeRef(const StyleString& str, const Context& context);
+  StyleRef MakeRef(const StyleString& str, const Context& context);
 
   /**
    * Adds a style from another string pool. Returns a reference to the
    * style in the string pool.
    */
-  StyleRef makeRef(const StyleRef& ref);
+  StyleRef MakeRef(const StyleRef& ref);
 
   /**
    * Moves pool into this one without coalescing strings. When this
    * function returns, pool will be empty.
    */
-  void merge(StringPool&& pool);
+  void Merge(StringPool&& pool);
 
   /**
-   * Retuns the number of strings in the table.
+   * Returns the number of strings in the table.
    */
   inline size_t size() const;
 
   /**
    * Reserves space for strings and styles as an optimization.
    */
-  void hintWillAdd(size_t stringCount, size_t styleCount);
+  void HintWillAdd(size_t string_count, size_t style_count);
 
   /**
    * Sorts the strings according to some comparison function.
    */
-  void sort(const std::function<bool(const Entry&, const Entry&)>& cmp);
+  void Sort(const std::function<bool(const Entry&, const Entry&)>& cmp);
 
   /**
    * Removes any strings that have no references.
    */
-  void prune();
+  void Prune();
 
  private:
   friend const_iterator begin(const StringPool& pool);
   friend const_iterator end(const StringPool& pool);
 
-  static bool flatten(BigBuffer* out, const StringPool& pool, bool utf8);
+  static bool Flatten(BigBuffer* out, const StringPool& pool, bool utf8);
 
-  Ref makeRefImpl(const StringPiece& str, const Context& context, bool unique);
+  Ref MakeRefImpl(const StringPiece& str, const Context& context, bool unique);
 
-  std::vector<std::unique_ptr<Entry>> mStrings;
-  std::vector<std::unique_ptr<StyleEntry>> mStyles;
-  std::unordered_multimap<StringPiece, Entry*> mIndexedStrings;
+  std::vector<std::unique_ptr<Entry>> strings_;
+  std::vector<std::unique_ptr<StyleEntry>> styles_;
+  std::unordered_multimap<StringPiece, Entry*> indexed_strings_;
 };
 
 //
 // Inline implementation
 //
 
-inline size_t StringPool::size() const { return mStrings.size(); }
+inline size_t StringPool::size() const { return strings_.size(); }
 
 inline StringPool::const_iterator begin(const StringPool& pool) {
-  return pool.mStrings.begin();
+  return pool.strings_.begin();
 }
 
 inline StringPool::const_iterator end(const StringPool& pool) {
-  return pool.mStrings.end();
+  return pool.strings_.end();
 }
 
 }  // namespace aapt
diff --git a/tools/aapt2/StringPool_test.cpp b/tools/aapt2/StringPool_test.cpp
index 2a7e1dd6a231f..e1394fc0221f5 100644
--- a/tools/aapt2/StringPool_test.cpp
+++ b/tools/aapt2/StringPool_test.cpp
@@ -15,25 +15,26 @@
  */
 
 #include "StringPool.h"
-#include "test/Test.h"
-#include "util/Util.h"
 
 #include <string>
 
+#include "test/Test.h"
+#include "util/Util.h"
+
 namespace aapt {
 
 TEST(StringPoolTest, InsertOneString) {
   StringPool pool;
 
-  StringPool::Ref ref = pool.makeRef("wut");
+  StringPool::Ref ref = pool.MakeRef("wut");
   EXPECT_EQ(*ref, "wut");
 }
 
 TEST(StringPoolTest, InsertTwoUniqueStrings) {
   StringPool pool;
 
-  StringPool::Ref ref = pool.makeRef("wut");
-  StringPool::Ref ref2 = pool.makeRef("hey");
+  StringPool::Ref ref = pool.MakeRef("wut");
+  StringPool::Ref ref2 = pool.MakeRef("hey");
 
   EXPECT_EQ(*ref, "wut");
   EXPECT_EQ(*ref2, "hey");
@@ -42,8 +43,8 @@ TEST(StringPoolTest, InsertTwoUniqueStrings) {
 TEST(StringPoolTest, DoNotInsertNewDuplicateString) {
   StringPool pool;
 
-  StringPool::Ref ref = pool.makeRef("wut");
-  StringPool::Ref ref2 = pool.makeRef("wut");
+  StringPool::Ref ref = pool.MakeRef("wut");
+  StringPool::Ref ref2 = pool.MakeRef("wut");
 
   EXPECT_EQ(*ref, "wut");
   EXPECT_EQ(*ref2, "wut");
@@ -53,28 +54,28 @@ TEST(StringPoolTest, DoNotInsertNewDuplicateString) {
 TEST(StringPoolTest, MaintainInsertionOrderIndex) {
   StringPool pool;
 
-  StringPool::Ref ref = pool.makeRef("z");
-  StringPool::Ref ref2 = pool.makeRef("a");
-  StringPool::Ref ref3 = pool.makeRef("m");
+  StringPool::Ref ref = pool.MakeRef("z");
+  StringPool::Ref ref2 = pool.MakeRef("a");
+  StringPool::Ref ref3 = pool.MakeRef("m");
 
-  EXPECT_EQ(0u, ref.getIndex());
-  EXPECT_EQ(1u, ref2.getIndex());
-  EXPECT_EQ(2u, ref3.getIndex());
+  EXPECT_EQ(0u, ref.index());
+  EXPECT_EQ(1u, ref2.index());
+  EXPECT_EQ(2u, ref3.index());
 }
 
 TEST(StringPoolTest, PruneStringsWithNoReferences) {
   StringPool pool;
 
-  StringPool::Ref refA = pool.makeRef("foo");
+  StringPool::Ref refA = pool.MakeRef("foo");
   {
-    StringPool::Ref ref = pool.makeRef("wut");
+    StringPool::Ref ref = pool.MakeRef("wut");
     EXPECT_EQ(*ref, "wut");
     EXPECT_EQ(2u, pool.size());
   }
-  StringPool::Ref refB = pool.makeRef("bar");
+  StringPool::Ref refB = pool.MakeRef("bar");
 
   EXPECT_EQ(3u, pool.size());
-  pool.prune();
+  pool.Prune();
   EXPECT_EQ(2u, pool.size());
   StringPool::const_iterator iter = begin(pool);
   EXPECT_EQ((*iter)->value, "foo");
@@ -87,51 +88,51 @@ TEST(StringPoolTest, PruneStringsWithNoReferences) {
 TEST(StringPoolTest, SortAndMaintainIndexesInReferences) {
   StringPool pool;
 
-  StringPool::Ref ref = pool.makeRef("z");
-  StringPool::StyleRef ref2 = pool.makeRef(StyleString{{"a"}});
-  StringPool::Ref ref3 = pool.makeRef("m");
+  StringPool::Ref ref = pool.MakeRef("z");
+  StringPool::StyleRef ref2 = pool.MakeRef(StyleString{{"a"}});
+  StringPool::Ref ref3 = pool.MakeRef("m");
 
   EXPECT_EQ(*ref, "z");
-  EXPECT_EQ(0u, ref.getIndex());
+  EXPECT_EQ(0u, ref.index());
 
   EXPECT_EQ(*(ref2->str), "a");
-  EXPECT_EQ(1u, ref2.getIndex());
+  EXPECT_EQ(1u, ref2.index());
 
   EXPECT_EQ(*ref3, "m");
-  EXPECT_EQ(2u, ref3.getIndex());
+  EXPECT_EQ(2u, ref3.index());
 
-  pool.sort([](const StringPool::Entry& a, const StringPool::Entry& b) -> bool {
+  pool.Sort([](const StringPool::Entry& a, const StringPool::Entry& b) -> bool {
     return a.value < b.value;
   });
 
   EXPECT_EQ(*ref, "z");
-  EXPECT_EQ(2u, ref.getIndex());
+  EXPECT_EQ(2u, ref.index());
 
   EXPECT_EQ(*(ref2->str), "a");
-  EXPECT_EQ(0u, ref2.getIndex());
+  EXPECT_EQ(0u, ref2.index());
 
   EXPECT_EQ(*ref3, "m");
-  EXPECT_EQ(1u, ref3.getIndex());
+  EXPECT_EQ(1u, ref3.index());
 }
 
 TEST(StringPoolTest, SortAndStillDedupe) {
   StringPool pool;
 
-  StringPool::Ref ref = pool.makeRef("z");
-  StringPool::Ref ref2 = pool.makeRef("a");
-  StringPool::Ref ref3 = pool.makeRef("m");
+  StringPool::Ref ref = pool.MakeRef("z");
+  StringPool::Ref ref2 = pool.MakeRef("a");
+  StringPool::Ref ref3 = pool.MakeRef("m");
 
-  pool.sort([](const StringPool::Entry& a, const StringPool::Entry& b) -> bool {
+  pool.Sort([](const StringPool::Entry& a, const StringPool::Entry& b) -> bool {
     return a.value < b.value;
   });
 
-  StringPool::Ref ref4 = pool.makeRef("z");
-  StringPool::Ref ref5 = pool.makeRef("a");
-  StringPool::Ref ref6 = pool.makeRef("m");
+  StringPool::Ref ref4 = pool.MakeRef("z");
+  StringPool::Ref ref5 = pool.MakeRef("a");
+  StringPool::Ref ref6 = pool.MakeRef("m");
 
-  EXPECT_EQ(ref4.getIndex(), ref.getIndex());
-  EXPECT_EQ(ref5.getIndex(), ref2.getIndex());
-  EXPECT_EQ(ref6.getIndex(), ref3.getIndex());
+  EXPECT_EQ(ref4.index(), ref.index());
+  EXPECT_EQ(ref5.index(), ref2.index());
+  EXPECT_EQ(ref6.index(), ref3.index());
 }
 
 TEST(StringPoolTest, AddStyles) {
@@ -139,27 +140,27 @@ TEST(StringPoolTest, AddStyles) {
 
   StyleString str{{"android"}, {Span{{"b"}, 2, 6}}};
 
-  StringPool::StyleRef ref = pool.makeRef(str);
+  StringPool::StyleRef ref = pool.MakeRef(str);
 
-  EXPECT_EQ(0u, ref.getIndex());
+  EXPECT_EQ(0u, ref.index());
   EXPECT_EQ(std::string("android"), *(ref->str));
   ASSERT_EQ(1u, ref->spans.size());
 
   const StringPool::Span& span = ref->spans.front();
   EXPECT_EQ(*(span.name), "b");
-  EXPECT_EQ(2u, span.firstChar);
-  EXPECT_EQ(6u, span.lastChar);
+  EXPECT_EQ(2u, span.first_char);
+  EXPECT_EQ(6u, span.last_char);
 }
 
 TEST(StringPoolTest, DoNotDedupeStyleWithSameStringAsNonStyle) {
   StringPool pool;
 
-  StringPool::Ref ref = pool.makeRef("android");
+  StringPool::Ref ref = pool.MakeRef("android");
 
   StyleString str{{"android"}};
-  StringPool::StyleRef styleRef = pool.makeRef(str);
+  StringPool::StyleRef styleRef = pool.MakeRef(str);
 
-  EXPECT_NE(ref.getIndex(), styleRef.getIndex());
+  EXPECT_NE(ref.index(), styleRef.index());
 }
 
 TEST(StringPoolTest, FlattenEmptyStringPoolUtf8) {
@@ -167,9 +168,9 @@ TEST(StringPoolTest, FlattenEmptyStringPoolUtf8) {
 
   StringPool pool;
   BigBuffer buffer(1024);
-  StringPool::flattenUtf8(&buffer, pool);
+  StringPool::FlattenUtf8(&buffer, pool);
 
-  std::unique_ptr<uint8_t[]> data = util::copy(buffer);
+  std::unique_ptr<uint8_t[]> data = util::Copy(buffer);
   ResStringPool test;
   ASSERT_EQ(test.setTo(data.get(), buffer.size()), NO_ERROR);
 }
@@ -178,11 +179,11 @@ TEST(StringPoolTest, FlattenOddCharactersUtf16) {
   using namespace android;  // For NO_ERROR on Windows.
 
   StringPool pool;
-  pool.makeRef("\u093f");
+  pool.MakeRef("\u093f");
   BigBuffer buffer(1024);
-  StringPool::flattenUtf16(&buffer, pool);
+  StringPool::FlattenUtf16(&buffer, pool);
 
-  std::unique_ptr<uint8_t[]> data = util::copy(buffer);
+  std::unique_ptr<uint8_t[]> data = util::Copy(buffer);
   ResStringPool test;
   ASSERT_EQ(test.setTo(data.get(), buffer.size()), NO_ERROR);
   size_t len = 0;
@@ -204,58 +205,58 @@ TEST(StringPoolTest, Flatten) {
 
   StringPool pool;
 
-  StringPool::Ref ref1 = pool.makeRef("hello");
-  StringPool::Ref ref2 = pool.makeRef("goodbye");
-  StringPool::Ref ref3 = pool.makeRef(sLongString);
-  StringPool::Ref ref4 = pool.makeRef("");
-  StringPool::StyleRef ref5 = pool.makeRef(
+  StringPool::Ref ref1 = pool.MakeRef("hello");
+  StringPool::Ref ref2 = pool.MakeRef("goodbye");
+  StringPool::Ref ref3 = pool.MakeRef(sLongString);
+  StringPool::Ref ref4 = pool.MakeRef("");
+  StringPool::StyleRef ref5 = pool.MakeRef(
       StyleString{{"style"}, {Span{{"b"}, 0, 1}, Span{{"i"}, 2, 3}}});
 
-  EXPECT_EQ(0u, ref1.getIndex());
-  EXPECT_EQ(1u, ref2.getIndex());
-  EXPECT_EQ(2u, ref3.getIndex());
-  EXPECT_EQ(3u, ref4.getIndex());
-  EXPECT_EQ(4u, ref5.getIndex());
+  EXPECT_EQ(0u, ref1.index());
+  EXPECT_EQ(1u, ref2.index());
+  EXPECT_EQ(2u, ref3.index());
+  EXPECT_EQ(3u, ref4.index());
+  EXPECT_EQ(4u, ref5.index());
 
   BigBuffer buffers[2] = {BigBuffer(1024), BigBuffer(1024)};
-  StringPool::flattenUtf8(&buffers[0], pool);
-  StringPool::flattenUtf16(&buffers[1], pool);
+  StringPool::FlattenUtf8(&buffers[0], pool);
+  StringPool::FlattenUtf16(&buffers[1], pool);
 
   // Test both UTF-8 and UTF-16 buffers.
   for (const BigBuffer& buffer : buffers) {
-    std::unique_ptr<uint8_t[]> data = util::copy(buffer);
+    std::unique_ptr<uint8_t[]> data = util::Copy(buffer);
 
     ResStringPool test;
     ASSERT_EQ(test.setTo(data.get(), buffer.size()), NO_ERROR);
 
-    EXPECT_EQ(std::string("hello"), util::getString(test, 0));
-    EXPECT_EQ(StringPiece16(u"hello"), util::getString16(test, 0));
+    EXPECT_EQ(std::string("hello"), util::GetString(test, 0));
+    EXPECT_EQ(StringPiece16(u"hello"), util::GetString16(test, 0));
 
-    EXPECT_EQ(std::string("goodbye"), util::getString(test, 1));
-    EXPECT_EQ(StringPiece16(u"goodbye"), util::getString16(test, 1));
+    EXPECT_EQ(std::string("goodbye"), util::GetString(test, 1));
+    EXPECT_EQ(StringPiece16(u"goodbye"), util::GetString16(test, 1));
 
-    EXPECT_EQ(StringPiece(sLongString), util::getString(test, 2));
-    EXPECT_EQ(util::utf8ToUtf16(sLongString),
-              util::getString16(test, 2).toString());
+    EXPECT_EQ(StringPiece(sLongString), util::GetString(test, 2));
+    EXPECT_EQ(util::Utf8ToUtf16(sLongString),
+              util::GetString16(test, 2).ToString());
 
     size_t len;
     EXPECT_TRUE(test.stringAt(3, &len) != nullptr ||
                 test.string8At(3, &len) != nullptr);
 
-    EXPECT_EQ(std::string("style"), util::getString(test, 4));
-    EXPECT_EQ(StringPiece16(u"style"), util::getString16(test, 4));
+    EXPECT_EQ(std::string("style"), util::GetString(test, 4));
+    EXPECT_EQ(StringPiece16(u"style"), util::GetString16(test, 4));
 
     const ResStringPool_span* span = test.styleAt(4);
     ASSERT_NE(nullptr, span);
-    EXPECT_EQ(std::string("b"), util::getString(test, span->name.index));
-    EXPECT_EQ(StringPiece16(u"b"), util::getString16(test, span->name.index));
+    EXPECT_EQ(std::string("b"), util::GetString(test, span->name.index));
+    EXPECT_EQ(StringPiece16(u"b"), util::GetString16(test, span->name.index));
     EXPECT_EQ(0u, span->firstChar);
     EXPECT_EQ(1u, span->lastChar);
     span++;
 
     ASSERT_NE(ResStringPool_span::END, span->name.index);
-    EXPECT_EQ(std::string("i"), util::getString(test, span->name.index));
-    EXPECT_EQ(StringPiece16(u"i"), util::getString16(test, span->name.index));
+    EXPECT_EQ(std::string("i"), util::GetString(test, span->name.index));
+    EXPECT_EQ(StringPiece16(u"i"), util::GetString16(test, span->name.index));
     EXPECT_EQ(2u, span->firstChar);
     EXPECT_EQ(3u, span->lastChar);
     span++;
diff --git a/tools/aapt2/ValueVisitor.h b/tools/aapt2/ValueVisitor.h
index 121c33709eefe..1cb6aa13f336f 100644
--- a/tools/aapt2/ValueVisitor.h
+++ b/tools/aapt2/ValueVisitor.h
@@ -24,32 +24,31 @@ namespace aapt {
 
 /**
  * Visits a value and invokes the appropriate method based on its type. Does not
- * traverse
- * into compound types. Use ValueVisitor for that.
+ * traverse into compound types. Use ValueVisitor for that.
  */
 struct RawValueVisitor {
   virtual ~RawValueVisitor() = default;
 
-  virtual void visitItem(Item* value) {}
-  virtual void visit(Reference* value) { visitItem(value); }
-  virtual void visit(RawString* value) { visitItem(value); }
-  virtual void visit(String* value) { visitItem(value); }
-  virtual void visit(StyledString* value) { visitItem(value); }
-  virtual void visit(FileReference* value) { visitItem(value); }
-  virtual void visit(Id* value) { visitItem(value); }
-  virtual void visit(BinaryPrimitive* value) { visitItem(value); }
+  virtual void VisitItem(Item* value) {}
+  virtual void Visit(Reference* value) { VisitItem(value); }
+  virtual void Visit(RawString* value) { VisitItem(value); }
+  virtual void Visit(String* value) { VisitItem(value); }
+  virtual void Visit(StyledString* value) { VisitItem(value); }
+  virtual void Visit(FileReference* value) { VisitItem(value); }
+  virtual void Visit(Id* value) { VisitItem(value); }
+  virtual void Visit(BinaryPrimitive* value) { VisitItem(value); }
 
-  virtual void visit(Attribute* value) {}
-  virtual void visit(Style* value) {}
-  virtual void visit(Array* value) {}
-  virtual void visit(Plural* value) {}
-  virtual void visit(Styleable* value) {}
+  virtual void Visit(Attribute* value) {}
+  virtual void Visit(Style* value) {}
+  virtual void Visit(Array* value) {}
+  virtual void Visit(Plural* value) {}
+  virtual void Visit(Styleable* value) {}
 };
 
 // NOLINT, do not add parentheses around T.
-#define DECL_VISIT_COMPOUND_VALUE(T)          \
-  virtual void visit(T* value) { /* NOLINT */ \
-    visitSubValues(value);                    \
+#define DECL_VISIT_COMPOUND_VALUE(T)                   \
+  virtual void Visit(T* value) override { /* NOLINT */ \
+    VisitSubValues(value);                             \
   }
 
 /**
@@ -59,44 +58,43 @@ struct RawValueVisitor {
 struct ValueVisitor : public RawValueVisitor {
   // The compiler will think we're hiding an overload, when we actually intend
   // to call into RawValueVisitor. This will expose the visit methods in the
-  // super
-  // class so the compiler knows we are trying to call them.
-  using RawValueVisitor::visit;
+  // super class so the compiler knows we are trying to call them.
+  using RawValueVisitor::Visit;
 
-  void visitSubValues(Attribute* attribute) {
+  void VisitSubValues(Attribute* attribute) {
     for (Attribute::Symbol& symbol : attribute->symbols) {
-      visit(&symbol.symbol);
+      Visit(&symbol.symbol);
     }
   }
 
-  void visitSubValues(Style* style) {
+  void VisitSubValues(Style* style) {
     if (style->parent) {
-      visit(&style->parent.value());
+      Visit(&style->parent.value());
     }
 
     for (Style::Entry& entry : style->entries) {
-      visit(&entry.key);
-      entry.value->accept(this);
+      Visit(&entry.key);
+      entry.value->Accept(this);
     }
   }
 
-  void visitSubValues(Array* array) {
+  void VisitSubValues(Array* array) {
     for (std::unique_ptr<Item>& item : array->items) {
-      item->accept(this);
+      item->Accept(this);
     }
   }
 
-  void visitSubValues(Plural* plural) {
+  void VisitSubValues(Plural* plural) {
     for (std::unique_ptr<Item>& item : plural->values) {
       if (item) {
-        item->accept(this);
+        item->Accept(this);
       }
     }
   }
 
-  void visitSubValues(Styleable* styleable) {
+  void VisitSubValues(Styleable* styleable) {
     for (Reference& reference : styleable->entries) {
-      visit(&reference);
+      Visit(&reference);
     }
   }
 
@@ -114,7 +112,7 @@ template <typename T>
 struct DynCastVisitor : public RawValueVisitor {
   T* value = nullptr;
 
-  void visit(T* v) override { value = v; }
+  void Visit(T* v) override { value = v; }
 };
 
 /**
@@ -124,12 +122,12 @@ template <>
 struct DynCastVisitor<Item> : public RawValueVisitor {
   Item* value = nullptr;
 
-  void visitItem(Item* item) override { value = item; }
+  void VisitItem(Item* item) override { value = item; }
 };
 
 template <typename T>
-const T* valueCast(const Value* value) {
-  return valueCast<T>(const_cast<Value*>(value));
+const T* ValueCast(const Value* value) {
+  return ValueCast<T>(const_cast<Value*>(value));
 }
 
 /**
@@ -137,30 +135,30 @@ const T* valueCast(const Value* value) {
  * Otherwise, returns nullptr.
  */
 template <typename T>
-T* valueCast(Value* value) {
+T* ValueCast(Value* value) {
   if (!value) {
     return nullptr;
   }
   DynCastVisitor<T> visitor;
-  value->accept(&visitor);
+  value->Accept(&visitor);
   return visitor.value;
 }
 
-inline void visitAllValuesInPackage(ResourceTablePackage* pkg,
+inline void VisitAllValuesInPackage(ResourceTablePackage* pkg,
                                     RawValueVisitor* visitor) {
   for (auto& type : pkg->types) {
     for (auto& entry : type->entries) {
-      for (auto& configValue : entry->values) {
-        configValue->value->accept(visitor);
+      for (auto& config_value : entry->values) {
+        config_value->value->Accept(visitor);
       }
     }
   }
 }
 
-inline void visitAllValuesInTable(ResourceTable* table,
+inline void VisitAllValuesInTable(ResourceTable* table,
                                   RawValueVisitor* visitor) {
   for (auto& pkg : table->packages) {
-    visitAllValuesInPackage(pkg.get(), visitor);
+    VisitAllValuesInPackage(pkg.get(), visitor);
   }
 }
 
diff --git a/tools/aapt2/ValueVisitor_test.cpp b/tools/aapt2/ValueVisitor_test.cpp
index ed9c7f6c8050c..eb75b102e427c 100644
--- a/tools/aapt2/ValueVisitor_test.cpp
+++ b/tools/aapt2/ValueVisitor_test.cpp
@@ -15,40 +15,41 @@
  */
 
 #include "ValueVisitor.h"
+
+#include <string>
+
 #include "ResourceValues.h"
 #include "test/Test.h"
 #include "util/Util.h"
 
-#include <string>
-
 namespace aapt {
 
 struct SingleReferenceVisitor : public ValueVisitor {
-  using ValueVisitor::visit;
+  using ValueVisitor::Visit;
 
   Reference* visited = nullptr;
 
-  void visit(Reference* ref) override { visited = ref; }
+  void Visit(Reference* ref) override { visited = ref; }
 };
 
 struct StyleVisitor : public ValueVisitor {
-  using ValueVisitor::visit;
+  using ValueVisitor::Visit;
 
-  std::list<Reference*> visitedRefs;
-  Style* visitedStyle = nullptr;
+  std::list<Reference*> visited_refs;
+  Style* visited_style = nullptr;
 
-  void visit(Reference* ref) override { visitedRefs.push_back(ref); }
+  void Visit(Reference* ref) override { visited_refs.push_back(ref); }
 
-  void visit(Style* style) override {
-    visitedStyle = style;
-    ValueVisitor::visit(style);
+  void Visit(Style* style) override {
+    visited_style = style;
+    ValueVisitor::Visit(style);
   }
 };
 
 TEST(ValueVisitorTest, VisitsReference) {
   Reference ref(ResourceName{"android", ResourceType::kAttr, "foo"});
   SingleReferenceVisitor visitor;
-  ref.accept(&visitor);
+  ref.Accept(&visitor);
 
   EXPECT_EQ(visitor.visited, &ref);
 }
@@ -56,31 +57,31 @@ TEST(ValueVisitorTest, VisitsReference) {
 TEST(ValueVisitorTest, VisitsReferencesInStyle) {
   std::unique_ptr<Style> style =
       test::StyleBuilder()
-          .setParent("android:style/foo")
-          .addItem("android:attr/one", test::buildReference("android:id/foo"))
-          .build();
+          .SetParent("android:style/foo")
+          .AddItem("android:attr/one", test::BuildReference("android:id/foo"))
+          .Build();
 
   StyleVisitor visitor;
-  style->accept(&visitor);
+  style->Accept(&visitor);
 
-  ASSERT_EQ(style.get(), visitor.visitedStyle);
+  ASSERT_EQ(style.get(), visitor.visited_style);
 
   // Entry attribute references, plus the parent reference, plus one value
   // reference.
-  ASSERT_EQ(style->entries.size() + 2, visitor.visitedRefs.size());
+  ASSERT_EQ(style->entries.size() + 2, visitor.visited_refs.size());
 }
 
 TEST(ValueVisitorTest, ValueCast) {
-  std::unique_ptr<Reference> ref = test::buildReference("android:color/white");
-  EXPECT_NE(valueCast<Reference>(ref.get()), nullptr);
+  std::unique_ptr<Reference> ref = test::BuildReference("android:color/white");
+  EXPECT_NE(ValueCast<Reference>(ref.get()), nullptr);
 
   std::unique_ptr<Style> style =
       test::StyleBuilder()
-          .addItem("android:attr/foo",
-                   test::buildReference("android:color/black"))
-          .build();
-  EXPECT_NE(valueCast<Style>(style.get()), nullptr);
-  EXPECT_EQ(valueCast<Reference>(style.get()), nullptr);
+          .AddItem("android:attr/foo",
+                   test::BuildReference("android:color/black"))
+          .Build();
+  EXPECT_NE(ValueCast<Style>(style.get()), nullptr);
+  EXPECT_EQ(ValueCast<Reference>(style.get()), nullptr);
 }
 
 }  // namespace aapt
diff --git a/tools/aapt2/compile/Compile.cpp b/tools/aapt2/compile/Compile.cpp
index 2ea63d02b7548..a06140cff5422 100644
--- a/tools/aapt2/compile/Compile.cpp
+++ b/tools/aapt2/compile/Compile.cpp
@@ -14,6 +14,11 @@
  * limitations under the License.
  */
 
+#include <dirent.h>
+
+#include <fstream>
+#include <string>
+
 #include "ConfigDescription.h"
 #include "Diagnostics.h"
 #include "Flags.h"
@@ -33,14 +38,10 @@
 #include "xml/XmlDom.h"
 #include "xml/XmlPullParser.h"
 
-#include <google/protobuf/io/coded_stream.h>
-#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
-
-#include <android-base/errors.h>
-#include <android-base/file.h>
-#include <dirent.h>
-#include <fstream>
-#include <string>
+#include "android-base/errors.h"
+#include "android-base/file.h"
+#include "google/protobuf/io/coded_stream.h"
+#include "google/protobuf/io/zero_copy_stream_impl_lite.h"
 
 using google::protobuf::io::CopyingOutputStreamAdaptor;
 using google::protobuf::io::ZeroCopyOutputStream;
@@ -49,7 +50,7 @@ namespace aapt {
 
 struct ResourcePathData {
   Source source;
-  std::string resourceDir;
+  std::string resource_dir;
   std::string name;
   std::string extension;
 
@@ -58,7 +59,7 @@ struct ResourcePathData {
   // version qualifiers. We want to preserve the original input so the output is
   // easily
   // computed before hand.
-  std::string configStr;
+  std::string config_str;
   ConfigDescription config;
 };
 
@@ -66,60 +67,60 @@ struct ResourcePathData {
  * Resource file paths are expected to look like:
  * [--/res/]type[-config]/name
  */
-static Maybe<ResourcePathData> extractResourcePathData(const std::string& path,
-                                                       std::string* outError) {
-  std::vector<std::string> parts = util::split(path, file::sDirSep);
+static Maybe<ResourcePathData> ExtractResourcePathData(const std::string& path,
+                                                       std::string* out_error) {
+  std::vector<std::string> parts = util::Split(path, file::sDirSep);
   if (parts.size() < 2) {
-    if (outError) *outError = "bad resource path";
+    if (out_error) *out_error = "bad resource path";
     return {};
   }
 
   std::string& dir = parts[parts.size() - 2];
-  StringPiece dirStr = dir;
+  StringPiece dir_str = dir;
 
-  StringPiece configStr;
+  StringPiece config_str;
   ConfigDescription config;
-  size_t dashPos = dir.find('-');
-  if (dashPos != std::string::npos) {
-    configStr = dirStr.substr(dashPos + 1, dir.size() - (dashPos + 1));
-    if (!ConfigDescription::parse(configStr, &config)) {
-      if (outError) {
-        std::stringstream errStr;
-        errStr << "invalid configuration '" << configStr << "'";
-        *outError = errStr.str();
+  size_t dash_pos = dir.find('-');
+  if (dash_pos != std::string::npos) {
+    config_str = dir_str.substr(dash_pos + 1, dir.size() - (dash_pos + 1));
+    if (!ConfigDescription::Parse(config_str, &config)) {
+      if (out_error) {
+        std::stringstream err_str;
+        err_str << "invalid configuration '" << config_str << "'";
+        *out_error = err_str.str();
       }
       return {};
     }
-    dirStr = dirStr.substr(0, dashPos);
+    dir_str = dir_str.substr(0, dash_pos);
   }
 
   std::string& filename = parts[parts.size() - 1];
   StringPiece name = filename;
   StringPiece extension;
-  size_t dotPos = filename.find('.');
-  if (dotPos != std::string::npos) {
-    extension = name.substr(dotPos + 1, filename.size() - (dotPos + 1));
-    name = name.substr(0, dotPos);
+  size_t dot_pos = filename.find('.');
+  if (dot_pos != std::string::npos) {
+    extension = name.substr(dot_pos + 1, filename.size() - (dot_pos + 1));
+    name = name.substr(0, dot_pos);
   }
 
-  return ResourcePathData{Source(path),         dirStr.toString(),
-                          name.toString(),      extension.toString(),
-                          configStr.toString(), config};
+  return ResourcePathData{Source(path),          dir_str.ToString(),
+                          name.ToString(),       extension.ToString(),
+                          config_str.ToString(), config};
 }
 
 struct CompileOptions {
-  std::string outputPath;
-  Maybe<std::string> resDir;
+  std::string output_path;
+  Maybe<std::string> res_dir;
   bool pseudolocalize = false;
-  bool legacyMode = false;
+  bool legacy_mode = false;
   bool verbose = false;
 };
 
-static std::string buildIntermediateFilename(const ResourcePathData& data) {
+static std::string BuildIntermediateFilename(const ResourcePathData& data) {
   std::stringstream name;
-  name << data.resourceDir;
-  if (!data.configStr.empty()) {
-    name << "-" << data.configStr;
+  name << data.resource_dir;
+  if (!data.config_str.empty()) {
+    name << "-" << data.config_str;
   }
   name << "_" << data.name;
   if (!data.extension.empty()) {
@@ -129,92 +130,93 @@ static std::string buildIntermediateFilename(const ResourcePathData& data) {
   return name.str();
 }
 
-static bool isHidden(const StringPiece& filename) {
-  return util::stringStartsWith(filename, ".");
+static bool IsHidden(const StringPiece& filename) {
+  return util::StartsWith(filename, ".");
 }
 
 /**
  * Walks the res directory structure, looking for resource files.
  */
-static bool loadInputFilesFromDir(IAaptContext* context,
-                                  const CompileOptions& options,
-                                  std::vector<ResourcePathData>* outPathData) {
-  const std::string& rootDir = options.resDir.value();
-  std::unique_ptr<DIR, decltype(closedir)*> d(opendir(rootDir.data()),
+static bool LoadInputFilesFromDir(
+    IAaptContext* context, const CompileOptions& options,
+    std::vector<ResourcePathData>* out_path_data) {
+  const std::string& root_dir = options.res_dir.value();
+  std::unique_ptr<DIR, decltype(closedir)*> d(opendir(root_dir.data()),
                                               closedir);
   if (!d) {
-    context->getDiagnostics()->error(DiagMessage() << strerror(errno));
+    context->GetDiagnostics()->Error(DiagMessage() << strerror(errno));
     return false;
   }
 
   while (struct dirent* entry = readdir(d.get())) {
-    if (isHidden(entry->d_name)) {
+    if (IsHidden(entry->d_name)) {
       continue;
     }
 
-    std::string prefixPath = rootDir;
-    file::appendPath(&prefixPath, entry->d_name);
+    std::string prefix_path = root_dir;
+    file::AppendPath(&prefix_path, entry->d_name);
 
-    if (file::getFileType(prefixPath) != file::FileType::kDirectory) {
+    if (file::GetFileType(prefix_path) != file::FileType::kDirectory) {
       continue;
     }
 
-    std::unique_ptr<DIR, decltype(closedir)*> subDir(opendir(prefixPath.data()),
-                                                     closedir);
-    if (!subDir) {
-      context->getDiagnostics()->error(DiagMessage() << strerror(errno));
+    std::unique_ptr<DIR, decltype(closedir)*> subdir(
+        opendir(prefix_path.data()), closedir);
+    if (!subdir) {
+      context->GetDiagnostics()->Error(DiagMessage() << strerror(errno));
       return false;
     }
 
-    while (struct dirent* leafEntry = readdir(subDir.get())) {
-      if (isHidden(leafEntry->d_name)) {
+    while (struct dirent* leaf_entry = readdir(subdir.get())) {
+      if (IsHidden(leaf_entry->d_name)) {
         continue;
       }
 
-      std::string fullPath = prefixPath;
-      file::appendPath(&fullPath, leafEntry->d_name);
+      std::string full_path = prefix_path;
+      file::AppendPath(&full_path, leaf_entry->d_name);
 
-      std::string errStr;
-      Maybe<ResourcePathData> pathData =
-          extractResourcePathData(fullPath, &errStr);
-      if (!pathData) {
-        context->getDiagnostics()->error(DiagMessage() << errStr);
+      std::string err_str;
+      Maybe<ResourcePathData> path_data =
+          ExtractResourcePathData(full_path, &err_str);
+      if (!path_data) {
+        context->GetDiagnostics()->Error(DiagMessage() << err_str);
         return false;
       }
 
-      outPathData->push_back(std::move(pathData.value()));
+      out_path_data->push_back(std::move(path_data.value()));
     }
   }
   return true;
 }
 
-static bool compileTable(IAaptContext* context, const CompileOptions& options,
-                         const ResourcePathData& pathData,
+static bool CompileTable(IAaptContext* context, const CompileOptions& options,
+                         const ResourcePathData& path_data,
                          IArchiveWriter* writer,
-                         const std::string& outputPath) {
+                         const std::string& output_path) {
   ResourceTable table;
   {
-    std::ifstream fin(pathData.source.path, std::ifstream::binary);
+    std::ifstream fin(path_data.source.path, std::ifstream::binary);
     if (!fin) {
-      context->getDiagnostics()->error(DiagMessage(pathData.source)
+      context->GetDiagnostics()->Error(DiagMessage(path_data.source)
                                        << strerror(errno));
       return false;
     }
 
     // Parse the values file from XML.
-    xml::XmlPullParser xmlParser(fin);
+    xml::XmlPullParser xml_parser(fin);
 
-    ResourceParserOptions parserOptions;
-    parserOptions.errorOnPositionalArguments = !options.legacyMode;
+    ResourceParserOptions parser_options;
+    parser_options.error_on_positional_arguments = !options.legacy_mode;
 
     // If the filename includes donottranslate, then the default translatable is
     // false.
-    parserOptions.translatable =
-        pathData.name.find("donottranslate") == std::string::npos;
+    parser_options.translatable =
+        path_data.name.find("donottranslate") == std::string::npos;
 
-    ResourceParser resParser(context->getDiagnostics(), &table, pathData.source,
-                             pathData.config, parserOptions);
-    if (!resParser.parse(&xmlParser)) {
+    ResourceParser res_parser(context->GetDiagnostics(), &table,
+                              path_data.source, path_data.config,
+                              parser_options);
+    if (!res_parser.Parse(&xml_parser)) {
       return false;
     }
 
@@ -226,242 +228,241 @@ static bool compileTable(IAaptContext* context, const CompileOptions& options,
     // These are created as weak symbols, and are only generated from default
     // configuration
     // strings and plurals.
-    PseudolocaleGenerator pseudolocaleGenerator;
-    if (!pseudolocaleGenerator.consume(context, &table)) {
+    PseudolocaleGenerator pseudolocale_generator;
+    if (!pseudolocale_generator.Consume(context, &table)) {
       return false;
     }
   }
 
   // Ensure we have the compilation package at least.
-  table.createPackage(context->getCompilationPackage());
+  table.CreatePackage(context->GetCompilationPackage());
 
   // Assign an ID to any package that has resources.
   for (auto& pkg : table.packages) {
     if (!pkg->id) {
       // If no package ID was set while parsing (public identifiers), auto
       // assign an ID.
-      pkg->id = context->getPackageId();
+      pkg->id = context->GetPackageId();
     }
   }
 
   // Create the file/zip entry.
-  if (!writer->startEntry(outputPath, 0)) {
-    context->getDiagnostics()->error(DiagMessage(outputPath)
+  if (!writer->StartEntry(output_path, 0)) {
+    context->GetDiagnostics()->Error(DiagMessage(output_path)
                                      << "failed to open");
     return false;
   }
 
   // Make sure CopyingOutputStreamAdaptor is deleted before we call
-  // writer->finishEntry().
+  // writer->FinishEntry().
   {
     // Wrap our IArchiveWriter with an adaptor that implements the
     // ZeroCopyOutputStream
     // interface.
-    CopyingOutputStreamAdaptor copyingAdaptor(writer);
+    CopyingOutputStreamAdaptor copying_adaptor(writer);
 
-    std::unique_ptr<pb::ResourceTable> pbTable = serializeTableToPb(&table);
-    if (!pbTable->SerializeToZeroCopyStream(&copyingAdaptor)) {
-      context->getDiagnostics()->error(DiagMessage(outputPath)
+    std::unique_ptr<pb::ResourceTable> pb_table = SerializeTableToPb(&table);
+    if (!pb_table->SerializeToZeroCopyStream(&copying_adaptor)) {
+      context->GetDiagnostics()->Error(DiagMessage(output_path)
                                        << "failed to write");
       return false;
     }
   }
 
-  if (!writer->finishEntry()) {
-    context->getDiagnostics()->error(DiagMessage(outputPath)
+  if (!writer->FinishEntry()) {
+    context->GetDiagnostics()->Error(DiagMessage(output_path)
                                      << "failed to finish entry");
     return false;
   }
   return true;
 }
 
-static bool writeHeaderAndBufferToWriter(const StringPiece& outputPath,
+static bool WriteHeaderAndBufferToWriter(const StringPiece& output_path,
                                          const ResourceFile& file,
                                          const BigBuffer& buffer,
                                          IArchiveWriter* writer,
                                          IDiagnostics* diag) {
   // Start the entry so we can write the header.
-  if (!writer->startEntry(outputPath, 0)) {
-    diag->error(DiagMessage(outputPath) << "failed to open file");
+  if (!writer->StartEntry(output_path, 0)) {
+    diag->Error(DiagMessage(output_path) << "failed to open file");
     return false;
   }
 
   // Make sure CopyingOutputStreamAdaptor is deleted before we call
-  // writer->finishEntry().
+  // writer->FinishEntry().
   {
     // Wrap our IArchiveWriter with an adaptor that implements the
     // ZeroCopyOutputStream
     // interface.
-    CopyingOutputStreamAdaptor copyingAdaptor(writer);
-    CompiledFileOutputStream outputStream(&copyingAdaptor);
+    CopyingOutputStreamAdaptor copying_adaptor(writer);
+    CompiledFileOutputStream output_stream(&copying_adaptor);
 
     // Number of CompiledFiles.
-    outputStream.WriteLittleEndian32(1);
+    output_stream.WriteLittleEndian32(1);
 
-    std::unique_ptr<pb::CompiledFile> compiledFile =
-        serializeCompiledFileToPb(file);
-    outputStream.WriteCompiledFile(compiledFile.get());
-    outputStream.WriteData(&buffer);
+    std::unique_ptr<pb::CompiledFile> compiled_file =
+        SerializeCompiledFileToPb(file);
+    output_stream.WriteCompiledFile(compiled_file.get());
+    output_stream.WriteData(&buffer);
 
-    if (outputStream.HadError()) {
-      diag->error(DiagMessage(outputPath) << "failed to write data");
+    if (output_stream.HadError()) {
+      diag->Error(DiagMessage(output_path) << "failed to write data");
       return false;
     }
   }
 
-  if (!writer->finishEntry()) {
-    diag->error(DiagMessage(outputPath) << "failed to finish writing data");
+  if (!writer->FinishEntry()) {
+    diag->Error(DiagMessage(output_path) << "failed to finish writing data");
     return false;
   }
   return true;
 }
 
-static bool writeHeaderAndMmapToWriter(const StringPiece& outputPath,
+static bool WriteHeaderAndMmapToWriter(const StringPiece& output_path,
                                        const ResourceFile& file,
                                        const android::FileMap& map,
                                        IArchiveWriter* writer,
                                        IDiagnostics* diag) {
   // Start the entry so we can write the header.
-  if (!writer->startEntry(outputPath, 0)) {
-    diag->error(DiagMessage(outputPath) << "failed to open file");
+  if (!writer->StartEntry(output_path, 0)) {
+    diag->Error(DiagMessage(output_path) << "failed to open file");
     return false;
   }
 
   // Make sure CopyingOutputStreamAdaptor is deleted before we call
-  // writer->finishEntry().
+  // writer->FinishEntry().
   {
     // Wrap our IArchiveWriter with an adaptor that implements the
-    // ZeroCopyOutputStream
-    // interface.
-    CopyingOutputStreamAdaptor copyingAdaptor(writer);
-    CompiledFileOutputStream outputStream(&copyingAdaptor);
+    // ZeroCopyOutputStream interface.
+    CopyingOutputStreamAdaptor copying_adaptor(writer);
+    CompiledFileOutputStream output_stream(&copying_adaptor);
 
     // Number of CompiledFiles.
-    outputStream.WriteLittleEndian32(1);
+    output_stream.WriteLittleEndian32(1);
 
-    std::unique_ptr<pb::CompiledFile> compiledFile =
-        serializeCompiledFileToPb(file);
-    outputStream.WriteCompiledFile(compiledFile.get());
-    outputStream.WriteData(map.getDataPtr(), map.getDataLength());
+    std::unique_ptr<pb::CompiledFile> compiled_file =
+        SerializeCompiledFileToPb(file);
+    output_stream.WriteCompiledFile(compiled_file.get());
+    output_stream.WriteData(map.getDataPtr(), map.getDataLength());
 
-    if (outputStream.HadError()) {
-      diag->error(DiagMessage(outputPath) << "failed to write data");
+    if (output_stream.HadError()) {
+      diag->Error(DiagMessage(output_path) << "failed to write data");
       return false;
     }
   }
 
-  if (!writer->finishEntry()) {
-    diag->error(DiagMessage(outputPath) << "failed to finish writing data");
+  if (!writer->FinishEntry()) {
+    diag->Error(DiagMessage(output_path) << "failed to finish writing data");
     return false;
   }
   return true;
 }
 
-static bool flattenXmlToOutStream(IAaptContext* context,
-                                  const StringPiece& outputPath,
-                                  xml::XmlResource* xmlRes,
+static bool FlattenXmlToOutStream(IAaptContext* context,
+                                  const StringPiece& output_path,
+                                  xml::XmlResource* xmlres,
                                   CompiledFileOutputStream* out) {
   BigBuffer buffer(1024);
-  XmlFlattenerOptions xmlFlattenerOptions;
-  xmlFlattenerOptions.keepRawValues = true;
-  XmlFlattener flattener(&buffer, xmlFlattenerOptions);
-  if (!flattener.consume(context, xmlRes)) {
+  XmlFlattenerOptions xml_flattener_options;
+  xml_flattener_options.keep_raw_values = true;
+  XmlFlattener flattener(&buffer, xml_flattener_options);
+  if (!flattener.Consume(context, xmlres)) {
     return false;
   }
 
-  std::unique_ptr<pb::CompiledFile> pbCompiledFile =
-      serializeCompiledFileToPb(xmlRes->file);
-  out->WriteCompiledFile(pbCompiledFile.get());
+  std::unique_ptr<pb::CompiledFile> pb_compiled_file =
+      SerializeCompiledFileToPb(xmlres->file);
+  out->WriteCompiledFile(pb_compiled_file.get());
   out->WriteData(&buffer);
 
   if (out->HadError()) {
-    context->getDiagnostics()->error(DiagMessage(outputPath)
+    context->GetDiagnostics()->Error(DiagMessage(output_path)
                                      << "failed to write data");
     return false;
   }
   return true;
 }
 
-static bool compileXml(IAaptContext* context, const CompileOptions& options,
-                       const ResourcePathData& pathData, IArchiveWriter* writer,
-                       const std::string& outputPath) {
-  if (context->verbose()) {
-    context->getDiagnostics()->note(DiagMessage(pathData.source)
+static bool CompileXml(IAaptContext* context, const CompileOptions& options,
+                       const ResourcePathData& path_data,
+                       IArchiveWriter* writer, const std::string& output_path) {
+  if (context->IsVerbose()) {
+    context->GetDiagnostics()->Note(DiagMessage(path_data.source)
                                     << "compiling XML");
   }
 
-  std::unique_ptr<xml::XmlResource> xmlRes;
+  std::unique_ptr<xml::XmlResource> xmlres;
   {
-    std::ifstream fin(pathData.source.path, std::ifstream::binary);
+    std::ifstream fin(path_data.source.path, std::ifstream::binary);
     if (!fin) {
-      context->getDiagnostics()->error(DiagMessage(pathData.source)
+      context->GetDiagnostics()->Error(DiagMessage(path_data.source)
                                        << strerror(errno));
       return false;
     }
 
-    xmlRes = xml::inflate(&fin, context->getDiagnostics(), pathData.source);
+    xmlres = xml::Inflate(&fin, context->GetDiagnostics(), path_data.source);
 
     fin.close();
   }
 
-  if (!xmlRes) {
+  if (!xmlres) {
     return false;
   }
 
-  xmlRes->file.name =
-      ResourceName({}, *parseResourceType(pathData.resourceDir), pathData.name);
-  xmlRes->file.config = pathData.config;
-  xmlRes->file.source = pathData.source;
+  xmlres->file.name = ResourceName(
+      {}, *ParseResourceType(path_data.resource_dir), path_data.name);
+  xmlres->file.config = path_data.config;
+  xmlres->file.source = path_data.source;
 
   // Collect IDs that are defined here.
   XmlIdCollector collector;
-  if (!collector.consume(context, xmlRes.get())) {
+  if (!collector.Consume(context, xmlres.get())) {
     return false;
   }
 
   // Look for and process any <aapt:attr> tags and create sub-documents.
-  InlineXmlFormatParser inlineXmlFormatParser;
-  if (!inlineXmlFormatParser.consume(context, xmlRes.get())) {
+  InlineXmlFormatParser inline_xml_format_parser;
+  if (!inline_xml_format_parser.Consume(context, xmlres.get())) {
     return false;
   }
 
   // Start the entry so we can write the header.
-  if (!writer->startEntry(outputPath, 0)) {
-    context->getDiagnostics()->error(DiagMessage(outputPath)
+  if (!writer->StartEntry(output_path, 0)) {
+    context->GetDiagnostics()->Error(DiagMessage(output_path)
                                      << "failed to open file");
     return false;
   }
 
   // Make sure CopyingOutputStreamAdaptor is deleted before we call
-  // writer->finishEntry().
+  // writer->FinishEntry().
   {
     // Wrap our IArchiveWriter with an adaptor that implements the
     // ZeroCopyOutputStream
     // interface.
-    CopyingOutputStreamAdaptor copyingAdaptor(writer);
-    CompiledFileOutputStream outputStream(&copyingAdaptor);
+    CopyingOutputStreamAdaptor copying_adaptor(writer);
+    CompiledFileOutputStream output_stream(&copying_adaptor);
 
-    std::vector<std::unique_ptr<xml::XmlResource>>& inlineDocuments =
-        inlineXmlFormatParser.getExtractedInlineXmlDocuments();
+    std::vector<std::unique_ptr<xml::XmlResource>>& inline_documents =
+        inline_xml_format_parser.GetExtractedInlineXmlDocuments();
 
     // Number of CompiledFiles.
-    outputStream.WriteLittleEndian32(1 + inlineDocuments.size());
+    output_stream.WriteLittleEndian32(1 + inline_documents.size());
 
-    if (!flattenXmlToOutStream(context, outputPath, xmlRes.get(),
-                               &outputStream)) {
+    if (!FlattenXmlToOutStream(context, output_path, xmlres.get(),
+                               &output_stream)) {
       return false;
     }
 
-    for (auto& inlineXmlDoc : inlineDocuments) {
-      if (!flattenXmlToOutStream(context, outputPath, inlineXmlDoc.get(),
-                                 &outputStream)) {
+    for (auto& inline_xml_doc : inline_documents) {
+      if (!FlattenXmlToOutStream(context, output_path, inline_xml_doc.get(),
+                                 &output_stream)) {
         return false;
       }
     }
   }
 
-  if (!writer->finishEntry()) {
-    context->getDiagnostics()->error(DiagMessage(outputPath)
+  if (!writer->FinishEntry()) {
+    context->GetDiagnostics()->Error(DiagMessage(output_path)
                                      << "failed to finish writing data");
     return false;
   }
@@ -470,69 +471,69 @@ static bool compileXml(IAaptContext* context, const CompileOptions& options,
 
 class BigBufferOutputStream : public io::OutputStream {
  public:
-  explicit BigBufferOutputStream(BigBuffer* buffer) : mBuffer(buffer) {}
+  explicit BigBufferOutputStream(BigBuffer* buffer) : buffer_(buffer) {}
 
   bool Next(void** data, int* len) override {
     size_t count;
-    *data = mBuffer->nextBlock(&count);
+    *data = buffer_->NextBlock(&count);
     *len = static_cast<int>(count);
     return true;
   }
 
-  void BackUp(int count) override { mBuffer->backUp(count); }
+  void BackUp(int count) override { buffer_->BackUp(count); }
 
-  int64_t ByteCount() const override { return mBuffer->size(); }
+  int64_t ByteCount() const override { return buffer_->size(); }
 
   bool HadError() const override { return false; }
 
  private:
-  BigBuffer* mBuffer;
+  BigBuffer* buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(BigBufferOutputStream);
 };
 
-static bool compilePng(IAaptContext* context, const CompileOptions& options,
-                       const ResourcePathData& pathData, IArchiveWriter* writer,
-                       const std::string& outputPath) {
-  if (context->verbose()) {
-    context->getDiagnostics()->note(DiagMessage(pathData.source)
+static bool CompilePng(IAaptContext* context, const CompileOptions& options,
+                       const ResourcePathData& path_data,
+                       IArchiveWriter* writer, const std::string& output_path) {
+  if (context->IsVerbose()) {
+    context->GetDiagnostics()->Note(DiagMessage(path_data.source)
                                     << "compiling PNG");
   }
 
   BigBuffer buffer(4096);
-  ResourceFile resFile;
-  resFile.name =
-      ResourceName({}, *parseResourceType(pathData.resourceDir), pathData.name);
-  resFile.config = pathData.config;
-  resFile.source = pathData.source;
+  ResourceFile res_file;
+  res_file.name = ResourceName({}, *ParseResourceType(path_data.resource_dir),
+                               path_data.name);
+  res_file.config = path_data.config;
+  res_file.source = path_data.source;
 
   {
     std::string content;
-    if (!android::base::ReadFileToString(pathData.source.path, &content)) {
-      context->getDiagnostics()->error(
-          DiagMessage(pathData.source)
+    if (!android::base::ReadFileToString(path_data.source.path, &content)) {
+      context->GetDiagnostics()->Error(
+          DiagMessage(path_data.source)
           << android::base::SystemErrorCodeToString(errno));
       return false;
     }
 
-    BigBuffer crunchedPngBuffer(4096);
-    BigBufferOutputStream crunchedPngBufferOut(&crunchedPngBuffer);
+    BigBuffer crunched_png_buffer(4096);
+    BigBufferOutputStream crunched_png_buffer_out(&crunched_png_buffer);
 
     // Ensure that we only keep the chunks we care about if we end up
     // using the original PNG instead of the crunched one.
-    PngChunkFilter pngChunkFilter(content);
-    std::unique_ptr<Image> image = readPng(context, &pngChunkFilter);
+    PngChunkFilter png_chunk_filter(content);
+    std::unique_ptr<Image> image = ReadPng(context, &png_chunk_filter);
     if (!image) {
       return false;
     }
 
-    std::unique_ptr<NinePatch> ninePatch;
-    if (pathData.extension == "9.png") {
+    std::unique_ptr<NinePatch> nine_patch;
+    if (path_data.extension == "9.png") {
       std::string err;
-      ninePatch = NinePatch::create(image->rows.get(), image->width,
-                                    image->height, &err);
-      if (!ninePatch) {
-        context->getDiagnostics()->error(DiagMessage() << err);
+      nine_patch = NinePatch::Create(image->rows.get(), image->width,
+                                     image->height, &err);
+      if (!nine_patch) {
+        context->GetDiagnostics()->Error(DiagMessage() << err);
         return false;
       }
 
@@ -549,89 +550,91 @@ static bool compilePng(IAaptContext* context, const CompileOptions& options,
         memmove(image->rows[h], image->rows[h] + 4, image->width * 4);
       }
 
-      if (context->verbose()) {
-        context->getDiagnostics()->note(DiagMessage(pathData.source)
-                                        << "9-patch: " << *ninePatch);
+      if (context->IsVerbose()) {
+        context->GetDiagnostics()->Note(DiagMessage(path_data.source)
+                                        << "9-patch: " << *nine_patch);
       }
     }
 
     // Write the crunched PNG.
-    if (!writePng(context, image.get(), ninePatch.get(), &crunchedPngBufferOut,
-                  {})) {
+    if (!WritePng(context, image.get(), nine_patch.get(),
+                  &crunched_png_buffer_out, {})) {
       return false;
     }
 
-    if (ninePatch != nullptr ||
-        crunchedPngBufferOut.ByteCount() <= pngChunkFilter.ByteCount()) {
+    if (nine_patch != nullptr ||
+        crunched_png_buffer_out.ByteCount() <= png_chunk_filter.ByteCount()) {
       // No matter what, we must use the re-encoded PNG, even if it is larger.
       // 9-patch images must be re-encoded since their borders are stripped.
-      buffer.appendBuffer(std::move(crunchedPngBuffer));
+      buffer.AppendBuffer(std::move(crunched_png_buffer));
     } else {
       // The re-encoded PNG is larger than the original, and there is
       // no mandatory transformation. Use the original.
-      if (context->verbose()) {
-        context->getDiagnostics()->note(
-            DiagMessage(pathData.source)
+      if (context->IsVerbose()) {
+        context->GetDiagnostics()->Note(
+            DiagMessage(path_data.source)
             << "original PNG is smaller than crunched PNG"
             << ", using original");
       }
 
-      PngChunkFilter pngChunkFilterAgain(content);
-      BigBuffer filteredPngBuffer(4096);
-      BigBufferOutputStream filteredPngBufferOut(&filteredPngBuffer);
-      io::copy(&filteredPngBufferOut, &pngChunkFilterAgain);
-      buffer.appendBuffer(std::move(filteredPngBuffer));
+      PngChunkFilter png_chunk_filter_again(content);
+      BigBuffer filtered_png_buffer(4096);
+      BigBufferOutputStream filtered_png_buffer_out(&filtered_png_buffer);
+      io::Copy(&filtered_png_buffer_out, &png_chunk_filter_again);
+      buffer.AppendBuffer(std::move(filtered_png_buffer));
     }
 
-    if (context->verbose()) {
+    if (context->IsVerbose()) {
       // For debugging only, use the legacy PNG cruncher and compare the
       // resulting file sizes.
       // This will help catch exotic cases where the new code may generate
       // larger PNGs.
-      std::stringstream legacyStream(content);
-      BigBuffer legacyBuffer(4096);
-      Png png(context->getDiagnostics());
-      if (!png.process(pathData.source, &legacyStream, &legacyBuffer, {})) {
+      std::stringstream legacy_stream(content);
+      BigBuffer legacy_buffer(4096);
+      Png png(context->GetDiagnostics());
+      if (!png.process(path_data.source, &legacy_stream, &legacy_buffer, {})) {
         return false;
       }
 
-      context->getDiagnostics()->note(DiagMessage(pathData.source)
-                                      << "legacy=" << legacyBuffer.size()
+      context->GetDiagnostics()->Note(DiagMessage(path_data.source)
+                                      << "legacy=" << legacy_buffer.size()
                                       << " new=" << buffer.size());
     }
   }
 
-  if (!writeHeaderAndBufferToWriter(outputPath, resFile, buffer, writer,
-                                    context->getDiagnostics())) {
+  if (!WriteHeaderAndBufferToWriter(output_path, res_file, buffer, writer,
+                                    context->GetDiagnostics())) {
     return false;
   }
   return true;
 }
 
-static bool compileFile(IAaptContext* context, const CompileOptions& options,
-                        const ResourcePathData& pathData,
-                        IArchiveWriter* writer, const std::string& outputPath) {
-  if (context->verbose()) {
-    context->getDiagnostics()->note(DiagMessage(pathData.source)
+static bool CompileFile(IAaptContext* context, const CompileOptions& options,
+                        const ResourcePathData& path_data,
+                        IArchiveWriter* writer,
+                        const std::string& output_path) {
+  if (context->IsVerbose()) {
+    context->GetDiagnostics()->Note(DiagMessage(path_data.source)
                                     << "compiling file");
   }
 
   BigBuffer buffer(256);
-  ResourceFile resFile;
-  resFile.name =
-      ResourceName({}, *parseResourceType(pathData.resourceDir), pathData.name);
-  resFile.config = pathData.config;
-  resFile.source = pathData.source;
+  ResourceFile res_file;
+  res_file.name = ResourceName({}, *ParseResourceType(path_data.resource_dir),
+                               path_data.name);
+  res_file.config = path_data.config;
+  res_file.source = path_data.source;
 
-  std::string errorStr;
-  Maybe<android::FileMap> f = file::mmapPath(pathData.source.path, &errorStr);
+  std::string error_str;
+  Maybe<android::FileMap> f = file::MmapPath(path_data.source.path, &error_str);
   if (!f) {
-    context->getDiagnostics()->error(DiagMessage(pathData.source) << errorStr);
+    context->GetDiagnostics()->Error(DiagMessage(path_data.source)
+                                     << error_str);
     return false;
   }
 
-  if (!writeHeaderAndMmapToWriter(outputPath, resFile, f.value(), writer,
-                                  context->getDiagnostics())) {
+  if (!WriteHeaderAndMmapToWriter(output_path, res_file, f.value(), writer,
+                                  context->GetDiagnostics())) {
     return false;
   }
   return true;
@@ -639,155 +642,156 @@ static bool compileFile(IAaptContext* context, const CompileOptions& options,
 
 class CompileContext : public IAaptContext {
  public:
-  void setVerbose(bool val) { mVerbose = val; }
+  void SetVerbose(bool val) { verbose_ = val; }
 
-  bool verbose() override { return mVerbose; }
+  bool IsVerbose() override { return verbose_; }
 
-  IDiagnostics* getDiagnostics() override { return &mDiagnostics; }
+  IDiagnostics* GetDiagnostics() override { return &diagnostics_; }
 
-  NameMangler* getNameMangler() override {
+  NameMangler* GetNameMangler() override {
     abort();
     return nullptr;
   }
 
-  const std::string& getCompilationPackage() override {
+  const std::string& GetCompilationPackage() override {
     static std::string empty;
     return empty;
   }
 
-  uint8_t getPackageId() override { return 0x0; }
+  uint8_t GetPackageId() override { return 0x0; }
 
-  SymbolTable* getExternalSymbols() override {
+  SymbolTable* GetExternalSymbols() override {
     abort();
     return nullptr;
   }
 
-  int getMinSdkVersion() override { return 0; }
+  int GetMinSdkVersion() override { return 0; }
 
  private:
-  StdErrDiagnostics mDiagnostics;
-  bool mVerbose = false;
+  StdErrDiagnostics diagnostics_;
+  bool verbose_ = false;
 };
 
 /**
  * Entry point for compilation phase. Parses arguments and dispatches to the
  * correct steps.
  */
-int compile(const std::vector<StringPiece>& args) {
+int Compile(const std::vector<StringPiece>& args) {
   CompileContext context;
   CompileOptions options;
 
   bool verbose = false;
   Flags flags =
       Flags()
-          .requiredFlag("-o", "Output path", &options.outputPath)
-          .optionalFlag("--dir", "Directory to scan for resources",
-                        &options.resDir)
-          .optionalSwitch("--pseudo-localize",
+          .RequiredFlag("-o", "Output path", &options.output_path)
+          .OptionalFlag("--dir", "Directory to scan for resources",
+                        &options.res_dir)
+          .OptionalSwitch("--pseudo-localize",
                           "Generate resources for pseudo-locales "
                           "(en-XA and ar-XB)",
                           &options.pseudolocalize)
-          .optionalSwitch(
+          .OptionalSwitch(
               "--legacy",
               "Treat errors that used to be valid in AAPT as warnings",
-              &options.legacyMode)
-          .optionalSwitch("-v", "Enables verbose logging", &verbose);
-  if (!flags.parse("aapt2 compile", args, &std::cerr)) {
+              &options.legacy_mode)
+          .OptionalSwitch("-v", "Enables verbose logging", &verbose);
+  if (!flags.Parse("aapt2 compile", args, &std::cerr)) {
     return 1;
   }
 
-  context.setVerbose(verbose);
+  context.SetVerbose(verbose);
 
-  std::unique_ptr<IArchiveWriter> archiveWriter;
+  std::unique_ptr<IArchiveWriter> archive_writer;
 
-  std::vector<ResourcePathData> inputData;
-  if (options.resDir) {
-    if (!flags.getArgs().empty()) {
+  std::vector<ResourcePathData> input_data;
+  if (options.res_dir) {
+    if (!flags.GetArgs().empty()) {
       // Can't have both files and a resource directory.
-      context.getDiagnostics()->error(DiagMessage()
+      context.GetDiagnostics()->Error(DiagMessage()
                                       << "files given but --dir specified");
-      flags.usage("aapt2 compile", &std::cerr);
+      flags.Usage("aapt2 compile", &std::cerr);
       return 1;
     }
 
-    if (!loadInputFilesFromDir(&context, options, &inputData)) {
+    if (!LoadInputFilesFromDir(&context, options, &input_data)) {
       return 1;
     }
 
-    archiveWriter = createZipFileArchiveWriter(context.getDiagnostics(),
-                                               options.outputPath);
+    archive_writer = CreateZipFileArchiveWriter(context.GetDiagnostics(),
+                                                options.output_path);
 
   } else {
-    inputData.reserve(flags.getArgs().size());
+    input_data.reserve(flags.GetArgs().size());
 
     // Collect data from the path for each input file.
-    for (const std::string& arg : flags.getArgs()) {
-      std::string errorStr;
-      if (Maybe<ResourcePathData> pathData =
-              extractResourcePathData(arg, &errorStr)) {
-        inputData.push_back(std::move(pathData.value()));
+    for (const std::string& arg : flags.GetArgs()) {
+      std::string error_str;
+      if (Maybe<ResourcePathData> path_data =
+              ExtractResourcePathData(arg, &error_str)) {
+        input_data.push_back(std::move(path_data.value()));
       } else {
-        context.getDiagnostics()->error(DiagMessage() << errorStr << " (" << arg
-                                                      << ")");
+        context.GetDiagnostics()->Error(DiagMessage() << error_str << " ("
+                                                      << arg << ")");
         return 1;
       }
     }
 
-    archiveWriter = createDirectoryArchiveWriter(context.getDiagnostics(),
-                                                 options.outputPath);
+    archive_writer = CreateDirectoryArchiveWriter(context.GetDiagnostics(),
+                                                  options.output_path);
   }
 
-  if (!archiveWriter) {
+  if (!archive_writer) {
     return 1;
   }
 
   bool error = false;
-  for (ResourcePathData& pathData : inputData) {
+  for (ResourcePathData& path_data : input_data) {
     if (options.verbose) {
-      context.getDiagnostics()->note(DiagMessage(pathData.source)
+      context.GetDiagnostics()->Note(DiagMessage(path_data.source)
                                      << "processing");
     }
 
-    if (pathData.resourceDir == "values") {
+    if (path_data.resource_dir == "values") {
       // Overwrite the extension.
-      pathData.extension = "arsc";
+      path_data.extension = "arsc";
 
-      const std::string outputFilename = buildIntermediateFilename(pathData);
-      if (!compileTable(&context, options, pathData, archiveWriter.get(),
-                        outputFilename)) {
+      const std::string output_filename = BuildIntermediateFilename(path_data);
+      if (!CompileTable(&context, options, path_data, archive_writer.get(),
+                        output_filename)) {
         error = true;
       }
 
     } else {
-      const std::string outputFilename = buildIntermediateFilename(pathData);
-      if (const ResourceType* type = parseResourceType(pathData.resourceDir)) {
+      const std::string output_filename = BuildIntermediateFilename(path_data);
+      if (const ResourceType* type =
+              ParseResourceType(path_data.resource_dir)) {
         if (*type != ResourceType::kRaw) {
-          if (pathData.extension == "xml") {
-            if (!compileXml(&context, options, pathData, archiveWriter.get(),
-                            outputFilename)) {
+          if (path_data.extension == "xml") {
+            if (!CompileXml(&context, options, path_data, archive_writer.get(),
+                            output_filename)) {
               error = true;
             }
-          } else if (pathData.extension == "png" ||
-                     pathData.extension == "9.png") {
-            if (!compilePng(&context, options, pathData, archiveWriter.get(),
-                            outputFilename)) {
+          } else if (path_data.extension == "png" ||
+                     path_data.extension == "9.png") {
+            if (!CompilePng(&context, options, path_data, archive_writer.get(),
+                            output_filename)) {
               error = true;
             }
           } else {
-            if (!compileFile(&context, options, pathData, archiveWriter.get(),
-                             outputFilename)) {
+            if (!CompileFile(&context, options, path_data, archive_writer.get(),
+                             output_filename)) {
               error = true;
             }
           }
         } else {
-          if (!compileFile(&context, options, pathData, archiveWriter.get(),
-                           outputFilename)) {
+          if (!CompileFile(&context, options, path_data, archive_writer.get(),
+                           output_filename)) {
             error = true;
           }
         }
       } else {
-        context.getDiagnostics()->error(
-            DiagMessage() << "invalid file path '" << pathData.source << "'");
+        context.GetDiagnostics()->Error(
+            DiagMessage() << "invalid file path '" << path_data.source << "'");
         error = true;
       }
     }
diff --git a/tools/aapt2/compile/IdAssigner.cpp b/tools/aapt2/compile/IdAssigner.cpp
index 73eb066b04d14..17c22c5aac6b7 100644
--- a/tools/aapt2/compile/IdAssigner.cpp
+++ b/tools/aapt2/compile/IdAssigner.cpp
@@ -15,13 +15,15 @@
  */
 
 #include "compile/IdAssigner.h"
+
+#include <map>
+
+#include "android-base/logging.h"
+
 #include "ResourceTable.h"
 #include "process/IResourceTableConsumer.h"
 #include "util/Util.h"
 
-#include <cassert>
-#include <map>
-
 namespace aapt {
 
 /**
@@ -29,44 +31,44 @@ namespace aapt {
  * ResourceEntry,
  * as long as there is no existing ID or the ID is the same.
  */
-static bool assignId(IDiagnostics* diag, const ResourceId& id,
+static bool AssignId(IDiagnostics* diag, const ResourceId& id,
                      const ResourceName& name, ResourceTablePackage* pkg,
                      ResourceTableType* type, ResourceEntry* entry) {
-  if (pkg->id.value() == id.packageId()) {
-    if (!type->id || type->id.value() == id.typeId()) {
-      type->id = id.typeId();
+  if (pkg->id.value() == id.package_id()) {
+    if (!type->id || type->id.value() == id.type_id()) {
+      type->id = id.type_id();
 
-      if (!entry->id || entry->id.value() == id.entryId()) {
-        entry->id = id.entryId();
+      if (!entry->id || entry->id.value() == id.entry_id()) {
+        entry->id = id.entry_id();
         return true;
       }
     }
   }
 
-  const ResourceId existingId(pkg->id.value(), type->id ? type->id.value() : 0,
-                              entry->id ? entry->id.value() : 0);
-  diag->error(DiagMessage() << "can't assign ID " << id << " to resource "
-                            << name << " with conflicting ID " << existingId);
+  const ResourceId existing_id(pkg->id.value(), type->id ? type->id.value() : 0,
+                               entry->id ? entry->id.value() : 0);
+  diag->Error(DiagMessage() << "can't assign ID " << id << " to resource "
+                            << name << " with conflicting ID " << existing_id);
   return false;
 }
 
-bool IdAssigner::consume(IAaptContext* context, ResourceTable* table) {
-  std::map<ResourceId, ResourceName> assignedIds;
+bool IdAssigner::Consume(IAaptContext* context, ResourceTable* table) {
+  std::map<ResourceId, ResourceName> assigned_ids;
 
   for (auto& package : table->packages) {
-    assert(package->id && "packages must have manually assigned IDs");
+    CHECK(bool(package->id)) << "packages must have manually assigned IDs";
 
     for (auto& type : package->types) {
       for (auto& entry : type->entries) {
         const ResourceName name(package->name, type->type, entry->name);
 
-        if (mAssignedIdMap) {
+        if (assigned_id_map_) {
           // Assign the pre-assigned stable ID meant for this resource.
-          const auto iter = mAssignedIdMap->find(name);
-          if (iter != mAssignedIdMap->end()) {
-            const ResourceId assignedId = iter->second;
+          const auto iter = assigned_id_map_->find(name);
+          if (iter != assigned_id_map_->end()) {
+            const ResourceId assigned_id = iter->second;
             const bool result =
-                assignId(context->getDiagnostics(), assignedId, name,
+                AssignId(context->GetDiagnostics(), assigned_id, name,
                          package.get(), type.get(), entry.get());
             if (!result) {
               return false;
@@ -76,14 +78,14 @@ bool IdAssigner::consume(IAaptContext* context, ResourceTable* table) {
 
         if (package->id && type->id && entry->id) {
           // If the ID is set for this resource, then reserve it.
-          ResourceId resourceId(package->id.value(), type->id.value(),
-                                entry->id.value());
-          auto result = assignedIds.insert({resourceId, name});
-          const ResourceName& existingName = result.first->second;
+          ResourceId resource_id(package->id.value(), type->id.value(),
+                                 entry->id.value());
+          auto result = assigned_ids.insert({resource_id, name});
+          const ResourceName& existing_name = result.first->second;
           if (!result.second) {
-            context->getDiagnostics()->error(
+            context->GetDiagnostics()->Error(
                 DiagMessage() << "resource " << name << " has same ID "
-                              << resourceId << " as " << existingName);
+                              << resource_id << " as " << existing_name);
             return false;
           }
         }
@@ -91,20 +93,20 @@ bool IdAssigner::consume(IAaptContext* context, ResourceTable* table) {
     }
   }
 
-  if (mAssignedIdMap) {
+  if (assigned_id_map_) {
     // Reserve all the IDs mentioned in the stable ID map. That way we won't
     // assign
     // IDs that were listed in the map if they don't exist in the table.
-    for (const auto& stableIdEntry : *mAssignedIdMap) {
-      const ResourceName& preAssignedName = stableIdEntry.first;
-      const ResourceId& preAssignedId = stableIdEntry.second;
-      auto result = assignedIds.insert({preAssignedId, preAssignedName});
-      const ResourceName& existingName = result.first->second;
-      if (!result.second && existingName != preAssignedName) {
-        context->getDiagnostics()->error(
-            DiagMessage() << "stable ID " << preAssignedId << " for resource "
-                          << preAssignedName << " is already taken by resource "
-                          << existingName);
+    for (const auto& stable_id_entry : *assigned_id_map_) {
+      const ResourceName& pre_assigned_name = stable_id_entry.first;
+      const ResourceId& pre_assigned_id = stable_id_entry.second;
+      auto result = assigned_ids.insert({pre_assigned_id, pre_assigned_name});
+      const ResourceName& existing_name = result.first->second;
+      if (!result.second && existing_name != pre_assigned_name) {
+        context->GetDiagnostics()->Error(
+            DiagMessage() << "stable ID " << pre_assigned_id << " for resource "
+                          << pre_assigned_name
+                          << " is already taken by resource " << existing_name);
         return false;
       }
     }
@@ -114,21 +116,21 @@ bool IdAssigner::consume(IAaptContext* context, ResourceTable* table) {
   // if possible,
   // unless those IDs have been reserved.
 
-  const auto assignedIdsIterEnd = assignedIds.end();
+  const auto assigned_ids_iter_end = assigned_ids.end();
   for (auto& package : table->packages) {
-    assert(package->id && "packages must have manually assigned IDs");
+    CHECK(bool(package->id)) << "packages must have manually assigned IDs";
 
     // Build a half filled ResourceId object, which will be used to find the
     // closest matching
     // reserved ID in the assignedId map. From that point the next available
     // type ID can be
     // found.
-    ResourceId resourceId(package->id.value(), 0, 0);
-    uint8_t nextExpectedTypeId = 1;
+    ResourceId resource_id(package->id.value(), 0, 0);
+    uint8_t next_expected_type_id = 1;
 
     // Find the closest matching ResourceId that is <= the one with only the
     // package set.
-    auto nextTypeIter = assignedIds.lower_bound(resourceId);
+    auto next_type_iter = assigned_ids.lower_bound(resource_id);
     for (auto& type : package->types) {
       if (!type->id) {
         // We need to assign a type ID. Iterate over the reserved IDs until we
@@ -136,41 +138,41 @@ bool IdAssigner::consume(IAaptContext* context, ResourceTable* table) {
         // some type ID that is a distance of 2 greater than the last one we've
         // seen.
         // That means there is an available type ID between these reserved IDs.
-        while (nextTypeIter != assignedIdsIterEnd) {
-          if (nextTypeIter->first.packageId() != package->id.value()) {
+        while (next_type_iter != assigned_ids_iter_end) {
+          if (next_type_iter->first.package_id() != package->id.value()) {
             break;
           }
 
-          const uint8_t typeId = nextTypeIter->first.typeId();
-          if (typeId > nextExpectedTypeId) {
+          const uint8_t type_id = next_type_iter->first.type_id();
+          if (type_id > next_expected_type_id) {
             // There is a gap in the type IDs, so use the missing one.
-            type->id = nextExpectedTypeId++;
+            type->id = next_expected_type_id++;
             break;
           }
 
           // Set our expectation to be the next type ID after the reserved one
           // we
           // just saw.
-          nextExpectedTypeId = typeId + 1;
+          next_expected_type_id = type_id + 1;
 
           // Move to the next reserved ID.
-          ++nextTypeIter;
+          ++next_type_iter;
         }
 
         if (!type->id) {
           // We must have hit the end of the reserved IDs and not found a gap.
           // That means the next ID is available.
-          type->id = nextExpectedTypeId++;
+          type->id = next_expected_type_id++;
         }
       }
 
-      resourceId = ResourceId(package->id.value(), type->id.value(), 0);
-      uint16_t nextExpectedEntryId = 0;
+      resource_id = ResourceId(package->id.value(), type->id.value(), 0);
+      uint16_t next_expected_entry_id = 0;
 
       // Find the closest matching ResourceId that is <= the one with only the
       // package
       // and type set.
-      auto nextEntryIter = assignedIds.lower_bound(resourceId);
+      auto next_entry_iter = assigned_ids.lower_bound(resource_id);
       for (auto& entry : type->entries) {
         if (!entry->id) {
           // We need to assign an entry ID. Iterate over the reserved IDs until
@@ -179,32 +181,32 @@ bool IdAssigner::consume(IAaptContext* context, ResourceTable* table) {
           // we've seen.
           // That means there is an available entry ID between these reserved
           // IDs.
-          while (nextEntryIter != assignedIdsIterEnd) {
-            if (nextEntryIter->first.packageId() != package->id.value() ||
-                nextEntryIter->first.typeId() != type->id.value()) {
+          while (next_entry_iter != assigned_ids_iter_end) {
+            if (next_entry_iter->first.package_id() != package->id.value() ||
+                next_entry_iter->first.type_id() != type->id.value()) {
               break;
             }
 
-            const uint16_t entryId = nextEntryIter->first.entryId();
-            if (entryId > nextExpectedEntryId) {
+            const uint16_t entry_id = next_entry_iter->first.entry_id();
+            if (entry_id > next_expected_entry_id) {
               // There is a gap in the entry IDs, so use the missing one.
-              entry->id = nextExpectedEntryId++;
+              entry->id = next_expected_entry_id++;
               break;
             }
 
             // Set our expectation to be the next type ID after the reserved one
             // we
             // just saw.
-            nextExpectedEntryId = entryId + 1;
+            next_expected_entry_id = entry_id + 1;
 
             // Move to the next reserved entry ID.
-            ++nextEntryIter;
+            ++next_entry_iter;
           }
 
           if (!entry->id) {
             // We must have hit the end of the reserved IDs and not found a gap.
             // That means the next ID is available.
-            entry->id = nextExpectedEntryId++;
+            entry->id = next_expected_entry_id++;
           }
         }
       }
diff --git a/tools/aapt2/compile/IdAssigner.h b/tools/aapt2/compile/IdAssigner.h
index d3990641abf5f..371ec01818cd9 100644
--- a/tools/aapt2/compile/IdAssigner.h
+++ b/tools/aapt2/compile/IdAssigner.h
@@ -17,11 +17,12 @@
 #ifndef AAPT_COMPILE_IDASSIGNER_H
 #define AAPT_COMPILE_IDASSIGNER_H
 
+#include <unordered_map>
+
 #include "Resource.h"
 #include "process/IResourceTableConsumer.h"
 
-#include <android-base/macros.h>
-#include <unordered_map>
+#include "android-base/macros.h"
 
 namespace aapt {
 
@@ -34,12 +35,13 @@ class IdAssigner : public IResourceTableConsumer {
  public:
   IdAssigner() = default;
   explicit IdAssigner(const std::unordered_map<ResourceName, ResourceId>* map)
-      : mAssignedIdMap(map) {}
+      : assigned_id_map_(map) {}
 
-  bool consume(IAaptContext* context, ResourceTable* table) override;
+  bool Consume(IAaptContext* context, ResourceTable* table) override;
 
  private:
-  const std::unordered_map<ResourceName, ResourceId>* mAssignedIdMap = nullptr;
+  const std::unordered_map<ResourceName, ResourceId>* assigned_id_map_ =
+      nullptr;
 };
 
 }  // namespace aapt
diff --git a/tools/aapt2/compile/IdAssigner_test.cpp b/tools/aapt2/compile/IdAssigner_test.cpp
index ff7bf5ce71952..d465091d224e7 100644
--- a/tools/aapt2/compile/IdAssigner_test.cpp
+++ b/tools/aapt2/compile/IdAssigner_test.cpp
@@ -15,128 +15,129 @@
  */
 
 #include "compile/IdAssigner.h"
+
 #include "test/Test.h"
 
 namespace aapt {
 
-::testing::AssertionResult verifyIds(ResourceTable* table);
+::testing::AssertionResult VerifyIds(ResourceTable* table);
 
 TEST(IdAssignerTest, AssignIds) {
   std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
-                                             .addSimple("android:attr/foo")
-                                             .addSimple("android:attr/bar")
-                                             .addSimple("android:id/foo")
-                                             .setPackageId("android", 0x01)
-                                             .build();
+                                             .AddSimple("android:attr/foo")
+                                             .AddSimple("android:attr/bar")
+                                             .AddSimple("android:id/foo")
+                                             .SetPackageId("android", 0x01)
+                                             .Build();
 
-  std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
+  std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
   IdAssigner assigner;
 
-  ASSERT_TRUE(assigner.consume(context.get(), table.get()));
-  ASSERT_TRUE(verifyIds(table.get()));
+  ASSERT_TRUE(assigner.Consume(context.get(), table.get()));
+  ASSERT_TRUE(VerifyIds(table.get()));
 }
 
 TEST(IdAssignerTest, AssignIdsWithReservedIds) {
   std::unique_ptr<ResourceTable> table =
       test::ResourceTableBuilder()
-          .addSimple("android:id/foo", ResourceId(0x01010000))
-          .addSimple("android:dimen/two")
-          .addSimple("android:integer/three")
-          .addSimple("android:string/five")
-          .addSimple("android:attr/fun", ResourceId(0x01040000))
-          .addSimple("android:attr/foo", ResourceId(0x01040006))
-          .addSimple("android:attr/bar")
-          .addSimple("android:attr/baz")
-          .addSimple("app:id/biz")
-          .setPackageId("android", 0x01)
-          .setPackageId("app", 0x7f)
-          .build();
+          .AddSimple("android:id/foo", ResourceId(0x01010000))
+          .AddSimple("android:dimen/two")
+          .AddSimple("android:integer/three")
+          .AddSimple("android:string/five")
+          .AddSimple("android:attr/fun", ResourceId(0x01040000))
+          .AddSimple("android:attr/foo", ResourceId(0x01040006))
+          .AddSimple("android:attr/bar")
+          .AddSimple("android:attr/baz")
+          .AddSimple("app:id/biz")
+          .SetPackageId("android", 0x01)
+          .SetPackageId("app", 0x7f)
+          .Build();
 
-  std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
+  std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
   IdAssigner assigner;
 
-  ASSERT_TRUE(assigner.consume(context.get(), table.get()));
-  ASSERT_TRUE(verifyIds(table.get()));
+  ASSERT_TRUE(assigner.Consume(context.get(), table.get()));
+  ASSERT_TRUE(VerifyIds(table.get()));
 
-  Maybe<ResourceTable::SearchResult> maybeResult;
+  Maybe<ResourceTable::SearchResult> maybe_result;
 
   // Expect to fill in the gaps between 0x0101XXXX and 0x0104XXXX.
 
-  maybeResult = table->findResource(test::parseNameOrDie("android:dimen/two"));
-  AAPT_ASSERT_TRUE(maybeResult);
-  EXPECT_EQ(make_value<uint8_t>(2), maybeResult.value().type->id);
+  maybe_result = table->FindResource(test::ParseNameOrDie("android:dimen/two"));
+  AAPT_ASSERT_TRUE(maybe_result);
+  EXPECT_EQ(make_value<uint8_t>(2), maybe_result.value().type->id);
 
-  maybeResult =
-      table->findResource(test::parseNameOrDie("android:integer/three"));
-  AAPT_ASSERT_TRUE(maybeResult);
-  EXPECT_EQ(make_value<uint8_t>(3), maybeResult.value().type->id);
+  maybe_result =
+      table->FindResource(test::ParseNameOrDie("android:integer/three"));
+  AAPT_ASSERT_TRUE(maybe_result);
+  EXPECT_EQ(make_value<uint8_t>(3), maybe_result.value().type->id);
 
   // Expect to bypass the reserved 0x0104XXXX IDs and use the next 0x0105XXXX
   // IDs.
 
-  maybeResult =
-      table->findResource(test::parseNameOrDie("android:string/five"));
-  AAPT_ASSERT_TRUE(maybeResult);
-  EXPECT_EQ(make_value<uint8_t>(5), maybeResult.value().type->id);
+  maybe_result =
+      table->FindResource(test::ParseNameOrDie("android:string/five"));
+  AAPT_ASSERT_TRUE(maybe_result);
+  EXPECT_EQ(make_value<uint8_t>(5), maybe_result.value().type->id);
 
   // Expect to fill in the gaps between 0x01040000 and 0x01040006.
 
-  maybeResult = table->findResource(test::parseNameOrDie("android:attr/bar"));
-  AAPT_ASSERT_TRUE(maybeResult);
-  EXPECT_EQ(make_value<uint16_t>(1), maybeResult.value().entry->id);
+  maybe_result = table->FindResource(test::ParseNameOrDie("android:attr/bar"));
+  AAPT_ASSERT_TRUE(maybe_result);
+  EXPECT_EQ(make_value<uint16_t>(1), maybe_result.value().entry->id);
 
-  maybeResult = table->findResource(test::parseNameOrDie("android:attr/baz"));
-  AAPT_ASSERT_TRUE(maybeResult);
-  EXPECT_EQ(make_value<uint16_t>(2), maybeResult.value().entry->id);
+  maybe_result = table->FindResource(test::ParseNameOrDie("android:attr/baz"));
+  AAPT_ASSERT_TRUE(maybe_result);
+  EXPECT_EQ(make_value<uint16_t>(2), maybe_result.value().entry->id);
 }
 
 TEST(IdAssignerTest, FailWhenNonUniqueIdsAssigned) {
   std::unique_ptr<ResourceTable> table =
       test::ResourceTableBuilder()
-          .addSimple("android:attr/foo", ResourceId(0x01040006))
-          .addSimple("android:attr/bar", ResourceId(0x01040006))
-          .setPackageId("android", 0x01)
-          .setPackageId("app", 0x7f)
-          .build();
+          .AddSimple("android:attr/foo", ResourceId(0x01040006))
+          .AddSimple("android:attr/bar", ResourceId(0x01040006))
+          .SetPackageId("android", 0x01)
+          .SetPackageId("app", 0x7f)
+          .Build();
 
-  std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
+  std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
   IdAssigner assigner;
 
-  ASSERT_FALSE(assigner.consume(context.get(), table.get()));
+  ASSERT_FALSE(assigner.Consume(context.get(), table.get()));
 }
 
 TEST(IdAssignerTest, AssignIdsWithIdMap) {
   std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
-                                             .addSimple("android:attr/foo")
-                                             .addSimple("android:attr/bar")
-                                             .setPackageId("android", 0x01)
-                                             .build();
+                                             .AddSimple("android:attr/foo")
+                                             .AddSimple("android:attr/bar")
+                                             .SetPackageId("android", 0x01)
+                                             .Build();
 
-  std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
-  std::unordered_map<ResourceName, ResourceId> idMap = {
-      {test::parseNameOrDie("android:attr/foo"), ResourceId(0x01010002)}};
-  IdAssigner assigner(&idMap);
-  ASSERT_TRUE(assigner.consume(context.get(), table.get()));
-  ASSERT_TRUE(verifyIds(table.get()));
+  std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
+  std::unordered_map<ResourceName, ResourceId> id_map = {
+      {test::ParseNameOrDie("android:attr/foo"), ResourceId(0x01010002)}};
+  IdAssigner assigner(&id_map);
+  ASSERT_TRUE(assigner.Consume(context.get(), table.get()));
+  ASSERT_TRUE(VerifyIds(table.get()));
   Maybe<ResourceTable::SearchResult> result =
-      table->findResource(test::parseNameOrDie("android:attr/foo"));
+      table->FindResource(test::ParseNameOrDie("android:attr/foo"));
   AAPT_ASSERT_TRUE(result);
 
-  const ResourceTable::SearchResult& searchResult = result.value();
-  EXPECT_EQ(make_value<uint8_t>(0x01), searchResult.package->id);
-  EXPECT_EQ(make_value<uint8_t>(0x01), searchResult.type->id);
-  EXPECT_EQ(make_value<uint16_t>(0x0002), searchResult.entry->id);
+  const ResourceTable::SearchResult& search_result = result.value();
+  EXPECT_EQ(make_value<uint8_t>(0x01), search_result.package->id);
+  EXPECT_EQ(make_value<uint8_t>(0x01), search_result.type->id);
+  EXPECT_EQ(make_value<uint16_t>(0x0002), search_result.entry->id);
 }
 
-::testing::AssertionResult verifyIds(ResourceTable* table) {
-  std::set<uint8_t> packageIds;
+::testing::AssertionResult VerifyIds(ResourceTable* table) {
+  std::set<uint8_t> package_ids;
   for (auto& package : table->packages) {
     if (!package->id) {
       return ::testing::AssertionFailure() << "package " << package->name
                                            << " has no ID";
     }
 
-    if (!packageIds.insert(package->id.value()).second) {
+    if (!package_ids.insert(package->id.value()).second) {
       return ::testing::AssertionFailure()
              << "package " << package->name << " has non-unique ID " << std::hex
              << (int)package->id.value() << std::dec;
@@ -144,7 +145,7 @@ TEST(IdAssignerTest, AssignIdsWithIdMap) {
   }
 
   for (auto& package : table->packages) {
-    std::set<uint8_t> typeIds;
+    std::set<uint8_t> type_ids;
     for (auto& type : package->types) {
       if (!type->id) {
         return ::testing::AssertionFailure() << "type " << type->type
@@ -152,7 +153,7 @@ TEST(IdAssignerTest, AssignIdsWithIdMap) {
                                              << " has no ID";
       }
 
-      if (!typeIds.insert(type->id.value()).second) {
+      if (!type_ids.insert(type->id.value()).second) {
         return ::testing::AssertionFailure()
                << "type " << type->type << " of package " << package->name
                << " has non-unique ID " << std::hex << (int)type->id.value()
@@ -161,7 +162,7 @@ TEST(IdAssignerTest, AssignIdsWithIdMap) {
     }
 
     for (auto& type : package->types) {
-      std::set<uint16_t> entryIds;
+      std::set<uint16_t> entry_ids;
       for (auto& entry : type->entries) {
         if (!entry->id) {
           return ::testing::AssertionFailure()
@@ -169,7 +170,7 @@ TEST(IdAssignerTest, AssignIdsWithIdMap) {
                  << " of package " << package->name << " has no ID";
         }
 
-        if (!entryIds.insert(entry->id.value()).second) {
+        if (!entry_ids.insert(entry->id.value()).second) {
           return ::testing::AssertionFailure()
                  << "entry " << entry->name << " of type " << type->type
                  << " of package " << package->name << " has non-unique ID "
diff --git a/tools/aapt2/compile/Image.h b/tools/aapt2/compile/Image.h
index 4cf2ea788b5cc..db0b945e1f18e 100644
--- a/tools/aapt2/compile/Image.h
+++ b/tools/aapt2/compile/Image.h
@@ -17,12 +17,13 @@
 #ifndef AAPT_COMPILE_IMAGE_H
 #define AAPT_COMPILE_IMAGE_H
 
-#include <android-base/macros.h>
 #include <cstdint>
 #include <memory>
 #include <string>
 #include <vector>
 
+#include "android-base/macros.h"
+
 namespace aapt {
 
 /**
@@ -113,15 +114,15 @@ inline bool operator==(const Bounds& left, const Bounds& right) {
  */
 class NinePatch {
  public:
-  static std::unique_ptr<NinePatch> create(uint8_t** rows, const int32_t width,
+  static std::unique_ptr<NinePatch> Create(uint8_t** rows, const int32_t width,
                                            const int32_t height,
-                                           std::string* errOut);
+                                           std::string* err_out);
 
   /**
    * Packs the RGBA_8888 data pointed to by pixel into a uint32_t
    * with format 0xAARRGGBB (the way 9-patch expects it).
    */
-  static uint32_t packRGBA(const uint8_t* pixel);
+  static uint32_t PackRGBA(const uint8_t* pixel);
 
   /**
    * 9-patch content padding/insets. All positions are relative to the 9-patch
@@ -136,7 +137,7 @@ class NinePatch {
    * See
    * https://developer.android.com/about/versions/android-4.3.html#OpticalBounds
    */
-  Bounds layoutBounds;
+  Bounds layout_bounds;
 
   /**
    * Outline of the image, calculated based on opacity.
@@ -147,51 +148,51 @@ class NinePatch {
    * The computed radius of the outline. If non-zero, the outline is a
    * rounded-rect.
    */
-  float outlineRadius = 0.0f;
+  float outline_radius = 0.0f;
 
   /**
    * The largest alpha value within the outline.
    */
-  uint32_t outlineAlpha = 0x000000ffu;
+  uint32_t outline_alpha = 0x000000ffu;
 
   /**
    * Horizontal regions of the image that are stretchable.
    * All positions are relative to the 9-patch
    * NOT including the 1px thick source border.
    */
-  std::vector<Range> horizontalStretchRegions;
+  std::vector<Range> horizontal_stretch_regions;
 
   /**
    * Vertical regions of the image that are stretchable.
    * All positions are relative to the 9-patch
    * NOT including the 1px thick source border.
    */
-  std::vector<Range> verticalStretchRegions;
+  std::vector<Range> vertical_stretch_regions;
 
   /**
    * The colors within each region, fixed or stretchable.
    * For w*h regions, the color of region (x,y) is addressable
    * via index y*w + x.
    */
-  std::vector<uint32_t> regionColors;
+  std::vector<uint32_t> region_colors;
 
   /**
    * Returns serialized data containing the original basic 9-patch meta data.
    * Optical layout bounds and round rect outline data must be serialized
-   * separately using serializeOpticalLayoutBounds() and
-   * serializeRoundedRectOutline().
+   * separately using SerializeOpticalLayoutBounds() and
+   * SerializeRoundedRectOutline().
    */
-  std::unique_ptr<uint8_t[]> serializeBase(size_t* outLen) const;
+  std::unique_ptr<uint8_t[]> SerializeBase(size_t* out_len) const;
 
   /**
    * Serializes the layout bounds.
    */
-  std::unique_ptr<uint8_t[]> serializeLayoutBounds(size_t* outLen) const;
+  std::unique_ptr<uint8_t[]> SerializeLayoutBounds(size_t* out_len) const;
 
   /**
    * Serializes the rounded-rect outline.
    */
-  std::unique_ptr<uint8_t[]> serializeRoundedRectOutline(size_t* outLen) const;
+  std::unique_ptr<uint8_t[]> SerializeRoundedRectOutline(size_t* out_len) const;
 
  private:
   explicit NinePatch() = default;
@@ -201,7 +202,7 @@ class NinePatch {
 
 ::std::ostream& operator<<(::std::ostream& out, const Range& range);
 ::std::ostream& operator<<(::std::ostream& out, const Bounds& bounds);
-::std::ostream& operator<<(::std::ostream& out, const NinePatch& ninePatch);
+::std::ostream& operator<<(::std::ostream& out, const NinePatch& nine_patch);
 
 }  // namespace aapt
 
diff --git a/tools/aapt2/compile/InlineXmlFormatParser.cpp b/tools/aapt2/compile/InlineXmlFormatParser.cpp
index 56f72b54ab7ea..786494b6ad1c3 100644
--- a/tools/aapt2/compile/InlineXmlFormatParser.cpp
+++ b/tools/aapt2/compile/InlineXmlFormatParser.cpp
@@ -15,16 +15,18 @@
  */
 
 #include "compile/InlineXmlFormatParser.h"
+
+#include <sstream>
+#include <string>
+
+#include "android-base/macros.h"
+
 #include "Debug.h"
 #include "ResourceUtils.h"
 #include "util/Util.h"
 #include "xml/XmlDom.h"
 #include "xml/XmlUtil.h"
 
-#include <android-base/macros.h>
-#include <sstream>
-#include <string>
-
 namespace aapt {
 
 namespace {
@@ -34,38 +36,38 @@ namespace {
  */
 class Visitor : public xml::PackageAwareVisitor {
  public:
-  using xml::PackageAwareVisitor::visit;
+  using xml::PackageAwareVisitor::Visit;
 
   struct InlineDeclaration {
     xml::Element* el;
-    std::string attrNamespaceUri;
-    std::string attrName;
+    std::string attr_namespace_uri;
+    std::string attr_name;
   };
 
-  explicit Visitor(IAaptContext* context, xml::XmlResource* xmlResource)
-      : mContext(context), mXmlResource(xmlResource) {}
+  explicit Visitor(IAaptContext* context, xml::XmlResource* xml_resource)
+      : context_(context), xml_resource_(xml_resource) {}
 
-  void visit(xml::Element* el) override {
-    if (el->namespaceUri != xml::kSchemaAapt || el->name != "attr") {
-      xml::PackageAwareVisitor::visit(el);
+  void Visit(xml::Element* el) override {
+    if (el->namespace_uri != xml::kSchemaAapt || el->name != "attr") {
+      xml::PackageAwareVisitor::Visit(el);
       return;
     }
 
-    const Source& src = mXmlResource->file.source.withLine(el->lineNumber);
+    const Source& src = xml_resource_->file.source.WithLine(el->line_number);
 
-    xml::Attribute* attr = el->findAttribute({}, "name");
+    xml::Attribute* attr = el->FindAttribute({}, "name");
     if (!attr) {
-      mContext->getDiagnostics()->error(DiagMessage(src)
+      context_->GetDiagnostics()->Error(DiagMessage(src)
                                         << "missing 'name' attribute");
-      mError = true;
+      error_ = true;
       return;
     }
 
-    Maybe<Reference> ref = ResourceUtils::parseXmlAttributeName(attr->value);
+    Maybe<Reference> ref = ResourceUtils::ParseXmlAttributeName(attr->value);
     if (!ref) {
-      mContext->getDiagnostics()->error(
+      context_->GetDiagnostics()->Error(
           DiagMessage(src) << "invalid XML attribute '" << attr->value << "'");
-      mError = true;
+      error_ = true;
       return;
     }
 
@@ -76,63 +78,63 @@ class Visitor : public xml::PackageAwareVisitor {
     // the local package if the user specified name="style" or something. This
     // should just
     // be the default namespace.
-    Maybe<xml::ExtractedPackage> maybePkg =
-        transformPackageAlias(name.package, {});
-    if (!maybePkg) {
-      mContext->getDiagnostics()->error(DiagMessage(src)
+    Maybe<xml::ExtractedPackage> maybe_pkg =
+        TransformPackageAlias(name.package, {});
+    if (!maybe_pkg) {
+      context_->GetDiagnostics()->Error(DiagMessage(src)
                                         << "invalid namespace prefix '"
                                         << name.package << "'");
-      mError = true;
+      error_ = true;
       return;
     }
 
-    const xml::ExtractedPackage& pkg = maybePkg.value();
-    const bool privateNamespace =
-        pkg.privateNamespace || ref.value().privateReference;
+    const xml::ExtractedPackage& pkg = maybe_pkg.value();
+    const bool private_namespace =
+        pkg.private_namespace || ref.value().private_reference;
 
     InlineDeclaration decl;
     decl.el = el;
-    decl.attrName = name.entry;
+    decl.attr_name = name.entry;
     if (!pkg.package.empty()) {
-      decl.attrNamespaceUri =
-          xml::buildPackageNamespace(pkg.package, privateNamespace);
+      decl.attr_namespace_uri =
+          xml::BuildPackageNamespace(pkg.package, private_namespace);
     }
 
-    mInlineDeclarations.push_back(std::move(decl));
+    inline_declarations_.push_back(std::move(decl));
   }
 
-  const std::vector<InlineDeclaration>& getInlineDeclarations() const {
-    return mInlineDeclarations;
+  const std::vector<InlineDeclaration>& GetInlineDeclarations() const {
+    return inline_declarations_;
   }
 
-  bool hasError() const { return mError; }
+  bool HasError() const { return error_; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Visitor);
 
-  IAaptContext* mContext;
-  xml::XmlResource* mXmlResource;
-  std::vector<InlineDeclaration> mInlineDeclarations;
-  bool mError = false;
+  IAaptContext* context_;
+  xml::XmlResource* xml_resource_;
+  std::vector<InlineDeclaration> inline_declarations_;
+  bool error_ = false;
 };
 
 }  // namespace
 
-bool InlineXmlFormatParser::consume(IAaptContext* context,
+bool InlineXmlFormatParser::Consume(IAaptContext* context,
                                     xml::XmlResource* doc) {
   Visitor visitor(context, doc);
-  doc->root->accept(&visitor);
-  if (visitor.hasError()) {
+  doc->root->Accept(&visitor);
+  if (visitor.HasError()) {
     return false;
   }
 
-  size_t nameSuffixCounter = 0;
+  size_t name_suffix_counter = 0;
   for (const Visitor::InlineDeclaration& decl :
-       visitor.getInlineDeclarations()) {
-    auto newDoc = util::make_unique<xml::XmlResource>();
-    newDoc->file.config = doc->file.config;
-    newDoc->file.source = doc->file.source.withLine(decl.el->lineNumber);
-    newDoc->file.name = doc->file.name;
+       visitor.GetInlineDeclarations()) {
+    auto new_doc = util::make_unique<xml::XmlResource>();
+    new_doc->file.config = doc->file.config;
+    new_doc->file.source = doc->file.source.WithLine(decl.el->line_number);
+    new_doc->file.name = doc->file.name;
 
     // Modify the new entry name. We need to suffix the entry with a number to
     // avoid
@@ -140,63 +142,64 @@ bool InlineXmlFormatParser::consume(IAaptContext* context,
     // won't show up
     // in R.java.
 
-    newDoc->file.name.entry = NameMangler::mangleEntry(
-        {}, newDoc->file.name.entry + "__" + std::to_string(nameSuffixCounter));
+    new_doc->file.name.entry =
+        NameMangler::MangleEntry({}, new_doc->file.name.entry + "__" +
+                                         std::to_string(name_suffix_counter));
 
     // Extracted elements must be the only child of <aapt:attr>.
     // Make sure there is one root node in the children (ignore empty text).
     for (auto& child : decl.el->children) {
-      const Source childSource = doc->file.source.withLine(child->lineNumber);
-      if (xml::Text* t = xml::nodeCast<xml::Text>(child.get())) {
-        if (!util::trimWhitespace(t->text).empty()) {
-          context->getDiagnostics()->error(
-              DiagMessage(childSource)
+      const Source child_source = doc->file.source.WithLine(child->line_number);
+      if (xml::Text* t = xml::NodeCast<xml::Text>(child.get())) {
+        if (!util::TrimWhitespace(t->text).empty()) {
+          context->GetDiagnostics()->Error(
+              DiagMessage(child_source)
               << "can't extract text into its own resource");
           return false;
         }
-      } else if (newDoc->root) {
-        context->getDiagnostics()->error(
-            DiagMessage(childSource)
+      } else if (new_doc->root) {
+        context->GetDiagnostics()->Error(
+            DiagMessage(child_source)
             << "inline XML resources must have a single root");
         return false;
       } else {
-        newDoc->root = std::move(child);
-        newDoc->root->parent = nullptr;
+        new_doc->root = std::move(child);
+        new_doc->root->parent = nullptr;
       }
     }
 
     // Walk up and find the parent element.
     xml::Node* node = decl.el;
-    xml::Element* parentEl = nullptr;
+    xml::Element* parent_el = nullptr;
     while (node->parent &&
-           (parentEl = xml::nodeCast<xml::Element>(node->parent)) == nullptr) {
+           (parent_el = xml::NodeCast<xml::Element>(node->parent)) == nullptr) {
       node = node->parent;
     }
 
-    if (!parentEl) {
-      context->getDiagnostics()->error(
-          DiagMessage(newDoc->file.source)
+    if (!parent_el) {
+      context->GetDiagnostics()->Error(
+          DiagMessage(new_doc->file.source)
           << "no suitable parent for inheriting attribute");
       return false;
     }
 
     // Add the inline attribute to the parent.
-    parentEl->attributes.push_back(
-        xml::Attribute{decl.attrNamespaceUri, decl.attrName,
-                       "@" + newDoc->file.name.toString()});
+    parent_el->attributes.push_back(
+        xml::Attribute{decl.attr_namespace_uri, decl.attr_name,
+                       "@" + new_doc->file.name.ToString()});
 
     // Delete the subtree.
-    for (auto iter = parentEl->children.begin();
-         iter != parentEl->children.end(); ++iter) {
+    for (auto iter = parent_el->children.begin();
+         iter != parent_el->children.end(); ++iter) {
       if (iter->get() == node) {
-        parentEl->children.erase(iter);
+        parent_el->children.erase(iter);
         break;
       }
     }
 
-    mQueue.push_back(std::move(newDoc));
+    queue_.push_back(std::move(new_doc));
 
-    nameSuffixCounter++;
+    name_suffix_counter++;
   }
   return true;
 }
diff --git a/tools/aapt2/compile/InlineXmlFormatParser.h b/tools/aapt2/compile/InlineXmlFormatParser.h
index cd8794ba9cc38..1a658fd6a1808 100644
--- a/tools/aapt2/compile/InlineXmlFormatParser.h
+++ b/tools/aapt2/compile/InlineXmlFormatParser.h
@@ -17,12 +17,13 @@
 #ifndef AAPT_COMPILE_INLINEXMLFORMATPARSER_H
 #define AAPT_COMPILE_INLINEXMLFORMATPARSER_H
 
-#include "process/IResourceTableConsumer.h"
-
-#include <android-base/macros.h>
 #include <memory>
 #include <vector>
 
+#include "android-base/macros.h"
+
+#include "process/IResourceTableConsumer.h"
+
 namespace aapt {
 
 /**
@@ -50,17 +51,17 @@ class InlineXmlFormatParser : public IXmlResourceConsumer {
  public:
   explicit InlineXmlFormatParser() = default;
 
-  bool consume(IAaptContext* context, xml::XmlResource* doc) override;
+  bool Consume(IAaptContext* context, xml::XmlResource* doc) override;
 
   std::vector<std::unique_ptr<xml::XmlResource>>&
-  getExtractedInlineXmlDocuments() {
-    return mQueue;
+  GetExtractedInlineXmlDocuments() {
+    return queue_;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(InlineXmlFormatParser);
 
-  std::vector<std::unique_ptr<xml::XmlResource>> mQueue;
+  std::vector<std::unique_ptr<xml::XmlResource>> queue_;
 };
 
 }  // namespace aapt
diff --git a/tools/aapt2/compile/InlineXmlFormatParser_test.cpp b/tools/aapt2/compile/InlineXmlFormatParser_test.cpp
index 4adb21cf98305..348796c98c227 100644
--- a/tools/aapt2/compile/InlineXmlFormatParser_test.cpp
+++ b/tools/aapt2/compile/InlineXmlFormatParser_test.cpp
@@ -15,13 +15,14 @@
  */
 
 #include "compile/InlineXmlFormatParser.h"
+
 #include "test/Test.h"
 
 namespace aapt {
 
 TEST(InlineXmlFormatParserTest, PassThrough) {
-  std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
-  std::unique_ptr<xml::XmlResource> doc = test::buildXmlDom(R"EOF(
+  std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
+  std::unique_ptr<xml::XmlResource> doc = test::BuildXmlDom(R"EOF(
       <View xmlns:android="http://schemas.android.com/apk/res/android">
         <View android:text="hey">
           <View android:id="hi" />
@@ -29,13 +30,13 @@ TEST(InlineXmlFormatParserTest, PassThrough) {
       </View>)EOF");
 
   InlineXmlFormatParser parser;
-  ASSERT_TRUE(parser.consume(context.get(), doc.get()));
-  EXPECT_EQ(0u, parser.getExtractedInlineXmlDocuments().size());
+  ASSERT_TRUE(parser.Consume(context.get(), doc.get()));
+  EXPECT_EQ(0u, parser.GetExtractedInlineXmlDocuments().size());
 }
 
 TEST(InlineXmlFormatParserTest, ExtractOneXmlResource) {
-  std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
-  std::unique_ptr<xml::XmlResource> doc = test::buildXmlDom(R"EOF(
+  std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
+  std::unique_ptr<xml::XmlResource> doc = test::BuildXmlDom(R"EOF(
       <View1 xmlns:android="http://schemas.android.com/apk/res/android"
             xmlns:aapt="http://schemas.android.com/aapt">
         <aapt:attr name="android:text">
@@ -45,48 +46,48 @@ TEST(InlineXmlFormatParserTest, ExtractOneXmlResource) {
         </aapt:attr>
       </View1>)EOF");
 
-  doc->file.name = test::parseNameOrDie("layout/main");
+  doc->file.name = test::ParseNameOrDie("layout/main");
 
   InlineXmlFormatParser parser;
-  ASSERT_TRUE(parser.consume(context.get(), doc.get()));
+  ASSERT_TRUE(parser.Consume(context.get(), doc.get()));
 
   // One XML resource should have been extracted.
-  EXPECT_EQ(1u, parser.getExtractedInlineXmlDocuments().size());
+  EXPECT_EQ(1u, parser.GetExtractedInlineXmlDocuments().size());
 
-  xml::Element* el = xml::findRootElement(doc.get());
+  xml::Element* el = xml::FindRootElement(doc.get());
   ASSERT_NE(nullptr, el);
 
   EXPECT_EQ("View1", el->name);
 
   // The <aapt:attr> tag should be extracted.
-  EXPECT_EQ(nullptr, el->findChild(xml::kSchemaAapt, "attr"));
+  EXPECT_EQ(nullptr, el->FindChild(xml::kSchemaAapt, "attr"));
 
   // The 'android:text' attribute should be set with a reference.
-  xml::Attribute* attr = el->findAttribute(xml::kSchemaAndroid, "text");
+  xml::Attribute* attr = el->FindAttribute(xml::kSchemaAndroid, "text");
   ASSERT_NE(nullptr, attr);
 
-  ResourceNameRef nameRef;
-  ASSERT_TRUE(ResourceUtils::parseReference(attr->value, &nameRef));
+  ResourceNameRef name_ref;
+  ASSERT_TRUE(ResourceUtils::ParseReference(attr->value, &name_ref));
 
-  xml::XmlResource* extractedDoc =
-      parser.getExtractedInlineXmlDocuments()[0].get();
-  ASSERT_NE(nullptr, extractedDoc);
+  xml::XmlResource* extracted_doc =
+      parser.GetExtractedInlineXmlDocuments()[0].get();
+  ASSERT_NE(nullptr, extracted_doc);
 
   // Make sure the generated reference is correct.
-  EXPECT_EQ(nameRef.package, extractedDoc->file.name.package);
-  EXPECT_EQ(nameRef.type, extractedDoc->file.name.type);
-  EXPECT_EQ(nameRef.entry, extractedDoc->file.name.entry);
+  EXPECT_EQ(name_ref.package, extracted_doc->file.name.package);
+  EXPECT_EQ(name_ref.type, extracted_doc->file.name.type);
+  EXPECT_EQ(name_ref.entry, extracted_doc->file.name.entry);
 
   // Verify the structure of the extracted XML.
-  el = xml::findRootElement(extractedDoc);
+  el = xml::FindRootElement(extracted_doc);
   ASSERT_NE(nullptr, el);
   EXPECT_EQ("View2", el->name);
-  EXPECT_NE(nullptr, el->findChild({}, "View3"));
+  EXPECT_NE(nullptr, el->FindChild({}, "View3"));
 }
 
 TEST(InlineXmlFormatParserTest, ExtractTwoXmlResources) {
-  std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
-  std::unique_ptr<xml::XmlResource> doc = test::buildXmlDom(R"EOF(
+  std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
+  std::unique_ptr<xml::XmlResource> doc = test::BuildXmlDom(R"EOF(
       <View1 xmlns:android="http://schemas.android.com/apk/res/android"
             xmlns:aapt="http://schemas.android.com/aapt">
         <aapt:attr name="android:text">
@@ -100,41 +101,41 @@ TEST(InlineXmlFormatParserTest, ExtractTwoXmlResources) {
         </aapt:attr>
       </View1>)EOF");
 
-  doc->file.name = test::parseNameOrDie("layout/main");
+  doc->file.name = test::ParseNameOrDie("layout/main");
 
   InlineXmlFormatParser parser;
-  ASSERT_TRUE(parser.consume(context.get(), doc.get()));
-  ASSERT_EQ(2u, parser.getExtractedInlineXmlDocuments().size());
+  ASSERT_TRUE(parser.Consume(context.get(), doc.get()));
+  ASSERT_EQ(2u, parser.GetExtractedInlineXmlDocuments().size());
 
-  xml::Element* el = xml::findRootElement(doc.get());
+  xml::Element* el = xml::FindRootElement(doc.get());
   ASSERT_NE(nullptr, el);
 
   EXPECT_EQ("View1", el->name);
 
-  xml::Attribute* attrText = el->findAttribute(xml::kSchemaAndroid, "text");
-  ASSERT_NE(nullptr, attrText);
+  xml::Attribute* attr_text = el->FindAttribute(xml::kSchemaAndroid, "text");
+  ASSERT_NE(nullptr, attr_text);
 
-  xml::Attribute* attrDrawable =
-      el->findAttribute(xml::kSchemaAndroid, "drawable");
-  ASSERT_NE(nullptr, attrDrawable);
+  xml::Attribute* attr_drawable =
+      el->FindAttribute(xml::kSchemaAndroid, "drawable");
+  ASSERT_NE(nullptr, attr_drawable);
 
   // The two extracted resources should have different names.
-  EXPECT_NE(attrText->value, attrDrawable->value);
+  EXPECT_NE(attr_text->value, attr_drawable->value);
 
   // The child <aapt:attr> elements should be gone.
-  EXPECT_EQ(nullptr, el->findChild(xml::kSchemaAapt, "attr"));
+  EXPECT_EQ(nullptr, el->FindChild(xml::kSchemaAapt, "attr"));
 
-  xml::XmlResource* extractedDocText =
-      parser.getExtractedInlineXmlDocuments()[0].get();
-  ASSERT_NE(nullptr, extractedDocText);
-  el = xml::findRootElement(extractedDocText);
+  xml::XmlResource* extracted_doc_text =
+      parser.GetExtractedInlineXmlDocuments()[0].get();
+  ASSERT_NE(nullptr, extracted_doc_text);
+  el = xml::FindRootElement(extracted_doc_text);
   ASSERT_NE(nullptr, el);
   EXPECT_EQ("View2", el->name);
 
-  xml::XmlResource* extractedDocDrawable =
-      parser.getExtractedInlineXmlDocuments()[1].get();
-  ASSERT_NE(nullptr, extractedDocDrawable);
-  el = xml::findRootElement(extractedDocDrawable);
+  xml::XmlResource* extracted_doc_drawable =
+      parser.GetExtractedInlineXmlDocuments()[1].get();
+  ASSERT_NE(nullptr, extracted_doc_drawable);
+  el = xml::FindRootElement(extracted_doc_drawable);
   ASSERT_NE(nullptr, el);
   EXPECT_EQ("vector", el->name);
 }
diff --git a/tools/aapt2/compile/NinePatch.cpp b/tools/aapt2/compile/NinePatch.cpp
index 8842eb70f3a09..eab5c97c437cf 100644
--- a/tools/aapt2/compile/NinePatch.cpp
+++ b/tools/aapt2/compile/NinePatch.cpp
@@ -15,14 +15,16 @@
  */
 
 #include "compile/Image.h"
-#include "util/StringPiece.h"
-#include "util/Util.h"
 
-#include <androidfw/ResourceTypes.h>
 #include <sstream>
 #include <string>
 #include <vector>
 
+#include "androidfw/ResourceTypes.h"
+
+#include "util/StringPiece.h"
+#include "util/Util.h"
+
 namespace aapt {
 
 // Colors in the format 0xAARRGGBB (the way 9-patch expects it).
@@ -36,7 +38,7 @@ constexpr static const uint32_t kSecondaryColor = kColorOpaqueRed;
 /**
  * Returns the alpha value encoded in the 0xAARRGBB encoded pixel.
  */
-static uint32_t getAlpha(uint32_t color);
+static uint32_t get_alpha(uint32_t color);
 
 /**
  * Determines whether a color on an ImageLine is valid.
@@ -53,19 +55,19 @@ class ColorValidator {
    * Returns true if the color specified is a neutral color
    * (no padding, stretching, or optical bounds).
    */
-  virtual bool isNeutralColor(uint32_t color) const = 0;
+  virtual bool IsNeutralColor(uint32_t color) const = 0;
 
   /**
    * Returns true if the color is either a neutral color
    * or one denoting padding, stretching, or optical bounds.
    */
-  bool isValidColor(uint32_t color) const {
+  bool IsValidColor(uint32_t color) const {
     switch (color) {
       case kPrimaryColor:
       case kSecondaryColor:
         return true;
     }
-    return isNeutralColor(color);
+    return IsNeutralColor(color);
   }
 };
 
@@ -81,42 +83,43 @@ class ColorValidator {
 //
 // class ImageLine {
 // public:
-//      virtual int32_t getLength() const = 0;
-//      virtual uint32_t getColor(int32_t idx) const = 0;
+//      virtual int32_t GetLength() const = 0;
+//      virtual uint32_t GetColor(int32_t idx) const = 0;
 // };
 //
 template <typename ImageLine>
-static bool fillRanges(const ImageLine* imageLine,
-                       const ColorValidator* colorValidator,
-                       std::vector<Range>* primaryRanges,
-                       std::vector<Range>* secondaryRanges, std::string* err) {
-  const int32_t length = imageLine->getLength();
+static bool FillRanges(const ImageLine* image_line,
+                       const ColorValidator* color_validator,
+                       std::vector<Range>* primary_ranges,
+                       std::vector<Range>* secondary_ranges,
+                       std::string* out_err) {
+  const int32_t length = image_line->GetLength();
 
-  uint32_t lastColor = 0xffffffffu;
+  uint32_t last_color = 0xffffffffu;
   for (int32_t idx = 1; idx < length - 1; idx++) {
-    const uint32_t color = imageLine->getColor(idx);
-    if (!colorValidator->isValidColor(color)) {
-      *err = "found an invalid color";
+    const uint32_t color = image_line->GetColor(idx);
+    if (!color_validator->IsValidColor(color)) {
+      *out_err = "found an invalid color";
       return false;
     }
 
-    if (color != lastColor) {
+    if (color != last_color) {
       // We are ending a range. Which range?
       // note: encode the x offset without the final 1 pixel border.
-      if (lastColor == kPrimaryColor) {
-        primaryRanges->back().end = idx - 1;
-      } else if (lastColor == kSecondaryColor) {
-        secondaryRanges->back().end = idx - 1;
+      if (last_color == kPrimaryColor) {
+        primary_ranges->back().end = idx - 1;
+      } else if (last_color == kSecondaryColor) {
+        secondary_ranges->back().end = idx - 1;
       }
 
       // We are starting a range. Which range?
       // note: encode the x offset without the final 1 pixel border.
       if (color == kPrimaryColor) {
-        primaryRanges->push_back(Range(idx - 1, length - 2));
+        primary_ranges->push_back(Range(idx - 1, length - 2));
       } else if (color == kSecondaryColor) {
-        secondaryRanges->push_back(Range(idx - 1, length - 2));
+        secondary_ranges->push_back(Range(idx - 1, length - 2));
       }
-      lastColor = color;
+      last_color = color;
     }
   }
   return true;
@@ -128,19 +131,19 @@ static bool fillRanges(const ImageLine* imageLine,
  */
 class HorizontalImageLine {
  public:
-  explicit HorizontalImageLine(uint8_t** rows, int32_t xOffset, int32_t yOffset,
+  explicit HorizontalImageLine(uint8_t** rows, int32_t xoffset, int32_t yoffset,
                                int32_t length)
-      : mRows(rows), mXOffset(xOffset), mYOffset(yOffset), mLength(length) {}
+      : rows_(rows), xoffset_(xoffset), yoffset_(yoffset), length_(length) {}
 
-  inline int32_t getLength() const { return mLength; }
+  inline int32_t GetLength() const { return length_; }
 
-  inline uint32_t getColor(int32_t idx) const {
-    return NinePatch::packRGBA(mRows[mYOffset] + (idx + mXOffset) * 4);
+  inline uint32_t GetColor(int32_t idx) const {
+    return NinePatch::PackRGBA(rows_[yoffset_] + (idx + xoffset_) * 4);
   }
 
  private:
-  uint8_t** mRows;
-  int32_t mXOffset, mYOffset, mLength;
+  uint8_t** rows_;
+  int32_t xoffset_, yoffset_, length_;
 
   DISALLOW_COPY_AND_ASSIGN(HorizontalImageLine);
 };
@@ -151,179 +154,180 @@ class HorizontalImageLine {
  */
 class VerticalImageLine {
  public:
-  explicit VerticalImageLine(uint8_t** rows, int32_t xOffset, int32_t yOffset,
+  explicit VerticalImageLine(uint8_t** rows, int32_t xoffset, int32_t yoffset,
                              int32_t length)
-      : mRows(rows), mXOffset(xOffset), mYOffset(yOffset), mLength(length) {}
+      : rows_(rows), xoffset_(xoffset), yoffset_(yoffset), length_(length) {}
 
-  inline int32_t getLength() const { return mLength; }
+  inline int32_t GetLength() const { return length_; }
 
-  inline uint32_t getColor(int32_t idx) const {
-    return NinePatch::packRGBA(mRows[mYOffset + idx] + (mXOffset * 4));
+  inline uint32_t GetColor(int32_t idx) const {
+    return NinePatch::PackRGBA(rows_[yoffset_ + idx] + (xoffset_ * 4));
   }
 
  private:
-  uint8_t** mRows;
-  int32_t mXOffset, mYOffset, mLength;
+  uint8_t** rows_;
+  int32_t xoffset_, yoffset_, length_;
 
   DISALLOW_COPY_AND_ASSIGN(VerticalImageLine);
 };
 
 class DiagonalImageLine {
  public:
-  explicit DiagonalImageLine(uint8_t** rows, int32_t xOffset, int32_t yOffset,
-                             int32_t xStep, int32_t yStep, int32_t length)
-      : mRows(rows),
-        mXOffset(xOffset),
-        mYOffset(yOffset),
-        mXStep(xStep),
-        mYStep(yStep),
-        mLength(length) {}
+  explicit DiagonalImageLine(uint8_t** rows, int32_t xoffset, int32_t yoffset,
+                             int32_t xstep, int32_t ystep, int32_t length)
+      : rows_(rows),
+        xoffset_(xoffset),
+        yoffset_(yoffset),
+        xstep_(xstep),
+        ystep_(ystep),
+        length_(length) {}
 
-  inline int32_t getLength() const { return mLength; }
+  inline int32_t GetLength() const { return length_; }
 
-  inline uint32_t getColor(int32_t idx) const {
-    return NinePatch::packRGBA(mRows[mYOffset + (idx * mYStep)] +
-                               ((idx + mXOffset) * mXStep) * 4);
+  inline uint32_t GetColor(int32_t idx) const {
+    return NinePatch::PackRGBA(rows_[yoffset_ + (idx * ystep_)] +
+                               ((idx + xoffset_) * xstep_) * 4);
   }
 
  private:
-  uint8_t** mRows;
-  int32_t mXOffset, mYOffset, mXStep, mYStep, mLength;
+  uint8_t** rows_;
+  int32_t xoffset_, yoffset_, xstep_, ystep_, length_;
 
   DISALLOW_COPY_AND_ASSIGN(DiagonalImageLine);
 };
 
 class TransparentNeutralColorValidator : public ColorValidator {
  public:
-  bool isNeutralColor(uint32_t color) const override {
-    return getAlpha(color) == 0;
+  bool IsNeutralColor(uint32_t color) const override {
+    return get_alpha(color) == 0;
   }
 };
 
 class WhiteNeutralColorValidator : public ColorValidator {
  public:
-  bool isNeutralColor(uint32_t color) const override {
+  bool IsNeutralColor(uint32_t color) const override {
     return color == kColorOpaqueWhite;
   }
 };
 
-inline static uint32_t getAlpha(uint32_t color) {
+inline static uint32_t get_alpha(uint32_t color) {
   return (color & 0xff000000u) >> 24;
 }
 
-static bool populateBounds(const std::vector<Range>& padding,
-                           const std::vector<Range>& layoutBounds,
-                           const std::vector<Range>& stretchRegions,
-                           const int32_t length, int32_t* paddingStart,
-                           int32_t* paddingEnd, int32_t* layoutStart,
-                           int32_t* layoutEnd, const StringPiece& edgeName,
-                           std::string* err) {
+static bool PopulateBounds(const std::vector<Range>& padding,
+                           const std::vector<Range>& layout_bounds,
+                           const std::vector<Range>& stretch_regions,
+                           const int32_t length, int32_t* padding_start,
+                           int32_t* padding_end, int32_t* layout_start,
+                           int32_t* layout_end, const StringPiece& edge_name,
+                           std::string* out_err) {
   if (padding.size() > 1) {
-    std::stringstream errStream;
-    errStream << "too many padding sections on " << edgeName << " border";
-    *err = errStream.str();
+    std::stringstream err_stream;
+    err_stream << "too many padding sections on " << edge_name << " border";
+    *out_err = err_stream.str();
     return false;
   }
 
-  *paddingStart = 0;
-  *paddingEnd = 0;
+  *padding_start = 0;
+  *padding_end = 0;
   if (!padding.empty()) {
     const Range& range = padding.front();
-    *paddingStart = range.start;
-    *paddingEnd = length - range.end;
-  } else if (!stretchRegions.empty()) {
+    *padding_start = range.start;
+    *padding_end = length - range.end;
+  } else if (!stretch_regions.empty()) {
     // No padding was defined. Compute the padding from the first and last
     // stretch regions.
-    *paddingStart = stretchRegions.front().start;
-    *paddingEnd = length - stretchRegions.back().end;
+    *padding_start = stretch_regions.front().start;
+    *padding_end = length - stretch_regions.back().end;
   }
 
-  if (layoutBounds.size() > 2) {
-    std::stringstream errStream;
-    errStream << "too many layout bounds sections on " << edgeName << " border";
-    *err = errStream.str();
+  if (layout_bounds.size() > 2) {
+    std::stringstream err_stream;
+    err_stream << "too many layout bounds sections on " << edge_name
+               << " border";
+    *out_err = err_stream.str();
     return false;
   }
 
-  *layoutStart = 0;
-  *layoutEnd = 0;
-  if (layoutBounds.size() >= 1) {
-    const Range& range = layoutBounds.front();
+  *layout_start = 0;
+  *layout_end = 0;
+  if (layout_bounds.size() >= 1) {
+    const Range& range = layout_bounds.front();
     // If there is only one layout bound segment, it might not start at 0, but
     // then it should
     // end at length.
     if (range.start != 0 && range.end != length) {
-      std::stringstream errStream;
-      errStream << "layout bounds on " << edgeName
-                << " border must start at edge";
-      *err = errStream.str();
+      std::stringstream err_stream;
+      err_stream << "layout bounds on " << edge_name
+                 << " border must start at edge";
+      *out_err = err_stream.str();
       return false;
     }
-    *layoutStart = range.end;
+    *layout_start = range.end;
 
-    if (layoutBounds.size() >= 2) {
-      const Range& range = layoutBounds.back();
+    if (layout_bounds.size() >= 2) {
+      const Range& range = layout_bounds.back();
       if (range.end != length) {
-        std::stringstream errStream;
-        errStream << "layout bounds on " << edgeName
-                  << " border must start at edge";
-        *err = errStream.str();
+        std::stringstream err_stream;
+        err_stream << "layout bounds on " << edge_name
+                   << " border must start at edge";
+        *out_err = err_stream.str();
         return false;
       }
-      *layoutEnd = length - range.start;
+      *layout_end = length - range.start;
     }
   }
   return true;
 }
 
-static int32_t calculateSegmentCount(const std::vector<Range>& stretchRegions,
+static int32_t CalculateSegmentCount(const std::vector<Range>& stretch_regions,
                                      int32_t length) {
-  if (stretchRegions.size() == 0) {
+  if (stretch_regions.size() == 0) {
     return 0;
   }
 
-  const bool startIsFixed = stretchRegions.front().start != 0;
-  const bool endIsFixed = stretchRegions.back().end != length;
+  const bool start_is_fixed = stretch_regions.front().start != 0;
+  const bool end_is_fixed = stretch_regions.back().end != length;
   int32_t modifier = 0;
-  if (startIsFixed && endIsFixed) {
+  if (start_is_fixed && end_is_fixed) {
     modifier = 1;
-  } else if (!startIsFixed && !endIsFixed) {
+  } else if (!start_is_fixed && !end_is_fixed) {
     modifier = -1;
   }
-  return static_cast<int32_t>(stretchRegions.size()) * 2 + modifier;
+  return static_cast<int32_t>(stretch_regions.size()) * 2 + modifier;
 }
 
-static uint32_t getRegionColor(uint8_t** rows, const Bounds& region) {
+static uint32_t GetRegionColor(uint8_t** rows, const Bounds& region) {
   // Sample the first pixel to compare against.
-  const uint32_t expectedColor =
-      NinePatch::packRGBA(rows[region.top] + region.left * 4);
+  const uint32_t expected_color =
+      NinePatch::PackRGBA(rows[region.top] + region.left * 4);
   for (int32_t y = region.top; y < region.bottom; y++) {
     const uint8_t* row = rows[y];
     for (int32_t x = region.left; x < region.right; x++) {
-      const uint32_t color = NinePatch::packRGBA(row + x * 4);
-      if (getAlpha(color) == 0) {
+      const uint32_t color = NinePatch::PackRGBA(row + x * 4);
+      if (get_alpha(color) == 0) {
         // The color is transparent.
         // If the expectedColor is not transparent, NO_COLOR.
-        if (getAlpha(expectedColor) != 0) {
+        if (get_alpha(expected_color) != 0) {
           return android::Res_png_9patch::NO_COLOR;
         }
-      } else if (color != expectedColor) {
+      } else if (color != expected_color) {
         return android::Res_png_9patch::NO_COLOR;
       }
     }
   }
 
-  if (getAlpha(expectedColor) == 0) {
+  if (get_alpha(expected_color) == 0) {
     return android::Res_png_9patch::TRANSPARENT_COLOR;
   }
-  return expectedColor;
+  return expected_color;
 }
 
-// Fills outColors with each 9-patch section's colour. If the whole section is
+// Fills out_colors with each 9-patch section's color. If the whole section is
 // transparent,
-// it gets the special TRANSPARENT colour. If the whole section is the same
-// colour, it is assigned
-// that colour. Otherwise it gets the special NO_COLOR colour.
+// it gets the special TRANSPARENT color. If the whole section is the same
+// color, it is assigned
+// that color. Otherwise it gets the special NO_COLOR color.
 //
 // Note that the rows contain the 9-patch 1px border, and the indices in the
 // stretch regions are
@@ -332,63 +336,63 @@ static uint32_t getRegionColor(uint8_t** rows, const Bounds& region) {
 // the indices must be offset by 1.
 //
 // width and height also include the 9-patch 1px border.
-static void calculateRegionColors(
-    uint8_t** rows, const std::vector<Range>& horizontalStretchRegions,
-    const std::vector<Range>& verticalStretchRegions, const int32_t width,
-    const int32_t height, std::vector<uint32_t>* outColors) {
-  int32_t nextTop = 0;
+static void CalculateRegionColors(
+    uint8_t** rows, const std::vector<Range>& horizontal_stretch_regions,
+    const std::vector<Range>& vertical_stretch_regions, const int32_t width,
+    const int32_t height, std::vector<uint32_t>* out_colors) {
+  int32_t next_top = 0;
   Bounds bounds;
-  auto rowIter = verticalStretchRegions.begin();
-  while (nextTop != height) {
-    if (rowIter != verticalStretchRegions.end()) {
-      if (nextTop != rowIter->start) {
+  auto row_iter = vertical_stretch_regions.begin();
+  while (next_top != height) {
+    if (row_iter != vertical_stretch_regions.end()) {
+      if (next_top != row_iter->start) {
         // This is a fixed segment.
         // Offset the bounds by 1 to accommodate the border.
-        bounds.top = nextTop + 1;
-        bounds.bottom = rowIter->start + 1;
-        nextTop = rowIter->start;
+        bounds.top = next_top + 1;
+        bounds.bottom = row_iter->start + 1;
+        next_top = row_iter->start;
       } else {
         // This is a stretchy segment.
         // Offset the bounds by 1 to accommodate the border.
-        bounds.top = rowIter->start + 1;
-        bounds.bottom = rowIter->end + 1;
-        nextTop = rowIter->end;
-        ++rowIter;
+        bounds.top = row_iter->start + 1;
+        bounds.bottom = row_iter->end + 1;
+        next_top = row_iter->end;
+        ++row_iter;
       }
     } else {
       // This is the end, fixed section.
       // Offset the bounds by 1 to accommodate the border.
-      bounds.top = nextTop + 1;
+      bounds.top = next_top + 1;
       bounds.bottom = height + 1;
-      nextTop = height;
+      next_top = height;
     }
 
-    int32_t nextLeft = 0;
-    auto colIter = horizontalStretchRegions.begin();
-    while (nextLeft != width) {
-      if (colIter != horizontalStretchRegions.end()) {
-        if (nextLeft != colIter->start) {
+    int32_t next_left = 0;
+    auto col_iter = horizontal_stretch_regions.begin();
+    while (next_left != width) {
+      if (col_iter != horizontal_stretch_regions.end()) {
+        if (next_left != col_iter->start) {
           // This is a fixed segment.
           // Offset the bounds by 1 to accommodate the border.
-          bounds.left = nextLeft + 1;
-          bounds.right = colIter->start + 1;
-          nextLeft = colIter->start;
+          bounds.left = next_left + 1;
+          bounds.right = col_iter->start + 1;
+          next_left = col_iter->start;
         } else {
           // This is a stretchy segment.
           // Offset the bounds by 1 to accommodate the border.
-          bounds.left = colIter->start + 1;
-          bounds.right = colIter->end + 1;
-          nextLeft = colIter->end;
-          ++colIter;
+          bounds.left = col_iter->start + 1;
+          bounds.right = col_iter->end + 1;
+          next_left = col_iter->end;
+          ++col_iter;
         }
       } else {
         // This is the end, fixed section.
         // Offset the bounds by 1 to accommodate the border.
-        bounds.left = nextLeft + 1;
+        bounds.left = next_left + 1;
         bounds.right = width + 1;
-        nextLeft = width;
+        next_left = width;
       }
-      outColors->push_back(getRegionColor(rows, bounds));
+      out_colors->push_back(GetRegionColor(rows, bounds));
     }
   }
 }
@@ -397,12 +401,12 @@ static void calculateRegionColors(
 // alpha value begins
 // (on both sides).
 template <typename ImageLine>
-static void findOutlineInsets(const ImageLine* imageLine, int32_t* outStart,
-                              int32_t* outEnd) {
-  *outStart = 0;
-  *outEnd = 0;
+static void FindOutlineInsets(const ImageLine* image_line, int32_t* out_start,
+                              int32_t* out_end) {
+  *out_start = 0;
+  *out_end = 0;
 
-  const int32_t length = imageLine->getLength();
+  const int32_t length = image_line->GetLength();
   if (length < 3) {
     return;
   }
@@ -413,179 +417,181 @@ static void findOutlineInsets(const ImageLine* imageLine, int32_t* outStart,
   const int32_t mid2 = length / 2;
   const int32_t mid1 = mid2 + (length % 2);
 
-  uint32_t maxAlpha = 0;
-  for (int32_t i = 0; i < mid1 && maxAlpha != 0xff; i++) {
-    uint32_t alpha = getAlpha(imageLine->getColor(i));
-    if (alpha > maxAlpha) {
-      maxAlpha = alpha;
-      *outStart = i;
+  uint32_t max_alpha = 0;
+  for (int32_t i = 0; i < mid1 && max_alpha != 0xff; i++) {
+    uint32_t alpha = get_alpha(image_line->GetColor(i));
+    if (alpha > max_alpha) {
+      max_alpha = alpha;
+      *out_start = i;
     }
   }
 
-  maxAlpha = 0;
-  for (int32_t i = length - 1; i >= mid2 && maxAlpha != 0xff; i--) {
-    uint32_t alpha = getAlpha(imageLine->getColor(i));
-    if (alpha > maxAlpha) {
-      maxAlpha = alpha;
-      *outEnd = length - (i + 1);
+  max_alpha = 0;
+  for (int32_t i = length - 1; i >= mid2 && max_alpha != 0xff; i--) {
+    uint32_t alpha = get_alpha(image_line->GetColor(i));
+    if (alpha > max_alpha) {
+      max_alpha = alpha;
+      *out_end = length - (i + 1);
     }
   }
   return;
 }
 
 template <typename ImageLine>
-static uint32_t findMaxAlpha(const ImageLine* imageLine) {
-  const int32_t length = imageLine->getLength();
-  uint32_t maxAlpha = 0;
-  for (int32_t idx = 0; idx < length && maxAlpha != 0xff; idx++) {
-    uint32_t alpha = getAlpha(imageLine->getColor(idx));
-    if (alpha > maxAlpha) {
-      maxAlpha = alpha;
+static uint32_t FindMaxAlpha(const ImageLine* image_line) {
+  const int32_t length = image_line->GetLength();
+  uint32_t max_alpha = 0;
+  for (int32_t idx = 0; idx < length && max_alpha != 0xff; idx++) {
+    uint32_t alpha = get_alpha(image_line->GetColor(idx));
+    if (alpha > max_alpha) {
+      max_alpha = alpha;
     }
   }
-  return maxAlpha;
+  return max_alpha;
 }
 
 // Pack the pixels in as 0xAARRGGBB (as 9-patch expects it).
-uint32_t NinePatch::packRGBA(const uint8_t* pixel) {
+uint32_t NinePatch::PackRGBA(const uint8_t* pixel) {
   return (pixel[3] << 24) | (pixel[0] << 16) | (pixel[1] << 8) | pixel[2];
 }
 
-std::unique_ptr<NinePatch> NinePatch::create(uint8_t** rows,
+std::unique_ptr<NinePatch> NinePatch::Create(uint8_t** rows,
                                              const int32_t width,
                                              const int32_t height,
-                                             std::string* err) {
+                                             std::string* out_err) {
   if (width < 3 || height < 3) {
-    *err = "image must be at least 3x3 (1x1 image with 1 pixel border)";
+    *out_err = "image must be at least 3x3 (1x1 image with 1 pixel border)";
     return {};
   }
 
-  std::vector<Range> horizontalPadding;
-  std::vector<Range> horizontalOpticalBounds;
-  std::vector<Range> verticalPadding;
-  std::vector<Range> verticalOpticalBounds;
-  std::vector<Range> unexpectedRanges;
-  std::unique_ptr<ColorValidator> colorValidator;
+  std::vector<Range> horizontal_padding;
+  std::vector<Range> horizontal_layout_bounds;
+  std::vector<Range> vertical_padding;
+  std::vector<Range> vertical_layout_bounds;
+  std::vector<Range> unexpected_ranges;
+  std::unique_ptr<ColorValidator> color_validator;
 
   if (rows[0][3] == 0) {
-    colorValidator = util::make_unique<TransparentNeutralColorValidator>();
-  } else if (packRGBA(rows[0]) == kColorOpaqueWhite) {
-    colorValidator = util::make_unique<WhiteNeutralColorValidator>();
+    color_validator = util::make_unique<TransparentNeutralColorValidator>();
+  } else if (PackRGBA(rows[0]) == kColorOpaqueWhite) {
+    color_validator = util::make_unique<WhiteNeutralColorValidator>();
   } else {
-    *err = "top-left corner pixel must be either opaque white or transparent";
+    *out_err =
+        "top-left corner pixel must be either opaque white or transparent";
     return {};
   }
 
   // Private constructor, can't use make_unique.
-  auto ninePatch = std::unique_ptr<NinePatch>(new NinePatch());
+  auto nine_patch = std::unique_ptr<NinePatch>(new NinePatch());
 
-  HorizontalImageLine topRow(rows, 0, 0, width);
-  if (!fillRanges(&topRow, colorValidator.get(),
-                  &ninePatch->horizontalStretchRegions, &unexpectedRanges,
-                  err)) {
+  HorizontalImageLine top_row(rows, 0, 0, width);
+  if (!FillRanges(&top_row, color_validator.get(),
+                  &nine_patch->horizontal_stretch_regions, &unexpected_ranges,
+                  out_err)) {
     return {};
   }
 
-  if (!unexpectedRanges.empty()) {
-    const Range& range = unexpectedRanges[0];
-    std::stringstream errStream;
-    errStream << "found unexpected optical bounds (red pixel) on top border "
-              << "at x=" << range.start + 1;
-    *err = errStream.str();
+  if (!unexpected_ranges.empty()) {
+    const Range& range = unexpected_ranges[0];
+    std::stringstream err_stream;
+    err_stream << "found unexpected optical bounds (red pixel) on top border "
+               << "at x=" << range.start + 1;
+    *out_err = err_stream.str();
     return {};
   }
 
-  VerticalImageLine leftCol(rows, 0, 0, height);
-  if (!fillRanges(&leftCol, colorValidator.get(),
-                  &ninePatch->verticalStretchRegions, &unexpectedRanges, err)) {
+  VerticalImageLine left_col(rows, 0, 0, height);
+  if (!FillRanges(&left_col, color_validator.get(),
+                  &nine_patch->vertical_stretch_regions, &unexpected_ranges,
+                  out_err)) {
     return {};
   }
 
-  if (!unexpectedRanges.empty()) {
-    const Range& range = unexpectedRanges[0];
-    std::stringstream errStream;
-    errStream << "found unexpected optical bounds (red pixel) on left border "
-              << "at y=" << range.start + 1;
+  if (!unexpected_ranges.empty()) {
+    const Range& range = unexpected_ranges[0];
+    std::stringstream err_stream;
+    err_stream << "found unexpected optical bounds (red pixel) on left border "
+               << "at y=" << range.start + 1;
     return {};
   }
 
-  HorizontalImageLine bottomRow(rows, 0, height - 1, width);
-  if (!fillRanges(&bottomRow, colorValidator.get(), &horizontalPadding,
-                  &horizontalOpticalBounds, err)) {
+  HorizontalImageLine bottom_row(rows, 0, height - 1, width);
+  if (!FillRanges(&bottom_row, color_validator.get(), &horizontal_padding,
+                  &horizontal_layout_bounds, out_err)) {
     return {};
   }
 
-  if (!populateBounds(horizontalPadding, horizontalOpticalBounds,
-                      ninePatch->horizontalStretchRegions, width - 2,
-                      &ninePatch->padding.left, &ninePatch->padding.right,
-                      &ninePatch->layoutBounds.left,
-                      &ninePatch->layoutBounds.right, "bottom", err)) {
+  if (!PopulateBounds(horizontal_padding, horizontal_layout_bounds,
+                      nine_patch->horizontal_stretch_regions, width - 2,
+                      &nine_patch->padding.left, &nine_patch->padding.right,
+                      &nine_patch->layout_bounds.left,
+                      &nine_patch->layout_bounds.right, "bottom", out_err)) {
     return {};
   }
 
-  VerticalImageLine rightCol(rows, width - 1, 0, height);
-  if (!fillRanges(&rightCol, colorValidator.get(), &verticalPadding,
-                  &verticalOpticalBounds, err)) {
+  VerticalImageLine right_col(rows, width - 1, 0, height);
+  if (!FillRanges(&right_col, color_validator.get(), &vertical_padding,
+                  &vertical_layout_bounds, out_err)) {
     return {};
   }
 
-  if (!populateBounds(verticalPadding, verticalOpticalBounds,
-                      ninePatch->verticalStretchRegions, height - 2,
-                      &ninePatch->padding.top, &ninePatch->padding.bottom,
-                      &ninePatch->layoutBounds.top,
-                      &ninePatch->layoutBounds.bottom, "right", err)) {
+  if (!PopulateBounds(vertical_padding, vertical_layout_bounds,
+                      nine_patch->vertical_stretch_regions, height - 2,
+                      &nine_patch->padding.top, &nine_patch->padding.bottom,
+                      &nine_patch->layout_bounds.top,
+                      &nine_patch->layout_bounds.bottom, "right", out_err)) {
     return {};
   }
 
   // Fill the region colors of the 9-patch.
-  const int32_t numRows =
-      calculateSegmentCount(ninePatch->horizontalStretchRegions, width - 2);
-  const int32_t numCols =
-      calculateSegmentCount(ninePatch->verticalStretchRegions, height - 2);
-  if ((int64_t)numRows * (int64_t)numCols > 0x7f) {
-    *err = "too many regions in 9-patch";
+  const int32_t num_rows =
+      CalculateSegmentCount(nine_patch->horizontal_stretch_regions, width - 2);
+  const int32_t num_cols =
+      CalculateSegmentCount(nine_patch->vertical_stretch_regions, height - 2);
+  if ((int64_t)num_rows * (int64_t)num_cols > 0x7f) {
+    *out_err = "too many regions in 9-patch";
     return {};
   }
 
-  ninePatch->regionColors.reserve(numRows * numCols);
-  calculateRegionColors(rows, ninePatch->horizontalStretchRegions,
-                        ninePatch->verticalStretchRegions, width - 2,
-                        height - 2, &ninePatch->regionColors);
+  nine_patch->region_colors.reserve(num_rows * num_cols);
+  CalculateRegionColors(rows, nine_patch->horizontal_stretch_regions,
+                        nine_patch->vertical_stretch_regions, width - 2,
+                        height - 2, &nine_patch->region_colors);
 
   // Compute the outline based on opacity.
 
   // Find left and right extent of 9-patch content on center row.
-  HorizontalImageLine midRow(rows, 1, height / 2, width - 2);
-  findOutlineInsets(&midRow, &ninePatch->outline.left,
-                    &ninePatch->outline.right);
+  HorizontalImageLine mid_row(rows, 1, height / 2, width - 2);
+  FindOutlineInsets(&mid_row, &nine_patch->outline.left,
+                    &nine_patch->outline.right);
 
   // Find top and bottom extent of 9-patch content on center column.
-  VerticalImageLine midCol(rows, width / 2, 1, height - 2);
-  findOutlineInsets(&midCol, &ninePatch->outline.top,
-                    &ninePatch->outline.bottom);
+  VerticalImageLine mid_col(rows, width / 2, 1, height - 2);
+  FindOutlineInsets(&mid_col, &nine_patch->outline.top,
+                    &nine_patch->outline.bottom);
 
-  const int32_t outlineWidth =
-      (width - 2) - ninePatch->outline.left - ninePatch->outline.right;
-  const int32_t outlineHeight =
-      (height - 2) - ninePatch->outline.top - ninePatch->outline.bottom;
+  const int32_t outline_width =
+      (width - 2) - nine_patch->outline.left - nine_patch->outline.right;
+  const int32_t outline_height =
+      (height - 2) - nine_patch->outline.top - nine_patch->outline.bottom;
 
   // Find the largest alpha value within the outline area.
-  HorizontalImageLine outlineMidRow(
-      rows, 1 + ninePatch->outline.left,
-      1 + ninePatch->outline.top + (outlineHeight / 2), outlineWidth);
-  VerticalImageLine outlineMidCol(
-      rows, 1 + ninePatch->outline.left + (outlineWidth / 2),
-      1 + ninePatch->outline.top, outlineHeight);
-  ninePatch->outlineAlpha =
-      std::max(findMaxAlpha(&outlineMidRow), findMaxAlpha(&outlineMidCol));
+  HorizontalImageLine outline_mid_row(
+      rows, 1 + nine_patch->outline.left,
+      1 + nine_patch->outline.top + (outline_height / 2), outline_width);
+  VerticalImageLine outline_mid_col(
+      rows, 1 + nine_patch->outline.left + (outline_width / 2),
+      1 + nine_patch->outline.top, outline_height);
+  nine_patch->outline_alpha =
+      std::max(FindMaxAlpha(&outline_mid_row), FindMaxAlpha(&outline_mid_col));
 
   // Assuming the image is a round rect, compute the radius by marching
   // diagonally from the top left corner towards the center.
-  DiagonalImageLine diagonal(rows, 1 + ninePatch->outline.left,
-                             1 + ninePatch->outline.top, 1, 1,
-                             std::min(outlineWidth, outlineHeight));
-  int32_t topLeft, bottomRight;
-  findOutlineInsets(&diagonal, &topLeft, &bottomRight);
+  DiagonalImageLine diagonal(rows, 1 + nine_patch->outline.left,
+                             1 + nine_patch->outline.top, 1, 1,
+                             std::min(outline_width, outline_height));
+  int32_t top_left, bottom_right;
+  FindOutlineInsets(&diagonal, &top_left, &bottom_right);
 
   /* Determine source radius based upon inset:
    *     sqrt(r^2 + r^2) = sqrt(i^2 + i^2) + r
@@ -593,15 +599,15 @@ std::unique_ptr<NinePatch> NinePatch::create(uint8_t** rows,
    *     (sqrt(2) - 1) * r = sqrt(2) * i
    *     r = sqrt(2) / (sqrt(2) - 1) * i
    */
-  ninePatch->outlineRadius = 3.4142f * topLeft;
-  return ninePatch;
+  nine_patch->outline_radius = 3.4142f * top_left;
+  return nine_patch;
 }
 
-std::unique_ptr<uint8_t[]> NinePatch::serializeBase(size_t* outLen) const {
+std::unique_ptr<uint8_t[]> NinePatch::SerializeBase(size_t* outLen) const {
   android::Res_png_9patch data;
-  data.numXDivs = static_cast<uint8_t>(horizontalStretchRegions.size()) * 2;
-  data.numYDivs = static_cast<uint8_t>(verticalStretchRegions.size()) * 2;
-  data.numColors = static_cast<uint8_t>(regionColors.size());
+  data.numXDivs = static_cast<uint8_t>(horizontal_stretch_regions.size()) * 2;
+  data.numYDivs = static_cast<uint8_t>(vertical_stretch_regions.size()) * 2;
+  data.numColors = static_cast<uint8_t>(region_colors.size());
   data.paddingLeft = padding.left;
   data.paddingRight = padding.right;
   data.paddingTop = padding.top;
@@ -609,8 +615,8 @@ std::unique_ptr<uint8_t[]> NinePatch::serializeBase(size_t* outLen) const {
 
   auto buffer = std::unique_ptr<uint8_t[]>(new uint8_t[data.serializedSize()]);
   android::Res_png_9patch::serialize(
-      data, (const int32_t*)horizontalStretchRegions.data(),
-      (const int32_t*)verticalStretchRegions.data(), regionColors.data(),
+      data, (const int32_t*)horizontal_stretch_regions.data(),
+      (const int32_t*)vertical_stretch_regions.data(), region_colors.data(),
       buffer.get());
   // Convert to file endianness.
   reinterpret_cast<android::Res_png_9patch*>(buffer.get())->deviceToFile();
@@ -619,32 +625,32 @@ std::unique_ptr<uint8_t[]> NinePatch::serializeBase(size_t* outLen) const {
   return buffer;
 }
 
-std::unique_ptr<uint8_t[]> NinePatch::serializeLayoutBounds(
-    size_t* outLen) const {
-  size_t chunkLen = sizeof(uint32_t) * 4;
-  auto buffer = std::unique_ptr<uint8_t[]>(new uint8_t[chunkLen]);
+std::unique_ptr<uint8_t[]> NinePatch::SerializeLayoutBounds(
+    size_t* out_len) const {
+  size_t chunk_len = sizeof(uint32_t) * 4;
+  auto buffer = std::unique_ptr<uint8_t[]>(new uint8_t[chunk_len]);
   uint8_t* cursor = buffer.get();
 
-  memcpy(cursor, &layoutBounds.left, sizeof(layoutBounds.left));
-  cursor += sizeof(layoutBounds.left);
+  memcpy(cursor, &layout_bounds.left, sizeof(layout_bounds.left));
+  cursor += sizeof(layout_bounds.left);
 
-  memcpy(cursor, &layoutBounds.top, sizeof(layoutBounds.top));
-  cursor += sizeof(layoutBounds.top);
+  memcpy(cursor, &layout_bounds.top, sizeof(layout_bounds.top));
+  cursor += sizeof(layout_bounds.top);
 
-  memcpy(cursor, &layoutBounds.right, sizeof(layoutBounds.right));
-  cursor += sizeof(layoutBounds.right);
+  memcpy(cursor, &layout_bounds.right, sizeof(layout_bounds.right));
+  cursor += sizeof(layout_bounds.right);
 
-  memcpy(cursor, &layoutBounds.bottom, sizeof(layoutBounds.bottom));
-  cursor += sizeof(layoutBounds.bottom);
+  memcpy(cursor, &layout_bounds.bottom, sizeof(layout_bounds.bottom));
+  cursor += sizeof(layout_bounds.bottom);
 
-  *outLen = chunkLen;
+  *out_len = chunk_len;
   return buffer;
 }
 
-std::unique_ptr<uint8_t[]> NinePatch::serializeRoundedRectOutline(
-    size_t* outLen) const {
-  size_t chunkLen = sizeof(uint32_t) * 6;
-  auto buffer = std::unique_ptr<uint8_t[]>(new uint8_t[chunkLen]);
+std::unique_ptr<uint8_t[]> NinePatch::SerializeRoundedRectOutline(
+    size_t* out_len) const {
+  size_t chunk_len = sizeof(uint32_t) * 6;
+  auto buffer = std::unique_ptr<uint8_t[]>(new uint8_t[chunk_len]);
   uint8_t* cursor = buffer.get();
 
   memcpy(cursor, &outline.left, sizeof(outline.left));
@@ -659,12 +665,12 @@ std::unique_ptr<uint8_t[]> NinePatch::serializeRoundedRectOutline(
   memcpy(cursor, &outline.bottom, sizeof(outline.bottom));
   cursor += sizeof(outline.bottom);
 
-  *((float*)cursor) = outlineRadius;
-  cursor += sizeof(outlineRadius);
+  *((float*)cursor) = outline_radius;
+  cursor += sizeof(outline_radius);
 
-  *((uint32_t*)cursor) = outlineAlpha;
+  *((uint32_t*)cursor) = outline_alpha;
 
-  *outLen = chunkLen;
+  *out_len = chunk_len;
   return buffer;
 }
 
@@ -677,16 +683,16 @@ std::unique_ptr<uint8_t[]> NinePatch::serializeRoundedRectOutline(
              << " r=" << bounds.right << " b=" << bounds.bottom;
 }
 
-::std::ostream& operator<<(::std::ostream& out, const NinePatch& ninePatch) {
+::std::ostream& operator<<(::std::ostream& out, const NinePatch& nine_patch) {
   return out << "horizontalStretch:"
-             << util::joiner(ninePatch.horizontalStretchRegions, " ")
+             << util::Joiner(nine_patch.horizontal_stretch_regions, " ")
              << " verticalStretch:"
-             << util::joiner(ninePatch.verticalStretchRegions, " ")
-             << " padding: " << ninePatch.padding
-             << ", bounds: " << ninePatch.layoutBounds
-             << ", outline: " << ninePatch.outline
-             << " rad=" << ninePatch.outlineRadius
-             << " alpha=" << ninePatch.outlineAlpha;
+             << util::Joiner(nine_patch.vertical_stretch_regions, " ")
+             << " padding: " << nine_patch.padding
+             << ", bounds: " << nine_patch.layout_bounds
+             << ", outline: " << nine_patch.outline
+             << " rad=" << nine_patch.outline_radius
+             << " alpha=" << nine_patch.outline_alpha;
 }
 
 }  // namespace aapt
diff --git a/tools/aapt2/compile/NinePatch_test.cpp b/tools/aapt2/compile/NinePatch_test.cpp
index b8eda09f59051..f54bb2e62842a 100644
--- a/tools/aapt2/compile/NinePatch_test.cpp
+++ b/tools/aapt2/compile/NinePatch_test.cpp
@@ -15,6 +15,7 @@
  */
 
 #include "compile/Image.h"
+
 #include "test/Test.h"
 
 namespace aapt {
@@ -182,169 +183,168 @@ static uint8_t* kStretchAndPadding5x5[] = {
 
 TEST(NinePatchTest, Minimum3x3) {
   std::string err;
-  EXPECT_EQ(nullptr, NinePatch::create(k2x2, 2, 2, &err));
+  EXPECT_EQ(nullptr, NinePatch::Create(k2x2, 2, 2, &err));
   EXPECT_FALSE(err.empty());
 }
 
 TEST(NinePatchTest, MixedNeutralColors) {
   std::string err;
-  EXPECT_EQ(nullptr, NinePatch::create(kMixedNeutralColor3x3, 3, 3, &err));
+  EXPECT_EQ(nullptr, NinePatch::Create(kMixedNeutralColor3x3, 3, 3, &err));
   EXPECT_FALSE(err.empty());
 }
 
 TEST(NinePatchTest, TransparentNeutralColor) {
   std::string err;
   EXPECT_NE(nullptr,
-            NinePatch::create(kTransparentNeutralColor3x3, 3, 3, &err));
+            NinePatch::Create(kTransparentNeutralColor3x3, 3, 3, &err));
 }
 
 TEST(NinePatchTest, SingleStretchRegion) {
   std::string err;
-  std::unique_ptr<NinePatch> ninePatch =
-      NinePatch::create(kSingleStretch7x6, 7, 6, &err);
-  ASSERT_NE(nullptr, ninePatch);
+  std::unique_ptr<NinePatch> nine_patch =
+      NinePatch::Create(kSingleStretch7x6, 7, 6, &err);
+  ASSERT_NE(nullptr, nine_patch);
 
-  ASSERT_EQ(1u, ninePatch->horizontalStretchRegions.size());
-  ASSERT_EQ(1u, ninePatch->verticalStretchRegions.size());
+  ASSERT_EQ(1u, nine_patch->horizontal_stretch_regions.size());
+  ASSERT_EQ(1u, nine_patch->vertical_stretch_regions.size());
 
-  EXPECT_EQ(Range(1, 4), ninePatch->horizontalStretchRegions.front());
-  EXPECT_EQ(Range(1, 3), ninePatch->verticalStretchRegions.front());
+  EXPECT_EQ(Range(1, 4), nine_patch->horizontal_stretch_regions.front());
+  EXPECT_EQ(Range(1, 3), nine_patch->vertical_stretch_regions.front());
 }
 
 TEST(NinePatchTest, MultipleStretchRegions) {
   std::string err;
-  std::unique_ptr<NinePatch> ninePatch =
-      NinePatch::create(kMultipleStretch10x7, 10, 7, &err);
-  ASSERT_NE(nullptr, ninePatch);
+  std::unique_ptr<NinePatch> nine_patch =
+      NinePatch::Create(kMultipleStretch10x7, 10, 7, &err);
+  ASSERT_NE(nullptr, nine_patch);
 
-  ASSERT_EQ(3u, ninePatch->horizontalStretchRegions.size());
-  ASSERT_EQ(2u, ninePatch->verticalStretchRegions.size());
+  ASSERT_EQ(3u, nine_patch->horizontal_stretch_regions.size());
+  ASSERT_EQ(2u, nine_patch->vertical_stretch_regions.size());
 
-  EXPECT_EQ(Range(1, 2), ninePatch->horizontalStretchRegions[0]);
-  EXPECT_EQ(Range(3, 5), ninePatch->horizontalStretchRegions[1]);
-  EXPECT_EQ(Range(6, 7), ninePatch->horizontalStretchRegions[2]);
+  EXPECT_EQ(Range(1, 2), nine_patch->horizontal_stretch_regions[0]);
+  EXPECT_EQ(Range(3, 5), nine_patch->horizontal_stretch_regions[1]);
+  EXPECT_EQ(Range(6, 7), nine_patch->horizontal_stretch_regions[2]);
 
-  EXPECT_EQ(Range(0, 2), ninePatch->verticalStretchRegions[0]);
-  EXPECT_EQ(Range(3, 5), ninePatch->verticalStretchRegions[1]);
+  EXPECT_EQ(Range(0, 2), nine_patch->vertical_stretch_regions[0]);
+  EXPECT_EQ(Range(3, 5), nine_patch->vertical_stretch_regions[1]);
 }
 
 TEST(NinePatchTest, InferPaddingFromStretchRegions) {
   std::string err;
-  std::unique_ptr<NinePatch> ninePatch =
-      NinePatch::create(kMultipleStretch10x7, 10, 7, &err);
-  ASSERT_NE(nullptr, ninePatch);
-  EXPECT_EQ(Bounds(1, 0, 1, 0), ninePatch->padding);
+  std::unique_ptr<NinePatch> nine_patch =
+      NinePatch::Create(kMultipleStretch10x7, 10, 7, &err);
+  ASSERT_NE(nullptr, nine_patch);
+  EXPECT_EQ(Bounds(1, 0, 1, 0), nine_patch->padding);
 }
 
 TEST(NinePatchTest, Padding) {
   std::string err;
-  std::unique_ptr<NinePatch> ninePatch =
-      NinePatch::create(kPadding6x5, 6, 5, &err);
-  ASSERT_NE(nullptr, ninePatch);
-  EXPECT_EQ(Bounds(1, 1, 1, 1), ninePatch->padding);
+  std::unique_ptr<NinePatch> nine_patch =
+      NinePatch::Create(kPadding6x5, 6, 5, &err);
+  ASSERT_NE(nullptr, nine_patch);
+  EXPECT_EQ(Bounds(1, 1, 1, 1), nine_patch->padding);
 }
 
 TEST(NinePatchTest, LayoutBoundsAreOnWrongEdge) {
   std::string err;
-  EXPECT_EQ(nullptr, NinePatch::create(kLayoutBoundsWrongEdge3x3, 3, 3, &err));
+  EXPECT_EQ(nullptr, NinePatch::Create(kLayoutBoundsWrongEdge3x3, 3, 3, &err));
   EXPECT_FALSE(err.empty());
 }
 
 TEST(NinePatchTest, LayoutBoundsMustTouchEdges) {
   std::string err;
   EXPECT_EQ(nullptr,
-            NinePatch::create(kLayoutBoundsNotEdgeAligned5x5, 5, 5, &err));
+            NinePatch::Create(kLayoutBoundsNotEdgeAligned5x5, 5, 5, &err));
   EXPECT_FALSE(err.empty());
 }
 
 TEST(NinePatchTest, LayoutBounds) {
   std::string err;
-  std::unique_ptr<NinePatch> ninePatch =
-      NinePatch::create(kLayoutBounds5x5, 5, 5, &err);
-  ASSERT_NE(nullptr, ninePatch);
-  EXPECT_EQ(Bounds(1, 1, 1, 1), ninePatch->layoutBounds);
+  std::unique_ptr<NinePatch> nine_patch =
+      NinePatch::Create(kLayoutBounds5x5, 5, 5, &err);
+  ASSERT_NE(nullptr, nine_patch);
+  EXPECT_EQ(Bounds(1, 1, 1, 1), nine_patch->layout_bounds);
 
-  ninePatch = NinePatch::create(kAsymmetricLayoutBounds5x5, 5, 5, &err);
-  ASSERT_NE(nullptr, ninePatch);
-  EXPECT_EQ(Bounds(1, 1, 0, 0), ninePatch->layoutBounds);
+  nine_patch = NinePatch::Create(kAsymmetricLayoutBounds5x5, 5, 5, &err);
+  ASSERT_NE(nullptr, nine_patch);
+  EXPECT_EQ(Bounds(1, 1, 0, 0), nine_patch->layout_bounds);
 }
 
 TEST(NinePatchTest, PaddingAndLayoutBounds) {
   std::string err;
-  std::unique_ptr<NinePatch> ninePatch =
-      NinePatch::create(kPaddingAndLayoutBounds5x5, 5, 5, &err);
-  ASSERT_NE(nullptr, ninePatch);
-  EXPECT_EQ(Bounds(1, 1, 1, 1), ninePatch->padding);
-  EXPECT_EQ(Bounds(1, 1, 1, 1), ninePatch->layoutBounds);
+  std::unique_ptr<NinePatch> nine_patch =
+      NinePatch::Create(kPaddingAndLayoutBounds5x5, 5, 5, &err);
+  ASSERT_NE(nullptr, nine_patch);
+  EXPECT_EQ(Bounds(1, 1, 1, 1), nine_patch->padding);
+  EXPECT_EQ(Bounds(1, 1, 1, 1), nine_patch->layout_bounds);
 }
 
 TEST(NinePatchTest, RegionColorsAreCorrect) {
   std::string err;
-  std::unique_ptr<NinePatch> ninePatch =
-      NinePatch::create(kColorfulImage5x5, 5, 5, &err);
-  ASSERT_NE(nullptr, ninePatch);
+  std::unique_ptr<NinePatch> nine_patch =
+      NinePatch::Create(kColorfulImage5x5, 5, 5, &err);
+  ASSERT_NE(nullptr, nine_patch);
 
-  std::vector<uint32_t> expectedColors = {
-      NinePatch::packRGBA((uint8_t*)RED),
+  std::vector<uint32_t> expected_colors = {
+      NinePatch::PackRGBA((uint8_t*)RED),
       (uint32_t)android::Res_png_9patch::NO_COLOR,
-      NinePatch::packRGBA((uint8_t*)GREEN),
+      NinePatch::PackRGBA((uint8_t*)GREEN),
       (uint32_t)android::Res_png_9patch::TRANSPARENT_COLOR,
-      NinePatch::packRGBA((uint8_t*)BLUE),
-      NinePatch::packRGBA((uint8_t*)GREEN),
+      NinePatch::PackRGBA((uint8_t*)BLUE),
+      NinePatch::PackRGBA((uint8_t*)GREEN),
   };
-  EXPECT_EQ(expectedColors, ninePatch->regionColors);
+  EXPECT_EQ(expected_colors, nine_patch->region_colors);
 }
 
 TEST(NinePatchTest, OutlineFromOpaqueImage) {
   std::string err;
-  std::unique_ptr<NinePatch> ninePatch =
-      NinePatch::create(kOutlineOpaque10x10, 10, 10, &err);
-  ASSERT_NE(nullptr, ninePatch);
-  EXPECT_EQ(Bounds(2, 2, 2, 2), ninePatch->outline);
-  EXPECT_EQ(0x000000ffu, ninePatch->outlineAlpha);
-  EXPECT_EQ(0.0f, ninePatch->outlineRadius);
+  std::unique_ptr<NinePatch> nine_patch =
+      NinePatch::Create(kOutlineOpaque10x10, 10, 10, &err);
+  ASSERT_NE(nullptr, nine_patch);
+  EXPECT_EQ(Bounds(2, 2, 2, 2), nine_patch->outline);
+  EXPECT_EQ(0x000000ffu, nine_patch->outline_alpha);
+  EXPECT_EQ(0.0f, nine_patch->outline_radius);
 }
 
 TEST(NinePatchTest, OutlineFromTranslucentImage) {
   std::string err;
-  std::unique_ptr<NinePatch> ninePatch =
-      NinePatch::create(kOutlineTranslucent10x10, 10, 10, &err);
-  ASSERT_NE(nullptr, ninePatch);
-  EXPECT_EQ(Bounds(3, 3, 3, 3), ninePatch->outline);
-  EXPECT_EQ(0x000000b3u, ninePatch->outlineAlpha);
-  EXPECT_EQ(0.0f, ninePatch->outlineRadius);
+  std::unique_ptr<NinePatch> nine_patch =
+      NinePatch::Create(kOutlineTranslucent10x10, 10, 10, &err);
+  ASSERT_NE(nullptr, nine_patch);
+  EXPECT_EQ(Bounds(3, 3, 3, 3), nine_patch->outline);
+  EXPECT_EQ(0x000000b3u, nine_patch->outline_alpha);
+  EXPECT_EQ(0.0f, nine_patch->outline_radius);
 }
 
 TEST(NinePatchTest, OutlineFromOffCenterImage) {
   std::string err;
-  std::unique_ptr<NinePatch> ninePatch =
-      NinePatch::create(kOutlineOffsetTranslucent12x10, 12, 10, &err);
-  ASSERT_NE(nullptr, ninePatch);
+  std::unique_ptr<NinePatch> nine_patch =
+      NinePatch::Create(kOutlineOffsetTranslucent12x10, 12, 10, &err);
+  ASSERT_NE(nullptr, nine_patch);
 
   // TODO(adamlesinski): The old AAPT algorithm searches from the outside to the
-  // middle
-  // for each inset. If the outline is shifted, the search may not find a closer
-  // bounds.
+  // middle for each inset. If the outline is shifted, the search may not find a
+  // closer bounds.
   // This check should be:
   //   EXPECT_EQ(Bounds(5, 3, 3, 3), ninePatch->outline);
-  // but until I know what behaviour I'm breaking, I will leave it at the
+  // but until I know what behavior I'm breaking, I will leave it at the
   // incorrect:
-  EXPECT_EQ(Bounds(4, 3, 3, 3), ninePatch->outline);
+  EXPECT_EQ(Bounds(4, 3, 3, 3), nine_patch->outline);
 
-  EXPECT_EQ(0x000000b3u, ninePatch->outlineAlpha);
-  EXPECT_EQ(0.0f, ninePatch->outlineRadius);
+  EXPECT_EQ(0x000000b3u, nine_patch->outline_alpha);
+  EXPECT_EQ(0.0f, nine_patch->outline_radius);
 }
 
 TEST(NinePatchTest, OutlineRadius) {
   std::string err;
-  std::unique_ptr<NinePatch> ninePatch =
-      NinePatch::create(kOutlineRadius5x5, 5, 5, &err);
-  ASSERT_NE(nullptr, ninePatch);
-  EXPECT_EQ(Bounds(0, 0, 0, 0), ninePatch->outline);
-  EXPECT_EQ(3.4142f, ninePatch->outlineRadius);
+  std::unique_ptr<NinePatch> nine_patch =
+      NinePatch::Create(kOutlineRadius5x5, 5, 5, &err);
+  ASSERT_NE(nullptr, nine_patch);
+  EXPECT_EQ(Bounds(0, 0, 0, 0), nine_patch->outline);
+  EXPECT_EQ(3.4142f, nine_patch->outline_radius);
 }
 
-::testing::AssertionResult bigEndianOne(uint8_t* cursor) {
+::testing::AssertionResult BigEndianOne(uint8_t* cursor) {
   if (cursor[0] == 0 && cursor[1] == 0 && cursor[2] == 0 && cursor[3] == 1) {
     return ::testing::AssertionSuccess();
   }
@@ -353,12 +353,12 @@ TEST(NinePatchTest, OutlineRadius) {
 
 TEST(NinePatchTest, SerializePngEndianness) {
   std::string err;
-  std::unique_ptr<NinePatch> ninePatch =
-      NinePatch::create(kStretchAndPadding5x5, 5, 5, &err);
-  ASSERT_NE(nullptr, ninePatch);
+  std::unique_ptr<NinePatch> nine_patch =
+      NinePatch::Create(kStretchAndPadding5x5, 5, 5, &err);
+  ASSERT_NE(nullptr, nine_patch);
 
   size_t len;
-  std::unique_ptr<uint8_t[]> data = ninePatch->serializeBase(&len);
+  std::unique_ptr<uint8_t[]> data = nine_patch->SerializeBase(&len);
   ASSERT_NE(nullptr, data);
   ASSERT_NE(0u, len);
 
@@ -368,10 +368,10 @@ TEST(NinePatchTest, SerializePngEndianness) {
   uint8_t* cursor = data.get() + 12;
 
   // Check that padding is big-endian. Expecting value 1.
-  EXPECT_TRUE(bigEndianOne(cursor));
-  EXPECT_TRUE(bigEndianOne(cursor + 4));
-  EXPECT_TRUE(bigEndianOne(cursor + 8));
-  EXPECT_TRUE(bigEndianOne(cursor + 12));
+  EXPECT_TRUE(BigEndianOne(cursor));
+  EXPECT_TRUE(BigEndianOne(cursor + 4));
+  EXPECT_TRUE(BigEndianOne(cursor + 8));
+  EXPECT_TRUE(BigEndianOne(cursor + 12));
 }
 
 }  // namespace aapt
diff --git a/tools/aapt2/compile/Png.cpp b/tools/aapt2/compile/Png.cpp
index 9b5fa7e091c2f..f1bc53ee9cf75 100644
--- a/tools/aapt2/compile/Png.cpp
+++ b/tools/aapt2/compile/Png.cpp
@@ -89,7 +89,7 @@ static void readDataFromStream(png_structp readPtr, png_bytep data,
 static void writeDataToStream(png_structp writePtr, png_bytep data,
                               png_size_t length) {
   BigBuffer* outBuffer = reinterpret_cast<BigBuffer*>(png_get_io_ptr(writePtr));
-  png_bytep buf = outBuffer->nextBlock<png_byte>(length);
+  png_bytep buf = outBuffer->NextBlock<png_byte>(length);
   memcpy(buf, data, length);
 }
 
@@ -98,13 +98,13 @@ static void flushDataToStream(png_structp /*writePtr*/) {}
 static void logWarning(png_structp readPtr, png_const_charp warningMessage) {
   IDiagnostics* diag =
       reinterpret_cast<IDiagnostics*>(png_get_error_ptr(readPtr));
-  diag->warn(DiagMessage() << warningMessage);
+  diag->Warn(DiagMessage() << warningMessage);
 }
 
 static bool readPng(IDiagnostics* diag, png_structp readPtr, png_infop infoPtr,
                     PngInfo* outInfo) {
   if (setjmp(png_jmpbuf(readPtr))) {
-    diag->error(DiagMessage() << "failed reading png");
+    diag->Error(DiagMessage() << "failed reading png");
     return false;
   }
 
@@ -373,7 +373,7 @@ static void analyze_image(IDiagnostics* diag, const PngInfo& imageInfo,
     *colorType = PNG_COLOR_TYPE_PALETTE;
   } else {
     if (maxGrayDeviation <= grayscaleTolerance) {
-      diag->note(DiagMessage() << "forcing image to gray (max deviation = "
+      diag->Note(DiagMessage() << "forcing image to gray (max deviation = "
                                << maxGrayDeviation << ")");
       *colorType = isOpaque ? PNG_COLOR_TYPE_GRAY : PNG_COLOR_TYPE_GRAY_ALPHA;
     } else {
@@ -424,7 +424,7 @@ static void analyze_image(IDiagnostics* diag, const PngInfo& imageInfo,
 static bool writePng(IDiagnostics* diag, png_structp writePtr,
                      png_infop infoPtr, PngInfo* info, int grayScaleTolerance) {
   if (setjmp(png_jmpbuf(writePtr))) {
-    diag->error(DiagMessage() << "failed to write png");
+    diag->Error(DiagMessage() << "failed to write png");
     return false;
   }
 
@@ -453,7 +453,7 @@ static bool writePng(IDiagnostics* diag, png_structp writePtr,
   png_set_compression_level(writePtr, Z_BEST_COMPRESSION);
 
   if (kDebug) {
-    diag->note(DiagMessage() << "writing image: w = " << info->width
+    diag->Note(DiagMessage() << "writing image: w = " << info->width
                              << ", h = " << info->height);
   }
 
@@ -476,23 +476,23 @@ static bool writePng(IDiagnostics* diag, png_structp writePtr,
   if (kDebug) {
     switch (colorType) {
       case PNG_COLOR_TYPE_PALETTE:
-        diag->note(DiagMessage() << "has " << paletteEntries << " colors"
+        diag->Note(DiagMessage() << "has " << paletteEntries << " colors"
                                  << (hasTransparency ? " (with alpha)" : "")
                                  << ", using PNG_COLOR_TYPE_PALLETTE");
         break;
       case PNG_COLOR_TYPE_GRAY:
-        diag->note(DiagMessage()
+        diag->Note(DiagMessage()
                    << "is opaque gray, using PNG_COLOR_TYPE_GRAY");
         break;
       case PNG_COLOR_TYPE_GRAY_ALPHA:
-        diag->note(DiagMessage()
+        diag->Note(DiagMessage()
                    << "is gray + alpha, using PNG_COLOR_TYPE_GRAY_ALPHA");
         break;
       case PNG_COLOR_TYPE_RGB:
-        diag->note(DiagMessage() << "is opaque RGB, using PNG_COLOR_TYPE_RGB");
+        diag->Note(DiagMessage() << "is opaque RGB, using PNG_COLOR_TYPE_RGB");
         break;
       case PNG_COLOR_TYPE_RGB_ALPHA:
-        diag->note(DiagMessage()
+        diag->Note(DiagMessage()
                    << "is RGB + alpha, using PNG_COLOR_TYPE_RGB_ALPHA");
         break;
     }
@@ -527,7 +527,7 @@ static bool writePng(IDiagnostics* diag, png_structp writePtr,
 
     // base 9 patch data
     if (kDebug) {
-      diag->note(DiagMessage() << "adding 9-patch info..");
+      diag->Note(DiagMessage() << "adding 9-patch info..");
     }
     strcpy((char*)unknowns[pIndex].name, "npTc");
     unknowns[pIndex].data = (png_byte*)info->serialize9Patch();
@@ -604,7 +604,7 @@ static bool writePng(IDiagnostics* diag, png_structp writePtr,
                &interlaceType, &compressionType, nullptr);
 
   if (kDebug) {
-    diag->note(DiagMessage() << "image written: w = " << width
+    diag->Note(DiagMessage() << "image written: w = " << width
                              << ", h = " << height << ", d = " << bitDepth
                              << ", colors = " << colorType
                              << ", inter = " << interlaceType
@@ -1228,13 +1228,13 @@ bool Png::process(const Source& source, std::istream* input,
 
   // Read the PNG signature first.
   if (!input->read(reinterpret_cast<char*>(signature), kPngSignatureSize)) {
-    mDiag->error(DiagMessage() << strerror(errno));
+    mDiag->Error(DiagMessage() << strerror(errno));
     return false;
   }
 
   // If the PNG signature doesn't match, bail early.
   if (png_sig_cmp(signature, 0, kPngSignatureSize) != 0) {
-    mDiag->error(DiagMessage() << "not a valid png file");
+    mDiag->Error(DiagMessage() << "not a valid png file");
     return false;
   }
 
@@ -1247,13 +1247,13 @@ bool Png::process(const Source& source, std::istream* input,
 
   readPtr = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, nullptr, nullptr);
   if (!readPtr) {
-    mDiag->error(DiagMessage() << "failed to allocate read ptr");
+    mDiag->Error(DiagMessage() << "failed to allocate read ptr");
     goto bail;
   }
 
   infoPtr = png_create_info_struct(readPtr);
   if (!infoPtr) {
-    mDiag->error(DiagMessage() << "failed to allocate info ptr");
+    mDiag->Error(DiagMessage() << "failed to allocate info ptr");
     goto bail;
   }
 
@@ -1267,10 +1267,10 @@ bool Png::process(const Source& source, std::istream* input,
     goto bail;
   }
 
-  if (util::stringEndsWith(source.path, ".9.png")) {
+  if (util::EndsWith(source.path, ".9.png")) {
     std::string errorMsg;
     if (!do9Patch(&pngInfo, &errorMsg)) {
-      mDiag->error(DiagMessage() << errorMsg);
+      mDiag->Error(DiagMessage() << errorMsg);
       goto bail;
     }
   }
@@ -1278,13 +1278,13 @@ bool Png::process(const Source& source, std::istream* input,
   writePtr =
       png_create_write_struct(PNG_LIBPNG_VER_STRING, 0, nullptr, nullptr);
   if (!writePtr) {
-    mDiag->error(DiagMessage() << "failed to allocate write ptr");
+    mDiag->Error(DiagMessage() << "failed to allocate write ptr");
     goto bail;
   }
 
   writeInfoPtr = png_create_info_struct(writePtr);
   if (!writeInfoPtr) {
-    mDiag->error(DiagMessage() << "failed to allocate write info ptr");
+    mDiag->Error(DiagMessage() << "failed to allocate write info ptr");
     goto bail;
   }
 
@@ -1295,7 +1295,7 @@ bool Png::process(const Source& source, std::istream* input,
                    flushDataToStream);
 
   if (!writePng(mDiag, writePtr, writeInfoPtr, &pngInfo,
-                options.grayScaleTolerance)) {
+                options.grayscale_tolerance)) {
     goto bail;
   }
 
diff --git a/tools/aapt2/compile/Png.h b/tools/aapt2/compile/Png.h
index f9038afa5f9f2..01c9adbc90942 100644
--- a/tools/aapt2/compile/Png.h
+++ b/tools/aapt2/compile/Png.h
@@ -17,6 +17,11 @@
 #ifndef AAPT_PNG_H
 #define AAPT_PNG_H
 
+#include <iostream>
+#include <string>
+
+#include "android-base/macros.h"
+
 #include "Diagnostics.h"
 #include "Source.h"
 #include "compile/Image.h"
@@ -24,16 +29,15 @@
 #include "process/IResourceTableConsumer.h"
 #include "util/BigBuffer.h"
 
-#include <android-base/macros.h>
-#include <iostream>
-#include <string>
-
 namespace aapt {
 
 struct PngOptions {
-  int grayScaleTolerance = 0;
+  int grayscale_tolerance = 0;
 };
 
+/**
+ * Deprecated. Removing once new PNG crunching code is proved to be correct.
+ */
 class Png {
  public:
   explicit Png(IDiagnostics* diag) : mDiag(diag) {}
@@ -59,18 +63,18 @@ class PngChunkFilter : public io::InputStream {
   bool Skip(int count) override;
 
   int64_t ByteCount() const override {
-    return static_cast<int64_t>(mWindowStart);
+    return static_cast<int64_t>(window_start_);
   }
 
-  bool HadError() const override { return mError; }
+  bool HadError() const override { return error_; }
 
  private:
-  bool consumeWindow(const void** buffer, int* len);
+  bool ConsumeWindow(const void** buffer, int* len);
 
-  StringPiece mData;
-  size_t mWindowStart = 0;
-  size_t mWindowEnd = 0;
-  bool mError = false;
+  StringPiece data_;
+  size_t window_start_ = 0;
+  size_t window_end_ = 0;
+  bool error_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(PngChunkFilter);
 };
@@ -78,14 +82,14 @@ class PngChunkFilter : public io::InputStream {
 /**
  * Reads a PNG from the InputStream into memory as an RGBA Image.
  */
-std::unique_ptr<Image> readPng(IAaptContext* context, io::InputStream* in);
+std::unique_ptr<Image> ReadPng(IAaptContext* context, io::InputStream* in);
 
 /**
  * Writes the RGBA Image, with optional 9-patch meta-data, into the OutputStream
  * as a PNG.
  */
-bool writePng(IAaptContext* context, const Image* image,
-              const NinePatch* ninePatch, io::OutputStream* out,
+bool WritePng(IAaptContext* context, const Image* image,
+              const NinePatch* nine_patch, io::OutputStream* out,
               const PngOptions& options);
 
 }  // namespace aapt
diff --git a/tools/aapt2/compile/PngChunkFilter.cpp b/tools/aapt2/compile/PngChunkFilter.cpp
index fb7fe9271f805..4cbefb9496ae2 100644
--- a/tools/aapt2/compile/PngChunkFilter.cpp
+++ b/tools/aapt2/compile/PngChunkFilter.cpp
@@ -15,6 +15,7 @@
  */
 
 #include "compile/Png.h"
+
 #include "io/Io.h"
 #include "util/StringPiece.h"
 
@@ -39,7 +40,7 @@ enum PngChunkTypes {
   kPngChunksRGB = u32(115, 82, 71, 66),
 };
 
-static uint32_t peek32LE(const char* data) {
+static uint32_t Peek32LE(const char* data) {
   uint32_t word = ((uint32_t)data[0]) & 0x000000ff;
   word <<= 8;
   word |= ((uint32_t)data[1]) & 0x000000ff;
@@ -50,7 +51,7 @@ static uint32_t peek32LE(const char* data) {
   return word;
 }
 
-static bool isPngChunkWhitelisted(uint32_t type) {
+static bool IsPngChunkWhitelisted(uint32_t type) {
   switch (type) {
     case kPngChunkIHDR:
     case kPngChunkIDAT:
@@ -64,93 +65,93 @@ static bool isPngChunkWhitelisted(uint32_t type) {
   }
 }
 
-PngChunkFilter::PngChunkFilter(const StringPiece& data) : mData(data) {
-  if (util::stringStartsWith(mData, kPngSignature)) {
-    mWindowStart = 0;
-    mWindowEnd = strlen(kPngSignature);
+PngChunkFilter::PngChunkFilter(const StringPiece& data) : data_(data) {
+  if (util::StartsWith(data_, kPngSignature)) {
+    window_start_ = 0;
+    window_end_ = strlen(kPngSignature);
   } else {
-    mError = true;
+    error_ = true;
   }
 }
 
-bool PngChunkFilter::consumeWindow(const void** buffer, int* len) {
-  if (mWindowStart != mWindowEnd) {
+bool PngChunkFilter::ConsumeWindow(const void** buffer, int* len) {
+  if (window_start_ != window_end_) {
     // We have bytes to give from our window.
-    const int bytesRead = (int)(mWindowEnd - mWindowStart);
-    *buffer = mData.data() + mWindowStart;
-    *len = bytesRead;
-    mWindowStart = mWindowEnd;
+    const int bytes_read = (int)(window_end_ - window_start_);
+    *buffer = data_.data() + window_start_;
+    *len = bytes_read;
+    window_start_ = window_end_;
     return true;
   }
   return false;
 }
 
 bool PngChunkFilter::Next(const void** buffer, int* len) {
-  if (mError) {
+  if (error_) {
     return false;
   }
 
   // In case BackUp was called, we must consume the window.
-  if (consumeWindow(buffer, len)) {
+  if (ConsumeWindow(buffer, len)) {
     return true;
   }
 
   // Advance the window as far as possible (until we meet a chunk that
   // we want to strip).
-  while (mWindowEnd < mData.size()) {
+  while (window_end_ < data_.size()) {
     // Chunk length (4 bytes) + type (4 bytes) + crc32 (4 bytes) = 12 bytes.
     const size_t kMinChunkHeaderSize = 3 * sizeof(uint32_t);
 
     // Is there enough room for a chunk header?
-    if (mData.size() - mWindowStart < kMinChunkHeaderSize) {
-      mError = true;
+    if (data_.size() - window_start_ < kMinChunkHeaderSize) {
+      error_ = true;
       return false;
     }
 
     // Verify the chunk length.
-    const uint32_t chunkLen = peek32LE(mData.data() + mWindowEnd);
-    if (((uint64_t)chunkLen) + ((uint64_t)mWindowEnd) + sizeof(uint32_t) >
-        mData.size()) {
+    const uint32_t chunk_len = Peek32LE(data_.data() + window_end_);
+    if (((uint64_t)chunk_len) + ((uint64_t)window_end_) + sizeof(uint32_t) >
+        data_.size()) {
       // Overflow.
-      mError = true;
+      error_ = true;
       return false;
     }
 
     // Do we strip this chunk?
-    const uint32_t chunkType =
-        peek32LE(mData.data() + mWindowEnd + sizeof(uint32_t));
-    if (isPngChunkWhitelisted(chunkType)) {
+    const uint32_t chunk_type =
+        Peek32LE(data_.data() + window_end_ + sizeof(uint32_t));
+    if (IsPngChunkWhitelisted(chunk_type)) {
       // Advance the window to include this chunk.
-      mWindowEnd += kMinChunkHeaderSize + chunkLen;
+      window_end_ += kMinChunkHeaderSize + chunk_len;
     } else {
       // We want to strip this chunk. If we accumulated a window,
       // we must return the window now.
-      if (mWindowStart != mWindowEnd) {
+      if (window_start_ != window_end_) {
         break;
       }
 
       // The window is empty, so we can advance past this chunk
       // and keep looking for the next good chunk,
-      mWindowEnd += kMinChunkHeaderSize + chunkLen;
-      mWindowStart = mWindowEnd;
+      window_end_ += kMinChunkHeaderSize + chunk_len;
+      window_start_ = window_end_;
     }
   }
 
-  if (consumeWindow(buffer, len)) {
+  if (ConsumeWindow(buffer, len)) {
     return true;
   }
   return false;
 }
 
 void PngChunkFilter::BackUp(int count) {
-  if (mError) {
+  if (error_) {
     return;
   }
-  mWindowStart -= count;
+  window_start_ -= count;
 }
 
 bool PngChunkFilter::Skip(int count) {
-  if (mError) {
+  if (error_) {
     return false;
   }
 
diff --git a/tools/aapt2/compile/PngCrunch.cpp b/tools/aapt2/compile/PngCrunch.cpp
index 4a74f7af79d81..3b46d8b4c782c 100644
--- a/tools/aapt2/compile/PngCrunch.cpp
+++ b/tools/aapt2/compile/PngCrunch.cpp
@@ -16,14 +16,17 @@
 
 #include "compile/Png.h"
 
-#include <android-base/errors.h>
-#include <android-base/macros.h>
 #include <png.h>
 #include <zlib.h>
+
 #include <algorithm>
 #include <unordered_map>
 #include <unordered_set>
 
+#include "android-base/errors.h"
+#include "android-base/logging.h"
+#include "android-base/macros.h"
+
 namespace aapt {
 
 // Size in bytes of the PNG signature.
@@ -34,16 +37,16 @@ constexpr size_t kPngSignatureSize = 8u;
  */
 class PngReadStructDeleter {
  public:
-  explicit PngReadStructDeleter(png_structp readPtr, png_infop infoPtr)
-      : mReadPtr(readPtr), mInfoPtr(infoPtr) {}
+  PngReadStructDeleter(png_structp read_ptr, png_infop info_ptr)
+      : read_ptr_(read_ptr), info_ptr_(info_ptr) {}
 
   ~PngReadStructDeleter() {
-    png_destroy_read_struct(&mReadPtr, &mInfoPtr, nullptr);
+    png_destroy_read_struct(&read_ptr_, &info_ptr_, nullptr);
   }
 
  private:
-  png_structp mReadPtr;
-  png_infop mInfoPtr;
+  png_structp read_ptr_;
+  png_infop info_ptr_;
 
   DISALLOW_COPY_AND_ASSIGN(PngReadStructDeleter);
 };
@@ -53,226 +56,229 @@ class PngReadStructDeleter {
  */
 class PngWriteStructDeleter {
  public:
-  explicit PngWriteStructDeleter(png_structp writePtr, png_infop infoPtr)
-      : mWritePtr(writePtr), mInfoPtr(infoPtr) {}
+  PngWriteStructDeleter(png_structp write_ptr, png_infop info_ptr)
+      : write_ptr_(write_ptr), info_ptr_(info_ptr) {}
 
-  ~PngWriteStructDeleter() { png_destroy_write_struct(&mWritePtr, &mInfoPtr); }
+  ~PngWriteStructDeleter() {
+    png_destroy_write_struct(&write_ptr_, &info_ptr_);
+  }
 
  private:
-  png_structp mWritePtr;
-  png_infop mInfoPtr;
+  png_structp write_ptr_;
+  png_infop info_ptr_;
 
   DISALLOW_COPY_AND_ASSIGN(PngWriteStructDeleter);
 };
 
 // Custom warning logging method that uses IDiagnostics.
-static void logWarning(png_structp pngPtr, png_const_charp warningMsg) {
-  IDiagnostics* diag = (IDiagnostics*)png_get_error_ptr(pngPtr);
-  diag->warn(DiagMessage() << warningMsg);
+static void LogWarning(png_structp png_ptr, png_const_charp warning_msg) {
+  IDiagnostics* diag = (IDiagnostics*)png_get_error_ptr(png_ptr);
+  diag->Warn(DiagMessage() << warning_msg);
 }
 
 // Custom error logging method that uses IDiagnostics.
-static void logError(png_structp pngPtr, png_const_charp errorMsg) {
-  IDiagnostics* diag = (IDiagnostics*)png_get_error_ptr(pngPtr);
-  diag->error(DiagMessage() << errorMsg);
+static void LogError(png_structp png_ptr, png_const_charp error_msg) {
+  IDiagnostics* diag = (IDiagnostics*)png_get_error_ptr(png_ptr);
+  diag->Error(DiagMessage() << error_msg);
 }
 
-static void readDataFromStream(png_structp pngPtr, png_bytep buffer,
+static void ReadDataFromStream(png_structp png_ptr, png_bytep buffer,
                                png_size_t len) {
-  io::InputStream* in = (io::InputStream*)png_get_io_ptr(pngPtr);
+  io::InputStream* in = (io::InputStream*)png_get_io_ptr(png_ptr);
 
-  const void* inBuffer;
-  int inLen;
-  if (!in->Next(&inBuffer, &inLen)) {
+  const void* in_buffer;
+  int in_len;
+  if (!in->Next(&in_buffer, &in_len)) {
     if (in->HadError()) {
       std::string err = in->GetError();
-      png_error(pngPtr, err.c_str());
+      png_error(png_ptr, err.c_str());
     }
     return;
   }
 
-  const size_t bytesRead = std::min(static_cast<size_t>(inLen), len);
-  memcpy(buffer, inBuffer, bytesRead);
-  if (bytesRead != static_cast<size_t>(inLen)) {
-    in->BackUp(inLen - static_cast<int>(bytesRead));
+  const size_t bytes_read = std::min(static_cast<size_t>(in_len), len);
+  memcpy(buffer, in_buffer, bytes_read);
+  if (bytes_read != static_cast<size_t>(in_len)) {
+    in->BackUp(in_len - static_cast<int>(bytes_read));
   }
 }
 
-static void writeDataToStream(png_structp pngPtr, png_bytep buffer,
+static void WriteDataToStream(png_structp png_ptr, png_bytep buffer,
                               png_size_t len) {
-  io::OutputStream* out = (io::OutputStream*)png_get_io_ptr(pngPtr);
+  io::OutputStream* out = (io::OutputStream*)png_get_io_ptr(png_ptr);
 
-  void* outBuffer;
-  int outLen;
+  void* out_buffer;
+  int out_len;
   while (len > 0) {
-    if (!out->Next(&outBuffer, &outLen)) {
+    if (!out->Next(&out_buffer, &out_len)) {
       if (out->HadError()) {
         std::string err = out->GetError();
-        png_error(pngPtr, err.c_str());
+        png_error(png_ptr, err.c_str());
       }
       return;
     }
 
-    const size_t bytesWritten = std::min(static_cast<size_t>(outLen), len);
-    memcpy(outBuffer, buffer, bytesWritten);
+    const size_t bytes_written = std::min(static_cast<size_t>(out_len), len);
+    memcpy(out_buffer, buffer, bytes_written);
 
     // Advance the input buffer.
-    buffer += bytesWritten;
-    len -= bytesWritten;
+    buffer += bytes_written;
+    len -= bytes_written;
 
     // Advance the output buffer.
-    outLen -= static_cast<int>(bytesWritten);
+    out_len -= static_cast<int>(bytes_written);
   }
 
   // If the entire output buffer wasn't used, backup.
-  if (outLen > 0) {
-    out->BackUp(outLen);
+  if (out_len > 0) {
+    out->BackUp(out_len);
   }
 }
 
-std::unique_ptr<Image> readPng(IAaptContext* context, io::InputStream* in) {
+std::unique_ptr<Image> ReadPng(IAaptContext* context, io::InputStream* in) {
   // Read the first 8 bytes of the file looking for the PNG signature.
   // Bail early if it does not match.
   const png_byte* signature;
-  int bufferSize;
-  if (!in->Next((const void**)&signature, &bufferSize)) {
-    context->getDiagnostics()->error(
+  int buffer_size;
+  if (!in->Next((const void**)&signature, &buffer_size)) {
+    context->GetDiagnostics()->Error(
         DiagMessage() << android::base::SystemErrorCodeToString(errno));
     return {};
   }
 
-  if (static_cast<size_t>(bufferSize) < kPngSignatureSize ||
+  if (static_cast<size_t>(buffer_size) < kPngSignatureSize ||
       png_sig_cmp(signature, 0, kPngSignatureSize) != 0) {
-    context->getDiagnostics()->error(
+    context->GetDiagnostics()->Error(
         DiagMessage() << "file signature does not match PNG signature");
     return {};
   }
 
   // Start at the beginning of the first chunk.
-  in->BackUp(bufferSize - static_cast<int>(kPngSignatureSize));
+  in->BackUp(buffer_size - static_cast<int>(kPngSignatureSize));
 
   // Create and initialize the png_struct with the default error and warning
   // handlers.
   // The header version is also passed in to ensure that this was built against
   // the same
   // version of libpng.
-  png_structp readPtr =
+  png_structp read_ptr =
       png_create_read_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr, nullptr);
-  if (readPtr == nullptr) {
-    context->getDiagnostics()->error(
+  if (read_ptr == nullptr) {
+    context->GetDiagnostics()->Error(
         DiagMessage() << "failed to create libpng read png_struct");
     return {};
   }
 
   // Create and initialize the memory for image header and data.
-  png_infop infoPtr = png_create_info_struct(readPtr);
-  if (infoPtr == nullptr) {
-    context->getDiagnostics()->error(
+  png_infop info_ptr = png_create_info_struct(read_ptr);
+  if (info_ptr == nullptr) {
+    context->GetDiagnostics()->Error(
         DiagMessage() << "failed to create libpng read png_info");
-    png_destroy_read_struct(&readPtr, nullptr, nullptr);
+    png_destroy_read_struct(&read_ptr, nullptr, nullptr);
     return {};
   }
 
   // Automatically release PNG resources at end of scope.
-  PngReadStructDeleter pngReadDeleter(readPtr, infoPtr);
+  PngReadStructDeleter png_read_deleter(read_ptr, info_ptr);
 
   // libpng uses longjmp to jump to an error handling routine.
   // setjmp will only return true if it was jumped to, aka there was
   // an error.
-  if (setjmp(png_jmpbuf(readPtr))) {
+  if (setjmp(png_jmpbuf(read_ptr))) {
     return {};
   }
 
   // Handle warnings ourselves via IDiagnostics.
-  png_set_error_fn(readPtr, (png_voidp)context->getDiagnostics(), logError,
-                   logWarning);
+  png_set_error_fn(read_ptr, (png_voidp)context->GetDiagnostics(), LogError,
+                   LogWarning);
 
   // Set up the read functions which read from our custom data sources.
-  png_set_read_fn(readPtr, (png_voidp)in, readDataFromStream);
+  png_set_read_fn(read_ptr, (png_voidp)in, ReadDataFromStream);
 
   // Skip the signature that we already read.
-  png_set_sig_bytes(readPtr, kPngSignatureSize);
+  png_set_sig_bytes(read_ptr, kPngSignatureSize);
 
   // Read the chunk headers.
-  png_read_info(readPtr, infoPtr);
+  png_read_info(read_ptr, info_ptr);
 
   // Extract image meta-data from the various chunk headers.
   uint32_t width, height;
-  int bitDepth, colorType, interlaceMethod, compressionMethod, filterMethod;
-  png_get_IHDR(readPtr, infoPtr, &width, &height, &bitDepth, &colorType,
-               &interlaceMethod, &compressionMethod, &filterMethod);
+  int bit_depth, color_type, interlace_method, compression_method,
+      filter_method;
+  png_get_IHDR(read_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
+               &interlace_method, &compression_method, &filter_method);
 
   // When the image is read, expand it so that it is in RGBA 8888 format
   // so that image handling is uniform.
 
-  if (colorType == PNG_COLOR_TYPE_PALETTE) {
-    png_set_palette_to_rgb(readPtr);
+  if (color_type == PNG_COLOR_TYPE_PALETTE) {
+    png_set_palette_to_rgb(read_ptr);
   }
 
-  if (colorType == PNG_COLOR_TYPE_GRAY && bitDepth < 8) {
-    png_set_expand_gray_1_2_4_to_8(readPtr);
+  if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) {
+    png_set_expand_gray_1_2_4_to_8(read_ptr);
   }
 
-  if (png_get_valid(readPtr, infoPtr, PNG_INFO_tRNS)) {
-    png_set_tRNS_to_alpha(readPtr);
+  if (png_get_valid(read_ptr, info_ptr, PNG_INFO_tRNS)) {
+    png_set_tRNS_to_alpha(read_ptr);
   }
 
-  if (bitDepth == 16) {
-    png_set_strip_16(readPtr);
+  if (bit_depth == 16) {
+    png_set_strip_16(read_ptr);
   }
 
-  if (!(colorType & PNG_COLOR_MASK_ALPHA)) {
-    png_set_add_alpha(readPtr, 0xFF, PNG_FILLER_AFTER);
+  if (!(color_type & PNG_COLOR_MASK_ALPHA)) {
+    png_set_add_alpha(read_ptr, 0xFF, PNG_FILLER_AFTER);
   }
 
-  if (colorType == PNG_COLOR_TYPE_GRAY ||
-      colorType == PNG_COLOR_TYPE_GRAY_ALPHA) {
-    png_set_gray_to_rgb(readPtr);
+  if (color_type == PNG_COLOR_TYPE_GRAY ||
+      color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
+    png_set_gray_to_rgb(read_ptr);
   }
 
-  if (interlaceMethod != PNG_INTERLACE_NONE) {
-    png_set_interlace_handling(readPtr);
+  if (interlace_method != PNG_INTERLACE_NONE) {
+    png_set_interlace_handling(read_ptr);
   }
 
   // Once all the options for reading have been set, we need to flush
   // them to libpng.
-  png_read_update_info(readPtr, infoPtr);
+  png_read_update_info(read_ptr, info_ptr);
 
   // 9-patch uses int32_t to index images, so we cap the image dimensions to
   // something
   // that can always be represented by 9-patch.
   if (width > std::numeric_limits<int32_t>::max() ||
       height > std::numeric_limits<int32_t>::max()) {
-    context->getDiagnostics()->error(DiagMessage()
+    context->GetDiagnostics()->Error(DiagMessage()
                                      << "PNG image dimensions are too large: "
                                      << width << "x" << height);
     return {};
   }
 
-  std::unique_ptr<Image> outputImage = util::make_unique<Image>();
-  outputImage->width = static_cast<int32_t>(width);
-  outputImage->height = static_cast<int32_t>(height);
+  std::unique_ptr<Image> output_image = util::make_unique<Image>();
+  output_image->width = static_cast<int32_t>(width);
+  output_image->height = static_cast<int32_t>(height);
 
-  const size_t rowBytes = png_get_rowbytes(readPtr, infoPtr);
-  assert(rowBytes == 4 * width);  // RGBA
+  const size_t row_bytes = png_get_rowbytes(read_ptr, info_ptr);
+  CHECK(row_bytes == 4 * width);  // RGBA
 
   // Allocate one large block to hold the image.
-  outputImage->data =
-      std::unique_ptr<uint8_t[]>(new uint8_t[height * rowBytes]);
+  output_image->data =
+      std::unique_ptr<uint8_t[]>(new uint8_t[height * row_bytes]);
 
   // Create an array of rows that index into the data block.
-  outputImage->rows = std::unique_ptr<uint8_t* []>(new uint8_t*[height]);
+  output_image->rows = std::unique_ptr<uint8_t* []>(new uint8_t*[height]);
   for (uint32_t h = 0; h < height; h++) {
-    outputImage->rows[h] = outputImage->data.get() + (h * rowBytes);
+    output_image->rows[h] = output_image->data.get() + (h * row_bytes);
   }
 
   // Actually read the image pixels.
-  png_read_image(readPtr, outputImage->rows.get());
+  png_read_image(read_ptr, output_image->rows.get());
 
   // Finish reading. This will read any other chunks after the image data.
-  png_read_end(readPtr, infoPtr);
+  png_read_end(read_ptr, info_ptr);
 
-  return outputImage;
+  return output_image;
 }
 
 /**
@@ -309,57 +315,58 @@ constexpr static const size_t kPaletteOverheadConstant = 1024u * 10u;
 // - Grayscale + cheap alpha
 // - Grayscale + alpha
 //
-static int pickColorType(int32_t width, int32_t height, bool grayScale,
-                         bool convertibleToGrayScale, bool hasNinePatch,
-                         size_t colorPaletteSize, size_t alphaPaletteSize) {
-  const size_t paletteChunkSize = 16 + colorPaletteSize * 3;
-  const size_t alphaChunkSize = 16 + alphaPaletteSize;
-  const size_t colorAlphaDataChunkSize = 16 + 4 * width * height;
-  const size_t colorDataChunkSize = 16 + 3 * width * height;
-  const size_t grayScaleAlphaDataChunkSize = 16 + 2 * width * height;
-  const size_t paletteDataChunkSize = 16 + width * height;
+static int PickColorType(int32_t width, int32_t height, bool grayscale,
+                         bool convertible_to_grayscale, bool has_nine_patch,
+                         size_t color_palette_size, size_t alpha_palette_size) {
+  const size_t palette_chunk_size = 16 + color_palette_size * 3;
+  const size_t alpha_chunk_size = 16 + alpha_palette_size;
+  const size_t color_alpha_data_chunk_size = 16 + 4 * width * height;
+  const size_t color_data_chunk_size = 16 + 3 * width * height;
+  const size_t grayscale_alpha_data_chunk_size = 16 + 2 * width * height;
+  const size_t palette_data_chunk_size = 16 + width * height;
 
-  if (grayScale) {
-    if (alphaPaletteSize == 0) {
+  if (grayscale) {
+    if (alpha_palette_size == 0) {
       // This is the smallest the data can be.
       return PNG_COLOR_TYPE_GRAY;
-    } else if (colorPaletteSize <= 256 && !hasNinePatch) {
+    } else if (color_palette_size <= 256 && !has_nine_patch) {
       // This grayscale has alpha and can fit within a palette.
       // See if it is worth fitting into a palette.
-      const size_t paletteThreshold = paletteChunkSize + alphaChunkSize +
-                                      paletteDataChunkSize +
-                                      kPaletteOverheadConstant;
-      if (grayScaleAlphaDataChunkSize > paletteThreshold) {
+      const size_t palette_threshold = palette_chunk_size + alpha_chunk_size +
+                                       palette_data_chunk_size +
+                                       kPaletteOverheadConstant;
+      if (grayscale_alpha_data_chunk_size > palette_threshold) {
         return PNG_COLOR_TYPE_PALETTE;
       }
     }
     return PNG_COLOR_TYPE_GRAY_ALPHA;
   }
 
-  if (colorPaletteSize <= 256 && !hasNinePatch) {
+  if (color_palette_size <= 256 && !has_nine_patch) {
     // This image can fit inside a palette. Let's see if it is worth it.
-    size_t totalSizeWithPalette = paletteDataChunkSize + paletteChunkSize;
-    size_t totalSizeWithoutPalette = colorDataChunkSize;
-    if (alphaPaletteSize > 0) {
-      totalSizeWithPalette += alphaPaletteSize;
-      totalSizeWithoutPalette = colorAlphaDataChunkSize;
+    size_t total_size_with_palette =
+        palette_data_chunk_size + palette_chunk_size;
+    size_t total_size_without_palette = color_data_chunk_size;
+    if (alpha_palette_size > 0) {
+      total_size_with_palette += alpha_palette_size;
+      total_size_without_palette = color_alpha_data_chunk_size;
     }
 
-    if (totalSizeWithoutPalette >
-        totalSizeWithPalette + kPaletteOverheadConstant) {
+    if (total_size_without_palette >
+        total_size_with_palette + kPaletteOverheadConstant) {
       return PNG_COLOR_TYPE_PALETTE;
     }
   }
 
-  if (convertibleToGrayScale) {
-    if (alphaPaletteSize == 0) {
+  if (convertible_to_grayscale) {
+    if (alpha_palette_size == 0) {
       return PNG_COLOR_TYPE_GRAY;
     } else {
       return PNG_COLOR_TYPE_GRAY_ALPHA;
     }
   }
 
-  if (alphaPaletteSize == 0) {
+  if (alpha_palette_size == 0) {
     return PNG_COLOR_TYPE_RGB;
   }
   return PNG_COLOR_TYPE_RGBA;
@@ -371,11 +378,11 @@ static int pickColorType(int32_t width, int32_t height, bool grayScale,
 // This must be done before writing image data.
 // Image data must be transformed to use the indices assigned within the
 // palette.
-static void writePalette(png_structp writePtr, png_infop writeInfoPtr,
-                         std::unordered_map<uint32_t, int>* colorPalette,
-                         std::unordered_set<uint32_t>* alphaPalette) {
-  assert(colorPalette->size() <= 256);
-  assert(alphaPalette->size() <= 256);
+static void WritePalette(png_structp write_ptr, png_infop write_info_ptr,
+                         std::unordered_map<uint32_t, int>* color_palette,
+                         std::unordered_set<uint32_t>* alpha_palette) {
+  CHECK(color_palette->size() <= 256);
+  CHECK(alpha_palette->size() <= 256);
 
   // Populate the PNG palette struct and assign indices to the color
   // palette.
@@ -384,160 +391,161 @@ static void writePalette(png_structp writePtr, png_infop writeInfoPtr,
   // This will ensure that we can truncate the alpha palette if it is
   // smaller than the color palette.
   int index = 0;
-  for (uint32_t color : *alphaPalette) {
-    (*colorPalette)[color] = index++;
+  for (uint32_t color : *alpha_palette) {
+    (*color_palette)[color] = index++;
   }
 
   // Assign the rest of the entries.
-  for (auto& entry : *colorPalette) {
+  for (auto& entry : *color_palette) {
     if (entry.second == -1) {
       entry.second = index++;
     }
   }
 
   // Create the PNG color palette struct.
-  auto colorPaletteBytes =
-      std::unique_ptr<png_color[]>(new png_color[colorPalette->size()]);
+  auto color_palette_bytes =
+      std::unique_ptr<png_color[]>(new png_color[color_palette->size()]);
 
-  std::unique_ptr<png_byte[]> alphaPaletteBytes;
-  if (!alphaPalette->empty()) {
-    alphaPaletteBytes =
-        std::unique_ptr<png_byte[]>(new png_byte[alphaPalette->size()]);
+  std::unique_ptr<png_byte[]> alpha_palette_bytes;
+  if (!alpha_palette->empty()) {
+    alpha_palette_bytes =
+        std::unique_ptr<png_byte[]>(new png_byte[alpha_palette->size()]);
   }
 
-  for (const auto& entry : *colorPalette) {
+  for (const auto& entry : *color_palette) {
     const uint32_t color = entry.first;
     const int index = entry.second;
-    assert(index >= 0);
-    assert(static_cast<size_t>(index) < colorPalette->size());
+    CHECK(index >= 0);
+    CHECK(static_cast<size_t>(index) < color_palette->size());
 
-    png_colorp slot = colorPaletteBytes.get() + index;
+    png_colorp slot = color_palette_bytes.get() + index;
     slot->red = color >> 24;
     slot->green = color >> 16;
     slot->blue = color >> 8;
 
     const png_byte alpha = color & 0x000000ff;
-    if (alpha != 0xff && alphaPaletteBytes) {
-      assert(static_cast<size_t>(index) < alphaPalette->size());
-      alphaPaletteBytes[index] = alpha;
+    if (alpha != 0xff && alpha_palette_bytes) {
+      CHECK(static_cast<size_t>(index) < alpha_palette->size());
+      alpha_palette_bytes[index] = alpha;
     }
   }
 
-  // The bytes get copied here, so it is safe to release colorPaletteBytes at
+  // The bytes get copied here, so it is safe to release color_palette_bytes at
   // the end of function
   // scope.
-  png_set_PLTE(writePtr, writeInfoPtr, colorPaletteBytes.get(),
-               colorPalette->size());
+  png_set_PLTE(write_ptr, write_info_ptr, color_palette_bytes.get(),
+               color_palette->size());
 
-  if (alphaPaletteBytes) {
-    png_set_tRNS(writePtr, writeInfoPtr, alphaPaletteBytes.get(),
-                 alphaPalette->size(), nullptr);
+  if (alpha_palette_bytes) {
+    png_set_tRNS(write_ptr, write_info_ptr, alpha_palette_bytes.get(),
+                 alpha_palette->size(), nullptr);
   }
 }
 
-// Write the 9-patch custom PNG chunks to writeInfoPtr. This must be done before
+// Write the 9-patch custom PNG chunks to write_info_ptr. This must be done
+// before
 // writing image data.
-static void writeNinePatch(png_structp writePtr, png_infop writeInfoPtr,
-                           const NinePatch* ninePatch) {
+static void WriteNinePatch(png_structp write_ptr, png_infop write_info_ptr,
+                           const NinePatch* nine_patch) {
   // The order of the chunks is important.
   // 9-patch code in older platforms expects the 9-patch chunk to
   // be last.
 
-  png_unknown_chunk unknownChunks[3];
-  memset(unknownChunks, 0, sizeof(unknownChunks));
+  png_unknown_chunk unknown_chunks[3];
+  memset(unknown_chunks, 0, sizeof(unknown_chunks));
 
   size_t index = 0;
-  size_t chunkLen = 0;
+  size_t chunk_len = 0;
 
-  std::unique_ptr<uint8_t[]> serializedOutline =
-      ninePatch->serializeRoundedRectOutline(&chunkLen);
-  strcpy((char*)unknownChunks[index].name, "npOl");
-  unknownChunks[index].size = chunkLen;
-  unknownChunks[index].data = (png_bytep)serializedOutline.get();
-  unknownChunks[index].location = PNG_HAVE_PLTE;
+  std::unique_ptr<uint8_t[]> serialized_outline =
+      nine_patch->SerializeRoundedRectOutline(&chunk_len);
+  strcpy((char*)unknown_chunks[index].name, "npOl");
+  unknown_chunks[index].size = chunk_len;
+  unknown_chunks[index].data = (png_bytep)serialized_outline.get();
+  unknown_chunks[index].location = PNG_HAVE_PLTE;
   index++;
 
-  std::unique_ptr<uint8_t[]> serializedLayoutBounds;
-  if (ninePatch->layoutBounds.nonZero()) {
-    serializedLayoutBounds = ninePatch->serializeLayoutBounds(&chunkLen);
-    strcpy((char*)unknownChunks[index].name, "npLb");
-    unknownChunks[index].size = chunkLen;
-    unknownChunks[index].data = (png_bytep)serializedLayoutBounds.get();
-    unknownChunks[index].location = PNG_HAVE_PLTE;
+  std::unique_ptr<uint8_t[]> serialized_layout_bounds;
+  if (nine_patch->layout_bounds.nonZero()) {
+    serialized_layout_bounds = nine_patch->SerializeLayoutBounds(&chunk_len);
+    strcpy((char*)unknown_chunks[index].name, "npLb");
+    unknown_chunks[index].size = chunk_len;
+    unknown_chunks[index].data = (png_bytep)serialized_layout_bounds.get();
+    unknown_chunks[index].location = PNG_HAVE_PLTE;
     index++;
   }
 
-  std::unique_ptr<uint8_t[]> serializedNinePatch =
-      ninePatch->serializeBase(&chunkLen);
-  strcpy((char*)unknownChunks[index].name, "npTc");
-  unknownChunks[index].size = chunkLen;
-  unknownChunks[index].data = (png_bytep)serializedNinePatch.get();
-  unknownChunks[index].location = PNG_HAVE_PLTE;
+  std::unique_ptr<uint8_t[]> serialized_nine_patch =
+      nine_patch->SerializeBase(&chunk_len);
+  strcpy((char*)unknown_chunks[index].name, "npTc");
+  unknown_chunks[index].size = chunk_len;
+  unknown_chunks[index].data = (png_bytep)serialized_nine_patch.get();
+  unknown_chunks[index].location = PNG_HAVE_PLTE;
   index++;
 
   // Handle all unknown chunks. We are manually setting the chunks here,
   // so we will only ever handle our custom chunks.
-  png_set_keep_unknown_chunks(writePtr, PNG_HANDLE_CHUNK_ALWAYS, nullptr, 0);
+  png_set_keep_unknown_chunks(write_ptr, PNG_HANDLE_CHUNK_ALWAYS, nullptr, 0);
 
   // Set the actual chunks here. The data gets copied, so our buffers can
   // safely go out of scope.
-  png_set_unknown_chunks(writePtr, writeInfoPtr, unknownChunks, index);
+  png_set_unknown_chunks(write_ptr, write_info_ptr, unknown_chunks, index);
 }
 
-bool writePng(IAaptContext* context, const Image* image,
-              const NinePatch* ninePatch, io::OutputStream* out,
+bool WritePng(IAaptContext* context, const Image* image,
+              const NinePatch* nine_patch, io::OutputStream* out,
               const PngOptions& options) {
   // Create and initialize the write png_struct with the default error and
   // warning handlers.
   // The header version is also passed in to ensure that this was built against
   // the same
   // version of libpng.
-  png_structp writePtr =
+  png_structp write_ptr =
       png_create_write_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr, nullptr);
-  if (writePtr == nullptr) {
-    context->getDiagnostics()->error(
+  if (write_ptr == nullptr) {
+    context->GetDiagnostics()->Error(
         DiagMessage() << "failed to create libpng write png_struct");
     return false;
   }
 
   // Allocate memory to store image header data.
-  png_infop writeInfoPtr = png_create_info_struct(writePtr);
-  if (writeInfoPtr == nullptr) {
-    context->getDiagnostics()->error(
+  png_infop write_info_ptr = png_create_info_struct(write_ptr);
+  if (write_info_ptr == nullptr) {
+    context->GetDiagnostics()->Error(
         DiagMessage() << "failed to create libpng write png_info");
-    png_destroy_write_struct(&writePtr, nullptr);
+    png_destroy_write_struct(&write_ptr, nullptr);
     return false;
   }
 
   // Automatically release PNG resources at end of scope.
-  PngWriteStructDeleter pngWriteDeleter(writePtr, writeInfoPtr);
+  PngWriteStructDeleter png_write_deleter(write_ptr, write_info_ptr);
 
   // libpng uses longjmp to jump to error handling routines.
   // setjmp will return true only if it was jumped to, aka, there was an error.
-  if (setjmp(png_jmpbuf(writePtr))) {
+  if (setjmp(png_jmpbuf(write_ptr))) {
     return false;
   }
 
   // Handle warnings with our IDiagnostics.
-  png_set_error_fn(writePtr, (png_voidp)context->getDiagnostics(), logError,
-                   logWarning);
+  png_set_error_fn(write_ptr, (png_voidp)context->GetDiagnostics(), LogError,
+                   LogWarning);
 
   // Set up the write functions which write to our custom data sources.
-  png_set_write_fn(writePtr, (png_voidp)out, writeDataToStream, nullptr);
+  png_set_write_fn(write_ptr, (png_voidp)out, WriteDataToStream, nullptr);
 
   // We want small files and can take the performance hit to achieve this goal.
-  png_set_compression_level(writePtr, Z_BEST_COMPRESSION);
+  png_set_compression_level(write_ptr, Z_BEST_COMPRESSION);
 
   // Begin analysis of the image data.
   // Scan the entire image and determine if:
   // 1. Every pixel has R == G == B (grayscale)
   // 2. Every pixel has A == 255 (opaque)
   // 3. There are no more than 256 distinct RGBA colors (palette).
-  std::unordered_map<uint32_t, int> colorPalette;
-  std::unordered_set<uint32_t> alphaPalette;
-  bool needsToZeroRGBChannelsOfTransparentPixels = false;
-  bool grayScale = true;
-  int maxGrayDeviation = 0;
+  std::unordered_map<uint32_t, int> color_palette;
+  std::unordered_set<uint32_t> alpha_palette;
+  bool needs_to_zero_rgb_channels_of_transparent_pixels = false;
+  bool grayscale = true;
+  int max_gray_deviation = 0;
 
   for (int32_t y = 0; y < image->height; y++) {
     const uint8_t* row = image->rows[y];
@@ -551,60 +559,60 @@ bool writePng(IAaptContext* context, const Image* image,
         // The color is completely transparent.
         // For purposes of palettes and grayscale optimization,
         // treat all channels as 0x00.
-        needsToZeroRGBChannelsOfTransparentPixels =
-            needsToZeroRGBChannelsOfTransparentPixels ||
+        needs_to_zero_rgb_channels_of_transparent_pixels =
+            needs_to_zero_rgb_channels_of_transparent_pixels ||
             (red != 0 || green != 0 || blue != 0);
         red = green = blue = 0;
       }
 
       // Insert the color into the color palette.
       const uint32_t color = red << 24 | green << 16 | blue << 8 | alpha;
-      colorPalette[color] = -1;
+      color_palette[color] = -1;
 
       // If the pixel has non-opaque alpha, insert it into the
       // alpha palette.
       if (alpha != 0xff) {
-        alphaPalette.insert(color);
+        alpha_palette.insert(color);
       }
 
       // Check if the image is indeed grayscale.
-      if (grayScale) {
+      if (grayscale) {
         if (red != green || red != blue) {
-          grayScale = false;
+          grayscale = false;
         }
       }
 
       // Calculate the gray scale deviation so that it can be compared
       // with the threshold.
-      maxGrayDeviation = std::max(std::abs(red - green), maxGrayDeviation);
-      maxGrayDeviation = std::max(std::abs(green - blue), maxGrayDeviation);
-      maxGrayDeviation = std::max(std::abs(blue - red), maxGrayDeviation);
+      max_gray_deviation = std::max(std::abs(red - green), max_gray_deviation);
+      max_gray_deviation = std::max(std::abs(green - blue), max_gray_deviation);
+      max_gray_deviation = std::max(std::abs(blue - red), max_gray_deviation);
     }
   }
 
-  if (context->verbose()) {
+  if (context->IsVerbose()) {
     DiagMessage msg;
-    msg << " paletteSize=" << colorPalette.size()
-        << " alphaPaletteSize=" << alphaPalette.size()
-        << " maxGrayDeviation=" << maxGrayDeviation
-        << " grayScale=" << (grayScale ? "true" : "false");
-    context->getDiagnostics()->note(msg);
+    msg << " paletteSize=" << color_palette.size()
+        << " alphaPaletteSize=" << alpha_palette.size()
+        << " maxGrayDeviation=" << max_gray_deviation
+        << " grayScale=" << (grayscale ? "true" : "false");
+    context->GetDiagnostics()->Note(msg);
   }
 
-  const bool convertibleToGrayScale =
-      maxGrayDeviation <= options.grayScaleTolerance;
+  const bool convertible_to_grayscale =
+      max_gray_deviation <= options.grayscale_tolerance;
 
-  const int newColorType = pickColorType(
-      image->width, image->height, grayScale, convertibleToGrayScale,
-      ninePatch != nullptr, colorPalette.size(), alphaPalette.size());
+  const int new_color_type = PickColorType(
+      image->width, image->height, grayscale, convertible_to_grayscale,
+      nine_patch != nullptr, color_palette.size(), alpha_palette.size());
 
-  if (context->verbose()) {
+  if (context->IsVerbose()) {
     DiagMessage msg;
     msg << "encoding PNG ";
-    if (ninePatch) {
+    if (nine_patch) {
       msg << "(with 9-patch) as ";
     }
-    switch (newColorType) {
+    switch (new_color_type) {
       case PNG_COLOR_TYPE_GRAY:
         msg << "GRAY";
         break;
@@ -621,137 +629,138 @@ bool writePng(IAaptContext* context, const Image* image,
         msg << "PALETTE";
         break;
       default:
-        msg << "unknown type " << newColorType;
+        msg << "unknown type " << new_color_type;
         break;
     }
-    context->getDiagnostics()->note(msg);
+    context->GetDiagnostics()->Note(msg);
   }
 
-  png_set_IHDR(writePtr, writeInfoPtr, image->width, image->height, 8,
-               newColorType, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT,
+  png_set_IHDR(write_ptr, write_info_ptr, image->width, image->height, 8,
+               new_color_type, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT,
                PNG_FILTER_TYPE_DEFAULT);
 
-  if (newColorType & PNG_COLOR_MASK_PALETTE) {
+  if (new_color_type & PNG_COLOR_MASK_PALETTE) {
     // Assigns indices to the palette, and writes the encoded palette to the
     // libpng writePtr.
-    writePalette(writePtr, writeInfoPtr, &colorPalette, &alphaPalette);
-    png_set_filter(writePtr, 0, PNG_NO_FILTERS);
+    WritePalette(write_ptr, write_info_ptr, &color_palette, &alpha_palette);
+    png_set_filter(write_ptr, 0, PNG_NO_FILTERS);
   } else {
-    png_set_filter(writePtr, 0, PNG_ALL_FILTERS);
+    png_set_filter(write_ptr, 0, PNG_ALL_FILTERS);
   }
 
-  if (ninePatch) {
-    writeNinePatch(writePtr, writeInfoPtr, ninePatch);
+  if (nine_patch) {
+    WriteNinePatch(write_ptr, write_info_ptr, nine_patch);
   }
 
   // Flush our updates to the header.
-  png_write_info(writePtr, writeInfoPtr);
+  png_write_info(write_ptr, write_info_ptr);
 
   // Write out each row of image data according to its encoding.
-  if (newColorType == PNG_COLOR_TYPE_PALETTE) {
+  if (new_color_type == PNG_COLOR_TYPE_PALETTE) {
     // 1 byte/pixel.
-    auto outRow = std::unique_ptr<png_byte[]>(new png_byte[image->width]);
+    auto out_row = std::unique_ptr<png_byte[]>(new png_byte[image->width]);
 
     for (int32_t y = 0; y < image->height; y++) {
-      png_const_bytep inRow = image->rows[y];
+      png_const_bytep in_row = image->rows[y];
       for (int32_t x = 0; x < image->width; x++) {
-        int rr = *inRow++;
-        int gg = *inRow++;
-        int bb = *inRow++;
-        int aa = *inRow++;
+        int rr = *in_row++;
+        int gg = *in_row++;
+        int bb = *in_row++;
+        int aa = *in_row++;
         if (aa == 0) {
           // Zero out color channels when transparent.
           rr = gg = bb = 0;
         }
 
         const uint32_t color = rr << 24 | gg << 16 | bb << 8 | aa;
-        const int idx = colorPalette[color];
-        assert(idx != -1);
-        outRow[x] = static_cast<png_byte>(idx);
+        const int idx = color_palette[color];
+        CHECK(idx != -1);
+        out_row[x] = static_cast<png_byte>(idx);
       }
-      png_write_row(writePtr, outRow.get());
+      png_write_row(write_ptr, out_row.get());
     }
-  } else if (newColorType == PNG_COLOR_TYPE_GRAY ||
-             newColorType == PNG_COLOR_TYPE_GRAY_ALPHA) {
-    const size_t bpp = newColorType == PNG_COLOR_TYPE_GRAY ? 1 : 2;
-    auto outRow = std::unique_ptr<png_byte[]>(new png_byte[image->width * bpp]);
+  } else if (new_color_type == PNG_COLOR_TYPE_GRAY ||
+             new_color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
+    const size_t bpp = new_color_type == PNG_COLOR_TYPE_GRAY ? 1 : 2;
+    auto out_row =
+        std::unique_ptr<png_byte[]>(new png_byte[image->width * bpp]);
 
     for (int32_t y = 0; y < image->height; y++) {
-      png_const_bytep inRow = image->rows[y];
+      png_const_bytep in_row = image->rows[y];
       for (int32_t x = 0; x < image->width; x++) {
-        int rr = inRow[x * 4];
-        int gg = inRow[x * 4 + 1];
-        int bb = inRow[x * 4 + 2];
-        int aa = inRow[x * 4 + 3];
+        int rr = in_row[x * 4];
+        int gg = in_row[x * 4 + 1];
+        int bb = in_row[x * 4 + 2];
+        int aa = in_row[x * 4 + 3];
         if (aa == 0) {
           // Zero out the gray channel when transparent.
           rr = gg = bb = 0;
         }
 
-        if (grayScale) {
+        if (grayscale) {
           // The image was already grayscale, red == green == blue.
-          outRow[x * bpp] = inRow[x * 4];
+          out_row[x * bpp] = in_row[x * 4];
         } else {
           // The image is convertible to grayscale, use linear-luminance of
           // sRGB colorspace:
           // https://en.wikipedia.org/wiki/Grayscale#Colorimetric_.28luminance-preserving.29_conversion_to_grayscale
-          outRow[x * bpp] =
+          out_row[x * bpp] =
               (png_byte)(rr * 0.2126f + gg * 0.7152f + bb * 0.0722f);
         }
 
         if (bpp == 2) {
           // Write out alpha if we have it.
-          outRow[x * bpp + 1] = aa;
+          out_row[x * bpp + 1] = aa;
         }
       }
-      png_write_row(writePtr, outRow.get());
+      png_write_row(write_ptr, out_row.get());
     }
-  } else if (newColorType == PNG_COLOR_TYPE_RGB ||
-             newColorType == PNG_COLOR_TYPE_RGBA) {
-    const size_t bpp = newColorType == PNG_COLOR_TYPE_RGB ? 3 : 4;
-    if (needsToZeroRGBChannelsOfTransparentPixels) {
+  } else if (new_color_type == PNG_COLOR_TYPE_RGB ||
+             new_color_type == PNG_COLOR_TYPE_RGBA) {
+    const size_t bpp = new_color_type == PNG_COLOR_TYPE_RGB ? 3 : 4;
+    if (needs_to_zero_rgb_channels_of_transparent_pixels) {
       // The source RGBA data can't be used as-is, because we need to zero out
       // the RGB
       // values of transparent pixels.
-      auto outRow =
+      auto out_row =
           std::unique_ptr<png_byte[]>(new png_byte[image->width * bpp]);
 
       for (int32_t y = 0; y < image->height; y++) {
-        png_const_bytep inRow = image->rows[y];
+        png_const_bytep in_row = image->rows[y];
         for (int32_t x = 0; x < image->width; x++) {
-          int rr = *inRow++;
-          int gg = *inRow++;
-          int bb = *inRow++;
-          int aa = *inRow++;
+          int rr = *in_row++;
+          int gg = *in_row++;
+          int bb = *in_row++;
+          int aa = *in_row++;
           if (aa == 0) {
             // Zero out the RGB channels when transparent.
             rr = gg = bb = 0;
           }
-          outRow[x * bpp] = rr;
-          outRow[x * bpp + 1] = gg;
-          outRow[x * bpp + 2] = bb;
+          out_row[x * bpp] = rr;
+          out_row[x * bpp + 1] = gg;
+          out_row[x * bpp + 2] = bb;
           if (bpp == 4) {
-            outRow[x * bpp + 3] = aa;
+            out_row[x * bpp + 3] = aa;
           }
         }
-        png_write_row(writePtr, outRow.get());
+        png_write_row(write_ptr, out_row.get());
       }
     } else {
       // The source image can be used as-is, just tell libpng whether or not to
       // ignore
       // the alpha channel.
-      if (newColorType == PNG_COLOR_TYPE_RGB) {
+      if (new_color_type == PNG_COLOR_TYPE_RGB) {
         // Delete the extraneous alpha values that we appended to our buffer
         // when reading the original values.
-        png_set_filler(writePtr, 0, PNG_FILLER_AFTER);
+        png_set_filler(write_ptr, 0, PNG_FILLER_AFTER);
       }
-      png_write_image(writePtr, image->rows.get());
+      png_write_image(write_ptr, image->rows.get());
     }
   } else {
-    assert(false && "unreachable");
+    LOG(FATAL) << "unreachable";
   }
 
-  png_write_end(writePtr, writeInfoPtr);
+  png_write_end(write_ptr, write_info_ptr);
   return true;
 }
 
diff --git a/tools/aapt2/compile/PseudolocaleGenerator.cpp b/tools/aapt2/compile/PseudolocaleGenerator.cpp
index d8ed0bba951e5..055a725213b7d 100644
--- a/tools/aapt2/compile/PseudolocaleGenerator.cpp
+++ b/tools/aapt2/compile/PseudolocaleGenerator.cpp
@@ -15,27 +15,29 @@
  */
 
 #include "compile/PseudolocaleGenerator.h"
+
+#include <algorithm>
+
 #include "ResourceTable.h"
 #include "ResourceValues.h"
 #include "ValueVisitor.h"
 #include "compile/Pseudolocalizer.h"
 
-#include <algorithm>
-
 namespace aapt {
 
-std::unique_ptr<StyledString> pseudolocalizeStyledString(
+std::unique_ptr<StyledString> PseudolocalizeStyledString(
     StyledString* string, Pseudolocalizer::Method method, StringPool* pool) {
   Pseudolocalizer localizer(method);
 
-  const StringPiece originalText = *string->value->str;
+  const StringPiece original_text = *string->value->str;
 
   StyleString localized;
 
   // Copy the spans. We will update their offsets when we localize.
   localized.spans.reserve(string->value->spans.size());
   for (const StringPool::Span& span : string->value->spans) {
-    localized.spans.push_back(Span{*span.name, span.firstChar, span.lastChar});
+    localized.spans.push_back(
+        Span{*span.name, span.first_char, span.last_char});
   }
 
   // The ranges are all represented with a single value. This is the start of
@@ -49,8 +51,8 @@ std::unique_ptr<StyledString> pseudolocalizeStyledString(
     // Since this struct represents the start of one range and end of another,
     // we have
     // the two pointers respectively.
-    uint32_t* updateStart;
-    uint32_t* updateEnd;
+    uint32_t* update_start;
+    uint32_t* update_end;
   };
 
   auto cmp = [](const Range& r, size_t index) -> bool {
@@ -64,109 +66,113 @@ std::unique_ptr<StyledString> pseudolocalizeStyledString(
   //
   std::vector<Range> ranges;
   ranges.push_back(Range{0});
-  ranges.push_back(Range{originalText.size() - 1});
+  ranges.push_back(Range{original_text.size() - 1});
   for (size_t i = 0; i < string->value->spans.size(); i++) {
     const StringPool::Span& span = string->value->spans[i];
 
     // Insert or update the Range marker for the start of this span.
     auto iter =
-        std::lower_bound(ranges.begin(), ranges.end(), span.firstChar, cmp);
-    if (iter != ranges.end() && iter->start == span.firstChar) {
-      iter->updateStart = &localized.spans[i].firstChar;
+        std::lower_bound(ranges.begin(), ranges.end(), span.first_char, cmp);
+    if (iter != ranges.end() && iter->start == span.first_char) {
+      iter->update_start = &localized.spans[i].first_char;
     } else {
-      ranges.insert(
-          iter, Range{span.firstChar, &localized.spans[i].firstChar, nullptr});
+      ranges.insert(iter, Range{span.first_char, &localized.spans[i].first_char,
+                                nullptr});
     }
 
     // Insert or update the Range marker for the end of this span.
-    iter = std::lower_bound(ranges.begin(), ranges.end(), span.lastChar, cmp);
-    if (iter != ranges.end() && iter->start == span.lastChar) {
-      iter->updateEnd = &localized.spans[i].lastChar;
+    iter = std::lower_bound(ranges.begin(), ranges.end(), span.last_char, cmp);
+    if (iter != ranges.end() && iter->start == span.last_char) {
+      iter->update_end = &localized.spans[i].last_char;
     } else {
       ranges.insert(
-          iter, Range{span.lastChar, nullptr, &localized.spans[i].lastChar});
+          iter, Range{span.last_char, nullptr, &localized.spans[i].last_char});
     }
   }
 
-  localized.str += localizer.start();
+  localized.str += localizer.Start();
 
   // Iterate over the ranges and localize each section.
   for (size_t i = 0; i < ranges.size(); i++) {
     const size_t start = ranges[i].start;
-    size_t len = originalText.size() - start;
+    size_t len = original_text.size() - start;
     if (i + 1 < ranges.size()) {
       len = ranges[i + 1].start - start;
     }
 
-    if (ranges[i].updateStart) {
-      *ranges[i].updateStart = localized.str.size();
+    if (ranges[i].update_start) {
+      *ranges[i].update_start = localized.str.size();
     }
 
-    if (ranges[i].updateEnd) {
-      *ranges[i].updateEnd = localized.str.size();
+    if (ranges[i].update_end) {
+      *ranges[i].update_end = localized.str.size();
     }
 
-    localized.str += localizer.text(originalText.substr(start, len));
+    localized.str += localizer.Text(original_text.substr(start, len));
   }
 
-  localized.str += localizer.end();
+  localized.str += localizer.End();
 
-  std::unique_ptr<StyledString> localizedString =
-      util::make_unique<StyledString>(pool->makeRef(localized));
-  localizedString->setSource(string->getSource());
-  return localizedString;
+  std::unique_ptr<StyledString> localized_string =
+      util::make_unique<StyledString>(pool->MakeRef(localized));
+  localized_string->SetSource(string->GetSource());
+  return localized_string;
 }
 
 namespace {
 
-struct Visitor : public RawValueVisitor {
-  StringPool* mPool;
-  Pseudolocalizer::Method mMethod;
-  Pseudolocalizer mLocalizer;
-
+class Visitor : public RawValueVisitor {
+ public:
   // Either value or item will be populated upon visiting the value.
-  std::unique_ptr<Value> mValue;
-  std::unique_ptr<Item> mItem;
+  std::unique_ptr<Value> value;
+  std::unique_ptr<Item> item;
 
   Visitor(StringPool* pool, Pseudolocalizer::Method method)
-      : mPool(pool), mMethod(method), mLocalizer(method) {}
+      : pool_(pool), method_(method), localizer_(method) {}
 
-  void visit(Plural* plural) override {
+  void Visit(Plural* plural) override {
     std::unique_ptr<Plural> localized = util::make_unique<Plural>();
     for (size_t i = 0; i < plural->values.size(); i++) {
-      Visitor subVisitor(mPool, mMethod);
+      Visitor sub_visitor(pool_, method_);
       if (plural->values[i]) {
-        plural->values[i]->accept(&subVisitor);
-        if (subVisitor.mValue) {
-          localized->values[i] = std::move(subVisitor.mItem);
+        plural->values[i]->Accept(&sub_visitor);
+        if (sub_visitor.value) {
+          localized->values[i] = std::move(sub_visitor.item);
         } else {
           localized->values[i] =
-              std::unique_ptr<Item>(plural->values[i]->clone(mPool));
+              std::unique_ptr<Item>(plural->values[i]->Clone(pool_));
         }
       }
     }
-    localized->setSource(plural->getSource());
-    localized->setWeak(true);
-    mValue = std::move(localized);
+    localized->SetSource(plural->GetSource());
+    localized->SetWeak(true);
+    value = std::move(localized);
   }
 
-  void visit(String* string) override {
+  void Visit(String* string) override {
     std::string result =
-        mLocalizer.start() + mLocalizer.text(*string->value) + mLocalizer.end();
+        localizer_.Start() + localizer_.Text(*string->value) + localizer_.End();
     std::unique_ptr<String> localized =
-        util::make_unique<String>(mPool->makeRef(result));
-    localized->setSource(string->getSource());
-    localized->setWeak(true);
-    mItem = std::move(localized);
+        util::make_unique<String>(pool_->MakeRef(result));
+    localized->SetSource(string->GetSource());
+    localized->SetWeak(true);
+    item = std::move(localized);
   }
 
-  void visit(StyledString* string) override {
-    mItem = pseudolocalizeStyledString(string, mMethod, mPool);
-    mItem->setWeak(true);
+  void Visit(StyledString* string) override {
+    item = PseudolocalizeStyledString(string, method_, pool_);
+    item->SetWeak(true);
   }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(Visitor);
+
+  StringPool* pool_;
+  Pseudolocalizer::Method method_;
+  Pseudolocalizer localizer_;
 };
 
-ConfigDescription modifyConfigForPseudoLocale(const ConfigDescription& base,
+ConfigDescription ModifyConfigForPseudoLocale(const ConfigDescription& base,
                                               Pseudolocalizer::Method m) {
   ConfigDescription modified = base;
   switch (m) {
@@ -189,31 +195,31 @@ ConfigDescription modifyConfigForPseudoLocale(const ConfigDescription& base,
   return modified;
 }
 
-void pseudolocalizeIfNeeded(const Pseudolocalizer::Method method,
-                            ResourceConfigValue* originalValue,
+void PseudolocalizeIfNeeded(const Pseudolocalizer::Method method,
+                            ResourceConfigValue* original_value,
                             StringPool* pool, ResourceEntry* entry) {
   Visitor visitor(pool, method);
-  originalValue->value->accept(&visitor);
+  original_value->value->Accept(&visitor);
 
-  std::unique_ptr<Value> localizedValue;
-  if (visitor.mValue) {
-    localizedValue = std::move(visitor.mValue);
-  } else if (visitor.mItem) {
-    localizedValue = std::move(visitor.mItem);
+  std::unique_ptr<Value> localized_value;
+  if (visitor.value) {
+    localized_value = std::move(visitor.value);
+  } else if (visitor.item) {
+    localized_value = std::move(visitor.item);
   }
 
-  if (!localizedValue) {
+  if (!localized_value) {
     return;
   }
 
-  ConfigDescription configWithAccent =
-      modifyConfigForPseudoLocale(originalValue->config, method);
+  ConfigDescription config_with_accent =
+      ModifyConfigForPseudoLocale(original_value->config, method);
 
-  ResourceConfigValue* newConfigValue =
-      entry->findOrCreateValue(configWithAccent, originalValue->product);
-  if (!newConfigValue->value) {
+  ResourceConfigValue* new_config_value =
+      entry->FindOrCreateValue(config_with_accent, original_value->product);
+  if (!new_config_value->value) {
     // Only use auto-generated pseudo-localization if none is defined.
-    newConfigValue->value = std::move(localizedValue);
+    new_config_value->value = std::move(localized_value);
   }
 }
 
@@ -222,29 +228,30 @@ void pseudolocalizeIfNeeded(const Pseudolocalizer::Method method,
  * default locale)
  * and is translateable.
  */
-static bool isPseudolocalizable(ResourceConfigValue* configValue) {
-  const int diff = configValue->config.diff(ConfigDescription::defaultConfig());
+static bool IsPseudolocalizable(ResourceConfigValue* config_value) {
+  const int diff =
+      config_value->config.diff(ConfigDescription::DefaultConfig());
   if (diff & ConfigDescription::CONFIG_LOCALE) {
     return false;
   }
-  return configValue->value->isTranslateable();
+  return config_value->value->IsTranslateable();
 }
 
 }  // namespace
 
-bool PseudolocaleGenerator::consume(IAaptContext* context,
+bool PseudolocaleGenerator::Consume(IAaptContext* context,
                                     ResourceTable* table) {
   for (auto& package : table->packages) {
     for (auto& type : package->types) {
       for (auto& entry : type->entries) {
         std::vector<ResourceConfigValue*> values =
-            entry->findValuesIf(isPseudolocalizable);
+            entry->FindValuesIf(IsPseudolocalizable);
 
         for (ResourceConfigValue* value : values) {
-          pseudolocalizeIfNeeded(Pseudolocalizer::Method::kAccent, value,
-                                 &table->stringPool, entry.get());
-          pseudolocalizeIfNeeded(Pseudolocalizer::Method::kBidi, value,
-                                 &table->stringPool, entry.get());
+          PseudolocalizeIfNeeded(Pseudolocalizer::Method::kAccent, value,
+                                 &table->string_pool, entry.get());
+          PseudolocalizeIfNeeded(Pseudolocalizer::Method::kBidi, value,
+                                 &table->string_pool, entry.get());
         }
       }
     }
diff --git a/tools/aapt2/compile/PseudolocaleGenerator.h b/tools/aapt2/compile/PseudolocaleGenerator.h
index 4e97cb989e683..ace378603f654 100644
--- a/tools/aapt2/compile/PseudolocaleGenerator.h
+++ b/tools/aapt2/compile/PseudolocaleGenerator.h
@@ -23,11 +23,11 @@
 
 namespace aapt {
 
-std::unique_ptr<StyledString> pseudolocalizeStyledString(
+std::unique_ptr<StyledString> PseudolocalizeStyledString(
     StyledString* string, Pseudolocalizer::Method method, StringPool* pool);
 
 struct PseudolocaleGenerator : public IResourceTableConsumer {
-  bool consume(IAaptContext* context, ResourceTable* table) override;
+  bool Consume(IAaptContext* context, ResourceTable* table) override;
 };
 
 }  // namespace aapt
diff --git a/tools/aapt2/compile/PseudolocaleGenerator_test.cpp b/tools/aapt2/compile/PseudolocaleGenerator_test.cpp
index 64a3e97a5aa6c..5a9884d34dd1b 100644
--- a/tools/aapt2/compile/PseudolocaleGenerator_test.cpp
+++ b/tools/aapt2/compile/PseudolocaleGenerator_test.cpp
@@ -15,118 +15,119 @@
  */
 
 #include "compile/PseudolocaleGenerator.h"
+
 #include "test/Test.h"
 #include "util/Util.h"
 
-#include <androidfw/ResourceTypes.h>
-
 namespace aapt {
 
 TEST(PseudolocaleGeneratorTest, PseudolocalizeStyledString) {
   StringPool pool;
-  StyleString originalStyle;
-  originalStyle.str = "Hello world!";
-  originalStyle.spans = {Span{"b", 2, 3}, Span{"b", 6, 7}, Span{"i", 1, 10}};
+  StyleString original_style;
+  original_style.str = "Hello world!";
+  original_style.spans = {Span{"b", 2, 3}, Span{"b", 6, 7}, Span{"i", 1, 10}};
 
-  std::unique_ptr<StyledString> newString = pseudolocalizeStyledString(
-      util::make_unique<StyledString>(pool.makeRef(originalStyle)).get(),
+  std::unique_ptr<StyledString> new_string = PseudolocalizeStyledString(
+      util::make_unique<StyledString>(pool.MakeRef(original_style)).get(),
       Pseudolocalizer::Method::kNone, &pool);
 
-  EXPECT_EQ(originalStyle.str, *newString->value->str);
-  ASSERT_EQ(originalStyle.spans.size(), newString->value->spans.size());
+  EXPECT_EQ(original_style.str, *new_string->value->str);
+  ASSERT_EQ(original_style.spans.size(), new_string->value->spans.size());
 
-  EXPECT_EQ(std::string("He").size(), newString->value->spans[0].firstChar);
-  EXPECT_EQ(std::string("Hel").size(), newString->value->spans[0].lastChar);
-  EXPECT_EQ(std::string("b"), *newString->value->spans[0].name);
+  EXPECT_EQ(std::string("He").size(), new_string->value->spans[0].first_char);
+  EXPECT_EQ(std::string("Hel").size(), new_string->value->spans[0].last_char);
+  EXPECT_EQ(std::string("b"), *new_string->value->spans[0].name);
 
-  EXPECT_EQ(std::string("Hello ").size(), newString->value->spans[1].firstChar);
-  EXPECT_EQ(std::string("Hello w").size(), newString->value->spans[1].lastChar);
-  EXPECT_EQ(std::string("b"), *newString->value->spans[1].name);
+  EXPECT_EQ(std::string("Hello ").size(),
+            new_string->value->spans[1].first_char);
+  EXPECT_EQ(std::string("Hello w").size(),
+            new_string->value->spans[1].last_char);
+  EXPECT_EQ(std::string("b"), *new_string->value->spans[1].name);
 
-  EXPECT_EQ(std::string("H").size(), newString->value->spans[2].firstChar);
+  EXPECT_EQ(std::string("H").size(), new_string->value->spans[2].first_char);
   EXPECT_EQ(std::string("Hello worl").size(),
-            newString->value->spans[2].lastChar);
-  EXPECT_EQ(std::string("i"), *newString->value->spans[2].name);
+            new_string->value->spans[2].last_char);
+  EXPECT_EQ(std::string("i"), *new_string->value->spans[2].name);
 
-  originalStyle.spans.push_back(Span{"em", 0, 11u});
+  original_style.spans.push_back(Span{"em", 0, 11u});
 
-  newString = pseudolocalizeStyledString(
-      util::make_unique<StyledString>(pool.makeRef(originalStyle)).get(),
+  new_string = PseudolocalizeStyledString(
+      util::make_unique<StyledString>(pool.MakeRef(original_style)).get(),
       Pseudolocalizer::Method::kAccent, &pool);
 
-  EXPECT_EQ(std::string("[Ĥéļļö ŵöŕļð¡ one two]"), *newString->value->str);
-  ASSERT_EQ(originalStyle.spans.size(), newString->value->spans.size());
+  EXPECT_EQ(std::string("[Ĥéļļö ŵöŕļð¡ one two]"), *new_string->value->str);
+  ASSERT_EQ(original_style.spans.size(), new_string->value->spans.size());
 
-  EXPECT_EQ(std::string("[Ĥé").size(), newString->value->spans[0].firstChar);
-  EXPECT_EQ(std::string("[Ĥéļ").size(), newString->value->spans[0].lastChar);
+  EXPECT_EQ(std::string("[Ĥé").size(), new_string->value->spans[0].first_char);
+  EXPECT_EQ(std::string("[Ĥéļ").size(), new_string->value->spans[0].last_char);
 
   EXPECT_EQ(std::string("[Ĥéļļö ").size(),
-            newString->value->spans[1].firstChar);
+            new_string->value->spans[1].first_char);
   EXPECT_EQ(std::string("[Ĥéļļö ŵ").size(),
-            newString->value->spans[1].lastChar);
+            new_string->value->spans[1].last_char);
 
-  EXPECT_EQ(std::string("[Ĥ").size(), newString->value->spans[2].firstChar);
+  EXPECT_EQ(std::string("[Ĥ").size(), new_string->value->spans[2].first_char);
   EXPECT_EQ(std::string("[Ĥéļļö ŵöŕļ").size(),
-            newString->value->spans[2].lastChar);
+            new_string->value->spans[2].last_char);
 
-  EXPECT_EQ(std::string("[").size(), newString->value->spans[3].firstChar);
+  EXPECT_EQ(std::string("[").size(), new_string->value->spans[3].first_char);
   EXPECT_EQ(std::string("[Ĥéļļö ŵöŕļð").size(),
-            newString->value->spans[3].lastChar);
+            new_string->value->spans[3].last_char);
 }
 
 TEST(PseudolocaleGeneratorTest, PseudolocalizeOnlyDefaultConfigs) {
   std::unique_ptr<ResourceTable> table =
       test::ResourceTableBuilder()
-          .addString("android:string/one", "one")
-          .addString("android:string/two", ResourceId{},
-                     test::parseConfigOrDie("en"), "two")
-          .addString("android:string/three", "three")
-          .addString("android:string/three", ResourceId{},
-                     test::parseConfigOrDie("en-rXA"), "three")
-          .addString("android:string/four", "four")
-          .build();
+          .AddString("android:string/one", "one")
+          .AddString("android:string/two", ResourceId{},
+                     test::ParseConfigOrDie("en"), "two")
+          .AddString("android:string/three", "three")
+          .AddString("android:string/three", ResourceId{},
+                     test::ParseConfigOrDie("en-rXA"), "three")
+          .AddString("android:string/four", "four")
+          .Build();
 
-  String* val = test::getValue<String>(table.get(), "android:string/four");
+  String* val = test::GetValue<String>(table.get(), "android:string/four");
   ASSERT_NE(nullptr, val);
-  val->setTranslateable(false);
+  val->SetTranslateable(false);
 
-  std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
+  std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
   PseudolocaleGenerator generator;
-  ASSERT_TRUE(generator.consume(context.get(), table.get()));
+  ASSERT_TRUE(generator.Consume(context.get(), table.get()));
 
   // Normal pseudolocalization should take place.
   ASSERT_NE(nullptr,
-            test::getValueForConfig<String>(table.get(), "android:string/one",
-                                            test::parseConfigOrDie("en-rXA")));
+            test::GetValueForConfig<String>(table.get(), "android:string/one",
+                                            test::ParseConfigOrDie("en-rXA")));
   ASSERT_NE(nullptr,
-            test::getValueForConfig<String>(table.get(), "android:string/one",
-                                            test::parseConfigOrDie("ar-rXB")));
+            test::GetValueForConfig<String>(table.get(), "android:string/one",
+                                            test::ParseConfigOrDie("ar-rXB")));
 
   // No default config for android:string/two, so no pseudlocales should exist.
   ASSERT_EQ(nullptr,
-            test::getValueForConfig<String>(table.get(), "android:string/two",
-                                            test::parseConfigOrDie("en-rXA")));
+            test::GetValueForConfig<String>(table.get(), "android:string/two",
+                                            test::ParseConfigOrDie("en-rXA")));
   ASSERT_EQ(nullptr,
-            test::getValueForConfig<String>(table.get(), "android:string/two",
-                                            test::parseConfigOrDie("ar-rXB")));
+            test::GetValueForConfig<String>(table.get(), "android:string/two",
+                                            test::ParseConfigOrDie("ar-rXB")));
 
   // Check that we didn't override manual pseudolocalization.
-  val = test::getValueForConfig<String>(table.get(), "android:string/three",
-                                        test::parseConfigOrDie("en-rXA"));
+  val = test::GetValueForConfig<String>(table.get(), "android:string/three",
+                                        test::ParseConfigOrDie("en-rXA"));
   ASSERT_NE(nullptr, val);
   EXPECT_EQ(std::string("three"), *val->value);
 
   ASSERT_NE(nullptr,
-            test::getValueForConfig<String>(table.get(), "android:string/three",
-                                            test::parseConfigOrDie("ar-rXB")));
+            test::GetValueForConfig<String>(table.get(), "android:string/three",
+                                            test::ParseConfigOrDie("ar-rXB")));
 
   // Check that four's translateable marker was honored.
   ASSERT_EQ(nullptr,
-            test::getValueForConfig<String>(table.get(), "android:string/four",
-                                            test::parseConfigOrDie("en-rXA")));
+            test::GetValueForConfig<String>(table.get(), "android:string/four",
+                                            test::ParseConfigOrDie("en-rXA")));
   ASSERT_EQ(nullptr,
-            test::getValueForConfig<String>(table.get(), "android:string/four",
-                                            test::parseConfigOrDie("ar-rXB")));
+            test::GetValueForConfig<String>(table.get(), "android:string/four",
+                                            test::ParseConfigOrDie("ar-rXB")));
 }
 
 }  // namespace aapt
diff --git a/tools/aapt2/compile/Pseudolocalizer.cpp b/tools/aapt2/compile/Pseudolocalizer.cpp
index c3aec98d89e0a..f89288f733338 100644
--- a/tools/aapt2/compile/Pseudolocalizer.cpp
+++ b/tools/aapt2/compile/Pseudolocalizer.cpp
@@ -15,77 +15,78 @@
  */
 
 #include "compile/Pseudolocalizer.h"
+
 #include "util/Util.h"
 
 namespace aapt {
 
 // String basis to generate expansion
-static const std::string k_expansion_string =
+static const std::string kExpansionString =
     "one two three "
     "four five six seven eight nine ten eleven twelve thirteen "
     "fourteen fiveteen sixteen seventeen nineteen twenty";
 
 // Special unicode characters to override directionality of the words
-static const std::string k_rlm = "\u200f";
-static const std::string k_rlo = "\u202e";
-static const std::string k_pdf = "\u202c";
+static const std::string kRlm = "\u200f";
+static const std::string kRlo = "\u202e";
+static const std::string kPdf = "\u202c";
 
 // Placeholder marks
-static const std::string k_placeholder_open = "\u00bb";
-static const std::string k_placeholder_close = "\u00ab";
+static const std::string kPlaceholderOpen = "\u00bb";
+static const std::string kPlaceholderClose = "\u00ab";
 
-static const char k_arg_start = '{';
-static const char k_arg_end = '}';
+static const char kArgStart = '{';
+static const char kArgEnd = '}';
 
 class PseudoMethodNone : public PseudoMethodImpl {
  public:
-  std::string text(const StringPiece& text) override { return text.toString(); }
-  std::string placeholder(const StringPiece& text) override {
-    return text.toString();
+  std::string Text(const StringPiece& text) override { return text.ToString(); }
+  std::string Placeholder(const StringPiece& text) override {
+    return text.ToString();
   }
 };
 
 class PseudoMethodBidi : public PseudoMethodImpl {
  public:
-  std::string text(const StringPiece& text) override;
-  std::string placeholder(const StringPiece& text) override;
+  std::string Text(const StringPiece& text) override;
+  std::string Placeholder(const StringPiece& text) override;
 };
 
 class PseudoMethodAccent : public PseudoMethodImpl {
  public:
-  PseudoMethodAccent() : mDepth(0), mWordCount(0), mLength(0) {}
-  std::string start() override;
-  std::string end() override;
-  std::string text(const StringPiece& text) override;
-  std::string placeholder(const StringPiece& text) override;
+  PseudoMethodAccent() : depth_(0), word_count_(0), length_(0) {}
+  std::string Start() override;
+  std::string End() override;
+  std::string Text(const StringPiece& text) override;
+  std::string Placeholder(const StringPiece& text) override;
 
  private:
-  size_t mDepth;
-  size_t mWordCount;
-  size_t mLength;
+  size_t depth_;
+  size_t word_count_;
+  size_t length_;
 };
 
-Pseudolocalizer::Pseudolocalizer(Method method) : mLastDepth(0) {
-  setMethod(method);
+Pseudolocalizer::Pseudolocalizer(Method method) : last_depth_(0) {
+  SetMethod(method);
 }
 
-void Pseudolocalizer::setMethod(Method method) {
+void Pseudolocalizer::SetMethod(Method method) {
   switch (method) {
     case Method::kNone:
-      mImpl = util::make_unique<PseudoMethodNone>();
+      impl_ = util::make_unique<PseudoMethodNone>();
       break;
     case Method::kAccent:
-      mImpl = util::make_unique<PseudoMethodAccent>();
+      impl_ = util::make_unique<PseudoMethodAccent>();
       break;
     case Method::kBidi:
-      mImpl = util::make_unique<PseudoMethodBidi>();
+      impl_ = util::make_unique<PseudoMethodBidi>();
       break;
   }
 }
 
-std::string Pseudolocalizer::text(const StringPiece& text) {
+std::string Pseudolocalizer::Text(const StringPiece& text) {
   std::string out;
-  size_t depth = mLastDepth;
+  size_t depth = last_depth_;
   size_t lastpos, pos;
   const size_t length = text.size();
   const char* str = text.data();
@@ -101,42 +102,41 @@ std::string Pseudolocalizer::text(const StringPiece& text) {
       continue;
     }
 
-    if (c == k_arg_start) {
+    if (c == kArgStart) {
       depth++;
-    } else if (c == k_arg_end && depth) {
+    } else if (c == kArgEnd && depth) {
       depth--;
     }
 
-    if (mLastDepth != depth || pos == length - 1) {
-      bool pseudo = ((mLastDepth % 2) == 0);
+    if (last_depth_ != depth || pos == length - 1) {
+      bool pseudo = ((last_depth_ % 2) == 0);
       size_t nextpos = pos;
-      if (!pseudo || depth == mLastDepth) {
+      if (!pseudo || depth == last_depth_) {
         nextpos++;
       }
       size_t size = nextpos - lastpos;
       if (size) {
-        std::string chunk = text.substr(lastpos, size).toString();
+        std::string chunk = text.substr(lastpos, size).ToString();
         if (pseudo) {
-          chunk = mImpl->text(chunk);
-        } else if (str[lastpos] == k_arg_start &&
-                   str[nextpos - 1] == k_arg_end) {
-          chunk = mImpl->placeholder(chunk);
+          chunk = impl_->Text(chunk);
+        } else if (str[lastpos] == kArgStart && str[nextpos - 1] == kArgEnd) {
+          chunk = impl_->Placeholder(chunk);
         }
         out.append(chunk);
       }
-      if (pseudo && depth < mLastDepth) {  // End of message
-        out.append(mImpl->end());
-      } else if (!pseudo && depth > mLastDepth) {  // Start of message
-        out.append(mImpl->start());
+      if (pseudo && depth < last_depth_) {  // End of message
+        out.append(impl_->End());
+      } else if (!pseudo && depth > last_depth_) {  // Start of message
+        out.append(impl_->Start());
       }
       lastpos = nextpos;
-      mLastDepth = depth;
+      last_depth_ = depth;
     }
   }
   return out;
 }
 
-static const char* pseudolocalizeChar(const char c) {
+static const char* PseudolocalizeChar(const char c) {
   switch (c) {
     case 'a':
       return "\u00e5";
@@ -251,7 +251,7 @@ static const char* pseudolocalizeChar(const char c) {
   }
 }
 
-static bool isPossibleNormalPlaceholderEnd(const char c) {
+static bool IsPossibleNormalPlaceholderEnd(const char c) {
   switch (c) {
     case 's':
       return true;
@@ -300,12 +300,12 @@ static bool isPossibleNormalPlaceholderEnd(const char c) {
   }
 }
 
-static std::string pseudoGenerateExpansion(const unsigned int length) {
-  std::string result = k_expansion_string;
+static std::string PseudoGenerateExpansion(const unsigned int length) {
+  std::string result = kExpansionString;
   const char* s = result.data();
   if (result.size() < length) {
     result += " ";
-    result += pseudoGenerateExpansion(length - result.size());
+    result += PseudoGenerateExpansion(length - result.size());
   } else {
     int ext = 0;
     // Should contain only whole words, so looking for a space
@@ -320,25 +320,25 @@ static std::string pseudoGenerateExpansion(const unsigned int length) {
   return result;
 }
 
-std::string PseudoMethodAccent::start() {
+std::string PseudoMethodAccent::Start() {
   std::string result;
-  if (mDepth == 0) {
+  if (depth_ == 0) {
     result = "[";
   }
-  mWordCount = mLength = 0;
-  mDepth++;
+  word_count_ = length_ = 0;
+  depth_++;
   return result;
 }
 
-std::string PseudoMethodAccent::end() {
+std::string PseudoMethodAccent::End() {
   std::string result;
-  if (mLength) {
+  if (length_) {
     result += " ";
-    result += pseudoGenerateExpansion(mWordCount > 3 ? mLength : mLength / 2);
+    result += PseudoGenerateExpansion(word_count_ > 3 ? length_ : length_ / 2);
   }
-  mWordCount = mLength = 0;
-  mDepth--;
-  if (mDepth == 0) {
+  word_count_ = length_ = 0;
+  depth_--;
+  if (depth_ == 0) {
     result += "]";
   }
   return result;
@@ -349,7 +349,7 @@ std::string PseudoMethodAccent::end() {
  *
  * Note: This leaves placeholder syntax untouched.
  */
-std::string PseudoMethodAccent::text(const StringPiece& source) {
+std::string PseudoMethodAccent::Text(const StringPiece& source) {
   const char* s = source.data();
   std::string result;
   const size_t I = source.size();
@@ -365,7 +365,7 @@ std::string PseudoMethodAccent::text(const StringPiece& source) {
         ++i;
         c = s[i];
         chunk.append(&c, 1);
-        if (isPossibleNormalPlaceholderEnd(c)) {
+        if (IsPossibleNormalPlaceholderEnd(c)) {
           end = true;
         } else if (i + 1 < I && c == 't') {
           ++i;
@@ -375,24 +375,24 @@ std::string PseudoMethodAccent::text(const StringPiece& source) {
         }
       }
       // Treat chunk as a placeholder unless it ends with %.
-      result += ((c == '%') ? chunk : placeholder(chunk));
+      result += ((c == '%') ? chunk : Placeholder(chunk));
     } else if (c == '<' || c == '&') {
       // html syntax, no need to pseudolocalize
       bool tag_closed = false;
       while (!tag_closed && i < I) {
         if (c == '&') {
-          std::string escapeText;
-          escapeText.append(&c, 1);
+          std::string escape_text;
+          escape_text.append(&c, 1);
           bool end = false;
-          size_t htmlCodePos = i;
-          while (!end && htmlCodePos < I) {
-            ++htmlCodePos;
-            c = s[htmlCodePos];
-            escapeText.append(&c, 1);
+          size_t html_code_pos = i;
+          while (!end && html_code_pos < I) {
+            ++html_code_pos;
+            c = s[html_code_pos];
+            escape_text.append(&c, 1);
             // Valid html code
             if (c == ';') {
               end = true;
-              i = htmlCodePos;
+              i = html_code_pos;
             }
             // Wrong html code
             else if (!((c == '#' || (c >= 'a' && c <= 'z') ||
@@ -400,8 +400,8 @@ std::string PseudoMethodAccent::text(const StringPiece& source) {
               end = true;
             }
           }
-          result += escapeText;
-          if (escapeText != "&lt;") {
+          result += escape_text;
+          if (escape_text != "&lt;") {
             tag_closed = true;
           }
           continue;
@@ -417,30 +417,30 @@ std::string PseudoMethodAccent::text(const StringPiece& source) {
       }
     } else {
       // This is a pure text that should be pseudolocalized
-      const char* p = pseudolocalizeChar(c);
+      const char* p = PseudolocalizeChar(c);
       if (p != nullptr) {
         result += p;
       } else {
         bool space = isspace(c);
         if (lastspace && !space) {
-          mWordCount++;
+          word_count_++;
         }
         lastspace = space;
         result.append(&c, 1);
       }
       // Count only pseudolocalizable chars and delimiters
-      mLength++;
+      length_++;
     }
   }
   return result;
 }
 
-std::string PseudoMethodAccent::placeholder(const StringPiece& source) {
+std::string PseudoMethodAccent::Placeholder(const StringPiece& source) {
   // Surround a placeholder with brackets
-  return k_placeholder_open + source.toString() + k_placeholder_close;
+  return kPlaceholderOpen + source.ToString() + kPlaceholderClose;
 }
 
-std::string PseudoMethodBidi::text(const StringPiece& source) {
+std::string PseudoMethodBidi::Text(const StringPiece& source) {
   const char* s = source.data();
   std::string result;
   bool lastspace = true;
@@ -450,24 +450,24 @@ std::string PseudoMethodBidi::text(const StringPiece& source) {
     space = isspace(c);
     if (lastspace && !space) {
       // Word start
-      result += k_rlm + k_rlo;
+      result += kRlm + kRlo;
     } else if (!lastspace && space) {
       // Word end
-      result += k_pdf + k_rlm;
+      result += kPdf + kRlm;
     }
     lastspace = space;
     result.append(&c, 1);
   }
   if (!lastspace) {
     // End of last word
-    result += k_pdf + k_rlm;
+    result += kPdf + kRlm;
   }
   return result;
 }
 
-std::string PseudoMethodBidi::placeholder(const StringPiece& source) {
+std::string PseudoMethodBidi::Placeholder(const StringPiece& source) {
   // Surround a placeholder with directionality change sequence
-  return k_rlm + k_rlo + source.toString() + k_pdf + k_rlm;
+  return kRlm + kRlo + source.ToString() + kPdf + kRlm;
 }
 
 }  // namespace aapt
diff --git a/tools/aapt2/compile/Pseudolocalizer.h b/tools/aapt2/compile/Pseudolocalizer.h
index a526877b47378..a6d2ad037d50e 100644
--- a/tools/aapt2/compile/Pseudolocalizer.h
+++ b/tools/aapt2/compile/Pseudolocalizer.h
@@ -17,22 +17,23 @@
 #ifndef AAPT_COMPILE_PSEUDOLOCALIZE_H
 #define AAPT_COMPILE_PSEUDOLOCALIZE_H
 
+#include <memory>
+
+#include "android-base/macros.h"
+
 #include "ResourceValues.h"
 #include "StringPool.h"
 #include "util/StringPiece.h"
 
-#include <android-base/macros.h>
-#include <memory>
-
 namespace aapt {
 
 class PseudoMethodImpl {
  public:
   virtual ~PseudoMethodImpl() {}
-  virtual std::string start() { return {}; }
-  virtual std::string end() { return {}; }
-  virtual std::string text(const StringPiece& text) = 0;
-  virtual std::string placeholder(const StringPiece& text) = 0;
+  virtual std::string Start() { return {}; }
+  virtual std::string End() { return {}; }
+  virtual std::string Text(const StringPiece& text) = 0;
+  virtual std::string Placeholder(const StringPiece& text) = 0;
 };
 
 class Pseudolocalizer {
@@ -44,14 +45,14 @@ class Pseudolocalizer {
   };
 
   explicit Pseudolocalizer(Method method);
-  void setMethod(Method method);
-  std::string start() { return mImpl->start(); }
-  std::string end() { return mImpl->end(); }
-  std::string text(const StringPiece& text);
+  void SetMethod(Method method);
+  std::string Start() { return impl_->Start(); }
+  std::string End() { return impl_->End(); }
+  std::string Text(const StringPiece& text);
 
  private:
-  std::unique_ptr<PseudoMethodImpl> mImpl;
-  size_t mLastDepth;
+  std::unique_ptr<PseudoMethodImpl> impl_;
+  size_t last_depth_;
 };
 
 }  // namespace aapt
diff --git a/tools/aapt2/compile/Pseudolocalizer_test.cpp b/tools/aapt2/compile/Pseudolocalizer_test.cpp
index a152ed6d00cf6..92eb3b58515ff 100644
--- a/tools/aapt2/compile/Pseudolocalizer_test.cpp
+++ b/tools/aapt2/compile/Pseudolocalizer_test.cpp
@@ -15,33 +15,32 @@
  */
 
 #include "compile/Pseudolocalizer.h"
-#include "util/Util.h"
 
-#include <androidfw/ResourceTypes.h>
-#include <gtest/gtest.h>
+#include "test/Test.h"
+#include "util/Util.h"
 
 namespace aapt {
 
 // In this context, 'Axis' represents a particular field in the configuration,
 // such as language or density.
 
-static ::testing::AssertionResult simpleHelper(const char* input,
+static ::testing::AssertionResult SimpleHelper(const char* input,
                                                const char* expected,
                                                Pseudolocalizer::Method method) {
   Pseudolocalizer pseudo(method);
-  std::string result = pseudo.start() + pseudo.text(input) + pseudo.end();
+  std::string result = pseudo.Start() + pseudo.Text(input) + pseudo.End();
   if (result != expected) {
     return ::testing::AssertionFailure() << expected << " != " << result;
   }
   return ::testing::AssertionSuccess();
 }
 
-static ::testing::AssertionResult compoundHelper(
+static ::testing::AssertionResult CompoundHelper(
     const char* in1, const char* in2, const char* in3, const char* expected,
     Pseudolocalizer::Method method) {
   Pseudolocalizer pseudo(method);
-  std::string result = pseudo.start() + pseudo.text(in1) + pseudo.text(in2) +
-                       pseudo.text(in3) + pseudo.end();
+  std::string result = pseudo.Start() + pseudo.Text(in1) + pseudo.Text(in2) +
+                       pseudo.Text(in3) + pseudo.End();
   if (result != expected) {
     return ::testing::AssertionFailure() << expected << " != " << result;
   }
@@ -49,49 +48,49 @@ static ::testing::AssertionResult compoundHelper(
 }
 
 TEST(PseudolocalizerTest, NoPseudolocalization) {
-  EXPECT_TRUE(simpleHelper("", "", Pseudolocalizer::Method::kNone));
-  EXPECT_TRUE(simpleHelper("Hello, world", "Hello, world",
+  EXPECT_TRUE(SimpleHelper("", "", Pseudolocalizer::Method::kNone));
+  EXPECT_TRUE(SimpleHelper("Hello, world", "Hello, world",
                            Pseudolocalizer::Method::kNone));
 
-  EXPECT_TRUE(compoundHelper("Hello,", " world", "", "Hello, world",
+  EXPECT_TRUE(CompoundHelper("Hello,", " world", "", "Hello, world",
                              Pseudolocalizer::Method::kNone));
 }
 
 TEST(PseudolocalizerTest, PlaintextAccent) {
-  EXPECT_TRUE(simpleHelper("", "[]", Pseudolocalizer::Method::kAccent));
-  EXPECT_TRUE(simpleHelper("Hello, world", "[Ĥéļļö, ŵöŕļð one two]",
+  EXPECT_TRUE(SimpleHelper("", "[]", Pseudolocalizer::Method::kAccent));
+  EXPECT_TRUE(SimpleHelper("Hello, world", "[Ĥéļļö, ŵöŕļð one two]",
                            Pseudolocalizer::Method::kAccent));
 
-  EXPECT_TRUE(simpleHelper("Hello, %1d", "[Ĥéļļö, »%1d« one two]",
+  EXPECT_TRUE(SimpleHelper("Hello, %1d", "[Ĥéļļö, »%1d« one two]",
                            Pseudolocalizer::Method::kAccent));
 
-  EXPECT_TRUE(simpleHelper("Battery %1d%%", "[βåţţéŕý »%1d«%% one two]",
+  EXPECT_TRUE(SimpleHelper("Battery %1d%%", "[βåţţéŕý »%1d«%% one two]",
                            Pseudolocalizer::Method::kAccent));
   EXPECT_TRUE(
-      simpleHelper("^1 %", "[^1 % one]", Pseudolocalizer::Method::kAccent));
+      SimpleHelper("^1 %", "[^1 % one]", Pseudolocalizer::Method::kAccent));
   EXPECT_TRUE(
-      compoundHelper("", "", "", "[]", Pseudolocalizer::Method::kAccent));
-  EXPECT_TRUE(compoundHelper("Hello,", " world", "", "[Ĥéļļö, ŵöŕļð one two]",
+      CompoundHelper("", "", "", "[]", Pseudolocalizer::Method::kAccent));
+  EXPECT_TRUE(CompoundHelper("Hello,", " world", "", "[Ĥéļļö, ŵöŕļð one two]",
                              Pseudolocalizer::Method::kAccent));
 }
 
 TEST(PseudolocalizerTest, PlaintextBidi) {
-  EXPECT_TRUE(simpleHelper("", "", Pseudolocalizer::Method::kBidi));
-  EXPECT_TRUE(simpleHelper(
+  EXPECT_TRUE(SimpleHelper("", "", Pseudolocalizer::Method::kBidi));
+  EXPECT_TRUE(SimpleHelper(
       "word", "\xe2\x80\x8f\xE2\x80\xaeword\xE2\x80\xac\xe2\x80\x8f",
       Pseudolocalizer::Method::kBidi));
-  EXPECT_TRUE(simpleHelper(
+  EXPECT_TRUE(SimpleHelper(
       "  word  ", "  \xe2\x80\x8f\xE2\x80\xaeword\xE2\x80\xac\xe2\x80\x8f  ",
       Pseudolocalizer::Method::kBidi));
-  EXPECT_TRUE(simpleHelper(
+  EXPECT_TRUE(SimpleHelper(
       "  word  ", "  \xe2\x80\x8f\xE2\x80\xaeword\xE2\x80\xac\xe2\x80\x8f  ",
       Pseudolocalizer::Method::kBidi));
   EXPECT_TRUE(
-      simpleHelper("hello\n  world\n",
+      SimpleHelper("hello\n  world\n",
                    "\xe2\x80\x8f\xE2\x80\xaehello\xE2\x80\xac\xe2\x80\x8f\n"
                    "  \xe2\x80\x8f\xE2\x80\xaeworld\xE2\x80\xac\xe2\x80\x8f\n",
                    Pseudolocalizer::Method::kBidi));
-  EXPECT_TRUE(compoundHelper(
+  EXPECT_TRUE(CompoundHelper(
       "hello", "\n ", " world\n",
       "\xe2\x80\x8f\xE2\x80\xaehello\xE2\x80\xac\xe2\x80\x8f\n"
       "  \xe2\x80\x8f\xE2\x80\xaeworld\xE2\x80\xac\xe2\x80\x8f\n",
@@ -100,33 +99,33 @@ TEST(PseudolocalizerTest, PlaintextBidi) {
 
 TEST(PseudolocalizerTest, SimpleICU) {
   // Single-fragment messages
-  EXPECT_TRUE(simpleHelper("{placeholder}", "[»{placeholder}«]",
+  EXPECT_TRUE(SimpleHelper("{placeholder}", "[»{placeholder}«]",
                            Pseudolocalizer::Method::kAccent));
-  EXPECT_TRUE(simpleHelper("{USER} is offline", "[»{USER}« îš öƒƒļîñé one two]",
+  EXPECT_TRUE(SimpleHelper("{USER} is offline", "[»{USER}« îš öƒƒļîñé one two]",
                            Pseudolocalizer::Method::kAccent));
-  EXPECT_TRUE(simpleHelper("Copy from {path1} to {path2}",
+  EXPECT_TRUE(SimpleHelper("Copy from {path1} to {path2}",
                            "[Çöþý ƒŕöḿ »{path1}« ţö »{path2}« one two three]",
                            Pseudolocalizer::Method::kAccent));
-  EXPECT_TRUE(simpleHelper("Today is {1,date} {1,time}",
+  EXPECT_TRUE(SimpleHelper("Today is {1,date} {1,time}",
                            "[Ţöðåý îš »{1,date}« »{1,time}« one two]",
                            Pseudolocalizer::Method::kAccent));
 
   // Multi-fragment messages
-  EXPECT_TRUE(compoundHelper("{USER}", " ", "is offline",
+  EXPECT_TRUE(CompoundHelper("{USER}", " ", "is offline",
                              "[»{USER}« îš öƒƒļîñé one two]",
                              Pseudolocalizer::Method::kAccent));
-  EXPECT_TRUE(compoundHelper("Copy from ", "{path1}", " to {path2}",
+  EXPECT_TRUE(CompoundHelper("Copy from ", "{path1}", " to {path2}",
                              "[Çöþý ƒŕöḿ »{path1}« ţö »{path2}« one two three]",
                              Pseudolocalizer::Method::kAccent));
 }
 
 TEST(PseudolocalizerTest, ICUBidi) {
   // Single-fragment messages
-  EXPECT_TRUE(simpleHelper(
+  EXPECT_TRUE(SimpleHelper(
       "{placeholder}",
       "\xe2\x80\x8f\xE2\x80\xae{placeholder}\xE2\x80\xac\xe2\x80\x8f",
       Pseudolocalizer::Method::kBidi));
-  EXPECT_TRUE(simpleHelper(
+  EXPECT_TRUE(SimpleHelper(
       "{COUNT, plural, one {one} other {other}}",
       "{COUNT, plural, "
       "one {\xe2\x80\x8f\xE2\x80\xaeone\xE2\x80\xac\xe2\x80\x8f} "
@@ -136,30 +135,30 @@ TEST(PseudolocalizerTest, ICUBidi) {
 
 TEST(PseudolocalizerTest, Escaping) {
   // Single-fragment messages
-  EXPECT_TRUE(simpleHelper("'{USER'} is offline",
+  EXPECT_TRUE(SimpleHelper("'{USER'} is offline",
                            "['{ÛŠÉŔ'} îš öƒƒļîñé one two three]",
                            Pseudolocalizer::Method::kAccent));
 
   // Multi-fragment messages
-  EXPECT_TRUE(compoundHelper("'{USER}", " ", "''is offline",
+  EXPECT_TRUE(CompoundHelper("'{USER}", " ", "''is offline",
                              "['{ÛŠÉŔ} ''îš öƒƒļîñé one two three]",
                              Pseudolocalizer::Method::kAccent));
 }
 
 TEST(PseudolocalizerTest, PluralsAndSelects) {
-  EXPECT_TRUE(simpleHelper(
+  EXPECT_TRUE(SimpleHelper(
       "{COUNT, plural, one {Delete a file} other {Delete {COUNT} files}}",
       "[{COUNT, plural, one {Ðéļéţé å ƒîļé one two} "
       "other {Ðéļéţé »{COUNT}« ƒîļéš one two}}]",
       Pseudolocalizer::Method::kAccent));
 
   EXPECT_TRUE(
-      simpleHelper("Distance is {COUNT, plural, one {# mile} other {# miles}}",
+      SimpleHelper("Distance is {COUNT, plural, one {# mile} other {# miles}}",
                    "[Ðîšţåñçé îš {COUNT, plural, one {# ḿîļé one two} "
                    "other {# ḿîļéš one two}}]",
                    Pseudolocalizer::Method::kAccent));
 
-  EXPECT_TRUE(simpleHelper(
+  EXPECT_TRUE(SimpleHelper(
       "{1, select, female {{1} added you} "
       "male {{1} added you} other {{1} added you}}",
       "[{1, select, female {»{1}« åððéð ýöû one two} "
@@ -167,7 +166,7 @@ TEST(PseudolocalizerTest, PluralsAndSelects) {
       Pseudolocalizer::Method::kAccent));
 
   EXPECT_TRUE(
-      compoundHelper("{COUNT, plural, one {Delete a file} "
+      CompoundHelper("{COUNT, plural, one {Delete a file} "
                      "other {Delete ",
                      "{COUNT}", " files}}",
                      "[{COUNT, plural, one {Ðéļéţé å ƒîļé one two} "
@@ -177,7 +176,7 @@ TEST(PseudolocalizerTest, PluralsAndSelects) {
 
 TEST(PseudolocalizerTest, NestedICU) {
   EXPECT_TRUE(
-      simpleHelper("{person, select, "
+      SimpleHelper("{person, select, "
                    "female {"
                    "{num_circles, plural,"
                    "=0{{person} didn't add you to any of her circles.}"
@@ -222,9 +221,9 @@ TEST(PseudolocalizerTest, NestedICU) {
 
 TEST(PseudolocalizerTest, RedefineMethod) {
   Pseudolocalizer pseudo(Pseudolocalizer::Method::kAccent);
-  std::string result = pseudo.text("Hello, ");
-  pseudo.setMethod(Pseudolocalizer::Method::kNone);
-  result += pseudo.text("world!");
+  std::string result = pseudo.Text("Hello, ");
+  pseudo.SetMethod(Pseudolocalizer::Method::kNone);
+  result += pseudo.Text("world!");
   ASSERT_EQ(StringPiece("Ĥéļļö, world!"), result);
 }
 
diff --git a/tools/aapt2/compile/XmlIdCollector.cpp b/tools/aapt2/compile/XmlIdCollector.cpp
index aa8b1dfe83119..d61a15af0d853 100644
--- a/tools/aapt2/compile/XmlIdCollector.cpp
+++ b/tools/aapt2/compile/XmlIdCollector.cpp
@@ -15,55 +15,59 @@
  */
 
 #include "compile/XmlIdCollector.h"
-#include "ResourceUtils.h"
-#include "ResourceValues.h"
-#include "xml/XmlDom.h"
 
 #include <algorithm>
 #include <vector>
 
+#include "ResourceUtils.h"
+#include "ResourceValues.h"
+#include "xml/XmlDom.h"
+
 namespace aapt {
 
 namespace {
 
-static bool cmpName(const SourcedResourceName& a, const ResourceNameRef& b) {
+static bool cmp_name(const SourcedResourceName& a, const ResourceNameRef& b) {
   return a.name < b;
 }
 
 struct IdCollector : public xml::Visitor {
-  using xml::Visitor::visit;
+ public:
+  using xml::Visitor::Visit;
 
-  std::vector<SourcedResourceName>* mOutSymbols;
+  explicit IdCollector(std::vector<SourcedResourceName>* out_symbols)
+      : out_symbols_(out_symbols) {}
 
-  explicit IdCollector(std::vector<SourcedResourceName>* outSymbols)
-      : mOutSymbols(outSymbols) {}
-
-  void visit(xml::Element* element) override {
+  void Visit(xml::Element* element) override {
     for (xml::Attribute& attr : element->attributes) {
       ResourceNameRef name;
       bool create = false;
-      if (ResourceUtils::parseReference(attr.value, &name, &create, nullptr)) {
+      if (ResourceUtils::ParseReference(attr.value, &name, &create, nullptr)) {
         if (create && name.type == ResourceType::kId) {
-          auto iter = std::lower_bound(mOutSymbols->begin(), mOutSymbols->end(),
-                                       name, cmpName);
-          if (iter == mOutSymbols->end() || iter->name != name) {
-            mOutSymbols->insert(iter, SourcedResourceName{name.toResourceName(),
-                                                          element->lineNumber});
+          auto iter = std::lower_bound(out_symbols_->begin(),
+                                       out_symbols_->end(), name, cmp_name);
+          if (iter == out_symbols_->end() || iter->name != name) {
+            out_symbols_->insert(iter,
+                                 SourcedResourceName{name.ToResourceName(),
+                                                     element->line_number});
           }
         }
       }
     }
 
-    xml::Visitor::visit(element);
+    xml::Visitor::Visit(element);
   }
+
+ private:
+  std::vector<SourcedResourceName>* out_symbols_;
 };
 
 }  // namespace
 
-bool XmlIdCollector::consume(IAaptContext* context, xml::XmlResource* xmlRes) {
-  xmlRes->file.exportedSymbols.clear();
-  IdCollector collector(&xmlRes->file.exportedSymbols);
-  xmlRes->root->accept(&collector);
+bool XmlIdCollector::Consume(IAaptContext* context, xml::XmlResource* xmlRes) {
+  xmlRes->file.exported_symbols.clear();
+  IdCollector collector(&xmlRes->file.exported_symbols);
+  xmlRes->root->Accept(&collector);
   return true;
 }
 
diff --git a/tools/aapt2/compile/XmlIdCollector.h b/tools/aapt2/compile/XmlIdCollector.h
index 8423f48929898..8febf0f250dd1 100644
--- a/tools/aapt2/compile/XmlIdCollector.h
+++ b/tools/aapt2/compile/XmlIdCollector.h
@@ -23,7 +23,7 @@
 namespace aapt {
 
 struct XmlIdCollector : public IXmlResourceConsumer {
-  bool consume(IAaptContext* context, xml::XmlResource* xmlRes) override;
+  bool Consume(IAaptContext* context, xml::XmlResource* xml_res) override;
 };
 
 }  // namespace aapt
diff --git a/tools/aapt2/compile/XmlIdCollector_test.cpp b/tools/aapt2/compile/XmlIdCollector_test.cpp
index 08ca7b1fbf9eb..98da56d03ae3e 100644
--- a/tools/aapt2/compile/XmlIdCollector_test.cpp
+++ b/tools/aapt2/compile/XmlIdCollector_test.cpp
@@ -15,18 +15,17 @@
  */
 
 #include "compile/XmlIdCollector.h"
-#include "test/Builders.h"
-#include "test/Context.h"
 
-#include <gtest/gtest.h>
 #include <algorithm>
 
+#include "test/Test.h"
+
 namespace aapt {
 
 TEST(XmlIdCollectorTest, CollectsIds) {
-  std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
+  std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
 
-  std::unique_ptr<xml::XmlResource> doc = test::buildXmlDom(R"EOF(
+  std::unique_ptr<xml::XmlResource> doc = test::BuildXmlDom(R"EOF(
             <View xmlns:android="http://schemas.android.com/apk/res/android"
                   android:id="@+id/foo"
                   text="@+id/bar">
@@ -35,34 +34,34 @@ TEST(XmlIdCollectorTest, CollectsIds) {
             </View>)EOF");
 
   XmlIdCollector collector;
-  ASSERT_TRUE(collector.consume(context.get(), doc.get()));
+  ASSERT_TRUE(collector.Consume(context.get(), doc.get()));
 
   EXPECT_EQ(
-      1, std::count(doc->file.exportedSymbols.begin(),
-                    doc->file.exportedSymbols.end(),
-                    SourcedResourceName{test::parseNameOrDie("id/foo"), 3u}));
+      1, std::count(doc->file.exported_symbols.begin(),
+                    doc->file.exported_symbols.end(),
+                    SourcedResourceName{test::ParseNameOrDie("id/foo"), 3u}));
 
   EXPECT_EQ(
-      1, std::count(doc->file.exportedSymbols.begin(),
-                    doc->file.exportedSymbols.end(),
-                    SourcedResourceName{test::parseNameOrDie("id/bar"), 3u}));
+      1, std::count(doc->file.exported_symbols.begin(),
+                    doc->file.exported_symbols.end(),
+                    SourcedResourceName{test::ParseNameOrDie("id/bar"), 3u}));
 
   EXPECT_EQ(
-      1, std::count(doc->file.exportedSymbols.begin(),
-                    doc->file.exportedSymbols.end(),
-                    SourcedResourceName{test::parseNameOrDie("id/car"), 6u}));
+      1, std::count(doc->file.exported_symbols.begin(),
+                    doc->file.exported_symbols.end(),
+                    SourcedResourceName{test::ParseNameOrDie("id/car"), 6u}));
 }
 
 TEST(XmlIdCollectorTest, DontCollectNonIds) {
-  std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
+  std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
 
   std::unique_ptr<xml::XmlResource> doc =
-      test::buildXmlDom("<View foo=\"@+string/foo\"/>");
+      test::BuildXmlDom("<View foo=\"@+string/foo\"/>");
 
   XmlIdCollector collector;
-  ASSERT_TRUE(collector.consume(context.get(), doc.get()));
+  ASSERT_TRUE(collector.Consume(context.get(), doc.get()));
 
-  EXPECT_TRUE(doc->file.exportedSymbols.empty());
+  EXPECT_TRUE(doc->file.exported_symbols.empty());
 }
 
 }  // namespace aapt
diff --git a/tools/aapt2/diff/Diff.cpp b/tools/aapt2/diff/Diff.cpp
index 01f45399511fd..593e7ab119f16 100644
--- a/tools/aapt2/diff/Diff.cpp
+++ b/tools/aapt2/diff/Diff.cpp
@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+#include "android-base/macros.h"
+
 #include "Flags.h"
 #include "ResourceTable.h"
 #include "ValueVisitor.h"
@@ -22,74 +24,72 @@
 #include "process/SymbolTable.h"
 #include "unflatten/BinaryResourceParser.h"
 
-#include <android-base/macros.h>
-
 namespace aapt {
 
 class DiffContext : public IAaptContext {
  public:
-  const std::string& getCompilationPackage() override { return mEmpty; }
+  const std::string& GetCompilationPackage() override { return empty_; }
 
-  uint8_t getPackageId() override { return 0x0; }
+  uint8_t GetPackageId() override { return 0x0; }
 
-  IDiagnostics* getDiagnostics() override { return &mDiagnostics; }
+  IDiagnostics* GetDiagnostics() override { return &diagnostics_; }
 
-  NameMangler* getNameMangler() override { return &mNameMangler; }
+  NameMangler* GetNameMangler() override { return &name_mangler_; }
 
-  SymbolTable* getExternalSymbols() override { return &mSymbolTable; }
+  SymbolTable* GetExternalSymbols() override { return &symbol_table_; }
 
-  bool verbose() override { return false; }
+  bool IsVerbose() override { return false; }
 
-  int getMinSdkVersion() override { return 0; }
+  int GetMinSdkVersion() override { return 0; }
 
  private:
-  std::string mEmpty;
-  StdErrDiagnostics mDiagnostics;
-  NameMangler mNameMangler = NameMangler(NameManglerPolicy{});
-  SymbolTable mSymbolTable;
+  std::string empty_;
+  StdErrDiagnostics diagnostics_;
+  NameMangler name_mangler_ = NameMangler(NameManglerPolicy{});
+  SymbolTable symbol_table_;
 };
 
 class LoadedApk {
  public:
   LoadedApk(const Source& source, std::unique_ptr<io::IFileCollection> apk,
             std::unique_ptr<ResourceTable> table)
-      : mSource(source), mApk(std::move(apk)), mTable(std::move(table)) {}
+      : source_(source), apk_(std::move(apk)), table_(std::move(table)) {}
 
-  io::IFileCollection* getFileCollection() { return mApk.get(); }
+  io::IFileCollection* GetFileCollection() { return apk_.get(); }
 
-  ResourceTable* getResourceTable() { return mTable.get(); }
+  ResourceTable* GetResourceTable() { return table_.get(); }
 
-  const Source& getSource() { return mSource; }
+  const Source& GetSource() { return source_; }
 
  private:
-  Source mSource;
-  std::unique_ptr<io::IFileCollection> mApk;
-  std::unique_ptr<ResourceTable> mTable;
+  Source source_;
+  std::unique_ptr<io::IFileCollection> apk_;
+  std::unique_ptr<ResourceTable> table_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadedApk);
 };
 
-static std::unique_ptr<LoadedApk> loadApkFromPath(IAaptContext* context,
+static std::unique_ptr<LoadedApk> LoadApkFromPath(IAaptContext* context,
                                                   const StringPiece& path) {
   Source source(path);
   std::string error;
   std::unique_ptr<io::ZipFileCollection> apk =
-      io::ZipFileCollection::create(path, &error);
+      io::ZipFileCollection::Create(path, &error);
   if (!apk) {
-    context->getDiagnostics()->error(DiagMessage(source) << error);
+    context->GetDiagnostics()->Error(DiagMessage(source) << error);
     return {};
   }
 
-  io::IFile* file = apk->findFile("resources.arsc");
+  io::IFile* file = apk->FindFile("resources.arsc");
   if (!file) {
-    context->getDiagnostics()->error(DiagMessage(source)
+    context->GetDiagnostics()->Error(DiagMessage(source)
                                      << "no resources.arsc found");
     return {};
   }
 
-  std::unique_ptr<io::IData> data = file->openAsData();
+  std::unique_ptr<io::IData> data = file->OpenAsData();
   if (!data) {
-    context->getDiagnostics()->error(DiagMessage(source)
+    context->GetDiagnostics()->Error(DiagMessage(source)
                                      << "could not open resources.arsc");
     return {};
   }
@@ -97,276 +97,281 @@ static std::unique_ptr<LoadedApk> loadApkFromPath(IAaptContext* context,
   std::unique_ptr<ResourceTable> table = util::make_unique<ResourceTable>();
   BinaryResourceParser parser(context, table.get(), source, data->data(),
                               data->size());
-  if (!parser.parse()) {
+  if (!parser.Parse()) {
     return {};
   }
 
   return util::make_unique<LoadedApk>(source, std::move(apk), std::move(table));
 }
 
-static void emitDiffLine(const Source& source, const StringPiece& message) {
+static void EmitDiffLine(const Source& source, const StringPiece& message) {
   std::cerr << source << ": " << message << "\n";
 }
 
-static bool isSymbolVisibilityDifferent(const Symbol& symbolA,
-                                        const Symbol& symbolB) {
-  return symbolA.state != symbolB.state;
+static bool IsSymbolVisibilityDifferent(const Symbol& symbol_a,
+                                        const Symbol& symbol_b) {
+  return symbol_a.state != symbol_b.state;
 }
 
 template <typename Id>
-static bool isIdDiff(const Symbol& symbolA, const Maybe<Id>& idA,
-                     const Symbol& symbolB, const Maybe<Id>& idB) {
-  if (symbolA.state == SymbolState::kPublic ||
-      symbolB.state == SymbolState::kPublic) {
-    return idA != idB;
+static bool IsIdDiff(const Symbol& symbol_a, const Maybe<Id>& id_a,
+                     const Symbol& symbol_b, const Maybe<Id>& id_b) {
+  if (symbol_a.state == SymbolState::kPublic ||
+      symbol_b.state == SymbolState::kPublic) {
+    return id_a != id_b;
   }
   return false;
 }
 
-static bool emitResourceConfigValueDiff(
-    IAaptContext* context, LoadedApk* apkA, ResourceTablePackage* pkgA,
-    ResourceTableType* typeA, ResourceEntry* entryA,
-    ResourceConfigValue* configValueA, LoadedApk* apkB,
-    ResourceTablePackage* pkgB, ResourceTableType* typeB, ResourceEntry* entryB,
-    ResourceConfigValue* configValueB) {
-  Value* valueA = configValueA->value.get();
-  Value* valueB = configValueB->value.get();
-  if (!valueA->equals(valueB)) {
-    std::stringstream strStream;
-    strStream << "value " << pkgA->name << ":" << typeA->type << "/"
-              << entryA->name << " config=" << configValueA->config
-              << " does not match:\n";
-    valueA->print(&strStream);
-    strStream << "\n vs \n";
-    valueB->print(&strStream);
-    emitDiffLine(apkB->getSource(), strStream.str());
+static bool EmitResourceConfigValueDiff(
+    IAaptContext* context, LoadedApk* apk_a, ResourceTablePackage* pkg_a,
+    ResourceTableType* type_a, ResourceEntry* entry_a,
+    ResourceConfigValue* config_value_a, LoadedApk* apk_b,
+    ResourceTablePackage* pkg_b, ResourceTableType* type_b,
+    ResourceEntry* entry_b, ResourceConfigValue* config_value_b) {
+  Value* value_a = config_value_a->value.get();
+  Value* value_b = config_value_b->value.get();
+  if (!value_a->Equals(value_b)) {
+    std::stringstream str_stream;
+    str_stream << "value " << pkg_a->name << ":" << type_a->type << "/"
+               << entry_a->name << " config=" << config_value_a->config
+               << " does not match:\n";
+    value_a->Print(&str_stream);
+    str_stream << "\n vs \n";
+    value_b->Print(&str_stream);
+    EmitDiffLine(apk_b->GetSource(), str_stream.str());
     return true;
   }
   return false;
 }
 
-static bool emitResourceEntryDiff(IAaptContext* context, LoadedApk* apkA,
-                                  ResourceTablePackage* pkgA,
-                                  ResourceTableType* typeA,
-                                  ResourceEntry* entryA, LoadedApk* apkB,
-                                  ResourceTablePackage* pkgB,
-                                  ResourceTableType* typeB,
-                                  ResourceEntry* entryB) {
+static bool EmitResourceEntryDiff(IAaptContext* context, LoadedApk* apk_a,
+                                  ResourceTablePackage* pkg_a,
+                                  ResourceTableType* type_a,
+                                  ResourceEntry* entry_a, LoadedApk* apk_b,
+                                  ResourceTablePackage* pkg_b,
+                                  ResourceTableType* type_b,
+                                  ResourceEntry* entry_b) {
   bool diff = false;
-  for (std::unique_ptr<ResourceConfigValue>& configValueA : entryA->values) {
-    ResourceConfigValue* configValueB = entryB->findValue(configValueA->config);
-    if (!configValueB) {
-      std::stringstream strStream;
-      strStream << "missing " << pkgA->name << ":" << typeA->type << "/"
-                << entryA->name << " config=" << configValueA->config;
-      emitDiffLine(apkB->getSource(), strStream.str());
+  for (std::unique_ptr<ResourceConfigValue>& config_value_a : entry_a->values) {
+    ResourceConfigValue* config_value_b =
+        entry_b->FindValue(config_value_a->config);
+    if (!config_value_b) {
+      std::stringstream str_stream;
+      str_stream << "missing " << pkg_a->name << ":" << type_a->type << "/"
+                 << entry_a->name << " config=" << config_value_a->config;
+      EmitDiffLine(apk_b->GetSource(), str_stream.str());
       diff = true;
     } else {
-      diff |= emitResourceConfigValueDiff(context, apkA, pkgA, typeA, entryA,
-                                          configValueA.get(), apkB, pkgB, typeB,
-                                          entryB, configValueB);
+      diff |= EmitResourceConfigValueDiff(
+          context, apk_a, pkg_a, type_a, entry_a, config_value_a.get(), apk_b,
+          pkg_b, type_b, entry_b, config_value_b);
     }
   }
 
   // Check for any newly added config values.
-  for (std::unique_ptr<ResourceConfigValue>& configValueB : entryB->values) {
-    ResourceConfigValue* configValueA = entryA->findValue(configValueB->config);
-    if (!configValueA) {
-      std::stringstream strStream;
-      strStream << "new config " << pkgB->name << ":" << typeB->type << "/"
-                << entryB->name << " config=" << configValueB->config;
-      emitDiffLine(apkB->getSource(), strStream.str());
+  for (std::unique_ptr<ResourceConfigValue>& config_value_b : entry_b->values) {
+    ResourceConfigValue* config_value_a =
+        entry_a->FindValue(config_value_b->config);
+    if (!config_value_a) {
+      std::stringstream str_stream;
+      str_stream << "new config " << pkg_b->name << ":" << type_b->type << "/"
+                 << entry_b->name << " config=" << config_value_b->config;
+      EmitDiffLine(apk_b->GetSource(), str_stream.str());
       diff = true;
     }
   }
   return false;
 }
 
-static bool emitResourceTypeDiff(IAaptContext* context, LoadedApk* apkA,
-                                 ResourceTablePackage* pkgA,
-                                 ResourceTableType* typeA, LoadedApk* apkB,
-                                 ResourceTablePackage* pkgB,
-                                 ResourceTableType* typeB) {
+static bool EmitResourceTypeDiff(IAaptContext* context, LoadedApk* apk_a,
+                                 ResourceTablePackage* pkg_a,
+                                 ResourceTableType* type_a, LoadedApk* apk_b,
+                                 ResourceTablePackage* pkg_b,
+                                 ResourceTableType* type_b) {
   bool diff = false;
-  for (std::unique_ptr<ResourceEntry>& entryA : typeA->entries) {
-    ResourceEntry* entryB = typeB->findEntry(entryA->name);
-    if (!entryB) {
-      std::stringstream strStream;
-      strStream << "missing " << pkgA->name << ":" << typeA->type << "/"
-                << entryA->name;
-      emitDiffLine(apkB->getSource(), strStream.str());
+  for (std::unique_ptr<ResourceEntry>& entry_a : type_a->entries) {
+    ResourceEntry* entry_b = type_b->FindEntry(entry_a->name);
+    if (!entry_b) {
+      std::stringstream str_stream;
+      str_stream << "missing " << pkg_a->name << ":" << type_a->type << "/"
+                 << entry_a->name;
+      EmitDiffLine(apk_b->GetSource(), str_stream.str());
       diff = true;
     } else {
-      if (isSymbolVisibilityDifferent(entryA->symbolStatus,
-                                      entryB->symbolStatus)) {
-        std::stringstream strStream;
-        strStream << pkgA->name << ":" << typeA->type << "/" << entryA->name
-                  << " has different visibility (";
-        if (entryB->symbolStatus.state == SymbolState::kPublic) {
-          strStream << "PUBLIC";
+      if (IsSymbolVisibilityDifferent(entry_a->symbol_status,
+                                      entry_b->symbol_status)) {
+        std::stringstream str_stream;
+        str_stream << pkg_a->name << ":" << type_a->type << "/" << entry_a->name
+                   << " has different visibility (";
+        if (entry_b->symbol_status.state == SymbolState::kPublic) {
+          str_stream << "PUBLIC";
         } else {
-          strStream << "PRIVATE";
+          str_stream << "PRIVATE";
         }
-        strStream << " vs ";
-        if (entryA->symbolStatus.state == SymbolState::kPublic) {
-          strStream << "PUBLIC";
+        str_stream << " vs ";
+        if (entry_a->symbol_status.state == SymbolState::kPublic) {
+          str_stream << "PUBLIC";
         } else {
-          strStream << "PRIVATE";
+          str_stream << "PRIVATE";
         }
-        strStream << ")";
-        emitDiffLine(apkB->getSource(), strStream.str());
+        str_stream << ")";
+        EmitDiffLine(apk_b->GetSource(), str_stream.str());
         diff = true;
-      } else if (isIdDiff(entryA->symbolStatus, entryA->id,
-                          entryB->symbolStatus, entryB->id)) {
-        std::stringstream strStream;
-        strStream << pkgA->name << ":" << typeA->type << "/" << entryA->name
-                  << " has different public ID (";
-        if (entryB->id) {
-          strStream << "0x" << std::hex << entryB->id.value();
+      } else if (IsIdDiff(entry_a->symbol_status, entry_a->id,
+                          entry_b->symbol_status, entry_b->id)) {
+        std::stringstream str_stream;
+        str_stream << pkg_a->name << ":" << type_a->type << "/" << entry_a->name
+                   << " has different public ID (";
+        if (entry_b->id) {
+          str_stream << "0x" << std::hex << entry_b->id.value();
         } else {
-          strStream << "none";
+          str_stream << "none";
         }
-        strStream << " vs ";
-        if (entryA->id) {
-          strStream << "0x " << std::hex << entryA->id.value();
+        str_stream << " vs ";
+        if (entry_a->id) {
+          str_stream << "0x " << std::hex << entry_a->id.value();
         } else {
-          strStream << "none";
+          str_stream << "none";
         }
-        strStream << ")";
-        emitDiffLine(apkB->getSource(), strStream.str());
+        str_stream << ")";
+        EmitDiffLine(apk_b->GetSource(), str_stream.str());
         diff = true;
       }
-      diff |= emitResourceEntryDiff(context, apkA, pkgA, typeA, entryA.get(),
-                                    apkB, pkgB, typeB, entryB);
+      diff |=
+          EmitResourceEntryDiff(context, apk_a, pkg_a, type_a, entry_a.get(),
+                                apk_b, pkg_b, type_b, entry_b);
     }
   }
 
   // Check for any newly added entries.
-  for (std::unique_ptr<ResourceEntry>& entryB : typeB->entries) {
-    ResourceEntry* entryA = typeA->findEntry(entryB->name);
-    if (!entryA) {
-      std::stringstream strStream;
-      strStream << "new entry " << pkgB->name << ":" << typeB->type << "/"
-                << entryB->name;
-      emitDiffLine(apkB->getSource(), strStream.str());
+  for (std::unique_ptr<ResourceEntry>& entry_b : type_b->entries) {
+    ResourceEntry* entry_a = type_a->FindEntry(entry_b->name);
+    if (!entry_a) {
+      std::stringstream str_stream;
+      str_stream << "new entry " << pkg_b->name << ":" << type_b->type << "/"
+                 << entry_b->name;
+      EmitDiffLine(apk_b->GetSource(), str_stream.str());
       diff = true;
     }
   }
   return diff;
 }
 
-static bool emitResourcePackageDiff(IAaptContext* context, LoadedApk* apkA,
-                                    ResourceTablePackage* pkgA, LoadedApk* apkB,
-                                    ResourceTablePackage* pkgB) {
+static bool EmitResourcePackageDiff(IAaptContext* context, LoadedApk* apk_a,
+                                    ResourceTablePackage* pkg_a,
+                                    LoadedApk* apk_b,
+                                    ResourceTablePackage* pkg_b) {
   bool diff = false;
-  for (std::unique_ptr<ResourceTableType>& typeA : pkgA->types) {
-    ResourceTableType* typeB = pkgB->findType(typeA->type);
-    if (!typeB) {
-      std::stringstream strStream;
-      strStream << "missing " << pkgA->name << ":" << typeA->type;
-      emitDiffLine(apkA->getSource(), strStream.str());
+  for (std::unique_ptr<ResourceTableType>& type_a : pkg_a->types) {
+    ResourceTableType* type_b = pkg_b->FindType(type_a->type);
+    if (!type_b) {
+      std::stringstream str_stream;
+      str_stream << "missing " << pkg_a->name << ":" << type_a->type;
+      EmitDiffLine(apk_a->GetSource(), str_stream.str());
       diff = true;
     } else {
-      if (isSymbolVisibilityDifferent(typeA->symbolStatus,
-                                      typeB->symbolStatus)) {
-        std::stringstream strStream;
-        strStream << pkgA->name << ":" << typeA->type
-                  << " has different visibility (";
-        if (typeB->symbolStatus.state == SymbolState::kPublic) {
-          strStream << "PUBLIC";
+      if (IsSymbolVisibilityDifferent(type_a->symbol_status,
+                                      type_b->symbol_status)) {
+        std::stringstream str_stream;
+        str_stream << pkg_a->name << ":" << type_a->type
+                   << " has different visibility (";
+        if (type_b->symbol_status.state == SymbolState::kPublic) {
+          str_stream << "PUBLIC";
         } else {
-          strStream << "PRIVATE";
+          str_stream << "PRIVATE";
         }
-        strStream << " vs ";
-        if (typeA->symbolStatus.state == SymbolState::kPublic) {
-          strStream << "PUBLIC";
+        str_stream << " vs ";
+        if (type_a->symbol_status.state == SymbolState::kPublic) {
+          str_stream << "PUBLIC";
         } else {
-          strStream << "PRIVATE";
+          str_stream << "PRIVATE";
         }
-        strStream << ")";
-        emitDiffLine(apkB->getSource(), strStream.str());
+        str_stream << ")";
+        EmitDiffLine(apk_b->GetSource(), str_stream.str());
         diff = true;
-      } else if (isIdDiff(typeA->symbolStatus, typeA->id, typeB->symbolStatus,
-                          typeB->id)) {
-        std::stringstream strStream;
-        strStream << pkgA->name << ":" << typeA->type
-                  << " has different public ID (";
-        if (typeB->id) {
-          strStream << "0x" << std::hex << typeB->id.value();
+      } else if (IsIdDiff(type_a->symbol_status, type_a->id,
+                          type_b->symbol_status, type_b->id)) {
+        std::stringstream str_stream;
+        str_stream << pkg_a->name << ":" << type_a->type
+                   << " has different public ID (";
+        if (type_b->id) {
+          str_stream << "0x" << std::hex << type_b->id.value();
         } else {
-          strStream << "none";
+          str_stream << "none";
         }
-        strStream << " vs ";
-        if (typeA->id) {
-          strStream << "0x " << std::hex << typeA->id.value();
+        str_stream << " vs ";
+        if (type_a->id) {
+          str_stream << "0x " << std::hex << type_a->id.value();
         } else {
-          strStream << "none";
+          str_stream << "none";
         }
-        strStream << ")";
-        emitDiffLine(apkB->getSource(), strStream.str());
+        str_stream << ")";
+        EmitDiffLine(apk_b->GetSource(), str_stream.str());
         diff = true;
       }
-      diff |= emitResourceTypeDiff(context, apkA, pkgA, typeA.get(), apkB, pkgB,
-                                   typeB);
+      diff |= EmitResourceTypeDiff(context, apk_a, pkg_a, type_a.get(), apk_b,
+                                   pkg_b, type_b);
     }
   }
 
   // Check for any newly added types.
-  for (std::unique_ptr<ResourceTableType>& typeB : pkgB->types) {
-    ResourceTableType* typeA = pkgA->findType(typeB->type);
-    if (!typeA) {
-      std::stringstream strStream;
-      strStream << "new type " << pkgB->name << ":" << typeB->type;
-      emitDiffLine(apkB->getSource(), strStream.str());
+  for (std::unique_ptr<ResourceTableType>& type_b : pkg_b->types) {
+    ResourceTableType* type_a = pkg_a->FindType(type_b->type);
+    if (!type_a) {
+      std::stringstream str_stream;
+      str_stream << "new type " << pkg_b->name << ":" << type_b->type;
+      EmitDiffLine(apk_b->GetSource(), str_stream.str());
       diff = true;
     }
   }
   return diff;
 }
 
-static bool emitResourceTableDiff(IAaptContext* context, LoadedApk* apkA,
-                                  LoadedApk* apkB) {
-  ResourceTable* tableA = apkA->getResourceTable();
-  ResourceTable* tableB = apkB->getResourceTable();
+static bool EmitResourceTableDiff(IAaptContext* context, LoadedApk* apk_a,
+                                  LoadedApk* apk_b) {
+  ResourceTable* table_a = apk_a->GetResourceTable();
+  ResourceTable* table_b = apk_b->GetResourceTable();
 
   bool diff = false;
-  for (std::unique_ptr<ResourceTablePackage>& pkgA : tableA->packages) {
-    ResourceTablePackage* pkgB = tableB->findPackage(pkgA->name);
-    if (!pkgB) {
-      std::stringstream strStream;
-      strStream << "missing package " << pkgA->name;
-      emitDiffLine(apkB->getSource(), strStream.str());
+  for (std::unique_ptr<ResourceTablePackage>& pkg_a : table_a->packages) {
+    ResourceTablePackage* pkg_b = table_b->FindPackage(pkg_a->name);
+    if (!pkg_b) {
+      std::stringstream str_stream;
+      str_stream << "missing package " << pkg_a->name;
+      EmitDiffLine(apk_b->GetSource(), str_stream.str());
       diff = true;
     } else {
-      if (pkgA->id != pkgB->id) {
-        std::stringstream strStream;
-        strStream << "package '" << pkgA->name << "' has different id (";
-        if (pkgB->id) {
-          strStream << "0x" << std::hex << pkgB->id.value();
+      if (pkg_a->id != pkg_b->id) {
+        std::stringstream str_stream;
+        str_stream << "package '" << pkg_a->name << "' has different id (";
+        if (pkg_b->id) {
+          str_stream << "0x" << std::hex << pkg_b->id.value();
         } else {
-          strStream << "none";
+          str_stream << "none";
         }
-        strStream << " vs ";
-        if (pkgA->id) {
-          strStream << "0x" << std::hex << pkgA->id.value();
+        str_stream << " vs ";
+        if (pkg_a->id) {
+          str_stream << "0x" << std::hex << pkg_a->id.value();
         } else {
-          strStream << "none";
+          str_stream << "none";
         }
-        strStream << ")";
-        emitDiffLine(apkB->getSource(), strStream.str());
+        str_stream << ")";
+        EmitDiffLine(apk_b->GetSource(), str_stream.str());
         diff = true;
       }
-      diff |= emitResourcePackageDiff(context, apkA, pkgA.get(), apkB, pkgB);
+      diff |=
+          EmitResourcePackageDiff(context, apk_a, pkg_a.get(), apk_b, pkg_b);
     }
   }
 
   // Check for any newly added packages.
-  for (std::unique_ptr<ResourceTablePackage>& pkgB : tableB->packages) {
-    ResourceTablePackage* pkgA = tableA->findPackage(pkgB->name);
-    if (!pkgA) {
-      std::stringstream strStream;
-      strStream << "new package " << pkgB->name;
-      emitDiffLine(apkB->getSource(), strStream.str());
+  for (std::unique_ptr<ResourceTablePackage>& pkg_b : table_b->packages) {
+    ResourceTablePackage* pkg_a = table_a->FindPackage(pkg_b->name);
+    if (!pkg_a) {
+      std::stringstream str_stream;
+      str_stream << "new package " << pkg_b->name;
+      EmitDiffLine(apk_b->GetSource(), str_stream.str());
       diff = true;
     }
   }
@@ -375,49 +380,49 @@ static bool emitResourceTableDiff(IAaptContext* context, LoadedApk* apkA,
 
 class ZeroingReferenceVisitor : public ValueVisitor {
  public:
-  using ValueVisitor::visit;
+  using ValueVisitor::Visit;
 
-  void visit(Reference* ref) override {
+  void Visit(Reference* ref) override {
     if (ref->name && ref->id) {
-      if (ref->id.value().packageId() == 0x7f) {
+      if (ref->id.value().package_id() == 0x7f) {
         ref->id = {};
       }
     }
   }
 };
 
-static void zeroOutAppReferences(ResourceTable* table) {
+static void ZeroOutAppReferences(ResourceTable* table) {
   ZeroingReferenceVisitor visitor;
-  visitAllValuesInTable(table, &visitor);
+  VisitAllValuesInTable(table, &visitor);
 }
 
-int diff(const std::vector<StringPiece>& args) {
+int Diff(const std::vector<StringPiece>& args) {
   DiffContext context;
 
   Flags flags;
-  if (!flags.parse("aapt2 diff", args, &std::cerr)) {
+  if (!flags.Parse("aapt2 diff", args, &std::cerr)) {
     return 1;
   }
 
-  if (flags.getArgs().size() != 2u) {
+  if (flags.GetArgs().size() != 2u) {
     std::cerr << "must have two apks as arguments.\n\n";
-    flags.usage("aapt2 diff", &std::cerr);
+    flags.Usage("aapt2 diff", &std::cerr);
     return 1;
   }
 
-  std::unique_ptr<LoadedApk> apkA =
-      loadApkFromPath(&context, flags.getArgs()[0]);
-  std::unique_ptr<LoadedApk> apkB =
-      loadApkFromPath(&context, flags.getArgs()[1]);
-  if (!apkA || !apkB) {
+  std::unique_ptr<LoadedApk> apk_a =
+      LoadApkFromPath(&context, flags.GetArgs()[0]);
+  std::unique_ptr<LoadedApk> apk_b =
+      LoadApkFromPath(&context, flags.GetArgs()[1]);
+  if (!apk_a || !apk_b) {
     return 1;
   }
 
   // Zero out Application IDs in references.
-  zeroOutAppReferences(apkA->getResourceTable());
-  zeroOutAppReferences(apkB->getResourceTable());
+  ZeroOutAppReferences(apk_a->GetResourceTable());
+  ZeroOutAppReferences(apk_b->GetResourceTable());
 
-  if (emitResourceTableDiff(&context, apkA.get(), apkB.get())) {
+  if (EmitResourceTableDiff(&context, apk_a.get(), apk_b.get())) {
     // We emitted a diff, so return 1 (failure).
     return 1;
   }
diff --git a/tools/aapt2/dump/Dump.cpp b/tools/aapt2/dump/Dump.cpp
index 3556cd882cf85..2920c2abb57ab 100644
--- a/tools/aapt2/dump/Dump.cpp
+++ b/tools/aapt2/dump/Dump.cpp
@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+#include <vector>
+
 #include "Debug.h"
 #include "Diagnostics.h"
 #include "Flags.h"
@@ -24,20 +26,14 @@
 #include "util/Files.h"
 #include "util/StringPiece.h"
 
-#include <vector>
-
 namespace aapt {
 
-// struct DumpOptions {
-//
-//};
-
-void dumpCompiledFile(const pb::CompiledFile& pbFile, const void* data,
+void DumpCompiledFile(const pb::CompiledFile& pb_file, const void* data,
                       size_t len, const Source& source, IAaptContext* context) {
   std::unique_ptr<ResourceFile> file =
-      deserializeCompiledFileFromPb(pbFile, source, context->getDiagnostics());
+      DeserializeCompiledFileFromPb(pb_file, source, context->GetDiagnostics());
   if (!file) {
-    context->getDiagnostics()->warn(DiagMessage()
+    context->GetDiagnostics()->Warn(DiagMessage()
                                     << "failed to read compiled file");
     return;
   }
@@ -47,50 +43,50 @@ void dumpCompiledFile(const pb::CompiledFile& pbFile, const void* data,
             << "Source:   " << file->source << "\n";
 }
 
-void tryDumpFile(IAaptContext* context, const std::string& filePath) {
+void TryDumpFile(IAaptContext* context, const std::string& file_path) {
   std::unique_ptr<ResourceTable> table;
 
   std::string err;
   std::unique_ptr<io::ZipFileCollection> zip =
-      io::ZipFileCollection::create(filePath, &err);
+      io::ZipFileCollection::Create(file_path, &err);
   if (zip) {
-    io::IFile* file = zip->findFile("resources.arsc.flat");
+    io::IFile* file = zip->FindFile("resources.arsc.flat");
     if (file) {
-      std::unique_ptr<io::IData> data = file->openAsData();
+      std::unique_ptr<io::IData> data = file->OpenAsData();
       if (!data) {
-        context->getDiagnostics()->error(
-            DiagMessage(filePath) << "failed to open resources.arsc.flat");
+        context->GetDiagnostics()->Error(
+            DiagMessage(file_path) << "failed to open resources.arsc.flat");
         return;
       }
 
-      pb::ResourceTable pbTable;
-      if (!pbTable.ParseFromArray(data->data(), data->size())) {
-        context->getDiagnostics()->error(DiagMessage(filePath)
+      pb::ResourceTable pb_table;
+      if (!pb_table.ParseFromArray(data->data(), data->size())) {
+        context->GetDiagnostics()->Error(DiagMessage(file_path)
                                          << "invalid resources.arsc.flat");
         return;
       }
 
-      table = deserializeTableFromPb(pbTable, Source(filePath),
-                                     context->getDiagnostics());
+      table = DeserializeTableFromPb(pb_table, Source(file_path),
+                                     context->GetDiagnostics());
       if (!table) {
         return;
       }
     }
 
     if (!table) {
-      file = zip->findFile("resources.arsc");
+      file = zip->FindFile("resources.arsc");
       if (file) {
-        std::unique_ptr<io::IData> data = file->openAsData();
+        std::unique_ptr<io::IData> data = file->OpenAsData();
         if (!data) {
-          context->getDiagnostics()->error(DiagMessage(filePath)
+          context->GetDiagnostics()->Error(DiagMessage(file_path)
                                            << "failed to open resources.arsc");
           return;
         }
 
         table = util::make_unique<ResourceTable>();
-        BinaryResourceParser parser(context, table.get(), Source(filePath),
+        BinaryResourceParser parser(context, table.get(), Source(file_path),
                                     data->data(), data->size());
-        if (!parser.parse()) {
+        if (!parser.Parse()) {
           return;
         }
       }
@@ -98,109 +94,109 @@ void tryDumpFile(IAaptContext* context, const std::string& filePath) {
   }
 
   if (!table) {
-    Maybe<android::FileMap> file = file::mmapPath(filePath, &err);
+    Maybe<android::FileMap> file = file::MmapPath(file_path, &err);
     if (!file) {
-      context->getDiagnostics()->error(DiagMessage(filePath) << err);
+      context->GetDiagnostics()->Error(DiagMessage(file_path) << err);
       return;
     }
 
-    android::FileMap* fileMap = &file.value();
+    android::FileMap* file_map = &file.value();
 
     // Try as a compiled table.
-    pb::ResourceTable pbTable;
-    if (pbTable.ParseFromArray(fileMap->getDataPtr(),
-                               fileMap->getDataLength())) {
-      table = deserializeTableFromPb(pbTable, Source(filePath),
-                                     context->getDiagnostics());
+    pb::ResourceTable pb_table;
+    if (pb_table.ParseFromArray(file_map->getDataPtr(),
+                                file_map->getDataLength())) {
+      table = DeserializeTableFromPb(pb_table, Source(file_path),
+                                     context->GetDiagnostics());
     }
 
     if (!table) {
       // Try as a compiled file.
-      CompiledFileInputStream input(fileMap->getDataPtr(),
-                                    fileMap->getDataLength());
+      CompiledFileInputStream input(file_map->getDataPtr(),
+                                    file_map->getDataLength());
 
-      uint32_t numFiles = 0;
-      if (!input.ReadLittleEndian32(&numFiles)) {
+      uint32_t num_files = 0;
+      if (!input.ReadLittleEndian32(&num_files)) {
         return;
       }
 
-      for (uint32_t i = 0; i < numFiles; i++) {
-        pb::CompiledFile compiledFile;
-        if (!input.ReadCompiledFile(&compiledFile)) {
-          context->getDiagnostics()->warn(DiagMessage()
+      for (uint32_t i = 0; i < num_files; i++) {
+        pb::CompiledFile compiled_file;
+        if (!input.ReadCompiledFile(&compiled_file)) {
+          context->GetDiagnostics()->Warn(DiagMessage()
                                           << "failed to read compiled file");
           return;
         }
 
         uint64_t offset, len;
         if (!input.ReadDataMetaData(&offset, &len)) {
-          context->getDiagnostics()->warn(DiagMessage()
+          context->GetDiagnostics()->Warn(DiagMessage()
                                           << "failed to read meta data");
           return;
         }
 
         const void* data =
-            static_cast<const uint8_t*>(fileMap->getDataPtr()) + offset;
-        dumpCompiledFile(compiledFile, data, len, Source(filePath), context);
+            static_cast<const uint8_t*>(file_map->getDataPtr()) + offset;
+        DumpCompiledFile(compiled_file, data, len, Source(file_path), context);
       }
     }
   }
 
   if (table) {
-    DebugPrintTableOptions debugPrintTableOptions;
-    debugPrintTableOptions.showSources = true;
-    Debug::printTable(table.get(), debugPrintTableOptions);
+    DebugPrintTableOptions options;
+    options.show_sources = true;
+    Debug::PrintTable(table.get(), options);
   }
 }
 
 class DumpContext : public IAaptContext {
  public:
-  IDiagnostics* getDiagnostics() override { return &mDiagnostics; }
+  IDiagnostics* GetDiagnostics() override { return &diagnostics_; }
 
-  NameMangler* getNameMangler() override {
+  NameMangler* GetNameMangler() override {
     abort();
     return nullptr;
   }
 
-  const std::string& getCompilationPackage() override {
+  const std::string& GetCompilationPackage() override {
     static std::string empty;
     return empty;
   }
 
-  uint8_t getPackageId() override { return 0; }
+  uint8_t GetPackageId() override { return 0; }
 
-  SymbolTable* getExternalSymbols() override {
+  SymbolTable* GetExternalSymbols() override {
     abort();
     return nullptr;
   }
 
-  bool verbose() override { return mVerbose; }
+  bool IsVerbose() override { return verbose_; }
 
-  void setVerbose(bool val) { mVerbose = val; }
+  void SetVerbose(bool val) { verbose_ = val; }
 
-  int getMinSdkVersion() override { return 0; }
+  int GetMinSdkVersion() override { return 0; }
 
  private:
-  StdErrDiagnostics mDiagnostics;
-  bool mVerbose = false;
+  StdErrDiagnostics diagnostics_;
+  bool verbose_ = false;
 };
 
 /**
  * Entry point for dump command.
  */
-int dump(const std::vector<StringPiece>& args) {
+int Dump(const std::vector<StringPiece>& args) {
   bool verbose = false;
   Flags flags =
-      Flags().optionalSwitch("-v", "increase verbosity of output", &verbose);
-  if (!flags.parse("aapt2 dump", args, &std::cerr)) {
+      Flags().OptionalSwitch("-v", "increase verbosity of output", &verbose);
+  if (!flags.Parse("aapt2 dump", args, &std::cerr)) {
     return 1;
   }
 
   DumpContext context;
-  context.setVerbose(verbose);
+  context.SetVerbose(verbose);
 
-  for (const std::string& arg : flags.getArgs()) {
-    tryDumpFile(&context, arg);
+  for (const std::string& arg : flags.GetArgs()) {
+    TryDumpFile(&context, arg);
   }
   return 0;
 }
diff --git a/tools/aapt2/filter/ConfigFilter.cpp b/tools/aapt2/filter/ConfigFilter.cpp
index 5af996ca8911e..66aff829d71c3 100644
--- a/tools/aapt2/filter/ConfigFilter.cpp
+++ b/tools/aapt2/filter/ConfigFilter.cpp
@@ -15,44 +15,45 @@
  */
 
 #include "filter/ConfigFilter.h"
-#include "ConfigDescription.h"
 
-#include <androidfw/ResourceTypes.h>
+#include "androidfw/ResourceTypes.h"
+
+#include "ConfigDescription.h"
 
 namespace aapt {
 
-void AxisConfigFilter::addConfig(ConfigDescription config) {
-  uint32_t diffMask = ConfigDescription::defaultConfig().diff(config);
+void AxisConfigFilter::AddConfig(ConfigDescription config) {
+  uint32_t diff_mask = ConfigDescription::DefaultConfig().diff(config);
 
   // Ignore the version
-  diffMask &= ~android::ResTable_config::CONFIG_VERSION;
+  diff_mask &= ~android::ResTable_config::CONFIG_VERSION;
 
   // Ignore any densities. Those are best handled in --preferred-density
-  if ((diffMask & android::ResTable_config::CONFIG_DENSITY) != 0) {
+  if ((diff_mask & android::ResTable_config::CONFIG_DENSITY) != 0) {
     config.density = 0;
-    diffMask &= ~android::ResTable_config::CONFIG_DENSITY;
+    diff_mask &= ~android::ResTable_config::CONFIG_DENSITY;
   }
 
-  mConfigs.insert(std::make_pair(config, diffMask));
-  mConfigMask |= diffMask;
+  configs_.insert(std::make_pair(config, diff_mask));
+  config_mask_ |= diff_mask;
 }
 
-bool AxisConfigFilter::match(const ConfigDescription& config) const {
-  const uint32_t mask = ConfigDescription::defaultConfig().diff(config);
-  if ((mConfigMask & mask) == 0) {
+bool AxisConfigFilter::Match(const ConfigDescription& config) const {
+  const uint32_t mask = ConfigDescription::DefaultConfig().diff(config);
+  if ((config_mask_ & mask) == 0) {
     // The two configurations don't have any common axis.
     return true;
   }
 
-  uint32_t matchedAxis = 0;
-  for (const auto& entry : mConfigs) {
+  uint32_t matched_axis = 0;
+  for (const auto& entry : configs_) {
     const ConfigDescription& target = entry.first;
-    const uint32_t diffMask = entry.second;
+    const uint32_t diff_mask = entry.second;
     uint32_t diff = target.diff(config);
-    if ((diff & diffMask) == 0) {
+    if ((diff & diff_mask) == 0) {
       // Mark the axis that was matched.
-      matchedAxis |= diffMask;
-    } else if ((diff & diffMask) == android::ResTable_config::CONFIG_LOCALE) {
+      matched_axis |= diff_mask;
+    } else if ((diff & diff_mask) == android::ResTable_config::CONFIG_LOCALE) {
       // If the locales differ, but the languages are the same and
       // the locale we are matching only has a language specified,
       // we match.
@@ -60,10 +61,10 @@ bool AxisConfigFilter::match(const ConfigDescription& config) const {
           memcmp(config.language, target.language, sizeof(config.language)) ==
               0) {
         if (config.country[0] == 0) {
-          matchedAxis |= android::ResTable_config::CONFIG_LOCALE;
+          matched_axis |= android::ResTable_config::CONFIG_LOCALE;
         }
       }
-    } else if ((diff & diffMask) ==
+    } else if ((diff & diff_mask) ==
                android::ResTable_config::CONFIG_SMALLEST_SCREEN_SIZE) {
       // Special case if the smallest screen width doesn't match. We check that
       // the
@@ -71,11 +72,11 @@ bool AxisConfigFilter::match(const ConfigDescription& config) const {
       // specified.
       if (config.smallestScreenWidthDp != 0 &&
           config.smallestScreenWidthDp < target.smallestScreenWidthDp) {
-        matchedAxis |= android::ResTable_config::CONFIG_SMALLEST_SCREEN_SIZE;
+        matched_axis |= android::ResTable_config::CONFIG_SMALLEST_SCREEN_SIZE;
       }
     }
   }
-  return matchedAxis == (mConfigMask & mask);
+  return matched_axis == (config_mask_ & mask);
 }
 
 }  // namespace aapt
diff --git a/tools/aapt2/filter/ConfigFilter.h b/tools/aapt2/filter/ConfigFilter.h
index c50160baaa37d..3f1341684912a 100644
--- a/tools/aapt2/filter/ConfigFilter.h
+++ b/tools/aapt2/filter/ConfigFilter.h
@@ -17,11 +17,11 @@
 #ifndef AAPT_FILTER_CONFIGFILTER_H
 #define AAPT_FILTER_CONFIGFILTER_H
 
-#include "ConfigDescription.h"
-
 #include <set>
 #include <utility>
 
+#include "ConfigDescription.h"
+
 namespace aapt {
 
 /**
@@ -34,7 +34,7 @@ class IConfigFilter {
   /**
    * Returns true if the filter matches the configuration, false otherwise.
    */
-  virtual bool match(const ConfigDescription& config) const = 0;
+  virtual bool Match(const ConfigDescription& config) const = 0;
 };
 
 /**
@@ -50,13 +50,13 @@ class IConfigFilter {
  */
 class AxisConfigFilter : public IConfigFilter {
  public:
-  void addConfig(ConfigDescription config);
+  void AddConfig(ConfigDescription config);
 
-  bool match(const ConfigDescription& config) const override;
+  bool Match(const ConfigDescription& config) const override;
 
  private:
-  std::set<std::pair<ConfigDescription, uint32_t>> mConfigs;
-  uint32_t mConfigMask = 0;
+  std::set<std::pair<ConfigDescription, uint32_t>> configs_;
+  uint32_t config_mask_ = 0;
 };
 
 }  // namespace aapt
diff --git a/tools/aapt2/filter/ConfigFilter_test.cpp b/tools/aapt2/filter/ConfigFilter_test.cpp
index edb40a8b33244..586dd5f68f1bb 100644
--- a/tools/aapt2/filter/ConfigFilter_test.cpp
+++ b/tools/aapt2/filter/ConfigFilter_test.cpp
@@ -15,99 +15,98 @@
  */
 
 #include "filter/ConfigFilter.h"
-#include "test/Common.h"
 
-#include <gtest/gtest.h>
+#include "test/Test.h"
 
 namespace aapt {
 
 TEST(ConfigFilterTest, EmptyFilterMatchesAnything) {
   AxisConfigFilter filter;
 
-  EXPECT_TRUE(filter.match(test::parseConfigOrDie("320dpi")));
-  EXPECT_TRUE(filter.match(test::parseConfigOrDie("fr")));
+  EXPECT_TRUE(filter.Match(test::ParseConfigOrDie("320dpi")));
+  EXPECT_TRUE(filter.Match(test::ParseConfigOrDie("fr")));
 }
 
 TEST(ConfigFilterTest, MatchesConfigWithUnrelatedAxis) {
   AxisConfigFilter filter;
-  filter.addConfig(test::parseConfigOrDie("fr"));
+  filter.AddConfig(test::ParseConfigOrDie("fr"));
 
-  EXPECT_TRUE(filter.match(test::parseConfigOrDie("320dpi")));
+  EXPECT_TRUE(filter.Match(test::ParseConfigOrDie("320dpi")));
 }
 
 TEST(ConfigFilterTest, MatchesConfigWithSameValueAxis) {
   AxisConfigFilter filter;
-  filter.addConfig(test::parseConfigOrDie("fr"));
+  filter.AddConfig(test::ParseConfigOrDie("fr"));
 
-  EXPECT_TRUE(filter.match(test::parseConfigOrDie("fr")));
+  EXPECT_TRUE(filter.Match(test::ParseConfigOrDie("fr")));
 }
 
 TEST(ConfigFilterTest, MatchesConfigWithSameValueAxisAndOtherUnrelatedAxis) {
   AxisConfigFilter filter;
-  filter.addConfig(test::parseConfigOrDie("fr"));
+  filter.AddConfig(test::ParseConfigOrDie("fr"));
 
-  EXPECT_TRUE(filter.match(test::parseConfigOrDie("fr-320dpi")));
+  EXPECT_TRUE(filter.Match(test::ParseConfigOrDie("fr-320dpi")));
 }
 
 TEST(ConfigFilterTest, MatchesConfigWithOneMatchingAxis) {
   AxisConfigFilter filter;
-  filter.addConfig(test::parseConfigOrDie("fr-rFR"));
-  filter.addConfig(test::parseConfigOrDie("sw360dp"));
-  filter.addConfig(test::parseConfigOrDie("normal"));
-  filter.addConfig(test::parseConfigOrDie("en-rUS"));
+  filter.AddConfig(test::ParseConfigOrDie("fr-rFR"));
+  filter.AddConfig(test::ParseConfigOrDie("sw360dp"));
+  filter.AddConfig(test::ParseConfigOrDie("normal"));
+  filter.AddConfig(test::ParseConfigOrDie("en-rUS"));
 
-  EXPECT_TRUE(filter.match(test::parseConfigOrDie("en")));
+  EXPECT_TRUE(filter.Match(test::ParseConfigOrDie("en")));
 }
 
 TEST(ConfigFilterTest, DoesNotMatchConfigWithDifferentValueAxis) {
   AxisConfigFilter filter;
-  filter.addConfig(test::parseConfigOrDie("fr"));
+  filter.AddConfig(test::ParseConfigOrDie("fr"));
 
-  EXPECT_FALSE(filter.match(test::parseConfigOrDie("de")));
+  EXPECT_FALSE(filter.Match(test::ParseConfigOrDie("de")));
 }
 
 TEST(ConfigFilterTest, DoesNotMatchWhenOneQualifierIsExplicitlyNotMatched) {
   AxisConfigFilter filter;
-  filter.addConfig(test::parseConfigOrDie("fr-rFR"));
-  filter.addConfig(test::parseConfigOrDie("en-rUS"));
-  filter.addConfig(test::parseConfigOrDie("normal"));
-  filter.addConfig(test::parseConfigOrDie("large"));
-  filter.addConfig(test::parseConfigOrDie("xxhdpi"));
-  filter.addConfig(test::parseConfigOrDie("sw320dp"));
+  filter.AddConfig(test::ParseConfigOrDie("fr-rFR"));
+  filter.AddConfig(test::ParseConfigOrDie("en-rUS"));
+  filter.AddConfig(test::ParseConfigOrDie("normal"));
+  filter.AddConfig(test::ParseConfigOrDie("large"));
+  filter.AddConfig(test::ParseConfigOrDie("xxhdpi"));
+  filter.AddConfig(test::ParseConfigOrDie("sw320dp"));
 
-  EXPECT_FALSE(filter.match(test::parseConfigOrDie("fr-sw600dp-v13")));
+  EXPECT_FALSE(filter.Match(test::ParseConfigOrDie("fr-sw600dp-v13")));
 }
 
 TEST(ConfigFilterTest, MatchesSmallestWidthWhenSmaller) {
   AxisConfigFilter filter;
-  filter.addConfig(test::parseConfigOrDie("sw600dp"));
+  filter.AddConfig(test::ParseConfigOrDie("sw600dp"));
 
-  EXPECT_TRUE(filter.match(test::parseConfigOrDie("fr-sw320dp-v13")));
+  EXPECT_TRUE(filter.Match(test::ParseConfigOrDie("fr-sw320dp-v13")));
 }
 
 TEST(ConfigFilterTest, MatchesConfigWithSameLanguageButNoRegionSpecified) {
   AxisConfigFilter filter;
-  filter.addConfig(test::parseConfigOrDie("de-rDE"));
+  filter.AddConfig(test::ParseConfigOrDie("de-rDE"));
 
-  EXPECT_TRUE(filter.match(test::parseConfigOrDie("de")));
+  EXPECT_TRUE(filter.Match(test::ParseConfigOrDie("de")));
 }
 
 TEST(ConfigFilterTest, IgnoresVersion) {
   AxisConfigFilter filter;
-  filter.addConfig(test::parseConfigOrDie("normal-v4"));
+  filter.AddConfig(test::ParseConfigOrDie("normal-v4"));
 
   // The configs don't match on any axis besides version, which should be
   // ignored.
-  EXPECT_TRUE(filter.match(test::parseConfigOrDie("sw600dp-v13")));
+  EXPECT_TRUE(filter.Match(test::ParseConfigOrDie("sw600dp-v13")));
 }
 
 TEST(ConfigFilterTest, MatchesConfigWithRegion) {
   AxisConfigFilter filter;
-  filter.addConfig(test::parseConfigOrDie("kok"));
-  filter.addConfig(test::parseConfigOrDie("kok-rIN"));
-  filter.addConfig(test::parseConfigOrDie("kok-v419"));
+  filter.AddConfig(test::ParseConfigOrDie("kok"));
+  filter.AddConfig(test::ParseConfigOrDie("kok-rIN"));
+  filter.AddConfig(test::ParseConfigOrDie("kok-v419"));
 
-  EXPECT_TRUE(filter.match(test::parseConfigOrDie("kok-rIN")));
+  EXPECT_TRUE(filter.Match(test::ParseConfigOrDie("kok-rIN")));
 }
 
 }  // namespace aapt
diff --git a/tools/aapt2/flatten/Archive.cpp b/tools/aapt2/flatten/Archive.cpp
index ae08f65882173..47de0a3b8d6c4 100644
--- a/tools/aapt2/flatten/Archive.cpp
+++ b/tools/aapt2/flatten/Archive.cpp
@@ -15,131 +15,139 @@
  */
 
 #include "flatten/Archive.h"
-#include "util/Files.h"
-#include "util/StringPiece.h"
 
-#include <ziparchive/zip_writer.h>
 #include <cstdio>
 #include <memory>
 #include <string>
 #include <vector>
 
+#include "android-base/macros.h"
+#include "ziparchive/zip_writer.h"
+
+#include "util/Files.h"
+#include "util/StringPiece.h"
+
 namespace aapt {
 
 namespace {
 
-struct DirectoryWriter : public IArchiveWriter {
-  std::string mOutDir;
-  std::unique_ptr<FILE, decltype(fclose)*> mFile = {nullptr, fclose};
+class DirectoryWriter : public IArchiveWriter {
+ public:
+  DirectoryWriter() = default;
 
-  bool open(IDiagnostics* diag, const StringPiece& outDir) {
-    mOutDir = outDir.toString();
-    file::FileType type = file::getFileType(mOutDir);
+  bool Open(IDiagnostics* diag, const StringPiece& out_dir) {
+    dir_ = out_dir.ToString();
+    file::FileType type = file::GetFileType(dir_);
     if (type == file::FileType::kNonexistant) {
-      diag->error(DiagMessage() << "directory " << mOutDir
-                                << " does not exist");
+      diag->Error(DiagMessage() << "directory " << dir_ << " does not exist");
       return false;
     } else if (type != file::FileType::kDirectory) {
-      diag->error(DiagMessage() << mOutDir << " is not a directory");
+      diag->Error(DiagMessage() << dir_ << " is not a directory");
       return false;
     }
     return true;
   }
 
-  bool startEntry(const StringPiece& path, uint32_t flags) override {
-    if (mFile) {
+  bool StartEntry(const StringPiece& path, uint32_t flags) override {
+    if (file_) {
       return false;
     }
 
-    std::string fullPath = mOutDir;
-    file::appendPath(&fullPath, path);
-    file::mkdirs(file::getStem(fullPath));
+    std::string full_path = dir_;
+    file::AppendPath(&full_path, path);
+    file::mkdirs(file::GetStem(full_path));
 
-    mFile = {fopen(fullPath.data(), "wb"), fclose};
-    if (!mFile) {
+    file_ = {fopen(full_path.data(), "wb"), fclose};
+    if (!file_) {
       return false;
     }
     return true;
   }
 
-  bool writeEntry(const BigBuffer& buffer) override {
-    if (!mFile) {
+  bool WriteEntry(const BigBuffer& buffer) override {
+    if (!file_) {
       return false;
     }
 
     for (const BigBuffer::Block& b : buffer) {
-      if (fwrite(b.buffer.get(), 1, b.size, mFile.get()) != b.size) {
-        mFile.reset(nullptr);
+      if (fwrite(b.buffer.get(), 1, b.size, file_.get()) != b.size) {
+        file_.reset(nullptr);
         return false;
       }
     }
     return true;
   }
 
-  bool writeEntry(const void* data, size_t len) override {
-    if (fwrite(data, 1, len, mFile.get()) != len) {
-      mFile.reset(nullptr);
+  bool WriteEntry(const void* data, size_t len) override {
+    if (fwrite(data, 1, len, file_.get()) != len) {
+      file_.reset(nullptr);
       return false;
     }
     return true;
   }
 
-  bool finishEntry() override {
-    if (!mFile) {
+  bool FinishEntry() override {
+    if (!file_) {
       return false;
     }
-    mFile.reset(nullptr);
+    file_.reset(nullptr);
     return true;
   }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(DirectoryWriter);
+
+  std::string dir_;
+  std::unique_ptr<FILE, decltype(fclose)*> file_ = {nullptr, fclose};
 };
 
-struct ZipFileWriter : public IArchiveWriter {
-  std::unique_ptr<FILE, decltype(fclose)*> mFile = {nullptr, fclose};
-  std::unique_ptr<ZipWriter> mWriter;
+class ZipFileWriter : public IArchiveWriter {
+ public:
+  ZipFileWriter() = default;
 
-  bool open(IDiagnostics* diag, const StringPiece& path) {
-    mFile = {fopen(path.data(), "w+b"), fclose};
-    if (!mFile) {
-      diag->error(DiagMessage() << "failed to open " << path << ": "
+  bool Open(IDiagnostics* diag, const StringPiece& path) {
+    file_ = {fopen(path.data(), "w+b"), fclose};
+    if (!file_) {
+      diag->Error(DiagMessage() << "failed to Open " << path << ": "
                                 << strerror(errno));
       return false;
     }
-    mWriter = util::make_unique<ZipWriter>(mFile.get());
+    writer_ = util::make_unique<ZipWriter>(file_.get());
     return true;
   }
 
-  bool startEntry(const StringPiece& path, uint32_t flags) override {
-    if (!mWriter) {
+  bool StartEntry(const StringPiece& path, uint32_t flags) override {
+    if (!writer_) {
       return false;
     }
 
-    size_t zipFlags = 0;
+    size_t zip_flags = 0;
     if (flags & ArchiveEntry::kCompress) {
-      zipFlags |= ZipWriter::kCompress;
+      zip_flags |= ZipWriter::kCompress;
     }
 
     if (flags & ArchiveEntry::kAlign) {
-      zipFlags |= ZipWriter::kAlign32;
+      zip_flags |= ZipWriter::kAlign32;
     }
 
-    int32_t result = mWriter->StartEntry(path.data(), zipFlags);
+    int32_t result = writer_->StartEntry(path.data(), zip_flags);
     if (result != 0) {
       return false;
     }
     return true;
   }
 
-  bool writeEntry(const void* data, size_t len) override {
-    int32_t result = mWriter->WriteBytes(data, len);
+  bool WriteEntry(const void* data, size_t len) override {
+    int32_t result = writer_->WriteBytes(data, len);
     if (result != 0) {
       return false;
     }
     return true;
   }
 
-  bool writeEntry(const BigBuffer& buffer) override {
+  bool WriteEntry(const BigBuffer& buffer) override {
     for (const BigBuffer::Block& b : buffer) {
-      int32_t result = mWriter->WriteBytes(b.buffer.get(), b.size);
+      int32_t result = writer_->WriteBytes(b.buffer.get(), b.size);
       if (result != 0) {
         return false;
       }
@@ -147,8 +155,8 @@ struct ZipFileWriter : public IArchiveWriter {
     return true;
   }
 
-  bool finishEntry() override {
-    int32_t result = mWriter->FinishEntry();
+  bool FinishEntry() override {
+    int32_t result = writer_->FinishEntry();
     if (result != 0) {
       return false;
     }
@@ -156,28 +164,34 @@ struct ZipFileWriter : public IArchiveWriter {
   }
 
   virtual ~ZipFileWriter() {
-    if (mWriter) {
-      mWriter->Finish();
+    if (writer_) {
+      writer_->Finish();
     }
   }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ZipFileWriter);
+
+  std::unique_ptr<FILE, decltype(fclose)*> file_ = {nullptr, fclose};
+  std::unique_ptr<ZipWriter> writer_;
 };
 
 }  // namespace
 
-std::unique_ptr<IArchiveWriter> createDirectoryArchiveWriter(
+std::unique_ptr<IArchiveWriter> CreateDirectoryArchiveWriter(
     IDiagnostics* diag, const StringPiece& path) {
   std::unique_ptr<DirectoryWriter> writer =
       util::make_unique<DirectoryWriter>();
-  if (!writer->open(diag, path)) {
+  if (!writer->Open(diag, path)) {
     return {};
   }
   return std::move(writer);
 }
 
-std::unique_ptr<IArchiveWriter> createZipFileArchiveWriter(
+std::unique_ptr<IArchiveWriter> CreateZipFileArchiveWriter(
     IDiagnostics* diag, const StringPiece& path) {
   std::unique_ptr<ZipFileWriter> writer = util::make_unique<ZipFileWriter>();
-  if (!writer->open(diag, path)) {
+  if (!writer->Open(diag, path)) {
     return {};
   }
   return std::move(writer);
diff --git a/tools/aapt2/flatten/Archive.h b/tools/aapt2/flatten/Archive.h
index 46cd0ac0adc27..4fcb3ffa2b78c 100644
--- a/tools/aapt2/flatten/Archive.h
+++ b/tools/aapt2/flatten/Archive.h
@@ -17,17 +17,18 @@
 #ifndef AAPT_FLATTEN_ARCHIVE_H
 #define AAPT_FLATTEN_ARCHIVE_H
 
-#include "Diagnostics.h"
-#include "util/BigBuffer.h"
-#include "util/Files.h"
-#include "util/StringPiece.h"
-
-#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
 #include <fstream>
 #include <memory>
 #include <string>
 #include <vector>
 
+#include "google/protobuf/io/zero_copy_stream_impl_lite.h"
+
+#include "Diagnostics.h"
+#include "util/BigBuffer.h"
+#include "util/Files.h"
+#include "util/StringPiece.h"
+
 namespace aapt {
 
 struct ArchiveEntry {
@@ -38,28 +39,28 @@ struct ArchiveEntry {
 
   std::string path;
   uint32_t flags;
-  size_t uncompressedSize;
+  size_t uncompressed_size;
 };
 
 class IArchiveWriter : public google::protobuf::io::CopyingOutputStream {
  public:
   virtual ~IArchiveWriter() = default;
 
-  virtual bool startEntry(const StringPiece& path, uint32_t flags) = 0;
-  virtual bool writeEntry(const BigBuffer& buffer) = 0;
-  virtual bool writeEntry(const void* data, size_t len) = 0;
-  virtual bool finishEntry() = 0;
+  virtual bool StartEntry(const StringPiece& path, uint32_t flags) = 0;
+  virtual bool WriteEntry(const BigBuffer& buffer) = 0;
+  virtual bool WriteEntry(const void* data, size_t len) = 0;
+  virtual bool FinishEntry() = 0;
 
   // CopyingOutputStream implementations.
   bool Write(const void* buffer, int size) override {
-    return writeEntry(buffer, size);
+    return WriteEntry(buffer, size);
   }
 };
 
-std::unique_ptr<IArchiveWriter> createDirectoryArchiveWriter(
+std::unique_ptr<IArchiveWriter> CreateDirectoryArchiveWriter(
     IDiagnostics* diag, const StringPiece& path);
 
-std::unique_ptr<IArchiveWriter> createZipFileArchiveWriter(
+std::unique_ptr<IArchiveWriter> CreateZipFileArchiveWriter(
     IDiagnostics* diag, const StringPiece& path);
 
 }  // namespace aapt
diff --git a/tools/aapt2/flatten/ChunkWriter.h b/tools/aapt2/flatten/ChunkWriter.h
index 852afd4255d97..968d3eef48ec1 100644
--- a/tools/aapt2/flatten/ChunkWriter.h
+++ b/tools/aapt2/flatten/ChunkWriter.h
@@ -17,62 +17,62 @@
 #ifndef AAPT_FLATTEN_CHUNKWRITER_H
 #define AAPT_FLATTEN_CHUNKWRITER_H
 
+#include "android-base/macros.h"
+#include "androidfw/ResourceTypes.h"
+
 #include "util/BigBuffer.h"
 #include "util/Util.h"
 
-#include <androidfw/ResourceTypes.h>
-
 namespace aapt {
 
 class ChunkWriter {
- private:
-  BigBuffer* mBuffer;
-  size_t mStartSize = 0;
-  android::ResChunk_header* mHeader = nullptr;
-
  public:
-  explicit inline ChunkWriter(BigBuffer* buffer) : mBuffer(buffer) {}
-
-  ChunkWriter(const ChunkWriter&) = delete;
-  ChunkWriter& operator=(const ChunkWriter&) = delete;
+  explicit inline ChunkWriter(BigBuffer* buffer) : buffer_(buffer) {}
   ChunkWriter(ChunkWriter&&) = default;
   ChunkWriter& operator=(ChunkWriter&&) = default;
 
   template <typename T>
-  inline T* startChunk(uint16_t type) {
-    mStartSize = mBuffer->size();
-    T* chunk = mBuffer->nextBlock<T>();
-    mHeader = &chunk->header;
-    mHeader->type = util::hostToDevice16(type);
-    mHeader->headerSize = util::hostToDevice16(sizeof(T));
+  inline T* StartChunk(uint16_t type) {
+    start_size_ = buffer_->size();
+    T* chunk = buffer_->NextBlock<T>();
+    header_ = &chunk->header;
+    header_->type = util::HostToDevice16(type);
+    header_->headerSize = util::HostToDevice16(sizeof(T));
     return chunk;
   }
 
   template <typename T>
-  inline T* nextBlock(size_t count = 1) {
-    return mBuffer->nextBlock<T>(count);
+  inline T* NextBlock(size_t count = 1) {
+    return buffer_->NextBlock<T>(count);
   }
 
-  inline BigBuffer* getBuffer() { return mBuffer; }
+  inline BigBuffer* buffer() { return buffer_; }
 
-  inline android::ResChunk_header* getChunkHeader() { return mHeader; }
+  inline android::ResChunk_header* chunk_header() { return header_; }
 
-  inline size_t size() { return mBuffer->size() - mStartSize; }
+  inline size_t size() { return buffer_->size() - start_size_; }
 
-  inline android::ResChunk_header* finish() {
-    mBuffer->align4();
-    mHeader->size = util::hostToDevice32(mBuffer->size() - mStartSize);
-    return mHeader;
+  inline android::ResChunk_header* Finish() {
+    buffer_->Align4();
+    header_->size = util::HostToDevice32(buffer_->size() - start_size_);
+    return header_;
   }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ChunkWriter);
+
+  BigBuffer* buffer_;
+  size_t start_size_ = 0;
+  android::ResChunk_header* header_ = nullptr;
 };
 
 template <>
-inline android::ResChunk_header* ChunkWriter::startChunk(uint16_t type) {
-  mStartSize = mBuffer->size();
-  mHeader = mBuffer->nextBlock<android::ResChunk_header>();
-  mHeader->type = util::hostToDevice16(type);
-  mHeader->headerSize = util::hostToDevice16(sizeof(android::ResChunk_header));
-  return mHeader;
+inline android::ResChunk_header* ChunkWriter::StartChunk(uint16_t type) {
+  start_size_ = buffer_->size();
+  header_ = buffer_->NextBlock<android::ResChunk_header>();
+  header_->type = util::HostToDevice16(type);
+  header_->headerSize = util::HostToDevice16(sizeof(android::ResChunk_header));
+  return header_;
 }
 
 }  // namespace aapt
diff --git a/tools/aapt2/flatten/ResourceTypeExtensions.h b/tools/aapt2/flatten/ResourceTypeExtensions.h
index 0b192404de28f..6359b4143f1e9 100644
--- a/tools/aapt2/flatten/ResourceTypeExtensions.h
+++ b/tools/aapt2/flatten/ResourceTypeExtensions.h
@@ -17,7 +17,7 @@
 #ifndef AAPT_RESOURCE_TYPE_EXTENSIONS_H
 #define AAPT_RESOURCE_TYPE_EXTENSIONS_H
 
-#include <androidfw/ResourceTypes.h>
+#include "androidfw/ResourceTypes.h"
 
 namespace aapt {
 
diff --git a/tools/aapt2/flatten/TableFlattener.cpp b/tools/aapt2/flatten/TableFlattener.cpp
index d4ea6c05c9b02..19d030ec4a25f 100644
--- a/tools/aapt2/flatten/TableFlattener.cpp
+++ b/tools/aapt2/flatten/TableFlattener.cpp
@@ -14,21 +14,23 @@
  * limitations under the License.
  */
 
-#include "ResourceTable.h"
-#include "ResourceValues.h"
-#include "ValueVisitor.h"
-
-#include "flatten/ChunkWriter.h"
-#include "flatten/ResourceTypeExtensions.h"
 #include "flatten/TableFlattener.h"
-#include "util/BigBuffer.h"
 
-#include <android-base/macros.h>
 #include <algorithm>
 #include <numeric>
 #include <sstream>
 #include <type_traits>
 
+#include "android-base/logging.h"
+#include "android-base/macros.h"
+
+#include "ResourceTable.h"
+#include "ResourceValues.h"
+#include "ValueVisitor.h"
+#include "flatten/ChunkWriter.h"
+#include "flatten/ResourceTypeExtensions.h"
+#include "util/BigBuffer.h"
+
 using namespace android;
 
 namespace aapt {
@@ -36,7 +38,7 @@ namespace aapt {
 namespace {
 
 template <typename T>
-static bool cmpIds(const T* a, const T* b) {
+static bool cmp_ids(const T* a, const T* b) {
   return a->id.value() < b->id.value();
 }
 
@@ -46,14 +48,14 @@ static void strcpy16_htod(uint16_t* dst, size_t len, const StringPiece16& src) {
   }
 
   size_t i;
-  const char16_t* srcData = src.data();
+  const char16_t* src_data = src.data();
   for (i = 0; i < len - 1 && i < src.size(); i++) {
-    dst[i] = util::hostToDevice16((uint16_t)srcData[i]);
+    dst[i] = util::HostToDevice16((uint16_t)src_data[i]);
   }
   dst[i] = 0;
 }
 
-static bool cmpStyleEntries(const Style::Entry& a, const Style::Entry& b) {
+static bool cmp_style_entries(const Style::Entry& a, const Style::Entry& b) {
   if (a.key.id) {
     if (b.key.id) {
       return a.key.id.value() < b.key.id.value();
@@ -70,75 +72,75 @@ struct FlatEntry {
   Value* value;
 
   // The entry string pool index to the entry's name.
-  uint32_t entryKey;
+  uint32_t entry_key;
 };
 
 class MapFlattenVisitor : public RawValueVisitor {
  public:
-  using RawValueVisitor::visit;
+  using RawValueVisitor::Visit;
 
-  MapFlattenVisitor(ResTable_entry_ext* outEntry, BigBuffer* buffer)
-      : mOutEntry(outEntry), mBuffer(buffer) {}
+  MapFlattenVisitor(ResTable_entry_ext* out_entry, BigBuffer* buffer)
+      : out_entry_(out_entry), buffer_(buffer) {}
 
-  void visit(Attribute* attr) override {
+  void Visit(Attribute* attr) override {
     {
       Reference key = Reference(ResourceId(ResTable_map::ATTR_TYPE));
-      BinaryPrimitive val(Res_value::TYPE_INT_DEC, attr->typeMask);
-      flattenEntry(&key, &val);
+      BinaryPrimitive val(Res_value::TYPE_INT_DEC, attr->type_mask);
+      FlattenEntry(&key, &val);
     }
 
-    if (attr->minInt != std::numeric_limits<int32_t>::min()) {
+    if (attr->min_int != std::numeric_limits<int32_t>::min()) {
       Reference key = Reference(ResourceId(ResTable_map::ATTR_MIN));
       BinaryPrimitive val(Res_value::TYPE_INT_DEC,
-                          static_cast<uint32_t>(attr->minInt));
-      flattenEntry(&key, &val);
+                          static_cast<uint32_t>(attr->min_int));
+      FlattenEntry(&key, &val);
     }
 
-    if (attr->maxInt != std::numeric_limits<int32_t>::max()) {
+    if (attr->max_int != std::numeric_limits<int32_t>::max()) {
       Reference key = Reference(ResourceId(ResTable_map::ATTR_MAX));
       BinaryPrimitive val(Res_value::TYPE_INT_DEC,
-                          static_cast<uint32_t>(attr->maxInt));
-      flattenEntry(&key, &val);
+                          static_cast<uint32_t>(attr->max_int));
+      FlattenEntry(&key, &val);
     }
 
     for (Attribute::Symbol& s : attr->symbols) {
       BinaryPrimitive val(Res_value::TYPE_INT_DEC, s.value);
-      flattenEntry(&s.symbol, &val);
+      FlattenEntry(&s.symbol, &val);
     }
   }
 
-  void visit(Style* style) override {
+  void Visit(Style* style) override {
     if (style->parent) {
-      const Reference& parentRef = style->parent.value();
-      assert(parentRef.id && "parent has no ID");
-      mOutEntry->parent.ident = util::hostToDevice32(parentRef.id.value().id);
+      const Reference& parent_ref = style->parent.value();
+      CHECK(bool(parent_ref.id)) << "parent has no ID";
+      out_entry_->parent.ident = util::HostToDevice32(parent_ref.id.value().id);
     }
 
     // Sort the style.
-    std::sort(style->entries.begin(), style->entries.end(), cmpStyleEntries);
+    std::sort(style->entries.begin(), style->entries.end(), cmp_style_entries);
 
     for (Style::Entry& entry : style->entries) {
-      flattenEntry(&entry.key, entry.value.get());
+      FlattenEntry(&entry.key, entry.value.get());
     }
   }
 
-  void visit(Styleable* styleable) override {
-    for (auto& attrRef : styleable->entries) {
+  void Visit(Styleable* styleable) override {
+    for (auto& attr_ref : styleable->entries) {
       BinaryPrimitive val(Res_value{});
-      flattenEntry(&attrRef, &val);
+      FlattenEntry(&attr_ref, &val);
     }
   }
 
-  void visit(Array* array) override {
+  void Visit(Array* array) override {
     for (auto& item : array->items) {
-      ResTable_map* outEntry = mBuffer->nextBlock<ResTable_map>();
-      flattenValue(item.get(), outEntry);
-      outEntry->value.size = util::hostToDevice16(sizeof(outEntry->value));
-      mEntryCount++;
+      ResTable_map* out_entry = buffer_->NextBlock<ResTable_map>();
+      FlattenValue(item.get(), out_entry);
+      out_entry->value.size = util::HostToDevice16(sizeof(out_entry->value));
+      entry_count_++;
     }
   }
 
-  void visit(Plural* plural) override {
+  void Visit(Plural* plural) override {
     const size_t count = plural->values.size();
     for (size_t i = 0; i < count; i++) {
       if (!plural->values[i]) {
@@ -172,12 +174,12 @@ class MapFlattenVisitor : public RawValueVisitor {
           break;
 
         default:
-          assert(false);
+          LOG(FATAL) << "unhandled plural type";
           break;
       }
 
       Reference key(q);
-      flattenEntry(&key, plural->values[i].get());
+      FlattenEntry(&key, plural->values[i].get());
     }
   }
 
@@ -185,267 +187,264 @@ class MapFlattenVisitor : public RawValueVisitor {
    * Call this after visiting a Value. This will finish any work that
    * needs to be done to prepare the entry.
    */
-  void finish() { mOutEntry->count = util::hostToDevice32(mEntryCount); }
+  void Finish() { out_entry_->count = util::HostToDevice32(entry_count_); }
 
  private:
-  void flattenKey(Reference* key, ResTable_map* outEntry) {
-    assert(key->id && "key has no ID");
-    outEntry->name.ident = util::hostToDevice32(key->id.value().id);
+  DISALLOW_COPY_AND_ASSIGN(MapFlattenVisitor);
+
+  void FlattenKey(Reference* key, ResTable_map* out_entry) {
+    CHECK(bool(key->id)) << "key has no ID";
+    out_entry->name.ident = util::HostToDevice32(key->id.value().id);
   }
 
-  void flattenValue(Item* value, ResTable_map* outEntry) {
-    bool result = value->flatten(&outEntry->value);
-    assert(result && "flatten failed");
+  void FlattenValue(Item* value, ResTable_map* out_entry) {
+    CHECK(value->Flatten(&out_entry->value)) << "flatten failed";
   }
 
-  void flattenEntry(Reference* key, Item* value) {
-    ResTable_map* outEntry = mBuffer->nextBlock<ResTable_map>();
-    flattenKey(key, outEntry);
-    flattenValue(value, outEntry);
-    outEntry->value.size = util::hostToDevice16(sizeof(outEntry->value));
-    mEntryCount++;
+  void FlattenEntry(Reference* key, Item* value) {
+    ResTable_map* out_entry = buffer_->NextBlock<ResTable_map>();
+    FlattenKey(key, out_entry);
+    FlattenValue(value, out_entry);
+    out_entry->value.size = util::HostToDevice16(sizeof(out_entry->value));
+    entry_count_++;
   }
 
-  ResTable_entry_ext* mOutEntry;
-  BigBuffer* mBuffer;
-  size_t mEntryCount = 0;
+  ResTable_entry_ext* out_entry_;
+  BigBuffer* buffer_;
+  size_t entry_count_ = 0;
 };
 
 class PackageFlattener {
  public:
   PackageFlattener(IDiagnostics* diag, ResourceTablePackage* package)
-      : mDiag(diag), mPackage(package) {}
+      : diag_(diag), package_(package) {}
 
-  bool flattenPackage(BigBuffer* buffer) {
-    ChunkWriter pkgWriter(buffer);
-    ResTable_package* pkgHeader =
-        pkgWriter.startChunk<ResTable_package>(RES_TABLE_PACKAGE_TYPE);
-    pkgHeader->id = util::hostToDevice32(mPackage->id.value());
+  bool FlattenPackage(BigBuffer* buffer) {
+    ChunkWriter pkg_writer(buffer);
+    ResTable_package* pkg_header =
+        pkg_writer.StartChunk<ResTable_package>(RES_TABLE_PACKAGE_TYPE);
+    pkg_header->id = util::HostToDevice32(package_->id.value());
 
-    if (mPackage->name.size() >= arraysize(pkgHeader->name)) {
-      mDiag->error(DiagMessage() << "package name '" << mPackage->name
+    if (package_->name.size() >= arraysize(pkg_header->name)) {
+      diag_->Error(DiagMessage() << "package name '" << package_->name
                                  << "' is too long");
       return false;
     }
 
     // Copy the package name in device endianness.
-    strcpy16_htod(pkgHeader->name, arraysize(pkgHeader->name),
-                  util::utf8ToUtf16(mPackage->name));
+    strcpy16_htod(pkg_header->name, arraysize(pkg_header->name),
+                  util::Utf8ToUtf16(package_->name));
 
     // Serialize the types. We do this now so that our type and key strings
     // are populated. We write those first.
-    BigBuffer typeBuffer(1024);
-    flattenTypes(&typeBuffer);
+    BigBuffer type_buffer(1024);
+    FlattenTypes(&type_buffer);
 
-    pkgHeader->typeStrings = util::hostToDevice32(pkgWriter.size());
-    StringPool::flattenUtf16(pkgWriter.getBuffer(), mTypePool);
+    pkg_header->typeStrings = util::HostToDevice32(pkg_writer.size());
+    StringPool::FlattenUtf16(pkg_writer.buffer(), type_pool_);
 
-    pkgHeader->keyStrings = util::hostToDevice32(pkgWriter.size());
-    StringPool::flattenUtf8(pkgWriter.getBuffer(), mKeyPool);
+    pkg_header->keyStrings = util::HostToDevice32(pkg_writer.size());
+    StringPool::FlattenUtf8(pkg_writer.buffer(), key_pool_);
 
     // Append the types.
-    buffer->appendBuffer(std::move(typeBuffer));
+    buffer->AppendBuffer(std::move(type_buffer));
 
-    pkgWriter.finish();
+    pkg_writer.Finish();
     return true;
   }
 
  private:
-  IDiagnostics* mDiag;
-  ResourceTablePackage* mPackage;
-  StringPool mTypePool;
-  StringPool mKeyPool;
+  DISALLOW_COPY_AND_ASSIGN(PackageFlattener);
 
   template <typename T, bool IsItem>
-  T* writeEntry(FlatEntry* entry, BigBuffer* buffer) {
+  T* WriteEntry(FlatEntry* entry, BigBuffer* buffer) {
     static_assert(std::is_same<ResTable_entry, T>::value ||
                       std::is_same<ResTable_entry_ext, T>::value,
                   "T must be ResTable_entry or ResTable_entry_ext");
 
-    T* result = buffer->nextBlock<T>();
-    ResTable_entry* outEntry = (ResTable_entry*)(result);
-    if (entry->entry->symbolStatus.state == SymbolState::kPublic) {
-      outEntry->flags |= ResTable_entry::FLAG_PUBLIC;
+    T* result = buffer->NextBlock<T>();
+    ResTable_entry* out_entry = (ResTable_entry*)result;
+    if (entry->entry->symbol_status.state == SymbolState::kPublic) {
+      out_entry->flags |= ResTable_entry::FLAG_PUBLIC;
     }
 
-    if (entry->value->isWeak()) {
-      outEntry->flags |= ResTable_entry::FLAG_WEAK;
+    if (entry->value->IsWeak()) {
+      out_entry->flags |= ResTable_entry::FLAG_WEAK;
     }
 
     if (!IsItem) {
-      outEntry->flags |= ResTable_entry::FLAG_COMPLEX;
+      out_entry->flags |= ResTable_entry::FLAG_COMPLEX;
     }
 
-    outEntry->flags = util::hostToDevice16(outEntry->flags);
-    outEntry->key.index = util::hostToDevice32(entry->entryKey);
-    outEntry->size = util::hostToDevice16(sizeof(T));
+    out_entry->flags = util::HostToDevice16(out_entry->flags);
+    out_entry->key.index = util::HostToDevice32(entry->entry_key);
+    out_entry->size = util::HostToDevice16(sizeof(T));
     return result;
   }
 
-  bool flattenValue(FlatEntry* entry, BigBuffer* buffer) {
-    if (Item* item = valueCast<Item>(entry->value)) {
-      writeEntry<ResTable_entry, true>(entry, buffer);
-      Res_value* outValue = buffer->nextBlock<Res_value>();
-      bool result = item->flatten(outValue);
-      assert(result && "flatten failed");
-      outValue->size = util::hostToDevice16(sizeof(*outValue));
+  bool FlattenValue(FlatEntry* entry, BigBuffer* buffer) {
+    if (Item* item = ValueCast<Item>(entry->value)) {
+      WriteEntry<ResTable_entry, true>(entry, buffer);
+      Res_value* outValue = buffer->NextBlock<Res_value>();
+      CHECK(item->Flatten(outValue)) << "flatten failed";
+      outValue->size = util::HostToDevice16(sizeof(*outValue));
     } else {
-      ResTable_entry_ext* outEntry =
-          writeEntry<ResTable_entry_ext, false>(entry, buffer);
-      MapFlattenVisitor visitor(outEntry, buffer);
-      entry->value->accept(&visitor);
-      visitor.finish();
+      ResTable_entry_ext* out_entry =
+          WriteEntry<ResTable_entry_ext, false>(entry, buffer);
+      MapFlattenVisitor visitor(out_entry, buffer);
+      entry->value->Accept(&visitor);
+      visitor.Finish();
     }
     return true;
   }
 
-  bool flattenConfig(const ResourceTableType* type,
+  bool FlattenConfig(const ResourceTableType* type,
                      const ConfigDescription& config,
                      std::vector<FlatEntry>* entries, BigBuffer* buffer) {
-    ChunkWriter typeWriter(buffer);
-    ResTable_type* typeHeader =
-        typeWriter.startChunk<ResTable_type>(RES_TABLE_TYPE_TYPE);
-    typeHeader->id = type->id.value();
-    typeHeader->config = config;
-    typeHeader->config.swapHtoD();
+    ChunkWriter type_writer(buffer);
+    ResTable_type* type_header =
+        type_writer.StartChunk<ResTable_type>(RES_TABLE_TYPE_TYPE);
+    type_header->id = type->id.value();
+    type_header->config = config;
+    type_header->config.swapHtoD();
 
-    auto maxAccum = [](uint32_t max,
-                       const std::unique_ptr<ResourceEntry>& a) -> uint32_t {
+    auto max_accum = [](uint32_t max,
+                        const std::unique_ptr<ResourceEntry>& a) -> uint32_t {
       return std::max(max, (uint32_t)a->id.value());
     };
 
     // Find the largest entry ID. That is how many entries we will have.
-    const uint32_t entryCount =
+    const uint32_t entry_count =
         std::accumulate(type->entries.begin(), type->entries.end(), 0,
-                        maxAccum) +
+                        max_accum) +
         1;
 
-    typeHeader->entryCount = util::hostToDevice32(entryCount);
-    uint32_t* indices = typeWriter.nextBlock<uint32_t>(entryCount);
+    type_header->entryCount = util::HostToDevice32(entry_count);
+    uint32_t* indices = type_writer.NextBlock<uint32_t>(entry_count);
 
-    assert((size_t)entryCount <= std::numeric_limits<uint16_t>::max() + 1);
-    memset(indices, 0xff, entryCount * sizeof(uint32_t));
+    CHECK((size_t)entry_count <= std::numeric_limits<uint16_t>::max());
+    memset(indices, 0xff, entry_count * sizeof(uint32_t));
 
-    typeHeader->entriesStart = util::hostToDevice32(typeWriter.size());
+    type_header->entriesStart = util::HostToDevice32(type_writer.size());
 
-    const size_t entryStart = typeWriter.getBuffer()->size();
-    for (FlatEntry& flatEntry : *entries) {
-      assert(flatEntry.entry->id.value() < entryCount);
-      indices[flatEntry.entry->id.value()] =
-          util::hostToDevice32(typeWriter.getBuffer()->size() - entryStart);
-      if (!flattenValue(&flatEntry, typeWriter.getBuffer())) {
-        mDiag->error(DiagMessage()
+    const size_t entry_start = type_writer.buffer()->size();
+    for (FlatEntry& flat_entry : *entries) {
+      CHECK(flat_entry.entry->id.value() < entry_count);
+      indices[flat_entry.entry->id.value()] =
+          util::HostToDevice32(type_writer.buffer()->size() - entry_start);
+      if (!FlattenValue(&flat_entry, type_writer.buffer())) {
+        diag_->Error(DiagMessage()
                      << "failed to flatten resource '"
-                     << ResourceNameRef(mPackage->name, type->type,
-                                        flatEntry.entry->name)
+                     << ResourceNameRef(package_->name, type->type,
+                                        flat_entry.entry->name)
                      << "' for configuration '" << config << "'");
         return false;
       }
     }
-    typeWriter.finish();
+    type_writer.Finish();
     return true;
   }
 
-  std::vector<ResourceTableType*> collectAndSortTypes() {
-    std::vector<ResourceTableType*> sortedTypes;
-    for (auto& type : mPackage->types) {
+  std::vector<ResourceTableType*> CollectAndSortTypes() {
+    std::vector<ResourceTableType*> sorted_types;
+    for (auto& type : package_->types) {
       if (type->type == ResourceType::kStyleable) {
         // Styleables aren't real Resource Types, they are represented in the
-        // R.java
-        // file.
+        // R.java file.
         continue;
       }
 
-      assert(type->id && "type must have an ID set");
+      CHECK(bool(type->id)) << "type must have an ID set";
 
-      sortedTypes.push_back(type.get());
+      sorted_types.push_back(type.get());
     }
-    std::sort(sortedTypes.begin(), sortedTypes.end(),
-              cmpIds<ResourceTableType>);
-    return sortedTypes;
+    std::sort(sorted_types.begin(), sorted_types.end(),
+              cmp_ids<ResourceTableType>);
+    return sorted_types;
   }
 
-  std::vector<ResourceEntry*> collectAndSortEntries(ResourceTableType* type) {
+  std::vector<ResourceEntry*> CollectAndSortEntries(ResourceTableType* type) {
     // Sort the entries by entry ID.
-    std::vector<ResourceEntry*> sortedEntries;
+    std::vector<ResourceEntry*> sorted_entries;
     for (auto& entry : type->entries) {
-      assert(entry->id && "entry must have an ID set");
-      sortedEntries.push_back(entry.get());
+      CHECK(bool(entry->id)) << "entry must have an ID set";
+      sorted_entries.push_back(entry.get());
     }
-    std::sort(sortedEntries.begin(), sortedEntries.end(),
-              cmpIds<ResourceEntry>);
-    return sortedEntries;
+    std::sort(sorted_entries.begin(), sorted_entries.end(),
+              cmp_ids<ResourceEntry>);
+    return sorted_entries;
   }
 
-  bool flattenTypeSpec(ResourceTableType* type,
-                       std::vector<ResourceEntry*>* sortedEntries,
+  bool FlattenTypeSpec(ResourceTableType* type,
+                       std::vector<ResourceEntry*>* sorted_entries,
                        BigBuffer* buffer) {
-    ChunkWriter typeSpecWriter(buffer);
-    ResTable_typeSpec* specHeader =
-        typeSpecWriter.startChunk<ResTable_typeSpec>(RES_TABLE_TYPE_SPEC_TYPE);
-    specHeader->id = type->id.value();
+    ChunkWriter type_spec_writer(buffer);
+    ResTable_typeSpec* spec_header =
+        type_spec_writer.StartChunk<ResTable_typeSpec>(
+            RES_TABLE_TYPE_SPEC_TYPE);
+    spec_header->id = type->id.value();
 
-    if (sortedEntries->empty()) {
-      typeSpecWriter.finish();
+    if (sorted_entries->empty()) {
+      type_spec_writer.Finish();
       return true;
     }
 
     // We can't just take the size of the vector. There may be holes in the
     // entry ID space.
     // Since the entries are sorted by ID, the last one will be the biggest.
-    const size_t numEntries = sortedEntries->back()->id.value() + 1;
+    const size_t num_entries = sorted_entries->back()->id.value() + 1;
 
-    specHeader->entryCount = util::hostToDevice32(numEntries);
+    spec_header->entryCount = util::HostToDevice32(num_entries);
 
     // Reserve space for the masks of each resource in this type. These
     // show for which configuration axis the resource changes.
-    uint32_t* configMasks = typeSpecWriter.nextBlock<uint32_t>(numEntries);
+    uint32_t* config_masks = type_spec_writer.NextBlock<uint32_t>(num_entries);
 
-    const size_t actualNumEntries = sortedEntries->size();
-    for (size_t entryIndex = 0; entryIndex < actualNumEntries; entryIndex++) {
-      ResourceEntry* entry = sortedEntries->at(entryIndex);
+    const size_t actual_num_entries = sorted_entries->size();
+    for (size_t entryIndex = 0; entryIndex < actual_num_entries; entryIndex++) {
+      ResourceEntry* entry = sorted_entries->at(entryIndex);
 
       // Populate the config masks for this entry.
 
-      if (entry->symbolStatus.state == SymbolState::kPublic) {
-        configMasks[entry->id.value()] |=
-            util::hostToDevice32(ResTable_typeSpec::SPEC_PUBLIC);
+      if (entry->symbol_status.state == SymbolState::kPublic) {
+        config_masks[entry->id.value()] |=
+            util::HostToDevice32(ResTable_typeSpec::SPEC_PUBLIC);
       }
 
-      const size_t configCount = entry->values.size();
-      for (size_t i = 0; i < configCount; i++) {
+      const size_t config_count = entry->values.size();
+      for (size_t i = 0; i < config_count; i++) {
         const ConfigDescription& config = entry->values[i]->config;
-        for (size_t j = i + 1; j < configCount; j++) {
-          configMasks[entry->id.value()] |=
-              util::hostToDevice32(config.diff(entry->values[j]->config));
+        for (size_t j = i + 1; j < config_count; j++) {
+          config_masks[entry->id.value()] |=
+              util::HostToDevice32(config.diff(entry->values[j]->config));
         }
       }
     }
-    typeSpecWriter.finish();
+    type_spec_writer.Finish();
     return true;
   }
 
-  bool flattenTypes(BigBuffer* buffer) {
+  bool FlattenTypes(BigBuffer* buffer) {
     // Sort the types by their IDs. They will be inserted into the StringPool in
     // this order.
-    std::vector<ResourceTableType*> sortedTypes = collectAndSortTypes();
+    std::vector<ResourceTableType*> sorted_types = CollectAndSortTypes();
 
-    size_t expectedTypeId = 1;
-    for (ResourceTableType* type : sortedTypes) {
+    size_t expected_type_id = 1;
+    for (ResourceTableType* type : sorted_types) {
       // If there is a gap in the type IDs, fill in the StringPool
       // with empty values until we reach the ID we expect.
-      while (type->id.value() > expectedTypeId) {
-        std::stringstream typeName;
-        typeName << "?" << expectedTypeId;
-        mTypePool.makeRef(typeName.str());
-        expectedTypeId++;
+      while (type->id.value() > expected_type_id) {
+        std::stringstream type_name;
+        type_name << "?" << expected_type_id;
+        type_pool_.MakeRef(type_name.str());
+        expected_type_id++;
       }
-      expectedTypeId++;
-      mTypePool.makeRef(toString(type->type));
+      expected_type_id++;
+      type_pool_.MakeRef(ToString(type->type));
 
-      std::vector<ResourceEntry*> sortedEntries = collectAndSortEntries(type);
+      std::vector<ResourceEntry*> sorted_entries = CollectAndSortEntries(type);
 
-      if (!flattenTypeSpec(type, &sortedEntries, buffer)) {
+      if (!FlattenTypeSpec(type, &sorted_entries, buffer)) {
         return false;
       }
 
@@ -455,35 +454,41 @@ class PackageFlattener {
       // each
       // configuration available. Here we reverse this to match the binary
       // table.
-      std::map<ConfigDescription, std::vector<FlatEntry>> configToEntryListMap;
-      for (ResourceEntry* entry : sortedEntries) {
-        const uint32_t keyIndex =
-            (uint32_t)mKeyPool.makeRef(entry->name).getIndex();
+      std::map<ConfigDescription, std::vector<FlatEntry>>
+          config_to_entry_list_map;
+      for (ResourceEntry* entry : sorted_entries) {
+        const uint32_t key_index =
+            (uint32_t)key_pool_.MakeRef(entry->name).index();
 
         // Group values by configuration.
-        for (auto& configValue : entry->values) {
-          configToEntryListMap[configValue->config].push_back(
-              FlatEntry{entry, configValue->value.get(), keyIndex});
+        for (auto& config_value : entry->values) {
+          config_to_entry_list_map[config_value->config].push_back(
+              FlatEntry{entry, config_value->value.get(), key_index});
         }
       }
 
       // Flatten a configuration value.
-      for (auto& entry : configToEntryListMap) {
-        if (!flattenConfig(type, entry.first, &entry.second, buffer)) {
+      for (auto& entry : config_to_entry_list_map) {
+        if (!FlattenConfig(type, entry.first, &entry.second, buffer)) {
           return false;
         }
       }
     }
     return true;
   }
+
+  IDiagnostics* diag_;
+  ResourceTablePackage* package_;
+  StringPool type_pool_;
+  StringPool key_pool_;
 };
 
 }  // namespace
 
-bool TableFlattener::consume(IAaptContext* context, ResourceTable* table) {
+bool TableFlattener::Consume(IAaptContext* context, ResourceTable* table) {
   // We must do this before writing the resources, since the string pool IDs may
   // change.
-  table->stringPool.sort(
+  table->string_pool.Sort(
       [](const StringPool::Entry& a, const StringPool::Entry& b) -> bool {
         int diff = a.context.priority - b.context.priority;
         if (diff < 0) return true;
@@ -493,30 +498,30 @@ bool TableFlattener::consume(IAaptContext* context, ResourceTable* table) {
         if (diff > 0) return false;
         return a.value < b.value;
       });
-  table->stringPool.prune();
+  table->string_pool.Prune();
 
   // Write the ResTable header.
-  ChunkWriter tableWriter(mBuffer);
-  ResTable_header* tableHeader =
-      tableWriter.startChunk<ResTable_header>(RES_TABLE_TYPE);
-  tableHeader->packageCount = util::hostToDevice32(table->packages.size());
+  ChunkWriter table_writer(buffer_);
+  ResTable_header* table_header =
+      table_writer.StartChunk<ResTable_header>(RES_TABLE_TYPE);
+  table_header->packageCount = util::HostToDevice32(table->packages.size());
 
   // Flatten the values string pool.
-  StringPool::flattenUtf8(tableWriter.getBuffer(), table->stringPool);
+  StringPool::FlattenUtf8(table_writer.buffer(), table->string_pool);
 
-  BigBuffer packageBuffer(1024);
+  BigBuffer package_buffer(1024);
 
   // Flatten each package.
   for (auto& package : table->packages) {
-    PackageFlattener flattener(context->getDiagnostics(), package.get());
-    if (!flattener.flattenPackage(&packageBuffer)) {
+    PackageFlattener flattener(context->GetDiagnostics(), package.get());
+    if (!flattener.FlattenPackage(&package_buffer)) {
       return false;
     }
   }
 
   // Finally merge all the packages into the main buffer.
-  tableWriter.getBuffer()->appendBuffer(std::move(packageBuffer));
-  tableWriter.finish();
+  table_writer.buffer()->AppendBuffer(std::move(package_buffer));
+  table_writer.Finish();
   return true;
 }
 
diff --git a/tools/aapt2/flatten/TableFlattener.h b/tools/aapt2/flatten/TableFlattener.h
index 91f96547fbd7e..53f52c29a6a35 100644
--- a/tools/aapt2/flatten/TableFlattener.h
+++ b/tools/aapt2/flatten/TableFlattener.h
@@ -17,21 +17,24 @@
 #ifndef AAPT_FLATTEN_TABLEFLATTENER_H
 #define AAPT_FLATTEN_TABLEFLATTENER_H
 
+#include "android-base/macros.h"
+
+#include "ResourceTable.h"
 #include "process/IResourceTableConsumer.h"
+#include "util/BigBuffer.h"
 
 namespace aapt {
 
-class BigBuffer;
-class ResourceTable;
-
 class TableFlattener : public IResourceTableConsumer {
  public:
-  explicit TableFlattener(BigBuffer* buffer) : mBuffer(buffer) {}
+  explicit TableFlattener(BigBuffer* buffer) : buffer_(buffer) {}
 
-  bool consume(IAaptContext* context, ResourceTable* table) override;
+  bool Consume(IAaptContext* context, ResourceTable* table) override;
 
  private:
-  BigBuffer* mBuffer;
+  DISALLOW_COPY_AND_ASSIGN(TableFlattener);
+
+  BigBuffer* buffer_;
 };
 
 }  // namespace aapt
diff --git a/tools/aapt2/flatten/TableFlattener_test.cpp b/tools/aapt2/flatten/TableFlattener_test.cpp
index a7706bd51e47c..c72624066fb85 100644
--- a/tools/aapt2/flatten/TableFlattener_test.cpp
+++ b/tools/aapt2/flatten/TableFlattener_test.cpp
@@ -15,6 +15,7 @@
  */
 
 #include "flatten/TableFlattener.h"
+
 #include "ResourceUtils.h"
 #include "test/Test.h"
 #include "unflatten/BinaryResourceParser.h"
@@ -27,162 +28,165 @@ namespace aapt {
 class TableFlattenerTest : public ::testing::Test {
  public:
   void SetUp() override {
-    mContext = test::ContextBuilder()
-                   .setCompilationPackage("com.app.test")
-                   .setPackageId(0x7f)
-                   .build();
+    context_ = test::ContextBuilder()
+                   .SetCompilationPackage("com.app.test")
+                   .SetPackageId(0x7f)
+                   .Build();
   }
 
-  ::testing::AssertionResult flatten(ResourceTable* table, ResTable* outTable) {
+  ::testing::AssertionResult Flatten(ResourceTable* table,
+                                     ResTable* out_table) {
     BigBuffer buffer(1024);
     TableFlattener flattener(&buffer);
-    if (!flattener.consume(mContext.get(), table)) {
+    if (!flattener.Consume(context_.get(), table)) {
       return ::testing::AssertionFailure() << "failed to flatten ResourceTable";
     }
 
-    std::unique_ptr<uint8_t[]> data = util::copy(buffer);
-    if (outTable->add(data.get(), buffer.size(), -1, true) != NO_ERROR) {
+    std::unique_ptr<uint8_t[]> data = util::Copy(buffer);
+    if (out_table->add(data.get(), buffer.size(), -1, true) != NO_ERROR) {
       return ::testing::AssertionFailure() << "flattened ResTable is corrupt";
     }
     return ::testing::AssertionSuccess();
   }
 
-  ::testing::AssertionResult flatten(ResourceTable* table,
-                                     ResourceTable* outTable) {
+  ::testing::AssertionResult Flatten(ResourceTable* table,
+                                     ResourceTable* out_table) {
     BigBuffer buffer(1024);
     TableFlattener flattener(&buffer);
-    if (!flattener.consume(mContext.get(), table)) {
+    if (!flattener.Consume(context_.get(), table)) {
       return ::testing::AssertionFailure() << "failed to flatten ResourceTable";
     }
 
-    std::unique_ptr<uint8_t[]> data = util::copy(buffer);
-    BinaryResourceParser parser(mContext.get(), outTable, {}, data.get(),
+    std::unique_ptr<uint8_t[]> data = util::Copy(buffer);
+    BinaryResourceParser parser(context_.get(), out_table, {}, data.get(),
                                 buffer.size());
-    if (!parser.parse()) {
+    if (!parser.Parse()) {
       return ::testing::AssertionFailure() << "flattened ResTable is corrupt";
     }
     return ::testing::AssertionSuccess();
   }
 
-  ::testing::AssertionResult exists(ResTable* table,
-                                    const StringPiece& expectedName,
-                                    const ResourceId& expectedId,
-                                    const ConfigDescription& expectedConfig,
-                                    const uint8_t expectedDataType,
-                                    const uint32_t expectedData,
-                                    const uint32_t expectedSpecFlags) {
-    const ResourceName expectedResName = test::parseNameOrDie(expectedName);
+  ::testing::AssertionResult Exists(ResTable* table,
+                                    const StringPiece& expected_name,
+                                    const ResourceId& expected_id,
+                                    const ConfigDescription& expected_config,
+                                    const uint8_t expected_data_type,
+                                    const uint32_t expected_data,
+                                    const uint32_t expected_spec_flags) {
+    const ResourceName expected_res_name = test::ParseNameOrDie(expected_name);
 
-    table->setParameters(&expectedConfig);
+    table->setParameters(&expected_config);
 
     ResTable_config config;
     Res_value val;
-    uint32_t specFlags;
-    if (table->getResource(expectedId.id, &val, false, 0, &specFlags, &config) <
-        0) {
+    uint32_t spec_flags;
+    if (table->getResource(expected_id.id, &val, false, 0, &spec_flags,
+                           &config) < 0) {
       return ::testing::AssertionFailure() << "could not find resource with";
     }
 
-    if (expectedDataType != val.dataType) {
+    if (expected_data_type != val.dataType) {
       return ::testing::AssertionFailure()
-             << "expected data type " << std::hex << (int)expectedDataType
+             << "expected data type " << std::hex << (int)expected_data_type
              << " but got data type " << (int)val.dataType << std::dec
              << " instead";
     }
 
-    if (expectedData != val.data) {
+    if (expected_data != val.data) {
       return ::testing::AssertionFailure()
-             << "expected data " << std::hex << expectedData << " but got data "
-             << val.data << std::dec << " instead";
+             << "expected data " << std::hex << expected_data
+             << " but got data " << val.data << std::dec << " instead";
     }
 
-    if (expectedSpecFlags != specFlags) {
+    if (expected_spec_flags != spec_flags) {
       return ::testing::AssertionFailure()
-             << "expected specFlags " << std::hex << expectedSpecFlags
-             << " but got specFlags " << specFlags << std::dec << " instead";
+             << "expected specFlags " << std::hex << expected_spec_flags
+             << " but got specFlags " << spec_flags << std::dec << " instead";
     }
 
-    ResTable::resource_name actualName;
-    if (!table->getResourceName(expectedId.id, false, &actualName)) {
+    ResTable::resource_name actual_name;
+    if (!table->getResourceName(expected_id.id, false, &actual_name)) {
       return ::testing::AssertionFailure() << "failed to find resource name";
     }
 
-    Maybe<ResourceName> resName = ResourceUtils::toResourceName(actualName);
+    Maybe<ResourceName> resName = ResourceUtils::ToResourceName(actual_name);
     if (!resName) {
       return ::testing::AssertionFailure()
-             << "expected name '" << expectedResName << "' but got '"
-             << StringPiece16(actualName.package, actualName.packageLen) << ":"
-             << StringPiece16(actualName.type, actualName.typeLen) << "/"
-             << StringPiece16(actualName.name, actualName.nameLen) << "'";
+             << "expected name '" << expected_res_name << "' but got '"
+             << StringPiece16(actual_name.package, actual_name.packageLen)
+             << ":" << StringPiece16(actual_name.type, actual_name.typeLen)
+             << "/" << StringPiece16(actual_name.name, actual_name.nameLen)
+             << "'";
     }
 
-    if (expectedConfig != config) {
+    if (expected_config != config) {
       return ::testing::AssertionFailure() << "expected config '"
-                                           << expectedConfig << "' but got '"
+                                           << expected_config << "' but got '"
                                            << ConfigDescription(config) << "'";
     }
     return ::testing::AssertionSuccess();
   }
 
  private:
-  std::unique_ptr<IAaptContext> mContext;
+  std::unique_ptr<IAaptContext> context_;
 };
 
 TEST_F(TableFlattenerTest, FlattenFullyLinkedTable) {
   std::unique_ptr<ResourceTable> table =
       test::ResourceTableBuilder()
-          .setPackageId("com.app.test", 0x7f)
-          .addSimple("com.app.test:id/one", ResourceId(0x7f020000))
-          .addSimple("com.app.test:id/two", ResourceId(0x7f020001))
-          .addValue("com.app.test:id/three", ResourceId(0x7f020002),
-                    test::buildReference("com.app.test:id/one",
+          .SetPackageId("com.app.test", 0x7f)
+          .AddSimple("com.app.test:id/one", ResourceId(0x7f020000))
+          .AddSimple("com.app.test:id/two", ResourceId(0x7f020001))
+          .AddValue("com.app.test:id/three", ResourceId(0x7f020002),
+                    test::BuildReference("com.app.test:id/one",
                                          ResourceId(0x7f020000)))
-          .addValue("com.app.test:integer/one", ResourceId(0x7f030000),
+          .AddValue("com.app.test:integer/one", ResourceId(0x7f030000),
                     util::make_unique<BinaryPrimitive>(
                         uint8_t(Res_value::TYPE_INT_DEC), 1u))
-          .addValue("com.app.test:integer/one", test::parseConfigOrDie("v1"),
+          .AddValue("com.app.test:integer/one", test::ParseConfigOrDie("v1"),
                     ResourceId(0x7f030000),
                     util::make_unique<BinaryPrimitive>(
                         uint8_t(Res_value::TYPE_INT_DEC), 2u))
-          .addString("com.app.test:string/test", ResourceId(0x7f040000), "foo")
-          .addString("com.app.test:layout/bar", ResourceId(0x7f050000),
+          .AddString("com.app.test:string/test", ResourceId(0x7f040000), "foo")
+          .AddString("com.app.test:layout/bar", ResourceId(0x7f050000),
                      "res/layout/bar.xml")
-          .build();
+          .Build();
 
-  ResTable resTable;
-  ASSERT_TRUE(flatten(table.get(), &resTable));
+  ResTable res_table;
+  ASSERT_TRUE(Flatten(table.get(), &res_table));
 
-  EXPECT_TRUE(exists(&resTable, "com.app.test:id/one", ResourceId(0x7f020000),
+  EXPECT_TRUE(Exists(&res_table, "com.app.test:id/one", ResourceId(0x7f020000),
                      {}, Res_value::TYPE_INT_BOOLEAN, 0u, 0u));
 
-  EXPECT_TRUE(exists(&resTable, "com.app.test:id/two", ResourceId(0x7f020001),
+  EXPECT_TRUE(Exists(&res_table, "com.app.test:id/two", ResourceId(0x7f020001),
                      {}, Res_value::TYPE_INT_BOOLEAN, 0u, 0u));
 
-  EXPECT_TRUE(exists(&resTable, "com.app.test:id/three", ResourceId(0x7f020002),
-                     {}, Res_value::TYPE_REFERENCE, 0x7f020000u, 0u));
+  EXPECT_TRUE(Exists(&res_table, "com.app.test:id/three",
+                     ResourceId(0x7f020002), {}, Res_value::TYPE_REFERENCE,
+                     0x7f020000u, 0u));
 
-  EXPECT_TRUE(exists(&resTable, "com.app.test:integer/one",
+  EXPECT_TRUE(Exists(&res_table, "com.app.test:integer/one",
                      ResourceId(0x7f030000), {}, Res_value::TYPE_INT_DEC, 1u,
                      ResTable_config::CONFIG_VERSION));
 
-  EXPECT_TRUE(exists(&resTable, "com.app.test:integer/one",
-                     ResourceId(0x7f030000), test::parseConfigOrDie("v1"),
+  EXPECT_TRUE(Exists(&res_table, "com.app.test:integer/one",
+                     ResourceId(0x7f030000), test::ParseConfigOrDie("v1"),
                      Res_value::TYPE_INT_DEC, 2u,
                      ResTable_config::CONFIG_VERSION));
 
-  std::u16string fooStr = u"foo";
-  ssize_t idx = resTable.getTableStringBlock(0)->indexOfString(fooStr.data(),
-                                                               fooStr.size());
+  std::u16string foo_str = u"foo";
+  ssize_t idx = res_table.getTableStringBlock(0)->indexOfString(foo_str.data(),
+                                                                foo_str.size());
   ASSERT_GE(idx, 0);
-  EXPECT_TRUE(exists(&resTable, "com.app.test:string/test",
+  EXPECT_TRUE(Exists(&res_table, "com.app.test:string/test",
                      ResourceId(0x7f040000), {}, Res_value::TYPE_STRING,
                      (uint32_t)idx, 0u));
 
-  std::u16string barPath = u"res/layout/bar.xml";
-  idx = resTable.getTableStringBlock(0)->indexOfString(barPath.data(),
-                                                       barPath.size());
+  std::u16string bar_path = u"res/layout/bar.xml";
+  idx = res_table.getTableStringBlock(0)->indexOfString(bar_path.data(),
+                                                        bar_path.size());
   ASSERT_GE(idx, 0);
-  EXPECT_TRUE(exists(&resTable, "com.app.test:layout/bar",
+  EXPECT_TRUE(Exists(&res_table, "com.app.test:layout/bar",
                      ResourceId(0x7f050000), {}, Res_value::TYPE_STRING,
                      (uint32_t)idx, 0u));
 }
@@ -190,42 +194,43 @@ TEST_F(TableFlattenerTest, FlattenFullyLinkedTable) {
 TEST_F(TableFlattenerTest, FlattenEntriesWithGapsInIds) {
   std::unique_ptr<ResourceTable> table =
       test::ResourceTableBuilder()
-          .setPackageId("com.app.test", 0x7f)
-          .addSimple("com.app.test:id/one", ResourceId(0x7f020001))
-          .addSimple("com.app.test:id/three", ResourceId(0x7f020003))
-          .build();
+          .SetPackageId("com.app.test", 0x7f)
+          .AddSimple("com.app.test:id/one", ResourceId(0x7f020001))
+          .AddSimple("com.app.test:id/three", ResourceId(0x7f020003))
+          .Build();
 
-  ResTable resTable;
-  ASSERT_TRUE(flatten(table.get(), &resTable));
+  ResTable res_table;
+  ASSERT_TRUE(Flatten(table.get(), &res_table));
 
-  EXPECT_TRUE(exists(&resTable, "com.app.test:id/one", ResourceId(0x7f020001),
-                     {}, Res_value::TYPE_INT_BOOLEAN, 0u, 0u));
-  EXPECT_TRUE(exists(&resTable, "com.app.test:id/three", ResourceId(0x7f020003),
+  EXPECT_TRUE(Exists(&res_table, "com.app.test:id/one", ResourceId(0x7f020001),
                      {}, Res_value::TYPE_INT_BOOLEAN, 0u, 0u));
+  EXPECT_TRUE(Exists(&res_table, "com.app.test:id/three",
+                     ResourceId(0x7f020003), {}, Res_value::TYPE_INT_BOOLEAN,
+                     0u, 0u));
 }
 
 TEST_F(TableFlattenerTest, FlattenMinMaxAttributes) {
   Attribute attr(false);
-  attr.typeMask = android::ResTable_map::TYPE_INTEGER;
-  attr.minInt = 10;
-  attr.maxInt = 23;
+  attr.type_mask = android::ResTable_map::TYPE_INTEGER;
+  attr.min_int = 10;
+  attr.max_int = 23;
   std::unique_ptr<ResourceTable> table =
       test::ResourceTableBuilder()
-          .setPackageId("android", 0x01)
-          .addValue("android:attr/foo", ResourceId(0x01010000),
+          .SetPackageId("android", 0x01)
+          .AddValue("android:attr/foo", ResourceId(0x01010000),
                     util::make_unique<Attribute>(attr))
-          .build();
+          .Build();
 
   ResourceTable result;
-  ASSERT_TRUE(flatten(table.get(), &result));
+  ASSERT_TRUE(Flatten(table.get(), &result));
 
   Attribute* actualAttr =
-      test::getValue<Attribute>(&result, "android:attr/foo");
+      test::GetValue<Attribute>(&result, "android:attr/foo");
   ASSERT_NE(nullptr, actualAttr);
-  EXPECT_EQ(attr.isWeak(), actualAttr->isWeak());
-  EXPECT_EQ(attr.typeMask, actualAttr->typeMask);
-  EXPECT_EQ(attr.minInt, actualAttr->minInt);
-  EXPECT_EQ(attr.maxInt, actualAttr->maxInt);
+  EXPECT_EQ(attr.IsWeak(), actualAttr->IsWeak());
+  EXPECT_EQ(attr.type_mask, actualAttr->type_mask);
+  EXPECT_EQ(attr.min_int, actualAttr->min_int);
+  EXPECT_EQ(attr.max_int, actualAttr->max_int);
 }
 
 }  // namespace aapt
diff --git a/tools/aapt2/flatten/XmlFlattener.cpp b/tools/aapt2/flatten/XmlFlattener.cpp
index b1536d5f21d2f..366c373223dc8 100644
--- a/tools/aapt2/flatten/XmlFlattener.cpp
+++ b/tools/aapt2/flatten/XmlFlattener.cpp
@@ -15,17 +15,21 @@
  */
 
 #include "flatten/XmlFlattener.h"
+
+#include <algorithm>
+#include <map>
+#include <vector>
+
+#include "android-base/logging.h"
+#include "android-base/macros.h"
+#include "androidfw/ResourceTypes.h"
+#include "utils/misc.h"
+
 #include "SdkConstants.h"
 #include "flatten/ChunkWriter.h"
 #include "flatten/ResourceTypeExtensions.h"
 #include "xml/XmlDom.h"
 
-#include <androidfw/ResourceTypes.h>
-#include <utils/misc.h>
-#include <algorithm>
-#include <map>
-#include <vector>
-
 using namespace android;
 
 namespace aapt {
@@ -34,216 +38,215 @@ namespace {
 
 constexpr uint32_t kLowPriority = 0xffffffffu;
 
-struct XmlFlattenerVisitor : public xml::Visitor {
-  using xml::Visitor::visit;
+static bool cmp_xml_attribute_by_id(const xml::Attribute* a,
+                                    const xml::Attribute* b) {
+  if (a->compiled_attribute && a->compiled_attribute.value().id) {
+    if (b->compiled_attribute && b->compiled_attribute.value().id) {
+      return a->compiled_attribute.value().id.value() <
+             b->compiled_attribute.value().id.value();
+    }
+    return true;
+  } else if (!b->compiled_attribute) {
+    int diff = a->namespace_uri.compare(b->namespace_uri);
+    if (diff < 0) {
+      return true;
+    } else if (diff > 0) {
+      return false;
+    }
+    return a->name < b->name;
+  }
+  return false;
+}
 
-  BigBuffer* mBuffer;
-  XmlFlattenerOptions mOptions;
-  StringPool mPool;
-  std::map<uint8_t, StringPool> mPackagePools;
+class XmlFlattenerVisitor : public xml::Visitor {
+ public:
+  using xml::Visitor::Visit;
+
+  StringPool pool;
+  std::map<uint8_t, StringPool> package_pools;
 
   struct StringFlattenDest {
     StringPool::Ref ref;
     ResStringPool_ref* dest;
   };
-  std::vector<StringFlattenDest> mStringRefs;
 
-  // Scratch vector to filter attributes. We avoid allocations
-  // making this a member.
-  std::vector<xml::Attribute*> mFilteredAttrs;
+  std::vector<StringFlattenDest> string_refs;
 
   XmlFlattenerVisitor(BigBuffer* buffer, XmlFlattenerOptions options)
-      : mBuffer(buffer), mOptions(options) {}
+      : buffer_(buffer), options_(options) {}
 
-  void addString(const StringPiece& str, uint32_t priority,
-                 android::ResStringPool_ref* dest,
-                 bool treatEmptyStringAsNull = false) {
-    if (str.empty() && treatEmptyStringAsNull) {
-      // Some parts of the runtime treat null differently than empty string.
-      dest->index = util::deviceToHost32(-1);
-    } else {
-      mStringRefs.push_back(StringFlattenDest{
-          mPool.makeRef(str, StringPool::Context(priority)), dest});
-    }
-  }
-
-  void addString(const StringPool::Ref& ref, android::ResStringPool_ref* dest) {
-    mStringRefs.push_back(StringFlattenDest{ref, dest});
-  }
-
-  void writeNamespace(xml::Namespace* node, uint16_t type) {
-    ChunkWriter writer(mBuffer);
-
-    ResXMLTree_node* flatNode = writer.startChunk<ResXMLTree_node>(type);
-    flatNode->lineNumber = util::hostToDevice32(node->lineNumber);
-    flatNode->comment.index = util::hostToDevice32(-1);
-
-    ResXMLTree_namespaceExt* flatNs =
-        writer.nextBlock<ResXMLTree_namespaceExt>();
-    addString(node->namespacePrefix, kLowPriority, &flatNs->prefix);
-    addString(node->namespaceUri, kLowPriority, &flatNs->uri);
-
-    writer.finish();
-  }
-
-  void visit(xml::Namespace* node) override {
-    if (node->namespaceUri == xml::kSchemaTools) {
+  void Visit(xml::Namespace* node) override {
+    if (node->namespace_uri == xml::kSchemaTools) {
       // Skip dedicated tools namespace.
-      xml::Visitor::visit(node);
+      xml::Visitor::Visit(node);
     } else {
-      writeNamespace(node, android::RES_XML_START_NAMESPACE_TYPE);
-      xml::Visitor::visit(node);
-      writeNamespace(node, android::RES_XML_END_NAMESPACE_TYPE);
+      WriteNamespace(node, android::RES_XML_START_NAMESPACE_TYPE);
+      xml::Visitor::Visit(node);
+      WriteNamespace(node, android::RES_XML_END_NAMESPACE_TYPE);
     }
   }
 
-  void visit(xml::Text* node) override {
-    if (util::trimWhitespace(node->text).empty()) {
+  void Visit(xml::Text* node) override {
+    if (util::TrimWhitespace(node->text).empty()) {
       // Skip whitespace only text nodes.
       return;
     }
 
-    ChunkWriter writer(mBuffer);
-    ResXMLTree_node* flatNode =
-        writer.startChunk<ResXMLTree_node>(RES_XML_CDATA_TYPE);
-    flatNode->lineNumber = util::hostToDevice32(node->lineNumber);
-    flatNode->comment.index = util::hostToDevice32(-1);
+    ChunkWriter writer(buffer_);
+    ResXMLTree_node* flat_node =
+        writer.StartChunk<ResXMLTree_node>(RES_XML_CDATA_TYPE);
+    flat_node->lineNumber = util::HostToDevice32(node->line_number);
+    flat_node->comment.index = util::HostToDevice32(-1);
 
-    ResXMLTree_cdataExt* flatText = writer.nextBlock<ResXMLTree_cdataExt>();
-    addString(node->text, kLowPriority, &flatText->data);
+    ResXMLTree_cdataExt* flat_text = writer.NextBlock<ResXMLTree_cdataExt>();
+    AddString(node->text, kLowPriority, &flat_text->data);
 
-    writer.finish();
+    writer.Finish();
   }
 
-  void visit(xml::Element* node) override {
+  void Visit(xml::Element* node) override {
     {
-      ChunkWriter startWriter(mBuffer);
-      ResXMLTree_node* flatNode =
-          startWriter.startChunk<ResXMLTree_node>(RES_XML_START_ELEMENT_TYPE);
-      flatNode->lineNumber = util::hostToDevice32(node->lineNumber);
-      flatNode->comment.index = util::hostToDevice32(-1);
+      ChunkWriter start_writer(buffer_);
+      ResXMLTree_node* flat_node =
+          start_writer.StartChunk<ResXMLTree_node>(RES_XML_START_ELEMENT_TYPE);
+      flat_node->lineNumber = util::HostToDevice32(node->line_number);
+      flat_node->comment.index = util::HostToDevice32(-1);
 
-      ResXMLTree_attrExt* flatElem =
-          startWriter.nextBlock<ResXMLTree_attrExt>();
+      ResXMLTree_attrExt* flat_elem =
+          start_writer.NextBlock<ResXMLTree_attrExt>();
 
       // A missing namespace must be null, not an empty string. Otherwise the
-      // runtime
-      // complains.
-      addString(node->namespaceUri, kLowPriority, &flatElem->ns,
-                true /* treatEmptyStringAsNull */);
-      addString(node->name, kLowPriority, &flatElem->name,
-                true /* treatEmptyStringAsNull */);
+      // runtime complains.
+      AddString(node->namespace_uri, kLowPriority, &flat_elem->ns,
+                true /* treat_empty_string_as_null */);
+      AddString(node->name, kLowPriority, &flat_elem->name,
+                true /* treat_empty_string_as_null */);
 
-      flatElem->attributeStart = util::hostToDevice16(sizeof(*flatElem));
-      flatElem->attributeSize =
-          util::hostToDevice16(sizeof(ResXMLTree_attribute));
+      flat_elem->attributeStart = util::HostToDevice16(sizeof(*flat_elem));
+      flat_elem->attributeSize =
+          util::HostToDevice16(sizeof(ResXMLTree_attribute));
 
-      writeAttributes(node, flatElem, &startWriter);
+      WriteAttributes(node, flat_elem, &start_writer);
 
-      startWriter.finish();
+      start_writer.Finish();
     }
 
-    xml::Visitor::visit(node);
+    xml::Visitor::Visit(node);
 
     {
-      ChunkWriter endWriter(mBuffer);
-      ResXMLTree_node* flatEndNode =
-          endWriter.startChunk<ResXMLTree_node>(RES_XML_END_ELEMENT_TYPE);
-      flatEndNode->lineNumber = util::hostToDevice32(node->lineNumber);
-      flatEndNode->comment.index = util::hostToDevice32(-1);
+      ChunkWriter end_writer(buffer_);
+      ResXMLTree_node* flat_end_node =
+          end_writer.StartChunk<ResXMLTree_node>(RES_XML_END_ELEMENT_TYPE);
+      flat_end_node->lineNumber = util::HostToDevice32(node->line_number);
+      flat_end_node->comment.index = util::HostToDevice32(-1);
 
-      ResXMLTree_endElementExt* flatEndElem =
-          endWriter.nextBlock<ResXMLTree_endElementExt>();
-      addString(node->namespaceUri, kLowPriority, &flatEndElem->ns,
-                true /* treatEmptyStringAsNull */);
-      addString(node->name, kLowPriority, &flatEndElem->name);
+      ResXMLTree_endElementExt* flat_end_elem =
+          end_writer.NextBlock<ResXMLTree_endElementExt>();
+      AddString(node->namespace_uri, kLowPriority, &flat_end_elem->ns,
+                true /* treat_empty_string_as_null */);
+      AddString(node->name, kLowPriority, &flat_end_elem->name);
 
-      endWriter.finish();
+      end_writer.Finish();
     }
   }
 
-  static bool cmpXmlAttributeById(const xml::Attribute* a,
-                                  const xml::Attribute* b) {
-    if (a->compiledAttribute && a->compiledAttribute.value().id) {
-      if (b->compiledAttribute && b->compiledAttribute.value().id) {
-        return a->compiledAttribute.value().id.value() <
-               b->compiledAttribute.value().id.value();
-      }
-      return true;
-    } else if (!b->compiledAttribute) {
-      int diff = a->namespaceUri.compare(b->namespaceUri);
-      if (diff < 0) {
-        return true;
-      } else if (diff > 0) {
-        return false;
-      }
-      return a->name < b->name;
+ private:
+  DISALLOW_COPY_AND_ASSIGN(XmlFlattenerVisitor);
+
+  void AddString(const StringPiece& str, uint32_t priority,
+                 android::ResStringPool_ref* dest,
+                 bool treat_empty_string_as_null = false) {
+    if (str.empty() && treat_empty_string_as_null) {
+      // Some parts of the runtime treat null differently than empty string.
+      dest->index = util::DeviceToHost32(-1);
+    } else {
+      string_refs.push_back(StringFlattenDest{
+          pool.MakeRef(str, StringPool::Context(priority)), dest});
     }
-    return false;
   }
 
-  void writeAttributes(xml::Element* node, ResXMLTree_attrExt* flatElem,
+  void AddString(const StringPool::Ref& ref, android::ResStringPool_ref* dest) {
+    string_refs.push_back(StringFlattenDest{ref, dest});
+  }
+
+  void WriteNamespace(xml::Namespace* node, uint16_t type) {
+    ChunkWriter writer(buffer_);
+
+    ResXMLTree_node* flatNode = writer.StartChunk<ResXMLTree_node>(type);
+    flatNode->lineNumber = util::HostToDevice32(node->line_number);
+    flatNode->comment.index = util::HostToDevice32(-1);
+
+    ResXMLTree_namespaceExt* flat_ns =
+        writer.NextBlock<ResXMLTree_namespaceExt>();
+    AddString(node->namespace_prefix, kLowPriority, &flat_ns->prefix);
+    AddString(node->namespace_uri, kLowPriority, &flat_ns->uri);
+
+    writer.Finish();
+  }
+
+  void WriteAttributes(xml::Element* node, ResXMLTree_attrExt* flat_elem,
                        ChunkWriter* writer) {
-    mFilteredAttrs.clear();
-    mFilteredAttrs.reserve(node->attributes.size());
+    filtered_attrs_.clear();
+    filtered_attrs_.reserve(node->attributes.size());
 
     // Filter the attributes.
     for (xml::Attribute& attr : node->attributes) {
-      if (mOptions.maxSdkLevel && attr.compiledAttribute &&
-          attr.compiledAttribute.value().id) {
-        size_t sdkLevel =
-            findAttributeSdkLevel(attr.compiledAttribute.value().id.value());
-        if (sdkLevel > mOptions.maxSdkLevel.value()) {
+      if (options_.max_sdk_level && attr.compiled_attribute &&
+          attr.compiled_attribute.value().id) {
+        size_t sdk_level =
+            FindAttributeSdkLevel(attr.compiled_attribute.value().id.value());
+        if (sdk_level > options_.max_sdk_level.value()) {
           continue;
         }
       }
-      if (attr.namespaceUri == xml::kSchemaTools) {
+      if (attr.namespace_uri == xml::kSchemaTools) {
         continue;
       }
-      mFilteredAttrs.push_back(&attr);
+      filtered_attrs_.push_back(&attr);
     }
 
-    if (mFilteredAttrs.empty()) {
+    if (filtered_attrs_.empty()) {
       return;
     }
 
     const ResourceId kIdAttr(0x010100d0);
 
-    std::sort(mFilteredAttrs.begin(), mFilteredAttrs.end(),
-              cmpXmlAttributeById);
+    std::sort(filtered_attrs_.begin(), filtered_attrs_.end(),
+              cmp_xml_attribute_by_id);
 
-    flatElem->attributeCount = util::hostToDevice16(mFilteredAttrs.size());
+    flat_elem->attributeCount = util::HostToDevice16(filtered_attrs_.size());
 
-    ResXMLTree_attribute* flatAttr =
-        writer->nextBlock<ResXMLTree_attribute>(mFilteredAttrs.size());
-    uint16_t attributeIndex = 1;
-    for (const xml::Attribute* xmlAttr : mFilteredAttrs) {
+    ResXMLTree_attribute* flat_attr =
+        writer->NextBlock<ResXMLTree_attribute>(filtered_attrs_.size());
+    uint16_t attribute_index = 1;
+    for (const xml::Attribute* xml_attr : filtered_attrs_) {
       // Assign the indices for specific attributes.
-      if (xmlAttr->compiledAttribute && xmlAttr->compiledAttribute.value().id &&
-          xmlAttr->compiledAttribute.value().id.value() == kIdAttr) {
-        flatElem->idIndex = util::hostToDevice16(attributeIndex);
-      } else if (xmlAttr->namespaceUri.empty()) {
-        if (xmlAttr->name == "class") {
-          flatElem->classIndex = util::hostToDevice16(attributeIndex);
-        } else if (xmlAttr->name == "style") {
-          flatElem->styleIndex = util::hostToDevice16(attributeIndex);
+      if (xml_attr->compiled_attribute &&
+          xml_attr->compiled_attribute.value().id &&
+          xml_attr->compiled_attribute.value().id.value() == kIdAttr) {
+        flat_elem->idIndex = util::HostToDevice16(attribute_index);
+      } else if (xml_attr->namespace_uri.empty()) {
+        if (xml_attr->name == "class") {
+          flat_elem->classIndex = util::HostToDevice16(attribute_index);
+        } else if (xml_attr->name == "style") {
+          flat_elem->styleIndex = util::HostToDevice16(attribute_index);
         }
       }
-      attributeIndex++;
+      attribute_index++;
 
       // Add the namespaceUri to the list of StringRefs to encode. Use null if
       // the namespace
       // is empty (doesn't exist).
-      addString(xmlAttr->namespaceUri, kLowPriority, &flatAttr->ns,
-                true /* treatEmptyStringAsNull */);
+      AddString(xml_attr->namespace_uri, kLowPriority, &flat_attr->ns,
+                true /* treat_empty_string_as_null */);
 
-      flatAttr->rawValue.index = util::hostToDevice32(-1);
+      flat_attr->rawValue.index = util::HostToDevice32(-1);
 
-      if (!xmlAttr->compiledAttribute ||
-          !xmlAttr->compiledAttribute.value().id) {
+      if (!xml_attr->compiled_attribute ||
+          !xml_attr->compiled_attribute.value().id) {
         // The attribute has no associated ResourceID, so the string order
         // doesn't matter.
-        addString(xmlAttr->name, kLowPriority, &flatAttr->name);
+        AddString(xml_attr->name, kLowPriority, &flat_attr->name);
       } else {
         // Attribute names are stored without packages, but we use
         // their StringPool index to lookup their resource IDs.
@@ -252,99 +255,106 @@ struct XmlFlattenerVisitor : public xml::Visitor {
         // pools that we later combine.
         //
         // Lookup the StringPool for this package and make the reference there.
-        const xml::AaptAttribute& aaptAttr = xmlAttr->compiledAttribute.value();
+        const xml::AaptAttribute& aapt_attr =
+            xml_attr->compiled_attribute.value();
 
-        StringPool::Ref nameRef =
-            mPackagePools[aaptAttr.id.value().packageId()].makeRef(
-                xmlAttr->name, StringPool::Context(aaptAttr.id.value().id));
+        StringPool::Ref name_ref =
+            package_pools[aapt_attr.id.value().package_id()].MakeRef(
+                xml_attr->name, StringPool::Context(aapt_attr.id.value().id));
 
         // Add it to the list of strings to flatten.
-        addString(nameRef, &flatAttr->name);
+        AddString(name_ref, &flat_attr->name);
       }
 
-      if (mOptions.keepRawValues || !xmlAttr->compiledValue) {
+      if (options_.keep_raw_values || !xml_attr->compiled_value) {
         // Keep raw values if the value is not compiled or
         // if we're building a static library (need symbols).
-        addString(xmlAttr->value, kLowPriority, &flatAttr->rawValue);
+        AddString(xml_attr->value, kLowPriority, &flat_attr->rawValue);
       }
 
-      if (xmlAttr->compiledValue) {
-        bool result = xmlAttr->compiledValue->flatten(&flatAttr->typedValue);
-        assert(result);
+      if (xml_attr->compiled_value) {
+        CHECK(xml_attr->compiled_value->Flatten(&flat_attr->typedValue));
       } else {
         // Flatten as a regular string type.
-        flatAttr->typedValue.dataType = android::Res_value::TYPE_STRING;
-        addString(xmlAttr->value, kLowPriority,
-                  (ResStringPool_ref*)&flatAttr->typedValue.data);
+        flat_attr->typedValue.dataType = android::Res_value::TYPE_STRING;
+        AddString(xml_attr->value, kLowPriority,
+                  (ResStringPool_ref*)&flat_attr->typedValue.data);
       }
 
-      flatAttr->typedValue.size =
-          util::hostToDevice16(sizeof(flatAttr->typedValue));
-      flatAttr++;
+      flat_attr->typedValue.size =
+          util::HostToDevice16(sizeof(flat_attr->typedValue));
+      flat_attr++;
     }
   }
+
+  BigBuffer* buffer_;
+  XmlFlattenerOptions options_;
+
+  // Scratch vector to filter attributes. We avoid allocations
+  // making this a member.
+  std::vector<xml::Attribute*> filtered_attrs_;
 };
 
 }  // namespace
 
-bool XmlFlattener::flatten(IAaptContext* context, xml::Node* node) {
-  BigBuffer nodeBuffer(1024);
-  XmlFlattenerVisitor visitor(&nodeBuffer, mOptions);
-  node->accept(&visitor);
+bool XmlFlattener::Flatten(IAaptContext* context, xml::Node* node) {
+  BigBuffer node_buffer(1024);
+  XmlFlattenerVisitor visitor(&node_buffer, options_);
+  node->Accept(&visitor);
 
   // Merge the package pools into the main pool.
-  for (auto& packagePoolEntry : visitor.mPackagePools) {
-    visitor.mPool.merge(std::move(packagePoolEntry.second));
+  for (auto& package_pool_entry : visitor.package_pools) {
+    visitor.pool.Merge(std::move(package_pool_entry.second));
   }
 
   // Sort the string pool so that attribute resource IDs show up first.
-  visitor.mPool.sort(
+  visitor.pool.Sort(
       [](const StringPool::Entry& a, const StringPool::Entry& b) -> bool {
         return a.context.priority < b.context.priority;
       });
 
   // Now we flatten the string pool references into the correct places.
-  for (const auto& refEntry : visitor.mStringRefs) {
-    refEntry.dest->index = util::hostToDevice32(refEntry.ref.getIndex());
+  for (const auto& ref_entry : visitor.string_refs) {
+    ref_entry.dest->index = util::HostToDevice32(ref_entry.ref.index());
   }
 
   // Write the XML header.
-  ChunkWriter xmlHeaderWriter(mBuffer);
-  xmlHeaderWriter.startChunk<ResXMLTree_header>(RES_XML_TYPE);
+  ChunkWriter xml_header_writer(buffer_);
+  xml_header_writer.StartChunk<ResXMLTree_header>(RES_XML_TYPE);
 
   // Flatten the StringPool.
-  StringPool::flattenUtf8(mBuffer, visitor.mPool);
+  StringPool::FlattenUtf8(buffer_, visitor.pool);
 
   {
     // Write the array of resource IDs, indexed by StringPool order.
-    ChunkWriter resIdMapWriter(mBuffer);
-    resIdMapWriter.startChunk<ResChunk_header>(RES_XML_RESOURCE_MAP_TYPE);
-    for (const auto& str : visitor.mPool) {
+    ChunkWriter res_id_map_writer(buffer_);
+    res_id_map_writer.StartChunk<ResChunk_header>(RES_XML_RESOURCE_MAP_TYPE);
+    for (const auto& str : visitor.pool) {
       ResourceId id = {str->context.priority};
-      if (id.id == kLowPriority || !id.isValid()) {
+      if (id.id == kLowPriority || !id.is_valid()) {
         // When we see the first non-resource ID,
         // we're done.
         break;
       }
 
-      *resIdMapWriter.nextBlock<uint32_t>() = id.id;
+      *res_id_map_writer.NextBlock<uint32_t>() = id.id;
     }
-    resIdMapWriter.finish();
+    res_id_map_writer.Finish();
   }
 
   // Move the nodeBuffer and append it to the out buffer.
-  mBuffer->appendBuffer(std::move(nodeBuffer));
+  buffer_->AppendBuffer(std::move(node_buffer));
 
   // Finish the xml header.
-  xmlHeaderWriter.finish();
+  xml_header_writer.Finish();
   return true;
 }
 
-bool XmlFlattener::consume(IAaptContext* context, xml::XmlResource* resource) {
+bool XmlFlattener::Consume(IAaptContext* context, xml::XmlResource* resource) {
   if (!resource->root) {
     return false;
   }
-  return flatten(context, resource->root.get());
+  return Flatten(context, resource->root.get());
 }
 
 }  // namespace aapt
diff --git a/tools/aapt2/flatten/XmlFlattener.h b/tools/aapt2/flatten/XmlFlattener.h
index d8d592b41c2c2..f5129fd40e996 100644
--- a/tools/aapt2/flatten/XmlFlattener.h
+++ b/tools/aapt2/flatten/XmlFlattener.h
@@ -17,6 +17,8 @@
 #ifndef AAPT_FLATTEN_XMLFLATTENER_H
 #define AAPT_FLATTEN_XMLFLATTENER_H
 
+#include "android-base/macros.h"
+
 #include "process/IResourceTableConsumer.h"
 #include "util/BigBuffer.h"
 #include "xml/XmlDom.h"
@@ -27,26 +29,28 @@ struct XmlFlattenerOptions {
   /**
    * Keep attribute raw string values along with typed values.
    */
-  bool keepRawValues = false;
+  bool keep_raw_values = false;
 
   /**
    * If set, the max SDK level of attribute to flatten. All others are ignored.
    */
-  Maybe<size_t> maxSdkLevel;
+  Maybe<size_t> max_sdk_level;
 };
 
 class XmlFlattener : public IXmlResourceConsumer {
  public:
   XmlFlattener(BigBuffer* buffer, XmlFlattenerOptions options)
-      : mBuffer(buffer), mOptions(options) {}
+      : buffer_(buffer), options_(options) {}
 
-  bool consume(IAaptContext* context, xml::XmlResource* resource) override;
+  bool Consume(IAaptContext* context, xml::XmlResource* resource) override;
 
  private:
-  BigBuffer* mBuffer;
-  XmlFlattenerOptions mOptions;
+  DISALLOW_COPY_AND_ASSIGN(XmlFlattener);
 
-  bool flatten(IAaptContext* context, xml::Node* node);
+  bool Flatten(IAaptContext* context, xml::Node* node);
+
+  BigBuffer* buffer_;
+  XmlFlattenerOptions options_;
 };
 
 }  // namespace aapt
diff --git a/tools/aapt2/flatten/XmlFlattener_test.cpp b/tools/aapt2/flatten/XmlFlattener_test.cpp
index e0159cb5dc498..2c83bb384cc5d 100644
--- a/tools/aapt2/flatten/XmlFlattener_test.cpp
+++ b/tools/aapt2/flatten/XmlFlattener_test.cpp
@@ -15,61 +15,62 @@
  */
 
 #include "flatten/XmlFlattener.h"
+
+#include "androidfw/ResourceTypes.h"
+
 #include "link/Linkers.h"
 #include "test/Test.h"
 #include "util/BigBuffer.h"
 #include "util/Util.h"
 
-#include <androidfw/ResourceTypes.h>
-
 namespace aapt {
 
 class XmlFlattenerTest : public ::testing::Test {
  public:
   void SetUp() override {
-    mContext =
+    context_ =
         test::ContextBuilder()
-            .setCompilationPackage("com.app.test")
-            .setNameManglerPolicy(NameManglerPolicy{"com.app.test"})
-            .addSymbolSource(
+            .SetCompilationPackage("com.app.test")
+            .SetNameManglerPolicy(NameManglerPolicy{"com.app.test"})
+            .AddSymbolSource(
                 test::StaticSymbolSourceBuilder()
-                    .addSymbol("android:attr/id", ResourceId(0x010100d0),
-                               test::AttributeBuilder().build())
-                    .addSymbol("com.app.test:id/id", ResourceId(0x7f020000))
-                    .addSymbol("android:attr/paddingStart",
+                    .AddSymbol("android:attr/id", ResourceId(0x010100d0),
+                               test::AttributeBuilder().Build())
+                    .AddSymbol("com.app.test:id/id", ResourceId(0x7f020000))
+                    .AddSymbol("android:attr/paddingStart",
                                ResourceId(0x010103b3),
-                               test::AttributeBuilder().build())
-                    .addSymbol("android:attr/colorAccent",
+                               test::AttributeBuilder().Build())
+                    .AddSymbol("android:attr/colorAccent",
                                ResourceId(0x01010435),
-                               test::AttributeBuilder().build())
-                    .build())
-            .build();
+                               test::AttributeBuilder().Build())
+                    .Build())
+            .Build();
   }
 
-  ::testing::AssertionResult flatten(xml::XmlResource* doc,
-                                     android::ResXMLTree* outTree,
+  ::testing::AssertionResult Flatten(xml::XmlResource* doc,
+                                     android::ResXMLTree* out_tree,
                                      const XmlFlattenerOptions& options = {}) {
     using namespace android;  // For NO_ERROR on windows because it is a macro.
 
     BigBuffer buffer(1024);
     XmlFlattener flattener(&buffer, options);
-    if (!flattener.consume(mContext.get(), doc)) {
+    if (!flattener.Consume(context_.get(), doc)) {
       return ::testing::AssertionFailure() << "failed to flatten XML Tree";
     }
 
-    std::unique_ptr<uint8_t[]> data = util::copy(buffer);
-    if (outTree->setTo(data.get(), buffer.size(), true) != NO_ERROR) {
+    std::unique_ptr<uint8_t[]> data = util::Copy(buffer);
+    if (out_tree->setTo(data.get(), buffer.size(), true) != NO_ERROR) {
       return ::testing::AssertionFailure() << "flattened XML is corrupt";
     }
     return ::testing::AssertionSuccess();
   }
 
  protected:
-  std::unique_ptr<IAaptContext> mContext;
+  std::unique_ptr<IAaptContext> context_;
 };
 
 TEST_F(XmlFlattenerTest, FlattenXmlWithNoCompiledAttributes) {
-  std::unique_ptr<xml::XmlResource> doc = test::buildXmlDom(R"EOF(
+  std::unique_ptr<xml::XmlResource> doc = test::BuildXmlDom(R"EOF(
             <View xmlns:test="http://com.test"
                   attr="hey">
               <Layout test:hello="hi" />
@@ -77,27 +78,27 @@ TEST_F(XmlFlattenerTest, FlattenXmlWithNoCompiledAttributes) {
             </View>)EOF");
 
   android::ResXMLTree tree;
-  ASSERT_TRUE(flatten(doc.get(), &tree));
+  ASSERT_TRUE(Flatten(doc.get(), &tree));
 
   ASSERT_EQ(tree.next(), android::ResXMLTree::START_NAMESPACE);
 
   size_t len;
-  const char16_t* namespacePrefix = tree.getNamespacePrefix(&len);
-  EXPECT_EQ(StringPiece16(namespacePrefix, len), u"test");
+  const char16_t* namespace_prefix = tree.getNamespacePrefix(&len);
+  EXPECT_EQ(StringPiece16(namespace_prefix, len), u"test");
 
-  const char16_t* namespaceUri = tree.getNamespaceUri(&len);
-  ASSERT_EQ(StringPiece16(namespaceUri, len), u"http://com.test");
+  const char16_t* namespace_uri = tree.getNamespaceUri(&len);
+  ASSERT_EQ(StringPiece16(namespace_uri, len), u"http://com.test");
 
   ASSERT_EQ(tree.next(), android::ResXMLTree::START_TAG);
 
   ASSERT_EQ(tree.getElementNamespace(&len), nullptr);
-  const char16_t* tagName = tree.getElementName(&len);
-  EXPECT_EQ(StringPiece16(tagName, len), u"View");
+  const char16_t* tag_name = tree.getElementName(&len);
+  EXPECT_EQ(StringPiece16(tag_name, len), u"View");
 
   ASSERT_EQ(1u, tree.getAttributeCount());
   ASSERT_EQ(tree.getAttributeNamespace(0, &len), nullptr);
-  const char16_t* attrName = tree.getAttributeName(0, &len);
-  EXPECT_EQ(StringPiece16(attrName, len), u"attr");
+  const char16_t* attr_name = tree.getAttributeName(0, &len);
+  EXPECT_EQ(StringPiece16(attr_name, len), u"attr");
 
   EXPECT_EQ(0, tree.indexOfAttribute(nullptr, 0, u"attr",
                                      StringPiece16(u"attr").size()));
@@ -105,22 +106,22 @@ TEST_F(XmlFlattenerTest, FlattenXmlWithNoCompiledAttributes) {
   ASSERT_EQ(tree.next(), android::ResXMLTree::START_TAG);
 
   ASSERT_EQ(tree.getElementNamespace(&len), nullptr);
-  tagName = tree.getElementName(&len);
-  EXPECT_EQ(StringPiece16(tagName, len), u"Layout");
+  tag_name = tree.getElementName(&len);
+  EXPECT_EQ(StringPiece16(tag_name, len), u"Layout");
 
   ASSERT_EQ(1u, tree.getAttributeCount());
-  const char16_t* attrNamespace = tree.getAttributeNamespace(0, &len);
-  EXPECT_EQ(StringPiece16(attrNamespace, len), u"http://com.test");
+  const char16_t* attr_namespace = tree.getAttributeNamespace(0, &len);
+  EXPECT_EQ(StringPiece16(attr_namespace, len), u"http://com.test");
 
-  attrName = tree.getAttributeName(0, &len);
-  EXPECT_EQ(StringPiece16(attrName, len), u"hello");
+  attr_name = tree.getAttributeName(0, &len);
+  EXPECT_EQ(StringPiece16(attr_name, len), u"hello");
 
   ASSERT_EQ(tree.next(), android::ResXMLTree::END_TAG);
   ASSERT_EQ(tree.next(), android::ResXMLTree::START_TAG);
 
   ASSERT_EQ(tree.getElementNamespace(&len), nullptr);
-  tagName = tree.getElementName(&len);
-  EXPECT_EQ(StringPiece16(tagName, len), u"Layout");
+  tag_name = tree.getElementName(&len);
+  EXPECT_EQ(StringPiece16(tag_name, len), u"Layout");
   ASSERT_EQ(0u, tree.getAttributeCount());
 
   ASSERT_EQ(tree.next(), android::ResXMLTree::TEXT);
@@ -129,39 +130,39 @@ TEST_F(XmlFlattenerTest, FlattenXmlWithNoCompiledAttributes) {
 
   ASSERT_EQ(tree.next(), android::ResXMLTree::END_TAG);
   ASSERT_EQ(tree.getElementNamespace(&len), nullptr);
-  tagName = tree.getElementName(&len);
-  EXPECT_EQ(StringPiece16(tagName, len), u"Layout");
+  tag_name = tree.getElementName(&len);
+  EXPECT_EQ(StringPiece16(tag_name, len), u"Layout");
 
   ASSERT_EQ(tree.next(), android::ResXMLTree::END_TAG);
   ASSERT_EQ(tree.getElementNamespace(&len), nullptr);
-  tagName = tree.getElementName(&len);
-  EXPECT_EQ(StringPiece16(tagName, len), u"View");
+  tag_name = tree.getElementName(&len);
+  EXPECT_EQ(StringPiece16(tag_name, len), u"View");
 
   ASSERT_EQ(tree.next(), android::ResXMLTree::END_NAMESPACE);
-  namespacePrefix = tree.getNamespacePrefix(&len);
-  EXPECT_EQ(StringPiece16(namespacePrefix, len), u"test");
+  namespace_prefix = tree.getNamespacePrefix(&len);
+  EXPECT_EQ(StringPiece16(namespace_prefix, len), u"test");
 
-  namespaceUri = tree.getNamespaceUri(&len);
-  ASSERT_EQ(StringPiece16(namespaceUri, len), u"http://com.test");
+  namespace_uri = tree.getNamespaceUri(&len);
+  ASSERT_EQ(StringPiece16(namespace_uri, len), u"http://com.test");
 
   ASSERT_EQ(tree.next(), android::ResXMLTree::END_DOCUMENT);
 }
 
 TEST_F(XmlFlattenerTest, FlattenCompiledXmlAndStripSdk21) {
-  std::unique_ptr<xml::XmlResource> doc = test::buildXmlDom(R"EOF(
+  std::unique_ptr<xml::XmlResource> doc = test::BuildXmlDom(R"EOF(
             <View xmlns:android="http://schemas.android.com/apk/res/android"
                 android:paddingStart="1dp"
                 android:colorAccent="#ffffff"/>)EOF");
 
   XmlReferenceLinker linker;
-  ASSERT_TRUE(linker.consume(mContext.get(), doc.get()));
-  ASSERT_TRUE(linker.getSdkLevels().count(17) == 1);
-  ASSERT_TRUE(linker.getSdkLevels().count(21) == 1);
+  ASSERT_TRUE(linker.Consume(context_.get(), doc.get()));
+  ASSERT_TRUE(linker.sdk_levels().count(17) == 1);
+  ASSERT_TRUE(linker.sdk_levels().count(21) == 1);
 
   android::ResXMLTree tree;
   XmlFlattenerOptions options;
-  options.maxSdkLevel = 17;
-  ASSERT_TRUE(flatten(doc.get(), &tree, options));
+  options.max_sdk_level = 17;
+  ASSERT_TRUE(Flatten(doc.get(), &tree, options));
 
   while (tree.next() != android::ResXMLTree::START_TAG) {
     ASSERT_NE(tree.getEventType(), android::ResXMLTree::BAD_DOCUMENT);
@@ -173,23 +174,23 @@ TEST_F(XmlFlattenerTest, FlattenCompiledXmlAndStripSdk21) {
 }
 
 TEST_F(XmlFlattenerTest, FlattenCompiledXmlAndStripOnlyTools) {
-  std::unique_ptr<xml::XmlResource> doc = test::buildXmlDom(R"EOF(
+  std::unique_ptr<xml::XmlResource> doc = test::BuildXmlDom(R"EOF(
             <View xmlns:tools="http://schemas.android.com/tools"
                 xmlns:foo="http://schemas.android.com/foo"
                 foo:bar="Foo"
                 tools:ignore="MissingTranslation"/>)EOF");
 
   android::ResXMLTree tree;
-  ASSERT_TRUE(flatten(doc.get(), &tree));
+  ASSERT_TRUE(Flatten(doc.get(), &tree));
 
   ASSERT_EQ(tree.next(), android::ResXMLTree::START_NAMESPACE);
 
   size_t len;
-  const char16_t* namespacePrefix = tree.getNamespacePrefix(&len);
-  EXPECT_EQ(StringPiece16(namespacePrefix, len), u"foo");
+  const char16_t* namespace_prefix = tree.getNamespacePrefix(&len);
+  EXPECT_EQ(StringPiece16(namespace_prefix, len), u"foo");
 
-  const char16_t* namespaceUri = tree.getNamespaceUri(&len);
-  ASSERT_EQ(StringPiece16(namespaceUri, len),
+  const char16_t* namespace_uri = tree.getNamespaceUri(&len);
+  ASSERT_EQ(StringPiece16(namespace_uri, len),
             u"http://schemas.android.com/foo");
 
   ASSERT_EQ(tree.next(), android::ResXMLTree::START_TAG);
@@ -200,14 +201,14 @@ TEST_F(XmlFlattenerTest, FlattenCompiledXmlAndStripOnlyTools) {
 }
 
 TEST_F(XmlFlattenerTest, AssignSpecialAttributeIndices) {
-  std::unique_ptr<xml::XmlResource> doc = test::buildXmlDom(R"EOF(
+  std::unique_ptr<xml::XmlResource> doc = test::BuildXmlDom(R"EOF(
             <View xmlns:android="http://schemas.android.com/apk/res/android"
                   android:id="@id/id"
                   class="str"
                   style="@id/id"/>)EOF");
 
   android::ResXMLTree tree;
-  ASSERT_TRUE(flatten(doc.get(), &tree));
+  ASSERT_TRUE(Flatten(doc.get(), &tree));
 
   while (tree.next() != android::ResXMLTree::START_TAG) {
     ASSERT_NE(tree.getEventType(), android::ResXMLTree::BAD_DOCUMENT);
@@ -225,10 +226,10 @@ TEST_F(XmlFlattenerTest, AssignSpecialAttributeIndices) {
  */
 TEST_F(XmlFlattenerTest, NoNamespaceIsNotTheSameAsEmptyNamespace) {
   std::unique_ptr<xml::XmlResource> doc =
-      test::buildXmlDom("<View package=\"android\"/>");
+      test::BuildXmlDom("<View package=\"android\"/>");
 
   android::ResXMLTree tree;
-  ASSERT_TRUE(flatten(doc.get(), &tree));
+  ASSERT_TRUE(Flatten(doc.get(), &tree));
 
   while (tree.next() != android::ResXMLTree::START_TAG) {
     ASSERT_NE(tree.getEventType(), android::ResXMLTree::BAD_DOCUMENT);
@@ -242,10 +243,10 @@ TEST_F(XmlFlattenerTest, NoNamespaceIsNotTheSameAsEmptyNamespace) {
 
 TEST_F(XmlFlattenerTest, EmptyStringValueInAttributeIsNotNull) {
   std::unique_ptr<xml::XmlResource> doc =
-      test::buildXmlDom("<View package=\"\"/>");
+      test::BuildXmlDom("<View package=\"\"/>");
 
   android::ResXMLTree tree;
-  ASSERT_TRUE(flatten(doc.get(), &tree));
+  ASSERT_TRUE(Flatten(doc.get(), &tree));
 
   while (tree.next() != android::ResXMLTree::START_TAG) {
     ASSERT_NE(tree.getEventType(), android::ResXMLTree::BAD_DOCUMENT);
diff --git a/tools/aapt2/io/Data.h b/tools/aapt2/io/Data.h
index 0479228b44e7e..fdc044d86e5a0 100644
--- a/tools/aapt2/io/Data.h
+++ b/tools/aapt2/io/Data.h
@@ -17,10 +17,11 @@
 #ifndef AAPT_IO_DATA_H
 #define AAPT_IO_DATA_H
 
-#include <android-base/macros.h>
-#include <utils/FileMap.h>
 #include <memory>
 
+#include "android-base/macros.h"
+#include "utils/FileMap.h"
+
 namespace aapt {
 namespace io {
 
@@ -39,20 +40,20 @@ class IData {
 class DataSegment : public IData {
  public:
   explicit DataSegment(std::unique_ptr<IData> data, size_t offset, size_t len)
-      : mData(std::move(data)), mOffset(offset), mLen(len) {}
+      : data_(std::move(data)), offset_(offset), len_(len) {}
 
   const void* data() const override {
-    return static_cast<const uint8_t*>(mData->data()) + mOffset;
+    return static_cast<const uint8_t*>(data_->data()) + offset_;
   }
 
-  size_t size() const override { return mLen; }
+  size_t size() const override { return len_; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DataSegment);
 
-  std::unique_ptr<IData> mData;
-  size_t mOffset;
-  size_t mLen;
+  std::unique_ptr<IData> data_;
+  size_t offset_;
+  size_t len_;
 };
 
 /**
@@ -63,14 +64,14 @@ class DataSegment : public IData {
 class MmappedData : public IData {
  public:
   explicit MmappedData(android::FileMap&& map)
-      : mMap(std::forward<android::FileMap>(map)) {}
+      : map_(std::forward<android::FileMap>(map)) {}
 
-  const void* data() const override { return mMap.getDataPtr(); }
+  const void* data() const override { return map_.getDataPtr(); }
 
-  size_t size() const override { return mMap.getDataLength(); }
+  size_t size() const override { return map_.getDataLength(); }
 
  private:
-  android::FileMap mMap;
+  android::FileMap map_;
 };
 
 /**
@@ -81,15 +82,15 @@ class MmappedData : public IData {
 class MallocData : public IData {
  public:
   MallocData(std::unique_ptr<const uint8_t[]> data, size_t size)
-      : mData(std::move(data)), mSize(size) {}
+      : data_(std::move(data)), size_(size) {}
 
-  const void* data() const override { return mData.get(); }
+  const void* data() const override { return data_.get(); }
 
-  size_t size() const override { return mSize; }
+  size_t size() const override { return size_; }
 
  private:
-  std::unique_ptr<const uint8_t[]> mData;
-  size_t mSize;
+  std::unique_ptr<const uint8_t[]> data_;
+  size_t size_;
 };
 
 /**
diff --git a/tools/aapt2/io/File.cpp b/tools/aapt2/io/File.cpp
index 739c0d21e06e7..ee737280ec81b 100644
--- a/tools/aapt2/io/File.cpp
+++ b/tools/aapt2/io/File.cpp
@@ -21,23 +21,23 @@
 namespace aapt {
 namespace io {
 
-IFile* IFile::createFileSegment(size_t offset, size_t len) {
-   FileSegment* fileSegment = new FileSegment(this, offset, len);
-   mSegments.push_back(std::unique_ptr<IFile>(fileSegment));
-   return fileSegment;
+IFile* IFile::CreateFileSegment(size_t offset, size_t len) {
+  FileSegment* file_segment = new FileSegment(this, offset, len);
+  segments_.push_back(std::unique_ptr<IFile>(file_segment));
+  return file_segment;
 }
 
-std::unique_ptr<IData> FileSegment::openAsData() {
-    std::unique_ptr<IData> data = mFile->openAsData();
-    if (!data) {
-        return {};
-    }
-
-    if (mOffset <= data->size() - mLen) {
-        return util::make_unique<DataSegment>(std::move(data), mOffset, mLen);
-    }
+std::unique_ptr<IData> FileSegment::OpenAsData() {
+  std::unique_ptr<IData> data = file_->OpenAsData();
+  if (!data) {
     return {};
+  }
+
+  if (offset_ <= data->size() - len_) {
+    return util::make_unique<DataSegment>(std::move(data), offset_, len_);
+  }
+  return {};
 }
 
-} // namespace io
-} // namespace aapt
+}  // namespace io
+}  // namespace aapt
diff --git a/tools/aapt2/io/File.h b/tools/aapt2/io/File.h
index 012f44631a9f2..644f59f8f3bad 100644
--- a/tools/aapt2/io/File.h
+++ b/tools/aapt2/io/File.h
@@ -17,15 +17,16 @@
 #ifndef AAPT_IO_FILE_H
 #define AAPT_IO_FILE_H
 
-#include "Source.h"
-#include "io/Data.h"
-#include "util/Util.h"
-
-#include <android-base/macros.h>
 #include <list>
 #include <memory>
 #include <vector>
 
+#include "android-base/macros.h"
+
+#include "Source.h"
+#include "io/Data.h"
+#include "util/Util.h"
+
 namespace aapt {
 namespace io {
 
@@ -49,7 +50,7 @@ class IFile {
    *
    * Returns nullptr on failure.
    */
-  virtual std::unique_ptr<IData> openAsData() = 0;
+  virtual std::unique_ptr<IData> OpenAsData() = 0;
 
   /**
    * Returns the source of this file. This is for presentation to the user and
@@ -58,9 +59,9 @@ class IFile {
    * the files within
    * a ZIP archive from the path to the containing ZIP archive.
    */
-  virtual const Source& getSource() const = 0;
+  virtual const Source& GetSource() const = 0;
 
-  IFile* createFileSegment(size_t offset, size_t len);
+  IFile* CreateFileSegment(size_t offset, size_t len);
 
  private:
   // Any segments created from this IFile need to be owned by this IFile, so
@@ -68,7 +69,7 @@ class IFile {
   // in a list. This will never be read, so we prefer better insertion
   // performance
   // than cache locality, hence the list.
-  std::list<std::unique_ptr<IFile>> mSegments;
+  std::list<std::unique_ptr<IFile>> segments_;
 };
 
 /**
@@ -78,26 +79,26 @@ class IFile {
 class FileSegment : public IFile {
  public:
   explicit FileSegment(IFile* file, size_t offset, size_t len)
-      : mFile(file), mOffset(offset), mLen(len) {}
+      : file_(file), offset_(offset), len_(len) {}
 
-  std::unique_ptr<IData> openAsData() override;
+  std::unique_ptr<IData> OpenAsData() override;
 
-  const Source& getSource() const override { return mFile->getSource(); }
+  const Source& GetSource() const override { return file_->GetSource(); }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FileSegment);
 
-  IFile* mFile;
-  size_t mOffset;
-  size_t mLen;
+  IFile* file_;
+  size_t offset_;
+  size_t len_;
 };
 
 class IFileCollectionIterator {
  public:
   virtual ~IFileCollectionIterator() = default;
 
-  virtual bool hasNext() = 0;
-  virtual IFile* next() = 0;
+  virtual bool HasNext() = 0;
+  virtual IFile* Next() = 0;
 };
 
 /**
@@ -109,8 +110,8 @@ class IFileCollection {
  public:
   virtual ~IFileCollection() = default;
 
-  virtual IFile* findFile(const StringPiece& path) = 0;
-  virtual std::unique_ptr<IFileCollectionIterator> iterator() = 0;
+  virtual IFile* FindFile(const StringPiece& path) = 0;
+  virtual std::unique_ptr<IFileCollectionIterator> Iterator() = 0;
 };
 
 }  // namespace io
diff --git a/tools/aapt2/io/FileSystem.cpp b/tools/aapt2/io/FileSystem.cpp
index e758d8a421e12..828f34e9c8837 100644
--- a/tools/aapt2/io/FileSystem.cpp
+++ b/tools/aapt2/io/FileSystem.cpp
@@ -14,65 +14,62 @@
  * limitations under the License.
  */
 
-#include "Source.h"
 #include "io/FileSystem.h"
+
+#include "utils/FileMap.h"
+
+#include "Source.h"
 #include "util/Files.h"
 #include "util/Maybe.h"
 #include "util/StringPiece.h"
 #include "util/Util.h"
 
-#include <utils/FileMap.h>
-
 namespace aapt {
 namespace io {
 
-RegularFile::RegularFile(const Source& source) : mSource(source) {
-}
+RegularFile::RegularFile(const Source& source) : source_(source) {}
 
-std::unique_ptr<IData> RegularFile::openAsData() {
-    android::FileMap map;
-    if (Maybe<android::FileMap> map = file::mmapPath(mSource.path, nullptr)) {
-        if (map.value().getDataPtr() && map.value().getDataLength() > 0) {
-            return util::make_unique<MmappedData>(std::move(map.value()));
-        }
-        return util::make_unique<EmptyData>();
+std::unique_ptr<IData> RegularFile::OpenAsData() {
+  android::FileMap map;
+  if (Maybe<android::FileMap> map = file::MmapPath(source_.path, nullptr)) {
+    if (map.value().getDataPtr() && map.value().getDataLength() > 0) {
+      return util::make_unique<MmappedData>(std::move(map.value()));
     }
-    return {};
+    return util::make_unique<EmptyData>();
+  }
+  return {};
 }
 
-const Source& RegularFile::getSource() const {
-    return mSource;
+const Source& RegularFile::GetSource() const { return source_; }
+
+FileCollectionIterator::FileCollectionIterator(FileCollection* collection)
+    : current_(collection->files_.begin()), end_(collection->files_.end()) {}
+
+bool FileCollectionIterator::HasNext() { return current_ != end_; }
+
+IFile* FileCollectionIterator::Next() {
+  IFile* result = current_->second.get();
+  ++current_;
+  return result;
 }
 
-FileCollectionIterator::FileCollectionIterator(FileCollection* collection) :
-        mCurrent(collection->mFiles.begin()), mEnd(collection->mFiles.end()) {
+IFile* FileCollection::InsertFile(const StringPiece& path) {
+  return (files_[path.ToString()] =
+              util::make_unique<RegularFile>(Source(path)))
+      .get();
 }
 
-bool FileCollectionIterator::hasNext() {
-    return mCurrent != mEnd;
+IFile* FileCollection::FindFile(const StringPiece& path) {
+  auto iter = files_.find(path.ToString());
+  if (iter != files_.end()) {
+    return iter->second.get();
+  }
+  return nullptr;
 }
 
-IFile* FileCollectionIterator::next() {
-    IFile* result = mCurrent->second.get();
-    ++mCurrent;
-    return result;
+std::unique_ptr<IFileCollectionIterator> FileCollection::Iterator() {
+  return util::make_unique<FileCollectionIterator>(this);
 }
 
-IFile* FileCollection::insertFile(const StringPiece& path) {
-    return (mFiles[path.toString()] = util::make_unique<RegularFile>(Source(path))).get();
-}
-
-IFile* FileCollection::findFile(const StringPiece& path) {
-    auto iter = mFiles.find(path.toString());
-    if (iter != mFiles.end()) {
-        return iter->second.get();
-    }
-    return nullptr;
-}
-
-std::unique_ptr<IFileCollectionIterator> FileCollection::iterator() {
-    return util::make_unique<FileCollectionIterator>(this);
-}
-
-} // namespace io
-} // namespace aapt
+}  // namespace io
+}  // namespace aapt
diff --git a/tools/aapt2/io/FileSystem.h b/tools/aapt2/io/FileSystem.h
index 8584d486685c7..84f851ff694b9 100644
--- a/tools/aapt2/io/FileSystem.h
+++ b/tools/aapt2/io/FileSystem.h
@@ -17,10 +17,10 @@
 #ifndef AAPT_IO_FILESYSTEM_H
 #define AAPT_IO_FILESYSTEM_H
 
-#include "io/File.h"
-
 #include <map>
 
+#include "io/File.h"
+
 namespace aapt {
 namespace io {
 
@@ -31,11 +31,11 @@ class RegularFile : public IFile {
  public:
   explicit RegularFile(const Source& source);
 
-  std::unique_ptr<IData> openAsData() override;
-  const Source& getSource() const override;
+  std::unique_ptr<IData> OpenAsData() override;
+  const Source& GetSource() const override;
 
  private:
-  Source mSource;
+  Source source_;
 };
 
 class FileCollection;
@@ -44,11 +44,11 @@ class FileCollectionIterator : public IFileCollectionIterator {
  public:
   explicit FileCollectionIterator(FileCollection* collection);
 
-  bool hasNext() override;
-  io::IFile* next() override;
+  bool HasNext() override;
+  io::IFile* Next() override;
 
  private:
-  std::map<std::string, std::unique_ptr<IFile>>::const_iterator mCurrent, mEnd;
+  std::map<std::string, std::unique_ptr<IFile>>::const_iterator current_, end_;
 };
 
 /**
@@ -59,13 +59,13 @@ class FileCollection : public IFileCollection {
   /**
    * Adds a file located at path. Returns the IFile representation of that file.
    */
-  IFile* insertFile(const StringPiece& path);
-  IFile* findFile(const StringPiece& path) override;
-  std::unique_ptr<IFileCollectionIterator> iterator() override;
+  IFile* InsertFile(const StringPiece& path);
+  IFile* FindFile(const StringPiece& path) override;
+  std::unique_ptr<IFileCollectionIterator> Iterator() override;
 
  private:
   friend class FileCollectionIterator;
-  std::map<std::string, std::unique_ptr<IFile>> mFiles;
+  std::map<std::string, std::unique_ptr<IFile>> files_;
 };
 
 }  // namespace io
diff --git a/tools/aapt2/io/Io.cpp b/tools/aapt2/io/Io.cpp
index 963c21c31806f..cab4b65f2f5ab 100644
--- a/tools/aapt2/io/Io.cpp
+++ b/tools/aapt2/io/Io.cpp
@@ -22,23 +22,23 @@
 namespace aapt {
 namespace io {
 
-bool copy(OutputStream* out, InputStream* in) {
-    const void* inBuffer;
-    int inLen;
-    while (in->Next(&inBuffer, &inLen)) {
-        void* outBuffer;
-        int outLen;
-        if (!out->Next(&outBuffer, &outLen)) {
-            return !out->HadError();
-        }
-
-        const int bytesToCopy = std::min(inLen, outLen);
-        memcpy(outBuffer, inBuffer, bytesToCopy);
-        out->BackUp(outLen - bytesToCopy);
-        in->BackUp(inLen - bytesToCopy);
+bool Copy(OutputStream* out, InputStream* in) {
+  const void* in_buffer;
+  int in_len;
+  while (in->Next(&in_buffer, &in_len)) {
+    void* out_buffer;
+    int out_len;
+    if (!out->Next(&out_buffer, &out_len)) {
+      return !out->HadError();
     }
-    return !in->HadError();
+
+    const int bytes_to_copy = std::min(in_len, out_len);
+    memcpy(out_buffer, in_buffer, bytes_to_copy);
+    out->BackUp(out_len - bytes_to_copy);
+    in->BackUp(in_len - bytes_to_copy);
+  }
+  return !in->HadError();
 }
 
-} // namespace io
-} // namespace aapt
+}  // namespace io
+}  // namespace aapt
diff --git a/tools/aapt2/io/Io.h b/tools/aapt2/io/Io.h
index 49b9fc36e2939..33cdc7bbe4988 100644
--- a/tools/aapt2/io/Io.h
+++ b/tools/aapt2/io/Io.h
@@ -17,9 +17,10 @@
 #ifndef AAPT_IO_IO_H
 #define AAPT_IO_IO_H
 
-#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
 #include <string>
 
+#include "google/protobuf/io/zero_copy_stream_impl_lite.h"
+
 namespace aapt {
 namespace io {
 
@@ -29,7 +30,7 @@ namespace io {
  *
  * The code style here matches the protobuf style.
  */
-class InputStream : public google::protobuf::io::ZeroCopyInputStream {
+class InputStream : public ::google::protobuf::io::ZeroCopyInputStream {
  public:
   virtual std::string GetError() const { return {}; }
 
@@ -42,7 +43,7 @@ class InputStream : public google::protobuf::io::ZeroCopyInputStream {
  *
  * The code style here matches the protobuf style.
  */
-class OutputStream : public google::protobuf::io::ZeroCopyOutputStream {
+class OutputStream : public ::google::protobuf::io::ZeroCopyOutputStream {
  public:
   virtual std::string GetError() const { return {}; }
 
@@ -54,7 +55,7 @@ class OutputStream : public google::protobuf::io::ZeroCopyOutputStream {
  * If there was an error, check the individual streams' HadError/GetError
  * methods.
  */
-bool copy(OutputStream* out, InputStream* in);
+bool Copy(OutputStream* out, InputStream* in);
 
 }  // namespace io
 }  // namespace aapt
diff --git a/tools/aapt2/io/ZipArchive.cpp b/tools/aapt2/io/ZipArchive.cpp
index b3e7a02102e4e..f4a128eca9d1e 100644
--- a/tools/aapt2/io/ZipArchive.cpp
+++ b/tools/aapt2/io/ZipArchive.cpp
@@ -14,129 +14,128 @@
  * limitations under the License.
  */
 
-#include "Source.h"
 #include "io/ZipArchive.h"
-#include "util/Util.h"
 
-#include <utils/FileMap.h>
-#include <ziparchive/zip_archive.h>
+#include "utils/FileMap.h"
+#include "ziparchive/zip_archive.h"
+
+#include "Source.h"
+#include "util/Util.h"
 
 namespace aapt {
 namespace io {
 
-ZipFile::ZipFile(ZipArchiveHandle handle, const ZipEntry& entry, const Source& source) :
-        mZipHandle(handle), mZipEntry(entry), mSource(source) {
-}
+ZipFile::ZipFile(ZipArchiveHandle handle, const ZipEntry& entry,
+                 const Source& source)
+    : zip_handle_(handle), zip_entry_(entry), source_(source) {}
 
-std::unique_ptr<IData> ZipFile::openAsData() {
-    if (mZipEntry.method == kCompressStored) {
-        int fd = GetFileDescriptor(mZipHandle);
+std::unique_ptr<IData> ZipFile::OpenAsData() {
+  if (zip_entry_.method == kCompressStored) {
+    int fd = GetFileDescriptor(zip_handle_);
 
-        android::FileMap fileMap;
-        bool result = fileMap.create(nullptr, fd, mZipEntry.offset,
-                                     mZipEntry.uncompressed_length, true);
-        if (!result) {
-            return {};
-        }
-        return util::make_unique<MmappedData>(std::move(fileMap));
-
-    } else {
-        std::unique_ptr<uint8_t[]> data = std::unique_ptr<uint8_t[]>(
-                new uint8_t[mZipEntry.uncompressed_length]);
-        int32_t result = ExtractToMemory(mZipHandle, &mZipEntry, data.get(),
-                                         static_cast<uint32_t>(mZipEntry.uncompressed_length));
-        if (result != 0) {
-            return {};
-        }
-        return util::make_unique<MallocData>(std::move(data), mZipEntry.uncompressed_length);
+    android::FileMap file_map;
+    bool result = file_map.create(nullptr, fd, zip_entry_.offset,
+                                  zip_entry_.uncompressed_length, true);
+    if (!result) {
+      return {};
     }
-}
+    return util::make_unique<MmappedData>(std::move(file_map));
 
-const Source& ZipFile::getSource() const {
-    return mSource;
-}
-
-ZipFileCollectionIterator::ZipFileCollectionIterator(ZipFileCollection* collection) :
-        mCurrent(collection->mFiles.begin()), mEnd(collection->mFiles.end()) {
-}
-
-bool ZipFileCollectionIterator::hasNext() {
-    return mCurrent != mEnd;
-}
-
-IFile* ZipFileCollectionIterator::next() {
-    IFile* result = mCurrent->second.get();
-    ++mCurrent;
-    return result;
-}
-
-ZipFileCollection::ZipFileCollection() : mHandle(nullptr) {
-}
-
-std::unique_ptr<ZipFileCollection> ZipFileCollection::create(const StringPiece& path,
-                                                             std::string* outError) {
-    constexpr static const int32_t kEmptyArchive = -6;
-
-    std::unique_ptr<ZipFileCollection> collection = std::unique_ptr<ZipFileCollection>(
-            new ZipFileCollection());
-
-    int32_t result = OpenArchive(path.data(), &collection->mHandle);
+  } else {
+    std::unique_ptr<uint8_t[]> data =
+        std::unique_ptr<uint8_t[]>(new uint8_t[zip_entry_.uncompressed_length]);
+    int32_t result =
+        ExtractToMemory(zip_handle_, &zip_entry_, data.get(),
+                        static_cast<uint32_t>(zip_entry_.uncompressed_length));
     if (result != 0) {
-        // If a zip is empty, result will be an error code. This is fine and we should
-        // return an empty ZipFileCollection.
-        if (result == kEmptyArchive) {
-            return collection;
-        }
-
-        if (outError) *outError = ErrorCodeString(result);
-        return {};
+      return {};
     }
-
-    void* cookie = nullptr;
-    result = StartIteration(collection->mHandle, &cookie, nullptr, nullptr);
-    if (result != 0) {
-        if (outError) *outError = ErrorCodeString(result);
-        return {};
-    }
-
-    using IterationEnder = std::unique_ptr<void, decltype(EndIteration)*>;
-    IterationEnder iterationEnder(cookie, EndIteration);
-
-    ZipString zipEntryName;
-    ZipEntry zipData;
-    while ((result = Next(cookie, &zipData, &zipEntryName)) == 0) {
-        std::string zipEntryPath = std::string(reinterpret_cast<const char*>(zipEntryName.name),
-                                               zipEntryName.name_length);
-        std::string nestedPath = path.toString() + "@" + zipEntryPath;
-        collection->mFiles[zipEntryPath] = util::make_unique<ZipFile>(collection->mHandle,
-                                                                      zipData,
-                                                                      Source(nestedPath));
-    }
-
-    if (result != -1) {
-        if (outError) *outError = ErrorCodeString(result);
-        return {};
-    }
-    return collection;
+    return util::make_unique<MallocData>(std::move(data),
+                                         zip_entry_.uncompressed_length);
+  }
 }
 
-IFile* ZipFileCollection::findFile(const StringPiece& path) {
-    auto iter = mFiles.find(path.toString());
-    if (iter != mFiles.end()) {
-        return iter->second.get();
-    }
-    return nullptr;
+const Source& ZipFile::GetSource() const { return source_; }
+
+ZipFileCollectionIterator::ZipFileCollectionIterator(
+    ZipFileCollection* collection)
+    : current_(collection->files_.begin()), end_(collection->files_.end()) {}
+
+bool ZipFileCollectionIterator::HasNext() { return current_ != end_; }
+
+IFile* ZipFileCollectionIterator::Next() {
+  IFile* result = current_->second.get();
+  ++current_;
+  return result;
 }
 
-std::unique_ptr<IFileCollectionIterator> ZipFileCollection::iterator() {
-    return util::make_unique<ZipFileCollectionIterator>(this);
+ZipFileCollection::ZipFileCollection() : handle_(nullptr) {}
+
+std::unique_ptr<ZipFileCollection> ZipFileCollection::Create(
+    const StringPiece& path, std::string* out_error) {
+  constexpr static const int32_t kEmptyArchive = -6;
+
+  std::unique_ptr<ZipFileCollection> collection =
+      std::unique_ptr<ZipFileCollection>(new ZipFileCollection());
+
+  int32_t result = OpenArchive(path.data(), &collection->handle_);
+  if (result != 0) {
+    // If a zip is empty, result will be an error code. This is fine and we
+    // should
+    // return an empty ZipFileCollection.
+    if (result == kEmptyArchive) {
+      return collection;
+    }
+
+    if (out_error) *out_error = ErrorCodeString(result);
+    return {};
+  }
+
+  void* cookie = nullptr;
+  result = StartIteration(collection->handle_, &cookie, nullptr, nullptr);
+  if (result != 0) {
+    if (out_error) *out_error = ErrorCodeString(result);
+    return {};
+  }
+
+  using IterationEnder = std::unique_ptr<void, decltype(EndIteration)*>;
+  IterationEnder iteration_ender(cookie, EndIteration);
+
+  ZipString zip_entry_name;
+  ZipEntry zip_data;
+  while ((result = Next(cookie, &zip_data, &zip_entry_name)) == 0) {
+    std::string zip_entry_path =
+        std::string(reinterpret_cast<const char*>(zip_entry_name.name),
+                    zip_entry_name.name_length);
+    std::string nested_path = path.ToString() + "@" + zip_entry_path;
+    collection->files_[zip_entry_path] = util::make_unique<ZipFile>(
+        collection->handle_, zip_data, Source(nested_path));
+  }
+
+  if (result != -1) {
+    if (out_error) *out_error = ErrorCodeString(result);
+    return {};
+  }
+  return collection;
+}
+
+IFile* ZipFileCollection::FindFile(const StringPiece& path) {
+  auto iter = files_.find(path.ToString());
+  if (iter != files_.end()) {
+    return iter->second.get();
+  }
+  return nullptr;
+}
+
+std::unique_ptr<IFileCollectionIterator> ZipFileCollection::Iterator() {
+  return util::make_unique<ZipFileCollectionIterator>(this);
 }
 
 ZipFileCollection::~ZipFileCollection() {
-    if (mHandle) {
-        CloseArchive(mHandle);
-    }
+  if (handle_) {
+    CloseArchive(handle_);
+  }
 }
 
-} // namespace io
-} // namespace aapt
+}  // namespace io
+}  // namespace aapt
diff --git a/tools/aapt2/io/ZipArchive.h b/tools/aapt2/io/ZipArchive.h
index e04525f51f4b9..85ca1aed4edcc 100644
--- a/tools/aapt2/io/ZipArchive.h
+++ b/tools/aapt2/io/ZipArchive.h
@@ -17,12 +17,13 @@
 #ifndef AAPT_IO_ZIPARCHIVE_H
 #define AAPT_IO_ZIPARCHIVE_H
 
+#include "ziparchive/zip_archive.h"
+
+#include <map>
+
 #include "io/File.h"
 #include "util/StringPiece.h"
 
-#include <ziparchive/zip_archive.h>
-#include <map>
-
 namespace aapt {
 namespace io {
 
@@ -36,13 +37,13 @@ class ZipFile : public IFile {
  public:
   ZipFile(ZipArchiveHandle handle, const ZipEntry& entry, const Source& source);
 
-  std::unique_ptr<IData> openAsData() override;
-  const Source& getSource() const override;
+  std::unique_ptr<IData> OpenAsData() override;
+  const Source& GetSource() const override;
 
  private:
-  ZipArchiveHandle mZipHandle;
-  ZipEntry mZipEntry;
-  Source mSource;
+  ZipArchiveHandle zip_handle_;
+  ZipEntry zip_entry_;
+  Source source_;
 };
 
 class ZipFileCollection;
@@ -51,11 +52,11 @@ class ZipFileCollectionIterator : public IFileCollectionIterator {
  public:
   explicit ZipFileCollectionIterator(ZipFileCollection* collection);
 
-  bool hasNext() override;
-  io::IFile* next() override;
+  bool HasNext() override;
+  io::IFile* Next() override;
 
  private:
-  std::map<std::string, std::unique_ptr<IFile>>::const_iterator mCurrent, mEnd;
+  std::map<std::string, std::unique_ptr<IFile>>::const_iterator current_, end_;
 };
 
 /**
@@ -63,11 +64,11 @@ class ZipFileCollectionIterator : public IFileCollectionIterator {
  */
 class ZipFileCollection : public IFileCollection {
  public:
-  static std::unique_ptr<ZipFileCollection> create(const StringPiece& path,
+  static std::unique_ptr<ZipFileCollection> Create(const StringPiece& path,
                                                    std::string* outError);
 
-  io::IFile* findFile(const StringPiece& path) override;
-  std::unique_ptr<IFileCollectionIterator> iterator() override;
+  io::IFile* FindFile(const StringPiece& path) override;
+  std::unique_ptr<IFileCollectionIterator> Iterator() override;
 
   ~ZipFileCollection() override;
 
@@ -75,8 +76,8 @@ class ZipFileCollection : public IFileCollection {
   friend class ZipFileCollectionIterator;
   ZipFileCollection();
 
-  ZipArchiveHandle mHandle;
-  std::map<std::string, std::unique_ptr<IFile>> mFiles;
+  ZipArchiveHandle handle_;
+  std::map<std::string, std::unique_ptr<IFile>> files_;
 };
 
 }  // namespace io
diff --git a/tools/aapt2/java/AnnotationProcessor.cpp b/tools/aapt2/java/AnnotationProcessor.cpp
index 23ff8abf8950c..2951e5cff6d7f 100644
--- a/tools/aapt2/java/AnnotationProcessor.cpp
+++ b/tools/aapt2/java/AnnotationProcessor.cpp
@@ -15,69 +15,71 @@
  */
 
 #include "java/AnnotationProcessor.h"
-#include "util/Util.h"
 
 #include <algorithm>
 
+#include "util/Util.h"
+
 namespace aapt {
 
-void AnnotationProcessor::appendCommentLine(std::string& comment) {
-    static const std::string sDeprecated = "@deprecated";
-    static const std::string sSystemApi = "@SystemApi";
+void AnnotationProcessor::AppendCommentLine(std::string& comment) {
+  static const std::string sDeprecated = "@deprecated";
+  static const std::string sSystemApi = "@SystemApi";
 
-    if (comment.find(sDeprecated) != std::string::npos) {
-        mAnnotationBitMask |= kDeprecated;
-    }
+  if (comment.find(sDeprecated) != std::string::npos) {
+    annotation_bit_mask_ |= kDeprecated;
+  }
 
-    std::string::size_type idx = comment.find(sSystemApi);
-    if (idx != std::string::npos) {
-        mAnnotationBitMask |= kSystemApi;
-        comment.erase(comment.begin() + idx, comment.begin() + idx + sSystemApi.size());
-    }
+  std::string::size_type idx = comment.find(sSystemApi);
+  if (idx != std::string::npos) {
+    annotation_bit_mask_ |= kSystemApi;
+    comment.erase(comment.begin() + idx,
+                  comment.begin() + idx + sSystemApi.size());
+  }
 
-    if (util::trimWhitespace(comment).empty()) {
-        return;
-    }
+  if (util::TrimWhitespace(comment).empty()) {
+    return;
+  }
 
-    if (!mHasComments) {
-        mHasComments = true;
-        mComment << "/**";
-    }
+  if (!has_comments_) {
+    has_comments_ = true;
+    comment_ << "/**";
+  }
 
-    mComment << "\n * " << std::move(comment);
+  comment_ << "\n * " << std::move(comment);
 }
 
-void AnnotationProcessor::appendComment(const StringPiece& comment) {
-    // We need to process line by line to clean-up whitespace and append prefixes.
-    for (StringPiece line : util::tokenize(comment, '\n')) {
-        line = util::trimWhitespace(line);
-        if (!line.empty()) {
-            std::string lineCopy = line.toString();
-            appendCommentLine(lineCopy);
-        }
+void AnnotationProcessor::AppendComment(const StringPiece& comment) {
+  // We need to process line by line to clean-up whitespace and append prefixes.
+  for (StringPiece line : util::Tokenize(comment, '\n')) {
+    line = util::TrimWhitespace(line);
+    if (!line.empty()) {
+      std::string lineCopy = line.ToString();
+      AppendCommentLine(lineCopy);
     }
+  }
 }
 
-void AnnotationProcessor::appendNewLine() {
-    mComment << "\n *";
+void AnnotationProcessor::AppendNewLine() { comment_ << "\n *"; }
+
+void AnnotationProcessor::WriteToStream(std::ostream* out,
+                                        const StringPiece& prefix) const {
+  if (has_comments_) {
+    std::string result = comment_.str();
+    for (StringPiece line : util::Tokenize(result, '\n')) {
+      *out << prefix << line << "\n";
+    }
+    *out << prefix << " */"
+         << "\n";
+  }
+
+  if (annotation_bit_mask_ & kDeprecated) {
+    *out << prefix << "@Deprecated\n";
+  }
+
+  if (annotation_bit_mask_ & kSystemApi) {
+    *out << prefix << "@android.annotation.SystemApi\n";
+  }
 }
 
-void AnnotationProcessor::writeToStream(std::ostream* out, const StringPiece& prefix) const {
-    if (mHasComments) {
-        std::string result = mComment.str();
-        for (StringPiece line : util::tokenize(result, '\n')) {
-           *out << prefix << line << "\n";
-        }
-        *out << prefix << " */" << "\n";
-    }
-
-    if (mAnnotationBitMask & kDeprecated) {
-        *out << prefix << "@Deprecated\n";
-    }
-
-    if (mAnnotationBitMask & kSystemApi) {
-        *out << prefix << "@android.annotation.SystemApi\n";
-    }
-}
-
-} // namespace aapt
+}  // namespace aapt
diff --git a/tools/aapt2/java/AnnotationProcessor.h b/tools/aapt2/java/AnnotationProcessor.h
index 54196085db176..666a7f3567688 100644
--- a/tools/aapt2/java/AnnotationProcessor.h
+++ b/tools/aapt2/java/AnnotationProcessor.h
@@ -17,11 +17,11 @@
 #ifndef AAPT_JAVA_ANNOTATIONPROCESSOR_H
 #define AAPT_JAVA_ANNOTATIONPROCESSOR_H
 
-#include "util/StringPiece.h"
-
 #include <sstream>
 #include <string>
 
+#include "util/StringPiece.h"
+
 namespace aapt {
 
 /**
@@ -58,15 +58,15 @@ class AnnotationProcessor {
    * configurations,
    * we need to collect all the comments.
    */
-  void appendComment(const StringPiece& comment);
+  void AppendComment(const StringPiece& comment);
 
-  void appendNewLine();
+  void AppendNewLine();
 
   /**
    * Writes the comments and annotations to the stream, with the given prefix
    * before each line.
    */
-  void writeToStream(std::ostream* out, const StringPiece& prefix) const;
+  void WriteToStream(std::ostream* out, const StringPiece& prefix) const;
 
  private:
   enum : uint32_t {
@@ -74,12 +74,12 @@ class AnnotationProcessor {
     kSystemApi = 0x02,
   };
 
-  std::stringstream mComment;
+  std::stringstream comment_;
   std::stringstream mAnnotations;
-  bool mHasComments = false;
-  uint32_t mAnnotationBitMask = 0;
+  bool has_comments_ = false;
+  uint32_t annotation_bit_mask_ = 0;
 
-  void appendCommentLine(std::string& line);
+  void AppendCommentLine(std::string& line);
 };
 
 }  // namespace aapt
diff --git a/tools/aapt2/java/AnnotationProcessor_test.cpp b/tools/aapt2/java/AnnotationProcessor_test.cpp
index 5a39add48fbd7..3e43c4295c078 100644
--- a/tools/aapt2/java/AnnotationProcessor_test.cpp
+++ b/tools/aapt2/java/AnnotationProcessor_test.cpp
@@ -15,38 +15,39 @@
  */
 
 #include "java/AnnotationProcessor.h"
+
 #include "test/Test.h"
 
 namespace aapt {
 
 TEST(AnnotationProcessorTest, EmitsDeprecated) {
-    const char* comment = "Some comment, and it should contain a marker word, "
-                          "something that marks this resource as nor needed. "
-                          "{@deprecated That's the marker! }";
+  const char* comment =
+      "Some comment, and it should contain a marker word, "
+      "something that marks this resource as nor needed. "
+      "{@deprecated That's the marker! }";
 
-    AnnotationProcessor processor;
-    processor.appendComment(comment);
+  AnnotationProcessor processor;
+  processor.AppendComment(comment);
 
-    std::stringstream result;
-    processor.writeToStream(&result, "");
-    std::string annotations = result.str();
+  std::stringstream result;
+  processor.WriteToStream(&result, "");
+  std::string annotations = result.str();
 
-    EXPECT_NE(std::string::npos, annotations.find("@Deprecated"));
+  EXPECT_NE(std::string::npos, annotations.find("@Deprecated"));
 }
 
 TEST(AnnotationProcessorTest, EmitsSystemApiAnnotationAndRemovesFromComment) {
-    AnnotationProcessor processor;
-    processor.appendComment("@SystemApi This is a system API");
+  AnnotationProcessor processor;
+  processor.AppendComment("@SystemApi This is a system API");
 
-    std::stringstream result;
-    processor.writeToStream(&result, "");
-    std::string annotations = result.str();
+  std::stringstream result;
+  processor.WriteToStream(&result, "");
+  std::string annotations = result.str();
 
-    EXPECT_NE(std::string::npos, annotations.find("@android.annotation.SystemApi"));
-    EXPECT_EQ(std::string::npos, annotations.find("@SystemApi"));
-    EXPECT_NE(std::string::npos, annotations.find("This is a system API"));
+  EXPECT_NE(std::string::npos,
+            annotations.find("@android.annotation.SystemApi"));
+  EXPECT_EQ(std::string::npos, annotations.find("@SystemApi"));
+  EXPECT_NE(std::string::npos, annotations.find("This is a system API"));
 }
 
-} // namespace aapt
-
-
+}  // namespace aapt
diff --git a/tools/aapt2/java/ClassDefinition.cpp b/tools/aapt2/java/ClassDefinition.cpp
index 08f2c8b9805ce..f1f1f925480c0 100644
--- a/tools/aapt2/java/ClassDefinition.cpp
+++ b/tools/aapt2/java/ClassDefinition.cpp
@@ -15,61 +15,59 @@
  */
 
 #include "java/ClassDefinition.h"
-#include "util/StringPiece.h"
 
-#include <ostream>
+#include "util/StringPiece.h"
 
 namespace aapt {
 
 bool ClassDefinition::empty() const {
-    for (const std::unique_ptr<ClassMember>& member : mMembers) {
-        if (!member->empty()) {
-            return false;
-        }
+  for (const std::unique_ptr<ClassMember>& member : members_) {
+    if (!member->empty()) {
+      return false;
     }
-    return true;
+  }
+  return true;
 }
 
-void ClassDefinition::writeToStream(const StringPiece& prefix, bool final,
+void ClassDefinition::WriteToStream(const StringPiece& prefix, bool final,
                                     std::ostream* out) const {
-    if (mMembers.empty() && !mCreateIfEmpty) {
-        return;
-    }
+  if (members_.empty() && !create_if_empty_) {
+    return;
+  }
 
-    ClassMember::writeToStream(prefix, final, out);
+  ClassMember::WriteToStream(prefix, final, out);
 
-    *out << prefix << "public ";
-    if (mQualifier == ClassQualifier::Static) {
-        *out << "static ";
-    }
-    *out << "final class " << mName << " {\n";
+  *out << prefix << "public ";
+  if (qualifier_ == ClassQualifier::Static) {
+    *out << "static ";
+  }
+  *out << "final class " << name_ << " {\n";
 
-    std::string newPrefix = prefix.toString();
-    newPrefix.append(kIndent);
+  std::string new_prefix = prefix.ToString();
+  new_prefix.append(kIndent);
 
-    for (const std::unique_ptr<ClassMember>& member : mMembers) {
-        member->writeToStream(newPrefix, final, out);
-        *out << "\n";
-    }
+  for (const std::unique_ptr<ClassMember>& member : members_) {
+    member->WriteToStream(new_prefix, final, out);
+    *out << "\n";
+  }
 
-    *out << prefix << "}";
+  *out << prefix << "}";
 }
 
 constexpr static const char* sWarningHeader =
-        "/* AUTO-GENERATED FILE. DO NOT MODIFY.\n"
-        " *\n"
-        " * This class was automatically generated by the\n"
-        " * aapt tool from the resource data it found. It\n"
-        " * should not be modified by hand.\n"
-        " */\n\n";
+    "/* AUTO-GENERATED FILE. DO NOT MODIFY.\n"
+    " *\n"
+    " * This class was automatically generated by the\n"
+    " * aapt tool from the resource data it found. It\n"
+    " * should not be modified by hand.\n"
+    " */\n\n";
 
-bool ClassDefinition::writeJavaFile(const ClassDefinition* def,
-                                    const StringPiece& package,
-                                    bool final,
+bool ClassDefinition::WriteJavaFile(const ClassDefinition* def,
+                                    const StringPiece& package, bool final,
                                     std::ostream* out) {
-    *out << sWarningHeader << "package " << package << ";\n\n";
-    def->writeToStream("", final, out);
-    return bool(*out);
+  *out << sWarningHeader << "package " << package << ";\n\n";
+  def->WriteToStream("", final, out);
+  return bool(*out);
 }
 
-} // namespace aapt
+}  // namespace aapt
diff --git a/tools/aapt2/java/ClassDefinition.h b/tools/aapt2/java/ClassDefinition.h
index bd7e7b277fe54..d8b61d919fd85 100644
--- a/tools/aapt2/java/ClassDefinition.h
+++ b/tools/aapt2/java/ClassDefinition.h
@@ -17,15 +17,16 @@
 #ifndef AAPT_JAVA_CLASSDEFINITION_H
 #define AAPT_JAVA_CLASSDEFINITION_H
 
+#include <ostream>
+#include <string>
+
+#include "android-base/macros.h"
+
 #include "Resource.h"
 #include "java/AnnotationProcessor.h"
 #include "util/StringPiece.h"
 #include "util/Util.h"
 
-#include <android-base/macros.h>
-#include <sstream>
-#include <string>
-
 namespace aapt {
 
 // The number of attributes to emit per line in a Styleable array.
@@ -36,38 +37,38 @@ class ClassMember {
  public:
   virtual ~ClassMember() = default;
 
-  AnnotationProcessor* getCommentBuilder() { return &mProcessor; }
+  AnnotationProcessor* GetCommentBuilder() { return &processor_; }
 
   virtual bool empty() const = 0;
 
-  virtual void writeToStream(const StringPiece& prefix, bool final,
+  virtual void WriteToStream(const StringPiece& prefix, bool final,
                              std::ostream* out) const {
-    mProcessor.writeToStream(out, prefix);
+    processor_.WriteToStream(out, prefix);
   }
 
  private:
-  AnnotationProcessor mProcessor;
+  AnnotationProcessor processor_;
 };
 
 template <typename T>
 class PrimitiveMember : public ClassMember {
  public:
   PrimitiveMember(const StringPiece& name, const T& val)
-      : mName(name.toString()), mVal(val) {}
+      : name_(name.ToString()), val_(val) {}
 
   bool empty() const override { return false; }
 
-  void writeToStream(const StringPiece& prefix, bool final,
+  void WriteToStream(const StringPiece& prefix, bool final,
                      std::ostream* out) const override {
-    ClassMember::writeToStream(prefix, final, out);
+    ClassMember::WriteToStream(prefix, final, out);
 
     *out << prefix << "public static " << (final ? "final " : "") << "int "
-         << mName << "=" << mVal << ";";
+         << name_ << "=" << val_ << ";";
   }
 
  private:
-  std::string mName;
-  T mVal;
+  std::string name_;
+  T val_;
 
   DISALLOW_COPY_AND_ASSIGN(PrimitiveMember);
 };
@@ -79,21 +80,21 @@ template <>
 class PrimitiveMember<std::string> : public ClassMember {
  public:
   PrimitiveMember(const StringPiece& name, const std::string& val)
-      : mName(name.toString()), mVal(val) {}
+      : name_(name.ToString()), val_(val) {}
 
   bool empty() const override { return false; }
 
-  void writeToStream(const StringPiece& prefix, bool final,
+  void WriteToStream(const StringPiece& prefix, bool final,
                      std::ostream* out) const override {
-    ClassMember::writeToStream(prefix, final, out);
+    ClassMember::WriteToStream(prefix, final, out);
 
     *out << prefix << "public static " << (final ? "final " : "") << "String "
-         << mName << "=\"" << mVal << "\";";
+         << name_ << "=\"" << val_ << "\";";
   }
 
  private:
-  std::string mName;
-  std::string mVal;
+  std::string name_;
+  std::string val_;
 
   DISALLOW_COPY_AND_ASSIGN(PrimitiveMember);
 };
@@ -106,20 +107,20 @@ template <typename T>
 class PrimitiveArrayMember : public ClassMember {
  public:
   explicit PrimitiveArrayMember(const StringPiece& name)
-      : mName(name.toString()) {}
+      : name_(name.ToString()) {}
 
-  void addElement(const T& val) { mElements.push_back(val); }
+  void AddElement(const T& val) { elements_.push_back(val); }
 
   bool empty() const override { return false; }
 
-  void writeToStream(const StringPiece& prefix, bool final,
+  void WriteToStream(const StringPiece& prefix, bool final,
                      std::ostream* out) const override {
-    ClassMember::writeToStream(prefix, final, out);
+    ClassMember::WriteToStream(prefix, final, out);
 
-    *out << prefix << "public static final int[] " << mName << "={";
+    *out << prefix << "public static final int[] " << name_ << "={";
 
-    const auto begin = mElements.begin();
-    const auto end = mElements.end();
+    const auto begin = elements_.begin();
+    const auto end = elements_.end();
     for (auto current = begin; current != end; ++current) {
       if (std::distance(begin, current) % kAttribsPerLine == 0) {
         *out << "\n" << prefix << kIndent << kIndent;
@@ -134,8 +135,8 @@ class PrimitiveArrayMember : public ClassMember {
   }
 
  private:
-  std::string mName;
-  std::vector<T> mElements;
+  std::string name_;
+  std::vector<T> elements_;
 
   DISALLOW_COPY_AND_ASSIGN(PrimitiveArrayMember);
 };
@@ -146,29 +147,29 @@ enum class ClassQualifier { None, Static };
 
 class ClassDefinition : public ClassMember {
  public:
-  static bool writeJavaFile(const ClassDefinition* def,
+  static bool WriteJavaFile(const ClassDefinition* def,
                             const StringPiece& package, bool final,
                             std::ostream* out);
 
   ClassDefinition(const StringPiece& name, ClassQualifier qualifier,
                   bool createIfEmpty)
-      : mName(name.toString()),
-        mQualifier(qualifier),
-        mCreateIfEmpty(createIfEmpty) {}
+      : name_(name.ToString()),
+        qualifier_(qualifier),
+        create_if_empty_(createIfEmpty) {}
 
-  void addMember(std::unique_ptr<ClassMember> member) {
-    mMembers.push_back(std::move(member));
+  void AddMember(std::unique_ptr<ClassMember> member) {
+    members_.push_back(std::move(member));
   }
 
   bool empty() const override;
-  void writeToStream(const StringPiece& prefix, bool final,
+  void WriteToStream(const StringPiece& prefix, bool final,
                      std::ostream* out) const override;
 
  private:
-  std::string mName;
-  ClassQualifier mQualifier;
-  bool mCreateIfEmpty;
-  std::vector<std::unique_ptr<ClassMember>> mMembers;
+  std::string name_;
+  ClassQualifier qualifier_;
+  bool create_if_empty_;
+  std::vector<std::unique_ptr<ClassMember>> members_;
 
   DISALLOW_COPY_AND_ASSIGN(ClassDefinition);
 };
diff --git a/tools/aapt2/java/JavaClassGenerator.cpp b/tools/aapt2/java/JavaClassGenerator.cpp
index fbaefb1f0c80b..6e7c707847b96 100644
--- a/tools/aapt2/java/JavaClassGenerator.cpp
+++ b/tools/aapt2/java/JavaClassGenerator.cpp
@@ -14,16 +14,7 @@
  * limitations under the License.
  */
 
-#include "NameMangler.h"
-#include "Resource.h"
-#include "ResourceTable.h"
-#include "ResourceValues.h"
-#include "ValueVisitor.h"
-#include "java/AnnotationProcessor.h"
-#include "java/ClassDefinition.h"
 #include "java/JavaClassGenerator.h"
-#include "process/SymbolTable.h"
-#include "util/StringPiece.h"
 
 #include <algorithm>
 #include <ostream>
@@ -31,42 +22,49 @@
 #include <sstream>
 #include <tuple>
 
+#include "android-base/logging.h"
+
+#include "NameMangler.h"
+#include "Resource.h"
+#include "ResourceTable.h"
+#include "ResourceValues.h"
+#include "ValueVisitor.h"
+#include "java/AnnotationProcessor.h"
+#include "java/ClassDefinition.h"
+#include "process/SymbolTable.h"
+#include "util/StringPiece.h"
+
 namespace aapt {
 
-JavaClassGenerator::JavaClassGenerator(IAaptContext* context, ResourceTable* table,
-                                       const JavaClassGeneratorOptions& options) :
-        mContext(context), mTable(table), mOptions(options) {
-}
-
 static const std::set<StringPiece> sJavaIdentifiers = {
-    "abstract", "assert", "boolean", "break", "byte",
-    "case", "catch", "char", "class", "const", "continue",
-    "default", "do", "double", "else", "enum", "extends",
-    "final", "finally", "float", "for", "goto", "if",
-    "implements", "import", "instanceof", "int", "interface",
-    "long", "native", "new", "package", "private", "protected",
-    "public", "return", "short", "static", "strictfp", "super",
-    "switch", "synchronized", "this", "throw", "throws",
-    "transient", "try", "void", "volatile", "while", "true",
-    "false", "null"
-};
+    "abstract",   "assert",       "boolean",   "break",      "byte",
+    "case",       "catch",        "char",      "class",      "const",
+    "continue",   "default",      "do",        "double",     "else",
+    "enum",       "extends",      "final",     "finally",    "float",
+    "for",        "goto",         "if",        "implements", "import",
+    "instanceof", "int",          "interface", "long",       "native",
+    "new",        "package",      "private",   "protected",  "public",
+    "return",     "short",        "static",    "strictfp",   "super",
+    "switch",     "synchronized", "this",      "throw",      "throws",
+    "transient",  "try",          "void",      "volatile",   "while",
+    "true",       "false",        "null"};
 
-static bool isValidSymbol(const StringPiece& symbol) {
-    return sJavaIdentifiers.find(symbol) == sJavaIdentifiers.end();
+static bool IsValidSymbol(const StringPiece& symbol) {
+  return sJavaIdentifiers.find(symbol) == sJavaIdentifiers.end();
 }
 
 /*
  * Java symbols can not contain . or -, but those are valid in a resource name.
  * Replace those with '_'.
  */
-static std::string transform(const StringPiece& symbol) {
-    std::string output = symbol.toString();
-    for (char& c : output) {
-        if (c == '.' || c == '-') {
-            c = '_';
-        }
+static std::string Transform(const StringPiece& symbol) {
+  std::string output = symbol.ToString();
+  for (char& c : output) {
+    if (c == '.' || c == '-') {
+      c = '_';
     }
-    return output;
+  }
+  return output;
 }
 
 /**
@@ -80,475 +78,519 @@ static std::string transform(const StringPiece& symbol) {
  * Foo_android_bar
  * Foo_bar
  */
-static std::string transformNestedAttr(const ResourceNameRef& attrName,
-                                       const std::string& styleableClassName,
-                                       const StringPiece& packageNameToGenerate) {
-    std::string output = styleableClassName;
+static std::string TransformNestedAttr(
+    const ResourceNameRef& attr_name, const std::string& styleable_class_name,
+    const StringPiece& package_name_to_generate) {
+  std::string output = styleable_class_name;
 
-    // We may reference IDs from other packages, so prefix the entry name with
-    // the package.
-    if (!attrName.package.empty() && packageNameToGenerate != attrName.package) {
-        output += "_" + transform(attrName.package);
-    }
-    output += "_" + transform(attrName.entry);
-    return output;
+  // We may reference IDs from other packages, so prefix the entry name with
+  // the package.
+  if (!attr_name.package.empty() &&
+      package_name_to_generate != attr_name.package) {
+    output += "_" + Transform(attr_name.package);
+  }
+  output += "_" + Transform(attr_name.entry);
+  return output;
 }
 
-static void addAttributeFormatDoc(AnnotationProcessor* processor, Attribute* attr) {
-    const uint32_t typeMask = attr->typeMask;
-    if (typeMask & android::ResTable_map::TYPE_REFERENCE) {
-        processor->appendComment(
-                "<p>May be a reference to another resource, in the form\n"
-                "\"<code>@[+][<i>package</i>:]<i>type</i>/<i>name</i></code>\" or a theme\n"
-                "attribute in the form\n"
-                "\"<code>?[<i>package</i>:]<i>type</i>/<i>name</i></code>\".");
+static void AddAttributeFormatDoc(AnnotationProcessor* processor,
+                                  Attribute* attr) {
+  const uint32_t type_mask = attr->type_mask;
+  if (type_mask & android::ResTable_map::TYPE_REFERENCE) {
+    processor->AppendComment(
+        "<p>May be a reference to another resource, in the form\n"
+        "\"<code>@[+][<i>package</i>:]<i>type</i>/<i>name</i></code>\" or a "
+        "theme\n"
+        "attribute in the form\n"
+        "\"<code>?[<i>package</i>:]<i>type</i>/<i>name</i></code>\".");
+  }
+
+  if (type_mask & android::ResTable_map::TYPE_STRING) {
+    processor->AppendComment(
+        "<p>May be a string value, using '\\\\;' to escape characters such as\n"
+        "'\\\\n' or '\\\\uxxxx' for a unicode character;");
+  }
+
+  if (type_mask & android::ResTable_map::TYPE_INTEGER) {
+    processor->AppendComment(
+        "<p>May be an integer value, such as \"<code>100</code>\".");
+  }
+
+  if (type_mask & android::ResTable_map::TYPE_BOOLEAN) {
+    processor->AppendComment(
+        "<p>May be a boolean value, such as \"<code>true</code>\" or\n"
+        "\"<code>false</code>\".");
+  }
+
+  if (type_mask & android::ResTable_map::TYPE_COLOR) {
+    processor->AppendComment(
+        "<p>May be a color value, in the form of "
+        "\"<code>#<i>rgb</i></code>\",\n"
+        "\"<code>#<i>argb</i></code>\", \"<code>#<i>rrggbb</i></code\", or \n"
+        "\"<code>#<i>aarrggbb</i></code>\".");
+  }
+
+  if (type_mask & android::ResTable_map::TYPE_FLOAT) {
+    processor->AppendComment(
+        "<p>May be a floating point value, such as \"<code>1.2</code>\".");
+  }
+
+  if (type_mask & android::ResTable_map::TYPE_DIMENSION) {
+    processor->AppendComment(
+        "<p>May be a dimension value, which is a floating point number "
+        "appended with a\n"
+        "unit such as \"<code>14.5sp</code>\".\n"
+        "Available units are: px (pixels), dp (density-independent pixels),\n"
+        "sp (scaled pixels based on preferred font size), in (inches), and\n"
+        "mm (millimeters).");
+  }
+
+  if (type_mask & android::ResTable_map::TYPE_FRACTION) {
+    processor->AppendComment(
+        "<p>May be a fractional value, which is a floating point number "
+        "appended with\n"
+        "either % or %p, such as \"<code>14.5%</code>\".\n"
+        "The % suffix always means a percentage of the base size;\n"
+        "the optional %p suffix provides a size relative to some parent "
+        "container.");
+  }
+
+  if (type_mask &
+      (android::ResTable_map::TYPE_FLAGS | android::ResTable_map::TYPE_ENUM)) {
+    if (type_mask & android::ResTable_map::TYPE_FLAGS) {
+      processor->AppendComment(
+          "<p>Must be one or more (separated by '|') of the following "
+          "constant values.</p>");
+    } else {
+      processor->AppendComment(
+          "<p>Must be one of the following constant values.</p>");
     }
 
-    if (typeMask & android::ResTable_map::TYPE_STRING) {
-        processor->appendComment(
-                "<p>May be a string value, using '\\\\;' to escape characters such as\n"
-                "'\\\\n' or '\\\\uxxxx' for a unicode character;");
-    }
-
-    if (typeMask & android::ResTable_map::TYPE_INTEGER) {
-        processor->appendComment("<p>May be an integer value, such as \"<code>100</code>\".");
-    }
-
-    if (typeMask & android::ResTable_map::TYPE_BOOLEAN) {
-        processor->appendComment(
-                "<p>May be a boolean value, such as \"<code>true</code>\" or\n"
-                "\"<code>false</code>\".");
-    }
-
-    if (typeMask & android::ResTable_map::TYPE_COLOR) {
-        processor->appendComment(
-                "<p>May be a color value, in the form of \"<code>#<i>rgb</i></code>\",\n"
-                "\"<code>#<i>argb</i></code>\", \"<code>#<i>rrggbb</i></code\", or \n"
-                "\"<code>#<i>aarrggbb</i></code>\".");
-    }
-
-    if (typeMask & android::ResTable_map::TYPE_FLOAT) {
-        processor->appendComment(
-                "<p>May be a floating point value, such as \"<code>1.2</code>\".");
-    }
-
-    if (typeMask & android::ResTable_map::TYPE_DIMENSION) {
-        processor->appendComment(
-                "<p>May be a dimension value, which is a floating point number appended with a\n"
-                "unit such as \"<code>14.5sp</code>\".\n"
-                "Available units are: px (pixels), dp (density-independent pixels),\n"
-                "sp (scaled pixels based on preferred font size), in (inches), and\n"
-                "mm (millimeters).");
-    }
-
-    if (typeMask & android::ResTable_map::TYPE_FRACTION) {
-        processor->appendComment(
-                "<p>May be a fractional value, which is a floating point number appended with\n"
-                "either % or %p, such as \"<code>14.5%</code>\".\n"
-                "The % suffix always means a percentage of the base size;\n"
-                "the optional %p suffix provides a size relative to some parent container.");
-    }
-
-    if (typeMask & (android::ResTable_map::TYPE_FLAGS | android::ResTable_map::TYPE_ENUM)) {
-        if (typeMask & android::ResTable_map::TYPE_FLAGS) {
-            processor->appendComment(
-                    "<p>Must be one or more (separated by '|') of the following "
-                    "constant values.</p>");
-        } else {
-            processor->appendComment("<p>Must be one of the following constant values.</p>");
-        }
-
-        processor->appendComment("<table>\n<colgroup align=\"left\" />\n"
-                                 "<colgroup align=\"left\" />\n"
-                                 "<colgroup align=\"left\" />\n"
-                                 "<tr><th>Constant</th><th>Value</th><th>Description</th></tr>\n");
-        for (const Attribute::Symbol& symbol : attr->symbols) {
-            std::stringstream line;
-            line << "<tr><td>" << symbol.symbol.name.value().entry << "</td>"
-            << "<td>" << std::hex << symbol.value << std::dec << "</td>"
-            << "<td>" << util::trimWhitespace(symbol.symbol.getComment()) << "</td></tr>";
-            processor->appendComment(line.str());
-        }
-        processor->appendComment("</table>");
+    processor->AppendComment(
+        "<table>\n<colgroup align=\"left\" />\n"
+        "<colgroup align=\"left\" />\n"
+        "<colgroup align=\"left\" />\n"
+        "<tr><th>Constant</th><th>Value</th><th>Description</th></tr>\n");
+    for (const Attribute::Symbol& symbol : attr->symbols) {
+      std::stringstream line;
+      line << "<tr><td>" << symbol.symbol.name.value().entry << "</td>"
+           << "<td>" << std::hex << symbol.value << std::dec << "</td>"
+           << "<td>" << util::TrimWhitespace(symbol.symbol.GetComment())
+           << "</td></tr>";
+      processor->AppendComment(line.str());
     }
+    processor->AppendComment("</table>");
+  }
 }
 
-bool JavaClassGenerator::skipSymbol(SymbolState state) {
-    switch (mOptions.types) {
+JavaClassGenerator::JavaClassGenerator(IAaptContext* context,
+                                       ResourceTable* table,
+                                       const JavaClassGeneratorOptions& options)
+    : context_(context), table_(table), options_(options) {}
+
+bool JavaClassGenerator::SkipSymbol(SymbolState state) {
+  switch (options_.types) {
     case JavaClassGeneratorOptions::SymbolTypes::kAll:
-        return false;
+      return false;
     case JavaClassGeneratorOptions::SymbolTypes::kPublicPrivate:
-        return state == SymbolState::kUndefined;
+      return state == SymbolState::kUndefined;
     case JavaClassGeneratorOptions::SymbolTypes::kPublic:
-        return state != SymbolState::kPublic;
-    }
-    return true;
+      return state != SymbolState::kPublic;
+  }
+  return true;
 }
 
 struct StyleableAttr {
-    const Reference* attrRef;
-    std::string fieldName;
-    std::unique_ptr<SymbolTable::Symbol> symbol;
+  const Reference* attr_ref;
+  std::string field_name;
+  std::unique_ptr<SymbolTable::Symbol> symbol;
 };
 
-static bool lessStyleableAttr(const StyleableAttr& lhs, const StyleableAttr& rhs) {
-    const ResourceId lhsId = lhs.attrRef->id ? lhs.attrRef->id.value() : ResourceId(0);
-    const ResourceId rhsId = rhs.attrRef->id ? rhs.attrRef->id.value() : ResourceId(0);
-    if (lhsId < rhsId) {
-        return true;
-    } else if (lhsId > rhsId) {
-        return false;
+static bool less_styleable_attr(const StyleableAttr& lhs,
+                                const StyleableAttr& rhs) {
+  const ResourceId lhs_id =
+      lhs.attr_ref->id ? lhs.attr_ref->id.value() : ResourceId(0);
+  const ResourceId rhs_id =
+      rhs.attr_ref->id ? rhs.attr_ref->id.value() : ResourceId(0);
+  if (lhs_id < rhs_id) {
+    return true;
+  } else if (lhs_id > rhs_id) {
+    return false;
+  } else {
+    return lhs.attr_ref->name.value() < rhs.attr_ref->name.value();
+  }
+}
+
+void JavaClassGenerator::AddMembersToStyleableClass(
+    const StringPiece& package_name_to_generate, const std::string& entry_name,
+    const Styleable* styleable, ClassDefinition* out_styleable_class_def) {
+  const std::string class_name = Transform(entry_name);
+
+  std::unique_ptr<ResourceArrayMember> styleable_array_def =
+      util::make_unique<ResourceArrayMember>(class_name);
+
+  // This must be sorted by resource ID.
+  std::vector<StyleableAttr> sorted_attributes;
+  sorted_attributes.reserve(styleable->entries.size());
+  for (const auto& attr : styleable->entries) {
+    // If we are not encoding final attributes, the styleable entry may have no
+    // ID if we are building a static library.
+    CHECK(!options_.use_final || attr.id) << "no ID set for Styleable entry";
+    CHECK(bool(attr.name)) << "no name set for Styleable entry";
+
+    // We will need the unmangled, transformed name in the comments and the
+    // field,
+    // so create it once and cache it in this StyleableAttr data structure.
+    StyleableAttr styleable_attr = {};
+    styleable_attr.attr_ref = &attr;
+    styleable_attr.field_name = TransformNestedAttr(
+        attr.name.value(), class_name, package_name_to_generate);
+
+    Reference mangled_reference;
+    mangled_reference.id = attr.id;
+    mangled_reference.name = attr.name;
+    if (mangled_reference.name.value().package.empty()) {
+      mangled_reference.name.value().package =
+          context_->GetCompilationPackage();
+    }
+
+    if (Maybe<ResourceName> mangled_name =
+            context_->GetNameMangler()->MangleName(
+                mangled_reference.name.value())) {
+      mangled_reference.name = mangled_name;
+    }
+
+    // Look up the symbol so that we can write out in the comments what are
+    // possible
+    // legal values for this attribute.
+    const SymbolTable::Symbol* symbol =
+        context_->GetExternalSymbols()->FindByReference(mangled_reference);
+    if (symbol && symbol->attribute) {
+      // Copy the symbol data structure because the returned instance can be
+      // destroyed.
+      styleable_attr.symbol = util::make_unique<SymbolTable::Symbol>(*symbol);
+    }
+    sorted_attributes.push_back(std::move(styleable_attr));
+  }
+
+  // Sort the attributes by ID.
+  std::sort(sorted_attributes.begin(), sorted_attributes.end(),
+            less_styleable_attr);
+
+  const size_t attr_count = sorted_attributes.size();
+  if (attr_count > 0) {
+    // Build the comment string for the Styleable. It includes details about the
+    // child attributes.
+    std::stringstream styleable_comment;
+    if (!styleable->GetComment().empty()) {
+      styleable_comment << styleable->GetComment() << "\n";
     } else {
-        return lhs.attrRef->name.value() < rhs.attrRef->name.value();
+      styleable_comment << "Attributes that can be used with a " << class_name
+                        << ".\n";
     }
+
+    styleable_comment << "<p>Includes the following attributes:</p>\n"
+                         "<table>\n"
+                         "<colgroup align=\"left\" />\n"
+                         "<colgroup align=\"left\" />\n"
+                         "<tr><th>Attribute</th><th>Description</th></tr>\n";
+
+    for (const StyleableAttr& entry : sorted_attributes) {
+      if (!entry.symbol) {
+        continue;
+      }
+
+      if (options_.types == JavaClassGeneratorOptions::SymbolTypes::kPublic &&
+          !entry.symbol->is_public) {
+        // Don't write entries for non-public attributes.
+        continue;
+      }
+
+      StringPiece attr_comment_line = entry.symbol->attribute->GetComment();
+      if (attr_comment_line.contains("@removed")) {
+        // Removed attributes are public but hidden from the documentation, so
+        // don't emit
+        // them as part of the class documentation.
+        continue;
+      }
+
+      const ResourceName& attr_name = entry.attr_ref->name.value();
+      styleable_comment << "<tr><td>";
+      styleable_comment << "<code>{@link #" << entry.field_name << " "
+                        << (!attr_name.package.empty()
+                                ? attr_name.package
+                                : context_->GetCompilationPackage())
+                        << ":" << attr_name.entry << "}</code>";
+      styleable_comment << "</td>";
+
+      styleable_comment << "<td>";
+
+      // Only use the comment up until the first '.'. This is to stay compatible
+      // with
+      // the way old AAPT did it (presumably to keep it short and to avoid
+      // including
+      // annotations like @hide which would affect this Styleable).
+      auto iter =
+          std::find(attr_comment_line.begin(), attr_comment_line.end(), u'.');
+      if (iter != attr_comment_line.end()) {
+        attr_comment_line =
+            attr_comment_line.substr(0, (iter - attr_comment_line.begin()) + 1);
+      }
+      styleable_comment << attr_comment_line << "</td></tr>\n";
+    }
+    styleable_comment << "</table>\n";
+
+    for (const StyleableAttr& entry : sorted_attributes) {
+      if (!entry.symbol) {
+        continue;
+      }
+
+      if (options_.types == JavaClassGeneratorOptions::SymbolTypes::kPublic &&
+          !entry.symbol->is_public) {
+        // Don't write entries for non-public attributes.
+        continue;
+      }
+      styleable_comment << "@see #" << entry.field_name << "\n";
+    }
+
+    styleable_array_def->GetCommentBuilder()->AppendComment(
+        styleable_comment.str());
+  }
+
+  // Add the ResourceIds to the array member.
+  for (const StyleableAttr& styleable_attr : sorted_attributes) {
+    styleable_array_def->AddElement(styleable_attr.attr_ref->id
+                                        ? styleable_attr.attr_ref->id.value()
+                                        : ResourceId(0));
+  }
+
+  // Add the Styleable array to the Styleable class.
+  out_styleable_class_def->AddMember(std::move(styleable_array_def));
+
+  // Now we emit the indices into the array.
+  for (size_t i = 0; i < attr_count; i++) {
+    const StyleableAttr& styleable_attr = sorted_attributes[i];
+
+    if (!styleable_attr.symbol) {
+      continue;
+    }
+
+    if (options_.types == JavaClassGeneratorOptions::SymbolTypes::kPublic &&
+        !styleable_attr.symbol->is_public) {
+      // Don't write entries for non-public attributes.
+      continue;
+    }
+
+    StringPiece comment = styleable_attr.attr_ref->GetComment();
+    if (styleable_attr.symbol->attribute && comment.empty()) {
+      comment = styleable_attr.symbol->attribute->GetComment();
+    }
+
+    if (comment.contains("@removed")) {
+      // Removed attributes are public but hidden from the documentation, so
+      // don't emit them
+      // as part of the class documentation.
+      continue;
+    }
+
+    const ResourceName& attr_name = styleable_attr.attr_ref->name.value();
+
+    StringPiece package_name = attr_name.package;
+    if (package_name.empty()) {
+      package_name = context_->GetCompilationPackage();
+    }
+
+    std::unique_ptr<IntMember> index_member = util::make_unique<IntMember>(
+        sorted_attributes[i].field_name, static_cast<uint32_t>(i));
+
+    AnnotationProcessor* attr_processor = index_member->GetCommentBuilder();
+
+    if (!comment.empty()) {
+      attr_processor->AppendComment("<p>\n@attr description");
+      attr_processor->AppendComment(comment);
+    } else {
+      std::stringstream default_comment;
+      default_comment << "<p>This symbol is the offset where the "
+                      << "{@link " << package_name << ".R.attr#"
+                      << Transform(attr_name.entry) << "}\n"
+                      << "attribute's value can be found in the "
+                      << "{@link #" << class_name << "} array.";
+      attr_processor->AppendComment(default_comment.str());
+    }
+
+    attr_processor->AppendNewLine();
+
+    AddAttributeFormatDoc(attr_processor,
+                          styleable_attr.symbol->attribute.get());
+    attr_processor->AppendNewLine();
+
+    std::stringstream doclava_name;
+    doclava_name << "@attr name " << package_name << ":" << attr_name.entry;
+
+    attr_processor->AppendComment(doclava_name.str());
+
+    out_styleable_class_def->AddMember(std::move(index_member));
+  }
 }
 
-void JavaClassGenerator::addMembersToStyleableClass(const StringPiece& packageNameToGenerate,
-                                                    const std::string& entryName,
-                                                    const Styleable* styleable,
-                                                    ClassDefinition* outStyleableClassDef) {
-    const std::string className = transform(entryName);
-
-    std::unique_ptr<ResourceArrayMember> styleableArrayDef =
-            util::make_unique<ResourceArrayMember>(className);
-
-    // This must be sorted by resource ID.
-    std::vector<StyleableAttr> sortedAttributes;
-    sortedAttributes.reserve(styleable->entries.size());
-    for (const auto& attr : styleable->entries) {
-        // If we are not encoding final attributes, the styleable entry may have no ID
-        // if we are building a static library.
-        assert((!mOptions.useFinal || attr.id) && "no ID set for Styleable entry");
-        assert(attr.name && "no name set for Styleable entry");
-
-        // We will need the unmangled, transformed name in the comments and the field,
-        // so create it once and cache it in this StyleableAttr data structure.
-        StyleableAttr styleableAttr = {};
-        styleableAttr.attrRef = &attr;
-        styleableAttr.fieldName = transformNestedAttr(attr.name.value(), className,
-                                                      packageNameToGenerate);
-
-        Reference mangledReference;
-        mangledReference.id = attr.id;
-        mangledReference.name = attr.name;
-        if (mangledReference.name.value().package.empty()) {
-            mangledReference.name.value().package = mContext->getCompilationPackage();
-        }
-
-        if (Maybe<ResourceName> mangledName =
-                mContext->getNameMangler()->mangleName(mangledReference.name.value())) {
-            mangledReference.name = mangledName;
-        }
-
-        // Look up the symbol so that we can write out in the comments what are possible
-        // legal values for this attribute.
-        const SymbolTable::Symbol* symbol = mContext->getExternalSymbols()->findByReference(
-                mangledReference);
-        if (symbol && symbol->attribute) {
-            // Copy the symbol data structure because the returned instance can be destroyed.
-            styleableAttr.symbol = util::make_unique<SymbolTable::Symbol>(*symbol);
-        }
-        sortedAttributes.push_back(std::move(styleableAttr));
+bool JavaClassGenerator::AddMembersToTypeClass(
+    const StringPiece& package_name_to_generate,
+    const ResourceTablePackage* package, const ResourceTableType* type,
+    ClassDefinition* out_type_class_def) {
+  for (const auto& entry : type->entries) {
+    if (SkipSymbol(entry->symbol_status.state)) {
+      continue;
     }
 
-    // Sort the attributes by ID.
-    std::sort(sortedAttributes.begin(), sortedAttributes.end(), lessStyleableAttr);
-
-    const size_t attrCount = sortedAttributes.size();
-    if (attrCount > 0) {
-        // Build the comment string for the Styleable. It includes details about the
-        // child attributes.
-        std::stringstream styleableComment;
-        if (!styleable->getComment().empty()) {
-            styleableComment << styleable->getComment() << "\n";
-        } else {
-            styleableComment << "Attributes that can be used with a " << className << ".\n";
-        }
-
-        styleableComment <<
-                "<p>Includes the following attributes:</p>\n"
-                "<table>\n"
-                "<colgroup align=\"left\" />\n"
-                "<colgroup align=\"left\" />\n"
-                "<tr><th>Attribute</th><th>Description</th></tr>\n";
-
-        for (const StyleableAttr& entry : sortedAttributes) {
-            if (!entry.symbol) {
-                continue;
-            }
-
-            if (mOptions.types == JavaClassGeneratorOptions::SymbolTypes::kPublic &&
-                    !entry.symbol->isPublic) {
-                // Don't write entries for non-public attributes.
-                continue;
-            }
-
-            StringPiece attrCommentLine = entry.symbol->attribute->getComment();
-            if (attrCommentLine.contains("@removed")) {
-                // Removed attributes are public but hidden from the documentation, so don't emit
-                // them as part of the class documentation.
-                continue;
-            }
-
-            const ResourceName& attrName = entry.attrRef->name.value();
-            styleableComment << "<tr><td>";
-            styleableComment << "<code>{@link #"
-                             << entry.fieldName << " "
-                             << (!attrName.package.empty()
-                                    ? attrName.package : mContext->getCompilationPackage())
-                             << ":" << attrName.entry
-                             << "}</code>";
-            styleableComment << "</td>";
-
-            styleableComment << "<td>";
-
-            // Only use the comment up until the first '.'. This is to stay compatible with
-            // the way old AAPT did it (presumably to keep it short and to avoid including
-            // annotations like @hide which would affect this Styleable).
-            auto iter = std::find(attrCommentLine.begin(), attrCommentLine.end(), u'.');
-            if (iter != attrCommentLine.end()) {
-                attrCommentLine = attrCommentLine.substr(
-                        0, (iter - attrCommentLine.begin()) + 1);
-            }
-            styleableComment << attrCommentLine << "</td></tr>\n";
-        }
-        styleableComment << "</table>\n";
-
-        for (const StyleableAttr& entry : sortedAttributes) {
-            if (!entry.symbol) {
-                continue;
-            }
-
-            if (mOptions.types == JavaClassGeneratorOptions::SymbolTypes::kPublic &&
-                    !entry.symbol->isPublic) {
-                // Don't write entries for non-public attributes.
-                continue;
-            }
-            styleableComment << "@see #" << entry.fieldName << "\n";
-        }
-
-        styleableArrayDef->getCommentBuilder()->appendComment(styleableComment.str());
+    ResourceId id;
+    if (package->id && type->id && entry->id) {
+      id = ResourceId(package->id.value(), type->id.value(), entry->id.value());
     }
 
-    // Add the ResourceIds to the array member.
-    for (const StyleableAttr& styleableAttr : sortedAttributes) {
-        styleableArrayDef->addElement(
-                styleableAttr.attrRef->id ? styleableAttr.attrRef->id.value() : ResourceId(0));
+    std::string unmangled_package;
+    std::string unmangled_name = entry->name;
+    if (NameMangler::Unmangle(&unmangled_name, &unmangled_package)) {
+      // The entry name was mangled, and we successfully unmangled it.
+      // Check that we want to emit this symbol.
+      if (package->name != unmangled_package) {
+        // Skip the entry if it doesn't belong to the package we're writing.
+        continue;
+      }
+    } else if (package_name_to_generate != package->name) {
+      // We are processing a mangled package name,
+      // but this is a non-mangled resource.
+      continue;
     }
 
-    // Add the Styleable array to the Styleable class.
-    outStyleableClassDef->addMember(std::move(styleableArrayDef));
-
-    // Now we emit the indices into the array.
-    for (size_t i = 0; i < attrCount; i++) {
-        const StyleableAttr& styleableAttr = sortedAttributes[i];
-
-        if (!styleableAttr.symbol) {
-            continue;
-        }
-
-        if (mOptions.types == JavaClassGeneratorOptions::SymbolTypes::kPublic &&
-                !styleableAttr.symbol->isPublic) {
-            // Don't write entries for non-public attributes.
-            continue;
-        }
-
-        StringPiece comment = styleableAttr.attrRef->getComment();
-        if (styleableAttr.symbol->attribute && comment.empty()) {
-            comment = styleableAttr.symbol->attribute->getComment();
-        }
-
-        if (comment.contains("@removed")) {
-            // Removed attributes are public but hidden from the documentation, so don't emit them
-            // as part of the class documentation.
-            continue;
-        }
-
-        const ResourceName& attrName = styleableAttr.attrRef->name.value();
-
-        StringPiece packageName = attrName.package;
-        if (packageName.empty()) {
-            packageName = mContext->getCompilationPackage();
-        }
-
-        std::unique_ptr<IntMember> indexMember = util::make_unique<IntMember>(
-                sortedAttributes[i].fieldName, static_cast<uint32_t>(i));
-
-        AnnotationProcessor* attrProcessor = indexMember->getCommentBuilder();
-
-        if (!comment.empty()) {
-            attrProcessor->appendComment("<p>\n@attr description");
-            attrProcessor->appendComment(comment);
-        } else {
-            std::stringstream defaultComment;
-            defaultComment
-                    << "<p>This symbol is the offset where the "
-                    << "{@link " << packageName << ".R.attr#" << transform(attrName.entry) << "}\n"
-                    << "attribute's value can be found in the "
-                    << "{@link #" << className << "} array.";
-            attrProcessor->appendComment(defaultComment.str());
-        }
-
-        attrProcessor->appendNewLine();
-
-        addAttributeFormatDoc(attrProcessor, styleableAttr.symbol->attribute.get());
-        attrProcessor->appendNewLine();
-
-        std::stringstream doclavaName;
-        doclavaName << "@attr name " << packageName << ":" << attrName.entry;;
-        attrProcessor->appendComment(doclavaName.str());
-
-        outStyleableClassDef->addMember(std::move(indexMember));
+    if (!IsValidSymbol(unmangled_name)) {
+      ResourceNameRef resource_name(package_name_to_generate, type->type,
+                                    unmangled_name);
+      std::stringstream err;
+      err << "invalid symbol name '" << resource_name << "'";
+      error_ = err.str();
+      return false;
     }
+
+    if (type->type == ResourceType::kStyleable) {
+      CHECK(!entry->values.empty());
+
+      const Styleable* styleable =
+          static_cast<const Styleable*>(entry->values.front()->value.get());
+
+      // Comments are handled within this method.
+      AddMembersToStyleableClass(package_name_to_generate, unmangled_name,
+                                 styleable, out_type_class_def);
+    } else {
+      std::unique_ptr<ResourceMember> resource_member =
+          util::make_unique<ResourceMember>(Transform(unmangled_name), id);
+
+      // Build the comments and annotations for this entry.
+      AnnotationProcessor* processor = resource_member->GetCommentBuilder();
+
+      // Add the comments from any <public> tags.
+      if (entry->symbol_status.state != SymbolState::kUndefined) {
+        processor->AppendComment(entry->symbol_status.comment);
+      }
+
+      // Add the comments from all configurations of this entry.
+      for (const auto& config_value : entry->values) {
+        processor->AppendComment(config_value->value->GetComment());
+      }
+
+      // If this is an Attribute, append the format Javadoc.
+      if (!entry->values.empty()) {
+        if (Attribute* attr =
+                ValueCast<Attribute>(entry->values.front()->value.get())) {
+          // We list out the available values for the given attribute.
+          AddAttributeFormatDoc(processor, attr);
+        }
+      }
+
+      out_type_class_def->AddMember(std::move(resource_member));
+    }
+  }
+  return true;
 }
 
-bool JavaClassGenerator::addMembersToTypeClass(const StringPiece& packageNameToGenerate,
-                                               const ResourceTablePackage* package,
-                                               const ResourceTableType* type,
-                                               ClassDefinition* outTypeClassDef) {
-
-    for (const auto& entry : type->entries) {
-        if (skipSymbol(entry->symbolStatus.state)) {
-            continue;
-        }
-
-        ResourceId id;
-        if (package->id && type->id && entry->id) {
-            id = ResourceId(package->id.value(), type->id.value(), entry->id.value());
-        }
-
-        std::string unmangledPackage;
-        std::string unmangledName = entry->name;
-        if (NameMangler::unmangle(&unmangledName, &unmangledPackage)) {
-            // The entry name was mangled, and we successfully unmangled it.
-            // Check that we want to emit this symbol.
-            if (package->name != unmangledPackage) {
-                // Skip the entry if it doesn't belong to the package we're writing.
-                continue;
-            }
-        } else if (packageNameToGenerate != package->name) {
-            // We are processing a mangled package name,
-            // but this is a non-mangled resource.
-            continue;
-        }
-
-        if (!isValidSymbol(unmangledName)) {
-            ResourceNameRef resourceName(packageNameToGenerate, type->type, unmangledName);
-            std::stringstream err;
-            err << "invalid symbol name '" << resourceName << "'";
-            mError = err.str();
-            return false;
-        }
-
-        if (type->type == ResourceType::kStyleable) {
-            assert(!entry->values.empty());
-
-            const Styleable* styleable = static_cast<const Styleable*>(
-                    entry->values.front()->value.get());
-
-            // Comments are handled within this method.
-            addMembersToStyleableClass(packageNameToGenerate, unmangledName, styleable,
-                                       outTypeClassDef);
-        } else {
-            std::unique_ptr<ResourceMember> resourceMember =
-                    util::make_unique<ResourceMember>(transform(unmangledName), id);
-
-            // Build the comments and annotations for this entry.
-            AnnotationProcessor* processor = resourceMember->getCommentBuilder();
-
-            // Add the comments from any <public> tags.
-            if (entry->symbolStatus.state != SymbolState::kUndefined) {
-                processor->appendComment(entry->symbolStatus.comment);
-            }
-
-            // Add the comments from all configurations of this entry.
-            for (const auto& configValue : entry->values) {
-                processor->appendComment(configValue->value->getComment());
-            }
-
-            // If this is an Attribute, append the format Javadoc.
-            if (!entry->values.empty()) {
-                if (Attribute* attr = valueCast<Attribute>(entry->values.front()->value.get())) {
-                    // We list out the available values for the given attribute.
-                    addAttributeFormatDoc(processor, attr);
-                }
-            }
-
-            outTypeClassDef->addMember(std::move(resourceMember));
-        }
-    }
-    return true;
+bool JavaClassGenerator::Generate(const StringPiece& package_name_to_generate,
+                                  std::ostream* out) {
+  return Generate(package_name_to_generate, package_name_to_generate, out);
 }
 
-bool JavaClassGenerator::generate(const StringPiece& packageNameToGenerate, std::ostream* out) {
-    return generate(packageNameToGenerate, packageNameToGenerate, out);
+static void AppendJavaDocAnnotations(
+    const std::vector<std::string>& annotations,
+    AnnotationProcessor* processor) {
+  for (const std::string& annotation : annotations) {
+    std::string proper_annotation = "@";
+    proper_annotation += annotation;
+    processor->AppendComment(proper_annotation);
+  }
 }
 
-static void appendJavaDocAnnotations(const std::vector<std::string>& annotations,
-                                     AnnotationProcessor* processor) {
-    for (const std::string& annotation : annotations) {
-        std::string properAnnotation = "@";
-        properAnnotation += annotation;
-        processor->appendComment(properAnnotation);
-    }
-}
+bool JavaClassGenerator::Generate(const StringPiece& package_name_to_generate,
+                                  const StringPiece& out_package_name,
+                                  std::ostream* out) {
+  ClassDefinition r_class("R", ClassQualifier::None, true);
 
-bool JavaClassGenerator::generate(const StringPiece& packageNameToGenerate,
-                                  const StringPiece& outPackageName, std::ostream* out) {
+  for (const auto& package : table_->packages) {
+    for (const auto& type : package->types) {
+      if (type->type == ResourceType::kAttrPrivate) {
+        continue;
+      }
 
-    ClassDefinition rClass("R", ClassQualifier::None, true);
+      const bool force_creation_if_empty =
+          (options_.types == JavaClassGeneratorOptions::SymbolTypes::kPublic);
 
-    for (const auto& package : mTable->packages) {
-        for (const auto& type : package->types) {
-            if (type->type == ResourceType::kAttrPrivate) {
-                continue;
-            }
+      std::unique_ptr<ClassDefinition> class_def =
+          util::make_unique<ClassDefinition>(ToString(type->type),
+                                             ClassQualifier::Static,
+                                             force_creation_if_empty);
 
-            const bool forceCreationIfEmpty =
-                    (mOptions.types == JavaClassGeneratorOptions::SymbolTypes::kPublic);
-
-            std::unique_ptr<ClassDefinition> classDef = util::make_unique<ClassDefinition>(
-                    toString(type->type), ClassQualifier::Static, forceCreationIfEmpty);
-
-            bool result = addMembersToTypeClass(packageNameToGenerate, package.get(), type.get(),
-                                                classDef.get());
-            if (!result) {
-                return false;
-            }
-
-            if (type->type == ResourceType::kAttr) {
-                // Also include private attributes in this same class.
-                ResourceTableType* privType = package->findType(ResourceType::kAttrPrivate);
-                if (privType) {
-                    result = addMembersToTypeClass(packageNameToGenerate, package.get(), privType,
-                                                   classDef.get());
-                    if (!result) {
-                        return false;
-                    }
-                }
-            }
-
-            if (type->type == ResourceType::kStyleable &&
-                    mOptions.types == JavaClassGeneratorOptions::SymbolTypes::kPublic) {
-                // When generating a public R class, we don't want Styleable to be part of the API.
-                // It is only emitted for documentation purposes.
-                classDef->getCommentBuilder()->appendComment("@doconly");
-            }
-
-            appendJavaDocAnnotations(mOptions.javadocAnnotations, classDef->getCommentBuilder());
-
-            rClass.addMember(std::move(classDef));
-        }
-    }
-
-    appendJavaDocAnnotations(mOptions.javadocAnnotations, rClass.getCommentBuilder());
-
-    if (!ClassDefinition::writeJavaFile(&rClass, outPackageName, mOptions.useFinal, out)) {
+      bool result = AddMembersToTypeClass(
+          package_name_to_generate, package.get(), type.get(), class_def.get());
+      if (!result) {
         return false;
-    }
+      }
 
-    out->flush();
-    return true;
+      if (type->type == ResourceType::kAttr) {
+        // Also include private attributes in this same class.
+        ResourceTableType* priv_type =
+            package->FindType(ResourceType::kAttrPrivate);
+        if (priv_type) {
+          result =
+              AddMembersToTypeClass(package_name_to_generate, package.get(),
+                                    priv_type, class_def.get());
+          if (!result) {
+            return false;
+          }
+        }
+      }
+
+      if (type->type == ResourceType::kStyleable &&
+          options_.types == JavaClassGeneratorOptions::SymbolTypes::kPublic) {
+        // When generating a public R class, we don't want Styleable to be part
+        // of the API.
+        // It is only emitted for documentation purposes.
+        class_def->GetCommentBuilder()->AppendComment("@doconly");
+      }
+
+      AppendJavaDocAnnotations(options_.javadoc_annotations,
+                               class_def->GetCommentBuilder());
+
+      r_class.AddMember(std::move(class_def));
+    }
+  }
+
+  AppendJavaDocAnnotations(options_.javadoc_annotations,
+                           r_class.GetCommentBuilder());
+
+  if (!ClassDefinition::WriteJavaFile(&r_class, out_package_name,
+                                      options_.use_final, out)) {
+    return false;
+  }
+
+  out->flush();
+  return true;
 }
 
-} // namespace aapt
+}  // namespace aapt
diff --git a/tools/aapt2/java/JavaClassGenerator.h b/tools/aapt2/java/JavaClassGenerator.h
index 2fdf2682a162b..190e73b66b9e3 100644
--- a/tools/aapt2/java/JavaClassGenerator.h
+++ b/tools/aapt2/java/JavaClassGenerator.h
@@ -17,14 +17,14 @@
 #ifndef AAPT_JAVA_CLASS_GENERATOR_H
 #define AAPT_JAVA_CLASS_GENERATOR_H
 
+#include <ostream>
+#include <string>
+
 #include "ResourceTable.h"
 #include "ResourceValues.h"
 #include "process/IResourceTableConsumer.h"
 #include "util/StringPiece.h"
 
-#include <ostream>
-#include <string>
-
 namespace aapt {
 
 class AnnotationProcessor;
@@ -35,7 +35,7 @@ struct JavaClassGeneratorOptions {
    * Specifies whether to use the 'final' modifier
    * on resource entries. Default is true.
    */
-  bool useFinal = true;
+  bool use_final = true;
 
   enum class SymbolTypes {
     kAll,
@@ -49,7 +49,7 @@ struct JavaClassGeneratorOptions {
    * A list of JavaDoc annotations to add to the comments of all generated
    * classes.
    */
-  std::vector<std::string> javadocAnnotations;
+  std::vector<std::string> javadoc_annotations;
 };
 
 /*
@@ -69,34 +69,34 @@ class JavaClassGenerator {
    * We need to generate these symbols in a separate file.
    * Returns true on success.
    */
-  bool generate(const StringPiece& packageNameToGenerate, std::ostream* out);
+  bool Generate(const StringPiece& packageNameToGenerate, std::ostream* out);
 
-  bool generate(const StringPiece& packageNameToGenerate,
+  bool Generate(const StringPiece& packageNameToGenerate,
                 const StringPiece& outputPackageName, std::ostream* out);
 
   const std::string& getError() const;
 
  private:
-  bool addMembersToTypeClass(const StringPiece& packageNameToGenerate,
+  bool AddMembersToTypeClass(const StringPiece& packageNameToGenerate,
                              const ResourceTablePackage* package,
                              const ResourceTableType* type,
                              ClassDefinition* outTypeClassDef);
 
-  void addMembersToStyleableClass(const StringPiece& packageNameToGenerate,
+  void AddMembersToStyleableClass(const StringPiece& packageNameToGenerate,
                                   const std::string& entryName,
                                   const Styleable* styleable,
                                   ClassDefinition* outStyleableClassDef);
 
-  bool skipSymbol(SymbolState state);
+  bool SkipSymbol(SymbolState state);
 
-  IAaptContext* mContext;
-  ResourceTable* mTable;
-  JavaClassGeneratorOptions mOptions;
-  std::string mError;
+  IAaptContext* context_;
+  ResourceTable* table_;
+  JavaClassGeneratorOptions options_;
+  std::string error_;
 };
 
 inline const std::string& JavaClassGenerator::getError() const {
-  return mError;
+  return error_;
 }
 
 }  // namespace aapt
diff --git a/tools/aapt2/java/JavaClassGenerator_test.cpp b/tools/aapt2/java/JavaClassGenerator_test.cpp
index ed7c6bd238b07..3d3d24e6aab51 100644
--- a/tools/aapt2/java/JavaClassGenerator_test.cpp
+++ b/tools/aapt2/java/JavaClassGenerator_test.cpp
@@ -15,154 +15,181 @@
  */
 
 #include "java/JavaClassGenerator.h"
-#include "test/Test.h"
-#include "util/Util.h"
 
 #include <sstream>
 #include <string>
 
+#include "test/Test.h"
+#include "util/Util.h"
+
 namespace aapt {
 
 TEST(JavaClassGeneratorTest, FailWhenEntryIsJavaKeyword) {
-    std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
-            .setPackageId("android", 0x01)
-            .addSimple("android:id/class", ResourceId(0x01020000))
-            .build();
+  std::unique_ptr<ResourceTable> table =
+      test::ResourceTableBuilder()
+          .SetPackageId("android", 0x01)
+          .AddSimple("android:id/class", ResourceId(0x01020000))
+          .Build();
 
-    std::unique_ptr<IAaptContext> context = test::ContextBuilder()
-            .addSymbolSource(util::make_unique<ResourceTableSymbolSource>(table.get()))
-            .setNameManglerPolicy(NameManglerPolicy{ "android" })
-            .build();
-    JavaClassGenerator generator(context.get(), table.get(), {});
+  std::unique_ptr<IAaptContext> context =
+      test::ContextBuilder()
+          .AddSymbolSource(
+              util::make_unique<ResourceTableSymbolSource>(table.get()))
+          .SetNameManglerPolicy(NameManglerPolicy{"android"})
+          .Build();
+  JavaClassGenerator generator(context.get(), table.get(), {});
 
-    std::stringstream out;
-    EXPECT_FALSE(generator.generate("android", &out));
+  std::stringstream out;
+  EXPECT_FALSE(generator.Generate("android", &out));
 }
 
 TEST(JavaClassGeneratorTest, TransformInvalidJavaIdentifierCharacter) {
-    std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
-            .setPackageId("android", 0x01)
-            .addSimple("android:id/hey-man", ResourceId(0x01020000))
-            .addValue("android:attr/cool.attr", ResourceId(0x01010000),
-                      test::AttributeBuilder(false).build())
-            .addValue("android:styleable/hey.dude", ResourceId(0x01030000),
-                      test::StyleableBuilder()
-                              .addItem("android:attr/cool.attr", ResourceId(0x01010000))
-                              .build())
-            .build();
+  std::unique_ptr<ResourceTable> table =
+      test::ResourceTableBuilder()
+          .SetPackageId("android", 0x01)
+          .AddSimple("android:id/hey-man", ResourceId(0x01020000))
+          .AddValue("android:attr/cool.attr", ResourceId(0x01010000),
+                    test::AttributeBuilder(false).Build())
+          .AddValue(
+              "android:styleable/hey.dude", ResourceId(0x01030000),
+              test::StyleableBuilder()
+                  .AddItem("android:attr/cool.attr", ResourceId(0x01010000))
+                  .Build())
+          .Build();
 
-    std::unique_ptr<IAaptContext> context = test::ContextBuilder()
-            .addSymbolSource(util::make_unique<ResourceTableSymbolSource>(table.get()))
-            .setNameManglerPolicy(NameManglerPolicy{ "android" })
-            .build();
-    JavaClassGenerator generator(context.get(), table.get(), {});
+  std::unique_ptr<IAaptContext> context =
+      test::ContextBuilder()
+          .AddSymbolSource(
+              util::make_unique<ResourceTableSymbolSource>(table.get()))
+          .SetNameManglerPolicy(NameManglerPolicy{"android"})
+          .Build();
+  JavaClassGenerator generator(context.get(), table.get(), {});
 
-    std::stringstream out;
-    EXPECT_TRUE(generator.generate("android", &out));
+  std::stringstream out;
+  EXPECT_TRUE(generator.Generate("android", &out));
 
-    std::string output = out.str();
+  std::string output = out.str();
 
-    EXPECT_NE(std::string::npos,
-              output.find("public static final int hey_man=0x01020000;"));
+  EXPECT_NE(std::string::npos,
+            output.find("public static final int hey_man=0x01020000;"));
 
-    EXPECT_NE(std::string::npos,
-              output.find("public static final int[] hey_dude={"));
+  EXPECT_NE(std::string::npos,
+            output.find("public static final int[] hey_dude={"));
 
-    EXPECT_NE(std::string::npos,
-              output.find("public static final int hey_dude_cool_attr=0;"));
+  EXPECT_NE(std::string::npos,
+            output.find("public static final int hey_dude_cool_attr=0;"));
 }
 
 TEST(JavaClassGeneratorTest, CorrectPackageNameIsUsed) {
-    std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
-            .setPackageId("android", 0x01)
-            .addSimple("android:id/one", ResourceId(0x01020000))
-            .addSimple("android:id/com.foo$two", ResourceId(0x01020001))
-            .build();
+  std::unique_ptr<ResourceTable> table =
+      test::ResourceTableBuilder()
+          .SetPackageId("android", 0x01)
+          .AddSimple("android:id/one", ResourceId(0x01020000))
+          .AddSimple("android:id/com.foo$two", ResourceId(0x01020001))
+          .Build();
 
-    std::unique_ptr<IAaptContext> context = test::ContextBuilder()
-            .addSymbolSource(util::make_unique<ResourceTableSymbolSource>(table.get()))
-            .setNameManglerPolicy(NameManglerPolicy{ "android" })
-            .build();
-    JavaClassGenerator generator(context.get(), table.get(), {});
-    std::stringstream out;
-    ASSERT_TRUE(generator.generate("android", "com.android.internal", &out));
+  std::unique_ptr<IAaptContext> context =
+      test::ContextBuilder()
+          .AddSymbolSource(
+              util::make_unique<ResourceTableSymbolSource>(table.get()))
+          .SetNameManglerPolicy(NameManglerPolicy{"android"})
+          .Build();
+  JavaClassGenerator generator(context.get(), table.get(), {});
+  std::stringstream out;
+  ASSERT_TRUE(generator.Generate("android", "com.android.internal", &out));
 
-    std::string output = out.str();
-    EXPECT_NE(std::string::npos, output.find("package com.android.internal;"));
-    EXPECT_NE(std::string::npos, output.find("public static final int one=0x01020000;"));
-    EXPECT_EQ(std::string::npos, output.find("two"));
-    EXPECT_EQ(std::string::npos, output.find("com_foo$two"));
+  std::string output = out.str();
+  EXPECT_NE(std::string::npos, output.find("package com.android.internal;"));
+  EXPECT_NE(std::string::npos,
+            output.find("public static final int one=0x01020000;"));
+  EXPECT_EQ(std::string::npos, output.find("two"));
+  EXPECT_EQ(std::string::npos, output.find("com_foo$two"));
 }
 
 TEST(JavaClassGeneratorTest, AttrPrivateIsWrittenAsAttr) {
-    std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
-            .setPackageId("android", 0x01)
-            .addSimple("android:attr/two", ResourceId(0x01010001))
-            .addSimple("android:^attr-private/one", ResourceId(0x01010000))
-            .build();
+  std::unique_ptr<ResourceTable> table =
+      test::ResourceTableBuilder()
+          .SetPackageId("android", 0x01)
+          .AddSimple("android:attr/two", ResourceId(0x01010001))
+          .AddSimple("android:^attr-private/one", ResourceId(0x01010000))
+          .Build();
 
-    std::unique_ptr<IAaptContext> context = test::ContextBuilder()
-            .addSymbolSource(util::make_unique<ResourceTableSymbolSource>(table.get()))
-            .setNameManglerPolicy(NameManglerPolicy{ "android" })
-            .build();
-    JavaClassGenerator generator(context.get(), table.get(), {});
-    std::stringstream out;
-    ASSERT_TRUE(generator.generate("android", &out));
+  std::unique_ptr<IAaptContext> context =
+      test::ContextBuilder()
+          .AddSymbolSource(
+              util::make_unique<ResourceTableSymbolSource>(table.get()))
+          .SetNameManglerPolicy(NameManglerPolicy{"android"})
+          .Build();
+  JavaClassGenerator generator(context.get(), table.get(), {});
+  std::stringstream out;
+  ASSERT_TRUE(generator.Generate("android", &out));
 
-    std::string output = out.str();
-    EXPECT_NE(std::string::npos, output.find("public static final class attr"));
-    EXPECT_EQ(std::string::npos, output.find("public static final class ^attr-private"));
+  std::string output = out.str();
+  EXPECT_NE(std::string::npos, output.find("public static final class attr"));
+  EXPECT_EQ(std::string::npos,
+            output.find("public static final class ^attr-private"));
 }
 
 TEST(JavaClassGeneratorTest, OnlyWritePublicResources) {
-    StdErrDiagnostics diag;
-    std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
-            .setPackageId("android", 0x01)
-            .addSimple("android:id/one", ResourceId(0x01020000))
-            .addSimple("android:id/two", ResourceId(0x01020001))
-            .addSimple("android:id/three", ResourceId(0x01020002))
-            .setSymbolState("android:id/one", ResourceId(0x01020000), SymbolState::kPublic)
-            .setSymbolState("android:id/two", ResourceId(0x01020001), SymbolState::kPrivate)
-            .build();
+  StdErrDiagnostics diag;
+  std::unique_ptr<ResourceTable> table =
+      test::ResourceTableBuilder()
+          .SetPackageId("android", 0x01)
+          .AddSimple("android:id/one", ResourceId(0x01020000))
+          .AddSimple("android:id/two", ResourceId(0x01020001))
+          .AddSimple("android:id/three", ResourceId(0x01020002))
+          .SetSymbolState("android:id/one", ResourceId(0x01020000),
+                          SymbolState::kPublic)
+          .SetSymbolState("android:id/two", ResourceId(0x01020001),
+                          SymbolState::kPrivate)
+          .Build();
 
-    std::unique_ptr<IAaptContext> context = test::ContextBuilder()
-            .addSymbolSource(util::make_unique<ResourceTableSymbolSource>(table.get()))
-            .setNameManglerPolicy(NameManglerPolicy{ "android" })
-            .build();
+  std::unique_ptr<IAaptContext> context =
+      test::ContextBuilder()
+          .AddSymbolSource(
+              util::make_unique<ResourceTableSymbolSource>(table.get()))
+          .SetNameManglerPolicy(NameManglerPolicy{"android"})
+          .Build();
 
-    JavaClassGeneratorOptions options;
-    options.types = JavaClassGeneratorOptions::SymbolTypes::kPublic;
-    {
-        JavaClassGenerator generator(context.get(), table.get(), options);
-        std::stringstream out;
-        ASSERT_TRUE(generator.generate("android", &out));
-        std::string output = out.str();
-        EXPECT_NE(std::string::npos, output.find("public static final int one=0x01020000;"));
-        EXPECT_EQ(std::string::npos, output.find("two"));
-        EXPECT_EQ(std::string::npos, output.find("three"));
-    }
+  JavaClassGeneratorOptions options;
+  options.types = JavaClassGeneratorOptions::SymbolTypes::kPublic;
+  {
+    JavaClassGenerator generator(context.get(), table.get(), options);
+    std::stringstream out;
+    ASSERT_TRUE(generator.Generate("android", &out));
+    std::string output = out.str();
+    EXPECT_NE(std::string::npos,
+              output.find("public static final int one=0x01020000;"));
+    EXPECT_EQ(std::string::npos, output.find("two"));
+    EXPECT_EQ(std::string::npos, output.find("three"));
+  }
 
-    options.types = JavaClassGeneratorOptions::SymbolTypes::kPublicPrivate;
-    {
-        JavaClassGenerator generator(context.get(), table.get(), options);
-        std::stringstream out;
-        ASSERT_TRUE(generator.generate("android", &out));
-        std::string output = out.str();
-        EXPECT_NE(std::string::npos, output.find("public static final int one=0x01020000;"));
-        EXPECT_NE(std::string::npos, output.find("public static final int two=0x01020001;"));
-        EXPECT_EQ(std::string::npos, output.find("three"));
-    }
+  options.types = JavaClassGeneratorOptions::SymbolTypes::kPublicPrivate;
+  {
+    JavaClassGenerator generator(context.get(), table.get(), options);
+    std::stringstream out;
+    ASSERT_TRUE(generator.Generate("android", &out));
+    std::string output = out.str();
+    EXPECT_NE(std::string::npos,
+              output.find("public static final int one=0x01020000;"));
+    EXPECT_NE(std::string::npos,
+              output.find("public static final int two=0x01020001;"));
+    EXPECT_EQ(std::string::npos, output.find("three"));
+  }
 
-    options.types = JavaClassGeneratorOptions::SymbolTypes::kAll;
-    {
-        JavaClassGenerator generator(context.get(), table.get(), options);
-        std::stringstream out;
-        ASSERT_TRUE(generator.generate("android", &out));
-        std::string output = out.str();
-        EXPECT_NE(std::string::npos, output.find("public static final int one=0x01020000;"));
-        EXPECT_NE(std::string::npos, output.find("public static final int two=0x01020001;"));
-        EXPECT_NE(std::string::npos, output.find("public static final int three=0x01020002;"));
-    }
+  options.types = JavaClassGeneratorOptions::SymbolTypes::kAll;
+  {
+    JavaClassGenerator generator(context.get(), table.get(), options);
+    std::stringstream out;
+    ASSERT_TRUE(generator.Generate("android", &out));
+    std::string output = out.str();
+    EXPECT_NE(std::string::npos,
+              output.find("public static final int one=0x01020000;"));
+    EXPECT_NE(std::string::npos,
+              output.find("public static final int two=0x01020001;"));
+    EXPECT_NE(std::string::npos,
+              output.find("public static final int three=0x01020002;"));
+  }
 }
 
 /*
@@ -172,12 +199,15 @@ TEST(JavaClassGeneratorTest, OnlyWritePublicResources) {
                             ResourceId{ 0x01, 0x02, 0x0000 }));
     ResourceTable table;
     table.setPackage(u"com.lib");
-    ASSERT_TRUE(table.addResource(ResourceName{ {}, ResourceType::kId, u"test" }, {},
-                                  Source{ "lib.xml", 33 }, util::make_unique<Id>()));
+    ASSERT_TRUE(table.addResource(ResourceName{ {}, ResourceType::kId, u"test"
+}, {},
+                                  Source{ "lib.xml", 33 },
+util::make_unique<Id>()));
     ASSERT_TRUE(mTable->merge(std::move(table)));
 
     Linker linker(mTable,
-                  std::make_shared<MockResolver>(mTable, std::map<ResourceName, ResourceId>()),
+                  std::make_shared<MockResolver>(mTable, std::map<ResourceName,
+ResourceId>()),
                   {});
     ASSERT_TRUE(linker.linkAndValidate());
 
@@ -197,126 +227,139 @@ TEST(JavaClassGeneratorTest, OnlyWritePublicResources) {
 }*/
 
 TEST(JavaClassGeneratorTest, EmitOtherPackagesAttributesInStyleable) {
-    std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
-                .setPackageId("android", 0x01)
-                .setPackageId("com.lib", 0x02)
-                .addValue("android:attr/bar", ResourceId(0x01010000),
-                          test::AttributeBuilder(false).build())
-                .addValue("com.lib:attr/bar", ResourceId(0x02010000),
-                           test::AttributeBuilder(false).build())
-                .addValue("android:styleable/foo", ResourceId(0x01030000),
-                          test::StyleableBuilder()
-                                  .addItem("android:attr/bar", ResourceId(0x01010000))
-                                  .addItem("com.lib:attr/bar", ResourceId(0x02010000))
-                                  .build())
-                .build();
+  std::unique_ptr<ResourceTable> table =
+      test::ResourceTableBuilder()
+          .SetPackageId("android", 0x01)
+          .SetPackageId("com.lib", 0x02)
+          .AddValue("android:attr/bar", ResourceId(0x01010000),
+                    test::AttributeBuilder(false).Build())
+          .AddValue("com.lib:attr/bar", ResourceId(0x02010000),
+                    test::AttributeBuilder(false).Build())
+          .AddValue("android:styleable/foo", ResourceId(0x01030000),
+                    test::StyleableBuilder()
+                        .AddItem("android:attr/bar", ResourceId(0x01010000))
+                        .AddItem("com.lib:attr/bar", ResourceId(0x02010000))
+                        .Build())
+          .Build();
 
-    std::unique_ptr<IAaptContext> context = test::ContextBuilder()
-            .addSymbolSource(util::make_unique<ResourceTableSymbolSource>(table.get()))
-            .setNameManglerPolicy(NameManglerPolicy{ "android" })
-            .build();
-    JavaClassGenerator generator(context.get(), table.get(), {});
+  std::unique_ptr<IAaptContext> context =
+      test::ContextBuilder()
+          .AddSymbolSource(
+              util::make_unique<ResourceTableSymbolSource>(table.get()))
+          .SetNameManglerPolicy(NameManglerPolicy{"android"})
+          .Build();
+  JavaClassGenerator generator(context.get(), table.get(), {});
 
-    std::stringstream out;
-    EXPECT_TRUE(generator.generate("android", &out));
+  std::stringstream out;
+  EXPECT_TRUE(generator.Generate("android", &out));
 
-    std::string output = out.str();
-    EXPECT_NE(std::string::npos, output.find("int foo_bar="));
-    EXPECT_NE(std::string::npos, output.find("int foo_com_lib_bar="));
+  std::string output = out.str();
+  EXPECT_NE(std::string::npos, output.find("int foo_bar="));
+  EXPECT_NE(std::string::npos, output.find("int foo_com_lib_bar="));
 }
 
 TEST(JavaClassGeneratorTest, CommentsForSimpleResourcesArePresent) {
-    std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
-            .setPackageId("android", 0x01)
-            .addSimple("android:id/foo", ResourceId(0x01010000))
-            .build();
-    test::getValue<Id>(table.get(), "android:id/foo")
-            ->setComment(std::string("This is a comment\n@deprecated"));
+  std::unique_ptr<ResourceTable> table =
+      test::ResourceTableBuilder()
+          .SetPackageId("android", 0x01)
+          .AddSimple("android:id/foo", ResourceId(0x01010000))
+          .Build();
+  test::GetValue<Id>(table.get(), "android:id/foo")
+      ->SetComment(std::string("This is a comment\n@deprecated"));
 
-    std::unique_ptr<IAaptContext> context = test::ContextBuilder()
-            .addSymbolSource(util::make_unique<ResourceTableSymbolSource>(table.get()))
-            .setNameManglerPolicy(NameManglerPolicy{ "android" })
-            .build();
-    JavaClassGenerator generator(context.get(), table.get(), {});
-    std::stringstream out;
-    ASSERT_TRUE(generator.generate("android", &out));
-    std::string actual = out.str();
+  std::unique_ptr<IAaptContext> context =
+      test::ContextBuilder()
+          .AddSymbolSource(
+              util::make_unique<ResourceTableSymbolSource>(table.get()))
+          .SetNameManglerPolicy(NameManglerPolicy{"android"})
+          .Build();
+  JavaClassGenerator generator(context.get(), table.get(), {});
+  std::stringstream out;
+  ASSERT_TRUE(generator.Generate("android", &out));
+  std::string actual = out.str();
 
-    const char* expectedText =
-R"EOF(/**
+  const char* expectedText =
+      R"EOF(/**
      * This is a comment
      * @deprecated
      */
     @Deprecated
     public static final int foo=0x01010000;)EOF";
 
-    EXPECT_NE(std::string::npos, actual.find(expectedText));
+  EXPECT_NE(std::string::npos, actual.find(expectedText));
 }
 
-TEST(JavaClassGeneratorTest, CommentsForEnumAndFlagAttributesArePresent) {
+TEST(JavaClassGeneratorTest, CommentsForEnumAndFlagAttributesArePresent) {}
 
-}
+TEST(JavaClassGeneratorTest,
+     CommentsForStyleablesAndNestedAttributesArePresent) {
+  Attribute attr(false);
+  attr.SetComment(StringPiece("This is an attribute"));
 
-TEST(JavaClassGeneratorTest, CommentsForStyleablesAndNestedAttributesArePresent) {
-    Attribute attr(false);
-    attr.setComment(StringPiece("This is an attribute"));
+  Styleable styleable;
+  styleable.entries.push_back(
+      Reference(test::ParseNameOrDie("android:attr/one")));
+  styleable.SetComment(StringPiece("This is a styleable"));
 
-    Styleable styleable;
-    styleable.entries.push_back(Reference(test::parseNameOrDie("android:attr/one")));
-    styleable.setComment(StringPiece("This is a styleable"));
+  std::unique_ptr<ResourceTable> table =
+      test::ResourceTableBuilder()
+          .SetPackageId("android", 0x01)
+          .AddValue("android:attr/one", util::make_unique<Attribute>(attr))
+          .AddValue("android:styleable/Container",
+                    std::unique_ptr<Styleable>(styleable.Clone(nullptr)))
+          .Build();
 
-    std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
-            .setPackageId("android", 0x01)
-            .addValue("android:attr/one", util::make_unique<Attribute>(attr))
-            .addValue("android:styleable/Container",
-                      std::unique_ptr<Styleable>(styleable.clone(nullptr)))
-            .build();
+  std::unique_ptr<IAaptContext> context =
+      test::ContextBuilder()
+          .AddSymbolSource(
+              util::make_unique<ResourceTableSymbolSource>(table.get()))
+          .SetNameManglerPolicy(NameManglerPolicy{"android"})
+          .Build();
+  JavaClassGeneratorOptions options;
+  options.use_final = false;
+  JavaClassGenerator generator(context.get(), table.get(), options);
+  std::stringstream out;
+  ASSERT_TRUE(generator.Generate("android", &out));
+  std::string actual = out.str();
 
-    std::unique_ptr<IAaptContext> context = test::ContextBuilder()
-            .addSymbolSource(util::make_unique<ResourceTableSymbolSource>(table.get()))
-            .setNameManglerPolicy(NameManglerPolicy{ "android" })
-            .build();
-    JavaClassGeneratorOptions options;
-    options.useFinal = false;
-    JavaClassGenerator generator(context.get(), table.get(), options);
-    std::stringstream out;
-    ASSERT_TRUE(generator.generate("android", &out));
-    std::string actual = out.str();
-
-    EXPECT_NE(std::string::npos, actual.find("attr name android:one"));
-    EXPECT_NE(std::string::npos, actual.find("attr description"));
-    EXPECT_NE(std::string::npos, actual.find(attr.getComment().data()));
-    EXPECT_NE(std::string::npos, actual.find(styleable.getComment().data()));
+  EXPECT_NE(std::string::npos, actual.find("attr name android:one"));
+  EXPECT_NE(std::string::npos, actual.find("attr description"));
+  EXPECT_NE(std::string::npos, actual.find(attr.GetComment().data()));
+  EXPECT_NE(std::string::npos, actual.find(styleable.GetComment().data()));
 }
 
 TEST(JavaClassGeneratorTest, CommentsForRemovedAttributesAreNotPresentInClass) {
-    Attribute attr(false);
-    attr.setComment(StringPiece("removed"));
+  Attribute attr(false);
+  attr.SetComment(StringPiece("removed"));
 
-    std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
-            .setPackageId("android", 0x01)
-            .addValue("android:attr/one", util::make_unique<Attribute>(attr))
-            .build();
+  std::unique_ptr<ResourceTable> table =
+      test::ResourceTableBuilder()
+          .SetPackageId("android", 0x01)
+          .AddValue("android:attr/one", util::make_unique<Attribute>(attr))
+          .Build();
 
-    std::unique_ptr<IAaptContext> context = test::ContextBuilder()
-            .addSymbolSource(util::make_unique<ResourceTableSymbolSource>(table.get()))
-            .setNameManglerPolicy(NameManglerPolicy{ "android" })
-            .build();
-    JavaClassGeneratorOptions options;
-    options.useFinal = false;
-    JavaClassGenerator generator(context.get(), table.get(), options);
-    std::stringstream out;
-    ASSERT_TRUE(generator.generate("android", &out));
-    std::string actual = out.str();
+  std::unique_ptr<IAaptContext> context =
+      test::ContextBuilder()
+          .AddSymbolSource(
+              util::make_unique<ResourceTableSymbolSource>(table.get()))
+          .SetNameManglerPolicy(NameManglerPolicy{"android"})
+          .Build();
+  JavaClassGeneratorOptions options;
+  options.use_final = false;
+  JavaClassGenerator generator(context.get(), table.get(), options);
+  std::stringstream out;
+  ASSERT_TRUE(generator.Generate("android", &out));
+  std::string actual = out.str();
 
-    EXPECT_EQ(std::string::npos, actual.find("@attr name android:one"));
-    EXPECT_EQ(std::string::npos, actual.find("@attr description"));
+  EXPECT_EQ(std::string::npos, actual.find("@attr name android:one"));
+  EXPECT_EQ(std::string::npos, actual.find("@attr description"));
 
-    // We should find @removed only in the attribute javadoc and not anywhere else (i.e. the class
-    // javadoc).
-    const size_t pos = actual.find("removed");
-    EXPECT_NE(std::string::npos, pos);
-    EXPECT_EQ(std::string::npos, actual.find("removed", pos + 1));
+  // We should find @removed only in the attribute javadoc and not anywhere else
+  // (i.e. the class
+  // javadoc).
+  const size_t pos = actual.find("removed");
+  EXPECT_NE(std::string::npos, pos);
+  EXPECT_EQ(std::string::npos, actual.find("removed", pos + 1));
 }
 
-} // namespace aapt
+}  // namespace aapt
diff --git a/tools/aapt2/java/ManifestClassGenerator.cpp b/tools/aapt2/java/ManifestClassGenerator.cpp
index 5ff11b1303d32..db84f295db2a3 100644
--- a/tools/aapt2/java/ManifestClassGenerator.cpp
+++ b/tools/aapt2/java/ManifestClassGenerator.cpp
@@ -14,111 +14,120 @@
  * limitations under the License.
  */
 
-#include "Source.h"
-#include "java/AnnotationProcessor.h"
-#include "java/ClassDefinition.h"
 #include "java/ManifestClassGenerator.h"
-#include "util/Maybe.h"
-#include "xml/XmlDom.h"
 
 #include <algorithm>
 
+#include "Source.h"
+#include "java/AnnotationProcessor.h"
+#include "java/ClassDefinition.h"
+#include "util/Maybe.h"
+#include "xml/XmlDom.h"
+
 namespace aapt {
 
-static Maybe<StringPiece> extractJavaIdentifier(IDiagnostics* diag, const Source& source,
+static Maybe<StringPiece> ExtractJavaIdentifier(IDiagnostics* diag,
+                                                const Source& source,
                                                 const StringPiece& value) {
-    const StringPiece sep = ".";
-    auto iter = std::find_end(value.begin(), value.end(), sep.begin(), sep.end());
+  const StringPiece sep = ".";
+  auto iter = std::find_end(value.begin(), value.end(), sep.begin(), sep.end());
 
-    StringPiece result;
-    if (iter != value.end()) {
-        result.assign(iter + sep.size(), value.end() - (iter + sep.size()));
-    } else {
-        result = value;
-    }
+  StringPiece result;
+  if (iter != value.end()) {
+    result.assign(iter + sep.size(), value.end() - (iter + sep.size()));
+  } else {
+    result = value;
+  }
 
-    if (result.empty()) {
-        diag->error(DiagMessage(source) << "empty symbol");
-        return {};
-    }
+  if (result.empty()) {
+    diag->Error(DiagMessage(source) << "empty symbol");
+    return {};
+  }
 
-    iter = util::findNonAlphaNumericAndNotInSet(result, "_");
-    if (iter != result.end()) {
-        diag->error(DiagMessage(source)
-                    << "invalid character '" << StringPiece(iter, 1)
-                    << "' in '" << result << "'");
-        return {};
-    }
+  iter = util::FindNonAlphaNumericAndNotInSet(result, "_");
+  if (iter != result.end()) {
+    diag->Error(DiagMessage(source) << "invalid character '"
+                                    << StringPiece(iter, 1) << "' in '"
+                                    << result << "'");
+    return {};
+  }
 
-    if (*result.begin() >= '0' && *result.begin() <= '9') {
-        diag->error(DiagMessage(source) << "symbol can not start with a digit");
-        return {};
-    }
+  if (*result.begin() >= '0' && *result.begin() <= '9') {
+    diag->Error(DiagMessage(source) << "symbol can not start with a digit");
+    return {};
+  }
 
-    return result;
+  return result;
 }
 
-static bool writeSymbol(const Source& source, IDiagnostics* diag, xml::Element* el,
-                        ClassDefinition* classDef) {
-    xml::Attribute* attr = el->findAttribute(xml::kSchemaAndroid, "name");
-    if (!attr) {
-        diag->error(DiagMessage(source) << "<" << el->name << "> must define 'android:name'");
-        return false;
-    }
+static bool WriteSymbol(const Source& source, IDiagnostics* diag,
+                        xml::Element* el, ClassDefinition* class_def) {
+  xml::Attribute* attr = el->FindAttribute(xml::kSchemaAndroid, "name");
+  if (!attr) {
+    diag->Error(DiagMessage(source) << "<" << el->name
+                                    << "> must define 'android:name'");
+    return false;
+  }
 
-    Maybe<StringPiece> result = extractJavaIdentifier(diag, source.withLine(el->lineNumber),
-                                                      attr->value);
-    if (!result) {
-        return false;
-    }
+  Maybe<StringPiece> result = ExtractJavaIdentifier(
+      diag, source.WithLine(el->line_number), attr->value);
+  if (!result) {
+    return false;
+  }
 
-    std::unique_ptr<StringMember> stringMember = util::make_unique<StringMember>(
-            result.value(), attr->value);
-    stringMember->getCommentBuilder()->appendComment(el->comment);
+  std::unique_ptr<StringMember> string_member =
+      util::make_unique<StringMember>(result.value(), attr->value);
+  string_member->GetCommentBuilder()->AppendComment(el->comment);
 
-    classDef->addMember(std::move(stringMember));
-    return true;
+  class_def->AddMember(std::move(string_member));
+  return true;
 }
 
-std::unique_ptr<ClassDefinition> generateManifestClass(IDiagnostics* diag, xml::XmlResource* res) {
-    xml::Element* el = xml::findRootElement(res->root.get());
-    if (!el) {
-        diag->error(DiagMessage(res->file.source) << "no root tag defined");
-        return {};
+std::unique_ptr<ClassDefinition> GenerateManifestClass(IDiagnostics* diag,
+                                                       xml::XmlResource* res) {
+  xml::Element* el = xml::FindRootElement(res->root.get());
+  if (!el) {
+    diag->Error(DiagMessage(res->file.source) << "no root tag defined");
+    return {};
+  }
+
+  if (el->name != "manifest" && !el->namespace_uri.empty()) {
+    diag->Error(DiagMessage(res->file.source)
+                << "no <manifest> root tag defined");
+    return {};
+  }
+
+  std::unique_ptr<ClassDefinition> permission_class =
+      util::make_unique<ClassDefinition>("permission", ClassQualifier::Static,
+                                         false);
+  std::unique_ptr<ClassDefinition> permission_group_class =
+      util::make_unique<ClassDefinition>("permission_group",
+                                         ClassQualifier::Static, false);
+
+  bool error = false;
+  std::vector<xml::Element*> children = el->GetChildElements();
+  for (xml::Element* child_el : children) {
+    if (child_el->namespace_uri.empty()) {
+      if (child_el->name == "permission") {
+        error |= !WriteSymbol(res->file.source, diag, child_el,
+                              permission_class.get());
+      } else if (child_el->name == "permission-group") {
+        error |= !WriteSymbol(res->file.source, diag, child_el,
+                              permission_group_class.get());
+      }
     }
+  }
 
-    if (el->name != "manifest" && !el->namespaceUri.empty()) {
-        diag->error(DiagMessage(res->file.source) << "no <manifest> root tag defined");
-        return {};
-    }
+  if (error) {
+    return {};
+  }
 
-    std::unique_ptr<ClassDefinition> permissionClass =
-            util::make_unique<ClassDefinition>("permission", ClassQualifier::Static, false);
-    std::unique_ptr<ClassDefinition> permissionGroupClass =
-            util::make_unique<ClassDefinition>("permission_group", ClassQualifier::Static, false);
-
-    bool error = false;
-
-    std::vector<xml::Element*> children = el->getChildElements();
-    for (xml::Element* childEl : children) {
-        if (childEl->namespaceUri.empty()) {
-            if (childEl->name == "permission") {
-                error |= !writeSymbol(res->file.source, diag, childEl, permissionClass.get());
-            } else if (childEl->name == "permission-group") {
-                error |= !writeSymbol(res->file.source, diag, childEl, permissionGroupClass.get());
-            }
-        }
-    }
-
-    if (error) {
-        return {};
-    }
-
-    std::unique_ptr<ClassDefinition> manifestClass =
-            util::make_unique<ClassDefinition>("Manifest", ClassQualifier::None, false);
-    manifestClass->addMember(std::move(permissionClass));
-    manifestClass->addMember(std::move(permissionGroupClass));
-    return manifestClass;
+  std::unique_ptr<ClassDefinition> manifest_class =
+      util::make_unique<ClassDefinition>("Manifest", ClassQualifier::None,
+                                         false);
+  manifest_class->AddMember(std::move(permission_class));
+  manifest_class->AddMember(std::move(permission_group_class));
+  return manifest_class;
 }
 
-} // namespace aapt
+}  // namespace aapt
diff --git a/tools/aapt2/java/ManifestClassGenerator.h b/tools/aapt2/java/ManifestClassGenerator.h
index 18176483fa012..b12202a8d137b 100644
--- a/tools/aapt2/java/ManifestClassGenerator.h
+++ b/tools/aapt2/java/ManifestClassGenerator.h
@@ -19,14 +19,11 @@
 
 #include "Diagnostics.h"
 #include "java/ClassDefinition.h"
-#include "util/StringPiece.h"
 #include "xml/XmlDom.h"
 
-#include <iostream>
-
 namespace aapt {
 
-std::unique_ptr<ClassDefinition> generateManifestClass(IDiagnostics* diag,
+std::unique_ptr<ClassDefinition> GenerateManifestClass(IDiagnostics* diag,
                                                        xml::XmlResource* res);
 
 }  // namespace aapt
diff --git a/tools/aapt2/java/ManifestClassGenerator_test.cpp b/tools/aapt2/java/ManifestClassGenerator_test.cpp
index eecb54464d407..5ebf508807e8a 100644
--- a/tools/aapt2/java/ManifestClassGenerator_test.cpp
+++ b/tools/aapt2/java/ManifestClassGenerator_test.cpp
@@ -15,30 +15,33 @@
  */
 
 #include "java/ManifestClassGenerator.h"
+
 #include "test/Test.h"
 
 namespace aapt {
 
-static ::testing::AssertionResult getManifestClassText(IAaptContext* context, xml::XmlResource* res,
-                                                       std::string* outStr) {
-    std::unique_ptr<ClassDefinition> manifestClass = generateManifestClass(
-            context->getDiagnostics(), res);
-    if (!manifestClass) {
-        return ::testing::AssertionFailure() << "manifestClass == nullptr";
-    }
+static ::testing::AssertionResult GetManifestClassText(IAaptContext* context,
+                                                       xml::XmlResource* res,
+                                                       std::string* out_str) {
+  std::unique_ptr<ClassDefinition> manifest_class =
+      GenerateManifestClass(context->GetDiagnostics(), res);
+  if (!manifest_class) {
+    return ::testing::AssertionFailure() << "manifest_class == nullptr";
+  }
 
-    std::stringstream out;
-    if (!manifestClass->writeJavaFile(manifestClass.get(), "android", true, &out)) {
-        return ::testing::AssertionFailure() << "failed to write java file";
-    }
+  std::stringstream out;
+  if (!manifest_class->WriteJavaFile(manifest_class.get(), "android", true,
+                                     &out)) {
+    return ::testing::AssertionFailure() << "failed to write java file";
+  }
 
-    *outStr = out.str();
-    return ::testing::AssertionSuccess();
+  *out_str = out.str();
+  return ::testing::AssertionSuccess();
 }
 
 TEST(ManifestClassGeneratorTest, NameIsProperlyGeneratedFromSymbol) {
-    std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
-    std::unique_ptr<xml::XmlResource> manifest = test::buildXmlDom(R"EOF(
+  std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
+  std::unique_ptr<xml::XmlResource> manifest = test::BuildXmlDom(R"EOF(
         <manifest xmlns:android="http://schemas.android.com/apk/res/android">
           <permission android:name="android.permission.ACCESS_INTERNET" />
           <permission android:name="android.DO_DANGEROUS_THINGS" />
@@ -46,46 +49,51 @@ TEST(ManifestClassGeneratorTest, NameIsProperlyGeneratedFromSymbol) {
           <permission-group android:name="foo.bar.PERMISSION" />
         </manifest>)EOF");
 
-    std::string actual;
-    ASSERT_TRUE(getManifestClassText(context.get(), manifest.get(), &actual));
+  std::string actual;
+  ASSERT_TRUE(GetManifestClassText(context.get(), manifest.get(), &actual));
 
-    const size_t permissionClassPos = actual.find("public static final class permission {");
-    const size_t permissionGroupClassPos =
-            actual.find("public static final class permission_group {");
-    ASSERT_NE(std::string::npos, permissionClassPos);
-    ASSERT_NE(std::string::npos, permissionGroupClassPos);
+  const size_t permission_class_pos =
+      actual.find("public static final class permission {");
+  const size_t permission_croup_class_pos =
+      actual.find("public static final class permission_group {");
+  ASSERT_NE(std::string::npos, permission_class_pos);
+  ASSERT_NE(std::string::npos, permission_croup_class_pos);
 
-    //
-    // Make sure these permissions are in the permission class.
-    //
+  //
+  // Make sure these permissions are in the permission class.
+  //
 
-    size_t pos = actual.find("public static final String ACCESS_INTERNET="
-                             "\"android.permission.ACCESS_INTERNET\";");
-    EXPECT_GT(pos, permissionClassPos);
-    EXPECT_LT(pos, permissionGroupClassPos);
+  size_t pos = actual.find(
+      "public static final String ACCESS_INTERNET="
+      "\"android.permission.ACCESS_INTERNET\";");
+  EXPECT_GT(pos, permission_class_pos);
+  EXPECT_LT(pos, permission_croup_class_pos);
 
-    pos = actual.find("public static final String DO_DANGEROUS_THINGS="
-                      "\"android.DO_DANGEROUS_THINGS\";");
-    EXPECT_GT(pos, permissionClassPos);
-    EXPECT_LT(pos, permissionGroupClassPos);
+  pos = actual.find(
+      "public static final String DO_DANGEROUS_THINGS="
+      "\"android.DO_DANGEROUS_THINGS\";");
+  EXPECT_GT(pos, permission_class_pos);
+  EXPECT_LT(pos, permission_croup_class_pos);
 
-    pos = actual.find("public static final String HUH=\"com.test.sample.permission.HUH\";");
-    EXPECT_GT(pos, permissionClassPos);
-    EXPECT_LT(pos, permissionGroupClassPos);
+  pos = actual.find(
+      "public static final String HUH=\"com.test.sample.permission.HUH\";");
+  EXPECT_GT(pos, permission_class_pos);
+  EXPECT_LT(pos, permission_croup_class_pos);
 
-    //
-    // Make sure these permissions are in the permission_group class
-    //
+  //
+  // Make sure these permissions are in the permission_group class
+  //
 
-    pos = actual.find("public static final String PERMISSION="
-                      "\"foo.bar.PERMISSION\";");
-    EXPECT_GT(pos, permissionGroupClassPos);
-    EXPECT_LT(pos, std::string::npos);
+  pos = actual.find(
+      "public static final String PERMISSION="
+      "\"foo.bar.PERMISSION\";");
+  EXPECT_GT(pos, permission_croup_class_pos);
+  EXPECT_LT(pos, std::string::npos);
 }
 
 TEST(ManifestClassGeneratorTest, CommentsAndAnnotationsArePresent) {
-    std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
-    std::unique_ptr<xml::XmlResource> manifest = test::buildXmlDom(R"EOF(
+  std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
+  std::unique_ptr<xml::XmlResource> manifest = test::BuildXmlDom(R"EOF(
         <manifest xmlns:android="http://schemas.android.com/apk/res/android">
           <!-- Required to access the internet.
                Added in API 1. -->
@@ -98,36 +106,36 @@ TEST(ManifestClassGeneratorTest, CommentsAndAnnotationsArePresent) {
           <permission android:name="android.permission.SECRET" />
         </manifest>)EOF");
 
-    std::string actual;
-    ASSERT_TRUE(getManifestClassText(context.get(), manifest.get(), &actual));
+  std::string actual;
+  ASSERT_TRUE(GetManifestClassText(context.get(), manifest.get(), &actual));
 
-    const char* expectedAccessInternet =
-R"EOF(    /**
+  const char* expected_access_internet =
+      R"EOF(    /**
      * Required to access the internet.
      * Added in API 1.
      */
     public static final String ACCESS_INTERNET="android.permission.ACCESS_INTERNET";)EOF";
 
-    EXPECT_NE(std::string::npos, actual.find(expectedAccessInternet));
+  EXPECT_NE(std::string::npos, actual.find(expected_access_internet));
 
-    const char* expectedPlayOutside =
-R"EOF(    /**
+  const char* expected_play_outside =
+      R"EOF(    /**
      * @deprecated This permission is for playing outside.
      */
     @Deprecated
     public static final String PLAY_OUTSIDE="android.permission.PLAY_OUTSIDE";)EOF";
 
-    EXPECT_NE(std::string::npos, actual.find(expectedPlayOutside));
+  EXPECT_NE(std::string::npos, actual.find(expected_play_outside));
 
-    const char* expectedSecret =
-R"EOF(    /**
+  const char* expected_secret =
+      R"EOF(    /**
      * This is a private permission for system only!
      * @hide
      */
     @android.annotation.SystemApi
     public static final String SECRET="android.permission.SECRET";)EOF";
 
-    EXPECT_NE(std::string::npos, actual.find(expectedSecret));
+  EXPECT_NE(std::string::npos, actual.find(expected_secret));
 }
 
-} // namespace aapt
+}  // namespace aapt
diff --git a/tools/aapt2/java/ProguardRules.cpp b/tools/aapt2/java/ProguardRules.cpp
index 902ec4cf3a0de..624a559c4daed 100644
--- a/tools/aapt2/java/ProguardRules.cpp
+++ b/tools/aapt2/java/ProguardRules.cpp
@@ -15,254 +15,281 @@
  */
 
 #include "java/ProguardRules.h"
-#include "util/Util.h"
-#include "xml/XmlDom.h"
 
 #include <memory>
 #include <string>
 
+#include "android-base/macros.h"
+
+#include "util/Util.h"
+#include "xml/XmlDom.h"
+
 namespace aapt {
 namespace proguard {
 
 class BaseVisitor : public xml::Visitor {
-public:
-    BaseVisitor(const Source& source, KeepSet* keepSet) : mSource(source), mKeepSet(keepSet) {
+ public:
+  BaseVisitor(const Source& source, KeepSet* keep_set)
+      : source_(source), keep_set_(keep_set) {}
+
+  virtual void Visit(xml::Text*) override{};
+
+  virtual void Visit(xml::Namespace* node) override {
+    for (const auto& child : node->children) {
+      child->Accept(this);
     }
+  }
 
-    virtual void visit(xml::Text*) override {};
-
-    virtual void visit(xml::Namespace* node) override {
-        for (const auto& child : node->children) {
-            child->accept(this);
+  virtual void Visit(xml::Element* node) override {
+    if (!node->namespace_uri.empty()) {
+      Maybe<xml::ExtractedPackage> maybe_package =
+          xml::ExtractPackageFromNamespace(node->namespace_uri);
+      if (maybe_package) {
+        // This is a custom view, let's figure out the class name from this.
+        std::string package = maybe_package.value().package + "." + node->name;
+        if (util::IsJavaClassName(package)) {
+          AddClass(node->line_number, package);
         }
+      }
+    } else if (util::IsJavaClassName(node->name)) {
+      AddClass(node->line_number, node->name);
     }
 
-    virtual void visit(xml::Element* node) override {
-        if (!node->namespaceUri.empty()) {
-            Maybe<xml::ExtractedPackage> maybePackage = xml::extractPackageFromNamespace(
-                    node->namespaceUri);
-            if (maybePackage) {
-                // This is a custom view, let's figure out the class name from this.
-                std::string package = maybePackage.value().package + "." + node->name;
-                if (util::isJavaClassName(package)) {
-                    addClass(node->lineNumber, package);
-                }
-            }
-        } else if (util::isJavaClassName(node->name)) {
-            addClass(node->lineNumber, node->name);
-        }
-
-        for (const auto& child: node->children) {
-            child->accept(this);
-        }
+    for (const auto& child : node->children) {
+      child->Accept(this);
     }
+  }
 
-protected:
-    void addClass(size_t lineNumber, const std::string& className) {
-        mKeepSet->addClass(Source(mSource.path, lineNumber), className);
-    }
+ protected:
+  void AddClass(size_t line_number, const std::string& class_name) {
+    keep_set_->AddClass(Source(source_.path, line_number), class_name);
+  }
 
-    void addMethod(size_t lineNumber, const std::string& methodName) {
-        mKeepSet->addMethod(Source(mSource.path, lineNumber), methodName);
-    }
+  void AddMethod(size_t line_number, const std::string& method_name) {
+    keep_set_->AddMethod(Source(source_.path, line_number), method_name);
+  }
 
-private:
-    Source mSource;
-    KeepSet* mKeepSet;
+ private:
+  DISALLOW_COPY_AND_ASSIGN(BaseVisitor);
+
+  Source source_;
+  KeepSet* keep_set_;
 };
 
-struct LayoutVisitor : public BaseVisitor {
-    LayoutVisitor(const Source& source, KeepSet* keepSet) : BaseVisitor(source, keepSet) {
+class LayoutVisitor : public BaseVisitor {
+ public:
+  LayoutVisitor(const Source& source, KeepSet* keep_set)
+      : BaseVisitor(source, keep_set) {}
+
+  virtual void Visit(xml::Element* node) override {
+    bool check_class = false;
+    bool check_name = false;
+    if (node->namespace_uri.empty()) {
+      check_class = node->name == "view" || node->name == "fragment";
+    } else if (node->namespace_uri == xml::kSchemaAndroid) {
+      check_name = node->name == "fragment";
     }
 
-    virtual void visit(xml::Element* node) override {
-        bool checkClass = false;
-        bool checkName = false;
-        if (node->namespaceUri.empty()) {
-            checkClass = node->name == "view" || node->name == "fragment";
-        } else if (node->namespaceUri == xml::kSchemaAndroid) {
-            checkName = node->name == "fragment";
-        }
-
-        for (const auto& attr : node->attributes) {
-            if (checkClass && attr.namespaceUri.empty() && attr.name == "class" &&
-                    util::isJavaClassName(attr.value)) {
-                addClass(node->lineNumber, attr.value);
-            } else if (checkName && attr.namespaceUri == xml::kSchemaAndroid &&
-                    attr.name == "name" && util::isJavaClassName(attr.value)) {
-                addClass(node->lineNumber, attr.value);
-            } else if (attr.namespaceUri == xml::kSchemaAndroid && attr.name == "onClick") {
-                addMethod(node->lineNumber, attr.value);
-            }
-        }
-
-        BaseVisitor::visit(node);
+    for (const auto& attr : node->attributes) {
+      if (check_class && attr.namespace_uri.empty() && attr.name == "class" &&
+          util::IsJavaClassName(attr.value)) {
+        AddClass(node->line_number, attr.value);
+      } else if (check_name && attr.namespace_uri == xml::kSchemaAndroid &&
+                 attr.name == "name" && util::IsJavaClassName(attr.value)) {
+        AddClass(node->line_number, attr.value);
+      } else if (attr.namespace_uri == xml::kSchemaAndroid &&
+                 attr.name == "onClick") {
+        AddMethod(node->line_number, attr.value);
+      }
     }
+
+    BaseVisitor::Visit(node);
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(LayoutVisitor);
 };
 
-struct XmlResourceVisitor : public BaseVisitor {
-    XmlResourceVisitor(const Source& source, KeepSet* keepSet) : BaseVisitor(source, keepSet) {
+class XmlResourceVisitor : public BaseVisitor {
+ public:
+  XmlResourceVisitor(const Source& source, KeepSet* keep_set)
+      : BaseVisitor(source, keep_set) {}
+
+  virtual void Visit(xml::Element* node) override {
+    bool check_fragment = false;
+    if (node->namespace_uri.empty()) {
+      check_fragment =
+          node->name == "PreferenceScreen" || node->name == "header";
     }
 
-    virtual void visit(xml::Element* node) override {
-        bool checkFragment = false;
-        if (node->namespaceUri.empty()) {
-            checkFragment = node->name == "PreferenceScreen" || node->name == "header";
-        }
-
-        if (checkFragment) {
-            xml::Attribute* attr = node->findAttribute(xml::kSchemaAndroid, "fragment");
-            if (attr && util::isJavaClassName(attr->value)) {
-                addClass(node->lineNumber, attr->value);
-            }
-        }
-
-        BaseVisitor::visit(node);
+    if (check_fragment) {
+      xml::Attribute* attr =
+          node->FindAttribute(xml::kSchemaAndroid, "fragment");
+      if (attr && util::IsJavaClassName(attr->value)) {
+        AddClass(node->line_number, attr->value);
+      }
     }
+
+    BaseVisitor::Visit(node);
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(XmlResourceVisitor);
 };
 
-struct TransitionVisitor : public BaseVisitor {
-    TransitionVisitor(const Source& source, KeepSet* keepSet) : BaseVisitor(source, keepSet) {
+class TransitionVisitor : public BaseVisitor {
+ public:
+  TransitionVisitor(const Source& source, KeepSet* keep_set)
+      : BaseVisitor(source, keep_set) {}
+
+  virtual void Visit(xml::Element* node) override {
+    bool check_class =
+        node->namespace_uri.empty() &&
+        (node->name == "transition" || node->name == "pathMotion");
+    if (check_class) {
+      xml::Attribute* attr = node->FindAttribute({}, "class");
+      if (attr && util::IsJavaClassName(attr->value)) {
+        AddClass(node->line_number, attr->value);
+      }
     }
 
-    virtual void visit(xml::Element* node) override {
-        bool checkClass = node->namespaceUri.empty() &&
-                (node->name == "transition" || node->name == "pathMotion");
-        if (checkClass) {
-            xml::Attribute* attr = node->findAttribute({}, "class");
-            if (attr && util::isJavaClassName(attr->value)) {
-                addClass(node->lineNumber, attr->value);
-            }
-        }
+    BaseVisitor::Visit(node);
+  }
 
-        BaseVisitor::visit(node);
-    }
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TransitionVisitor);
 };
 
-struct ManifestVisitor : public BaseVisitor {
-    ManifestVisitor(const Source& source, KeepSet* keepSet, bool mainDexOnly)
-            : BaseVisitor(source, keepSet), mMainDexOnly(mainDexOnly) {
-    }
+class ManifestVisitor : public BaseVisitor {
+ public:
+  ManifestVisitor(const Source& source, KeepSet* keep_set, bool main_dex_only)
+      : BaseVisitor(source, keep_set), main_dex_only_(main_dex_only) {}
 
-    virtual void visit(xml::Element* node) override {
-        if (node->namespaceUri.empty()) {
-            bool getName = false;
-            if (node->name == "manifest") {
-                xml::Attribute* attr = node->findAttribute({}, "package");
-                if (attr) {
-                    mPackage = attr->value;
-                }
-            } else if (node->name == "application") {
-                getName = true;
-                xml::Attribute* attr = node->findAttribute(xml::kSchemaAndroid, "backupAgent");
-                if (attr) {
-                    Maybe<std::string> result = util::getFullyQualifiedClassName(mPackage,
-                                                                                 attr->value);
-                    if (result) {
-                        addClass(node->lineNumber, result.value());
-                    }
-                }
-                if (mMainDexOnly) {
-                    xml::Attribute* defaultProcess = node->findAttribute(xml::kSchemaAndroid,
-                                                                         "process");
-                    if (defaultProcess) {
-                        mDefaultProcess = defaultProcess->value;
-                    }
-                }
-            } else if (node->name == "activity" || node->name == "service" ||
-                    node->name == "receiver" || node->name == "provider") {
-                getName = true;
-
-                if (mMainDexOnly) {
-                    xml::Attribute* componentProcess = node->findAttribute(xml::kSchemaAndroid,
-                                                                           "process");
-
-                    const std::string& process = componentProcess ? componentProcess->value
-                            : mDefaultProcess;
-                    getName = !process.empty() && process[0] != ':';
-                }
-            } else if (node-> name == "instrumentation") {
-                getName = true;
-            }
-
-            if (getName) {
-                xml::Attribute* attr = node->findAttribute(xml::kSchemaAndroid, "name");
-                getName = attr != nullptr;
-
-                if (getName) {
-                    Maybe<std::string> result = util::getFullyQualifiedClassName(mPackage,
-                                                                                 attr->value);
-                    if (result) {
-                        addClass(node->lineNumber, result.value());
-                    }
-                }
-            }
+  virtual void Visit(xml::Element* node) override {
+    if (node->namespace_uri.empty()) {
+      bool get_name = false;
+      if (node->name == "manifest") {
+        xml::Attribute* attr = node->FindAttribute({}, "package");
+        if (attr) {
+          package_ = attr->value;
         }
-        BaseVisitor::visit(node);
-    }
+      } else if (node->name == "application") {
+        get_name = true;
+        xml::Attribute* attr =
+            node->FindAttribute(xml::kSchemaAndroid, "backupAgent");
+        if (attr) {
+          Maybe<std::string> result =
+              util::GetFullyQualifiedClassName(package_, attr->value);
+          if (result) {
+            AddClass(node->line_number, result.value());
+          }
+        }
+        if (main_dex_only_) {
+          xml::Attribute* default_process =
+              node->FindAttribute(xml::kSchemaAndroid, "process");
+          if (default_process) {
+            default_process_ = default_process->value;
+          }
+        }
+      } else if (node->name == "activity" || node->name == "service" ||
+                 node->name == "receiver" || node->name == "provider") {
+        get_name = true;
 
-private:
-    std::string mPackage;
-    const bool mMainDexOnly;
-    std::string mDefaultProcess;
+        if (main_dex_only_) {
+          xml::Attribute* component_process =
+              node->FindAttribute(xml::kSchemaAndroid, "process");
+
+          const std::string& process =
+              component_process ? component_process->value : default_process_;
+          get_name = !process.empty() && process[0] != ':';
+        }
+      } else if (node->name == "instrumentation") {
+        get_name = true;
+      }
+
+      if (get_name) {
+        xml::Attribute* attr = node->FindAttribute(xml::kSchemaAndroid, "name");
+        get_name = attr != nullptr;
+
+        if (get_name) {
+          Maybe<std::string> result =
+              util::GetFullyQualifiedClassName(package_, attr->value);
+          if (result) {
+            AddClass(node->line_number, result.value());
+          }
+        }
+      }
+    }
+    BaseVisitor::Visit(node);
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ManifestVisitor);
+
+  std::string package_;
+  const bool main_dex_only_;
+  std::string default_process_;
 };
 
-bool collectProguardRulesForManifest(const Source& source, xml::XmlResource* res,
-                                     KeepSet* keepSet, bool mainDexOnly) {
-    ManifestVisitor visitor(source, keepSet, mainDexOnly);
-    if (res->root) {
-        res->root->accept(&visitor);
-        return true;
-    }
+bool CollectProguardRulesForManifest(const Source& source,
+                                     xml::XmlResource* res, KeepSet* keep_set,
+                                     bool main_dex_only) {
+  ManifestVisitor visitor(source, keep_set, main_dex_only);
+  if (res->root) {
+    res->root->Accept(&visitor);
+    return true;
+  }
+  return false;
+}
+
+bool CollectProguardRules(const Source& source, xml::XmlResource* res,
+                          KeepSet* keep_set) {
+  if (!res->root) {
     return false;
+  }
+
+  switch (res->file.name.type) {
+    case ResourceType::kLayout: {
+      LayoutVisitor visitor(source, keep_set);
+      res->root->Accept(&visitor);
+      break;
+    }
+
+    case ResourceType::kXml: {
+      XmlResourceVisitor visitor(source, keep_set);
+      res->root->Accept(&visitor);
+      break;
+    }
+
+    case ResourceType::kTransition: {
+      TransitionVisitor visitor(source, keep_set);
+      res->root->Accept(&visitor);
+      break;
+    }
+
+    default:
+      break;
+  }
+  return true;
 }
 
-bool collectProguardRules(const Source& source, xml::XmlResource* res, KeepSet* keepSet) {
-    if (!res->root) {
-        return false;
+bool WriteKeepSet(std::ostream* out, const KeepSet& keep_set) {
+  for (const auto& entry : keep_set.keep_set_) {
+    for (const Source& source : entry.second) {
+      *out << "# Referenced at " << source << "\n";
     }
+    *out << "-keep class " << entry.first << " { <init>(...); }\n" << std::endl;
+  }
 
-    switch (res->file.name.type) {
-        case ResourceType::kLayout: {
-            LayoutVisitor visitor(source, keepSet);
-            res->root->accept(&visitor);
-            break;
-        }
-
-        case ResourceType::kXml: {
-            XmlResourceVisitor visitor(source, keepSet);
-            res->root->accept(&visitor);
-            break;
-        }
-
-        case ResourceType::kTransition: {
-            TransitionVisitor visitor(source, keepSet);
-            res->root->accept(&visitor);
-            break;
-        }
-
-        default:
-            break;
+  for (const auto& entry : keep_set.keep_method_set_) {
+    for (const Source& source : entry.second) {
+      *out << "# Referenced at " << source << "\n";
     }
-    return true;
+    *out << "-keepclassmembers class * { *** " << entry.first << "(...); }\n"
+         << std::endl;
+  }
+  return true;
 }
 
-bool writeKeepSet(std::ostream* out, const KeepSet& keepSet) {
-    for (const auto& entry : keepSet.mKeepSet) {
-        for (const Source& source : entry.second) {
-            *out << "# Referenced at " << source << "\n";
-        }
-        *out << "-keep class " << entry.first << " { <init>(...); }\n" << std::endl;
-    }
-
-    for (const auto& entry : keepSet.mKeepMethodSet) {
-        for (const Source& source : entry.second) {
-            *out << "# Referenced at " << source << "\n";
-        }
-        *out << "-keepclassmembers class * { *** " << entry.first << "(...); }\n" << std::endl;
-    }
-    return true;
-}
-
-} // namespace proguard
-} // namespace aapt
+}  // namespace proguard
+}  // namespace aapt
diff --git a/tools/aapt2/java/ProguardRules.h b/tools/aapt2/java/ProguardRules.h
index 7578ec2abf589..3c349bab12179 100644
--- a/tools/aapt2/java/ProguardRules.h
+++ b/tools/aapt2/java/ProguardRules.h
@@ -17,42 +17,42 @@
 #ifndef AAPT_PROGUARD_RULES_H
 #define AAPT_PROGUARD_RULES_H
 
-#include "Resource.h"
-#include "Source.h"
-#include "xml/XmlDom.h"
-
 #include <map>
 #include <ostream>
 #include <set>
 #include <string>
 
+#include "Resource.h"
+#include "Source.h"
+#include "xml/XmlDom.h"
+
 namespace aapt {
 namespace proguard {
 
 class KeepSet {
  public:
-  inline void addClass(const Source& source, const std::string& className) {
-    mKeepSet[className].insert(source);
+  inline void AddClass(const Source& source, const std::string& class_name) {
+    keep_set_[class_name].insert(source);
   }
 
-  inline void addMethod(const Source& source, const std::string& methodName) {
-    mKeepMethodSet[methodName].insert(source);
+  inline void AddMethod(const Source& source, const std::string& method_name) {
+    keep_method_set_[method_name].insert(source);
   }
 
  private:
-  friend bool writeKeepSet(std::ostream* out, const KeepSet& keepSet);
+  friend bool WriteKeepSet(std::ostream* out, const KeepSet& keep_set);
 
-  std::map<std::string, std::set<Source>> mKeepSet;
-  std::map<std::string, std::set<Source>> mKeepMethodSet;
+  std::map<std::string, std::set<Source>> keep_set_;
+  std::map<std::string, std::set<Source>> keep_method_set_;
 };
 
-bool collectProguardRulesForManifest(const Source& source,
-                                     xml::XmlResource* res, KeepSet* keepSet,
-                                     bool mainDexOnly = false);
-bool collectProguardRules(const Source& source, xml::XmlResource* res,
-                          KeepSet* keepSet);
+bool CollectProguardRulesForManifest(const Source& source,
+                                     xml::XmlResource* res, KeepSet* keep_set,
+                                     bool main_dex_only = false);
+bool CollectProguardRules(const Source& source, xml::XmlResource* res,
+                          KeepSet* keep_set);
 
-bool writeKeepSet(std::ostream* out, const KeepSet& keepSet);
+bool WriteKeepSet(std::ostream* out, const KeepSet& keep_set);
 
 }  // namespace proguard
 }  // namespace aapt
diff --git a/tools/aapt2/jni/aapt2_jni.cpp b/tools/aapt2/jni/aapt2_jni.cpp
index dff77b972b084..211ada8db078a 100644
--- a/tools/aapt2/jni/aapt2_jni.cpp
+++ b/tools/aapt2/jni/aapt2_jni.cpp
@@ -14,84 +14,81 @@
  * limitations under the License.
  */
 
+#include "com_android_tools_aapt2_Aapt2.h"
+
 #include <algorithm>
-#include <cassert>
 #include <memory>
 #include <utility>
 #include <vector>
 
-#include <ScopedUtfChars.h>
+#include "android-base/logging.h"
+#include "nativehelper/ScopedUtfChars.h"
 
 #include "util/Util.h"
 
-#include "com_android_tools_aapt2_Aapt2.h"
-
 namespace aapt {
-    extern int compile(const std::vector<StringPiece>& args);
-    extern int link(const std::vector<StringPiece>& args);
+extern int Compile(const std::vector<StringPiece> &args);
+extern int Link(const std::vector<StringPiece> &args);
 }
 
 /*
  * Converts a java List<String> into C++ vector<ScopedUtfChars>.
  */
 static std::vector<ScopedUtfChars> list_to_utfchars(JNIEnv *env, jobject obj) {
-    std::vector<ScopedUtfChars> converted;
+  std::vector<ScopedUtfChars> converted;
 
-    // Call size() method on the list to know how many elements there are.
-    jclass list_cls = env->GetObjectClass(obj);
-    jmethodID size_method_id = env->GetMethodID(list_cls, "size", "()I");
-    assert(size_method_id != 0);
-    jint size = env->CallIntMethod(obj, size_method_id);
-    assert(size >= 0);
+  // Call size() method on the list to know how many elements there are.
+  jclass list_cls = env->GetObjectClass(obj);
+  jmethodID size_method_id = env->GetMethodID(list_cls, "size", "()I");
+  CHECK(size_method_id != 0);
+  jint size = env->CallIntMethod(obj, size_method_id);
+  CHECK(size >= 0);
 
-    // Now, iterate all strings in the list
-    // (note: generic erasure means get() return an Object)
-    jmethodID get_method_id = env->GetMethodID(list_cls, "get", "()Ljava/lang/Object;");
-    for (jint i = 0; i < size; i++) {
-        // Call get(i) to get the string in the ith position.
-        jobject string_obj_uncast = env->CallObjectMethod(obj, get_method_id, i);
-        assert(string_obj_uncast != nullptr);
-        jstring string_obj = static_cast<jstring>(string_obj_uncast);
-        converted.push_back(ScopedUtfChars(env, string_obj));
-    }
+  // Now, iterate all strings in the list
+  // (note: generic erasure means get() return an Object)
+  jmethodID get_method_id =
+      env->GetMethodID(list_cls, "get", "()Ljava/lang/Object;");
+  for (jint i = 0; i < size; i++) {
+    // Call get(i) to get the string in the ith position.
+    jobject string_obj_uncast = env->CallObjectMethod(obj, get_method_id, i);
+    CHECK(string_obj_uncast != nullptr);
+    jstring string_obj = static_cast<jstring>(string_obj_uncast);
+    converted.push_back(ScopedUtfChars(env, string_obj));
+  }
 
-    return converted;
+  return converted;
 }
 
 /*
  * Extracts all StringPiece from the ScopedUtfChars instances.
- * 
+ *
  * The returned pieces can only be used while the original ones have not been
  * destroyed.
  */
 static std::vector<aapt::StringPiece> extract_pieces(
-        const std::vector<ScopedUtfChars> &strings) {
-    std::vector<aapt::StringPiece> pieces;
-  
-    std::for_each(
-            strings.begin(),
-            strings.end(),
-            [&pieces](const ScopedUtfChars &p) {
-              pieces.push_back(p.c_str());
-            });
-  
-    return pieces;
+    const std::vector<ScopedUtfChars> &strings) {
+  std::vector<aapt::StringPiece> pieces;
+
+  std::for_each(
+      strings.begin(), strings.end(),
+      [&pieces](const ScopedUtfChars &p) { pieces.push_back(p.c_str()); });
+
+  return pieces;
 }
 
 JNIEXPORT void JNICALL Java_com_android_tools_aapt2_Aapt2_nativeCompile(
-        JNIEnv *env,
-        jclass aapt_obj,
-        jobject arguments_obj) {
-    std::vector<ScopedUtfChars> compile_args_jni = list_to_utfchars(env, arguments_obj);
-    std::vector<aapt::StringPiece> compile_args = extract_pieces(compile_args_jni);
-    aapt::compile(compile_args);
+    JNIEnv *env, jclass aapt_obj, jobject arguments_obj) {
+  std::vector<ScopedUtfChars> compile_args_jni =
+      list_to_utfchars(env, arguments_obj);
+  std::vector<aapt::StringPiece> compile_args =
+      extract_pieces(compile_args_jni);
+  aapt::Compile(compile_args);
 }
 
 JNIEXPORT void JNICALL Java_com_android_tools_aapt2_Aapt2_nativeLink(
-        JNIEnv *env,
-        jclass aapt_obj,
-        jobject arguments_obj) {
-    std::vector<ScopedUtfChars> link_args_jni = list_to_utfchars(env, arguments_obj);
-    std::vector<aapt::StringPiece> link_args = extract_pieces(link_args_jni);
-    aapt::link(link_args);
+    JNIEnv *env, jclass aapt_obj, jobject arguments_obj) {
+  std::vector<ScopedUtfChars> link_args_jni =
+      list_to_utfchars(env, arguments_obj);
+  std::vector<aapt::StringPiece> link_args = extract_pieces(link_args_jni);
+  aapt::Link(link_args);
 }
diff --git a/tools/aapt2/link/AutoVersioner.cpp b/tools/aapt2/link/AutoVersioner.cpp
index 5ba981931f3b5..77471ea5d0dad 100644
--- a/tools/aapt2/link/AutoVersioner.cpp
+++ b/tools/aapt2/link/AutoVersioner.cpp
@@ -14,34 +14,36 @@
  * limitations under the License.
  */
 
+#include "link/Linkers.h"
+
+#include <algorithm>
+
+#include "android-base/logging.h"
+
 #include "ConfigDescription.h"
 #include "ResourceTable.h"
 #include "SdkConstants.h"
 #include "ValueVisitor.h"
-#include "link/Linkers.h"
-
-#include <algorithm>
-#include <cassert>
 
 namespace aapt {
 
-bool shouldGenerateVersionedResource(const ResourceEntry* entry,
+bool ShouldGenerateVersionedResource(const ResourceEntry* entry,
                                      const ConfigDescription& config,
-                                     const int sdkVersionToGenerate) {
+                                     const int sdk_version_to_generate) {
   // We assume the caller is trying to generate a version greater than the
   // current configuration.
-  assert(sdkVersionToGenerate > config.sdkVersion);
+  CHECK(sdk_version_to_generate > config.sdkVersion);
 
-  const auto endIter = entry->values.end();
+  const auto end_iter = entry->values.end();
   auto iter = entry->values.begin();
-  for (; iter != endIter; ++iter) {
+  for (; iter != end_iter; ++iter) {
     if ((*iter)->config == config) {
       break;
     }
   }
 
   // The source config came from this list, so it should be here.
-  assert(iter != entry->values.end());
+  CHECK(iter != entry->values.end());
   ++iter;
 
   // The next configuration either only varies in sdkVersion, or it is
@@ -53,12 +55,12 @@ bool shouldGenerateVersionedResource(const ResourceEntry* entry,
   // than other
   // qualifiers, so we need to iterate through the entire list to be sure there
   // are no higher sdk level versions of this resource.
-  ConfigDescription tempConfig(config);
-  for (; iter != endIter; ++iter) {
-    tempConfig.sdkVersion = (*iter)->config.sdkVersion;
-    if (tempConfig == (*iter)->config) {
+  ConfigDescription temp_config(config);
+  for (; iter != end_iter; ++iter) {
+    temp_config.sdkVersion = (*iter)->config.sdkVersion;
+    if (temp_config == (*iter)->config) {
       // The two configs are the same, check the sdk version.
-      return sdkVersionToGenerate < (*iter)->config.sdkVersion;
+      return sdk_version_to_generate < (*iter)->config.sdkVersion;
     }
   }
 
@@ -66,7 +68,7 @@ bool shouldGenerateVersionedResource(const ResourceEntry* entry,
   return true;
 }
 
-bool AutoVersioner::consume(IAaptContext* context, ResourceTable* table) {
+bool AutoVersioner::Consume(IAaptContext* context, ResourceTable* table) {
   for (auto& package : table->packages) {
     for (auto& type : package->types) {
       if (type->type != ResourceType::kStyle) {
@@ -75,36 +77,37 @@ bool AutoVersioner::consume(IAaptContext* context, ResourceTable* table) {
 
       for (auto& entry : type->entries) {
         for (size_t i = 0; i < entry->values.size(); i++) {
-          ResourceConfigValue* configValue = entry->values[i].get();
-          if (configValue->config.sdkVersion >= SDK_LOLLIPOP_MR1) {
+          ResourceConfigValue* config_value = entry->values[i].get();
+          if (config_value->config.sdkVersion >= SDK_LOLLIPOP_MR1) {
             // If this configuration is only used on L-MR1 then we don't need
             // to do anything since we use private attributes since that
             // version.
             continue;
           }
 
-          if (Style* style = valueCast<Style>(configValue->value.get())) {
-            Maybe<size_t> minSdkStripped;
+          if (Style* style = ValueCast<Style>(config_value->value.get())) {
+            Maybe<size_t> min_sdk_stripped;
             std::vector<Style::Entry> stripped;
 
             auto iter = style->entries.begin();
             while (iter != style->entries.end()) {
-              assert(iter->key.id && "IDs must be assigned and linked");
+              CHECK(bool(iter->key.id)) << "IDs must be assigned and linked";
 
               // Find the SDK level that is higher than the configuration
               // allows.
-              const size_t sdkLevel =
-                  findAttributeSdkLevel(iter->key.id.value());
-              if (sdkLevel >
-                  std::max<size_t>(configValue->config.sdkVersion, 1)) {
+              const size_t sdk_level =
+                  FindAttributeSdkLevel(iter->key.id.value());
+              if (sdk_level >
+                  std::max<size_t>(config_value->config.sdkVersion, 1)) {
                 // Record that we are about to strip this.
                 stripped.emplace_back(std::move(*iter));
 
                 // We use the smallest SDK level to generate the new style.
-                if (minSdkStripped) {
-                  minSdkStripped = std::min(minSdkStripped.value(), sdkLevel);
+                if (min_sdk_stripped) {
+                  min_sdk_stripped =
+                      std::min(min_sdk_stripped.value(), sdk_level);
                 } else {
-                  minSdkStripped = sdkLevel;
+                  min_sdk_stripped = sdk_level;
                 }
 
                 // Erase this from this style.
@@ -114,31 +117,31 @@ bool AutoVersioner::consume(IAaptContext* context, ResourceTable* table) {
               ++iter;
             }
 
-            if (minSdkStripped && !stripped.empty()) {
+            if (min_sdk_stripped && !stripped.empty()) {
               // We found attributes from a higher SDK level. Check that
               // there is no other defined resource for the version we want to
               // generate.
-              if (shouldGenerateVersionedResource(entry.get(),
-                                                  configValue->config,
-                                                  minSdkStripped.value())) {
+              if (ShouldGenerateVersionedResource(entry.get(),
+                                                  config_value->config,
+                                                  min_sdk_stripped.value())) {
                 // Let's create a new Style for this versioned resource.
-                ConfigDescription newConfig(configValue->config);
-                newConfig.sdkVersion = minSdkStripped.value();
+                ConfigDescription new_config(config_value->config);
+                new_config.sdkVersion = min_sdk_stripped.value();
 
-                std::unique_ptr<Style> newStyle(
-                    style->clone(&table->stringPool));
-                newStyle->setComment(style->getComment());
-                newStyle->setSource(style->getSource());
+                std::unique_ptr<Style> new_style(
+                    style->Clone(&table->string_pool));
+                new_style->SetComment(style->GetComment());
+                new_style->SetSource(style->GetSource());
 
                 // Move the previously stripped attributes into this style.
-                newStyle->entries.insert(
-                    newStyle->entries.end(),
+                new_style->entries.insert(
+                    new_style->entries.end(),
                     std::make_move_iterator(stripped.begin()),
                     std::make_move_iterator(stripped.end()));
 
                 // Insert the new Resource into the correct place.
-                entry->findOrCreateValue(newConfig, {})->value =
-                    std::move(newStyle);
+                entry->FindOrCreateValue(new_config, {})->value =
+                    std::move(new_style);
               }
             }
           }
diff --git a/tools/aapt2/link/AutoVersioner_test.cpp b/tools/aapt2/link/AutoVersioner_test.cpp
index 04bf9cd7fc0bc..755af0a1c6cc9 100644
--- a/tools/aapt2/link/AutoVersioner_test.cpp
+++ b/tools/aapt2/link/AutoVersioner_test.cpp
@@ -14,121 +14,124 @@
  * limitations under the License.
  */
 
-#include "ConfigDescription.h"
 #include "link/Linkers.h"
+
+#include "ConfigDescription.h"
 #include "test/Test.h"
 
 namespace aapt {
 
 TEST(AutoVersionerTest, GenerateVersionedResources) {
-  const ConfigDescription defaultConfig = {};
-  const ConfigDescription landConfig = test::parseConfigOrDie("land");
-  const ConfigDescription sw600dpLandConfig =
-      test::parseConfigOrDie("sw600dp-land");
+  const ConfigDescription land_config = test::ParseConfigOrDie("land");
+  const ConfigDescription sw600dp_land_config =
+      test::ParseConfigOrDie("sw600dp-land");
 
   ResourceEntry entry("foo");
+  entry.values.push_back(util::make_unique<ResourceConfigValue>(
+      ConfigDescription::DefaultConfig(), ""));
   entry.values.push_back(
-      util::make_unique<ResourceConfigValue>(defaultConfig, ""));
+      util::make_unique<ResourceConfigValue>(land_config, ""));
   entry.values.push_back(
-      util::make_unique<ResourceConfigValue>(landConfig, ""));
-  entry.values.push_back(
-      util::make_unique<ResourceConfigValue>(sw600dpLandConfig, ""));
+      util::make_unique<ResourceConfigValue>(sw600dp_land_config, ""));
 
-  EXPECT_TRUE(shouldGenerateVersionedResource(&entry, defaultConfig, 17));
-  EXPECT_TRUE(shouldGenerateVersionedResource(&entry, landConfig, 17));
+  EXPECT_TRUE(ShouldGenerateVersionedResource(
+      &entry, ConfigDescription::DefaultConfig(), 17));
+  EXPECT_TRUE(ShouldGenerateVersionedResource(&entry, land_config, 17));
 }
 
 TEST(AutoVersionerTest, GenerateVersionedResourceWhenHigherVersionExists) {
-  const ConfigDescription defaultConfig = {};
-  const ConfigDescription sw600dpV13Config =
-      test::parseConfigOrDie("sw600dp-v13");
-  const ConfigDescription v21Config = test::parseConfigOrDie("v21");
+  const ConfigDescription sw600dp_v13_config =
+      test::ParseConfigOrDie("sw600dp-v13");
+  const ConfigDescription v21_config = test::ParseConfigOrDie("v21");
 
   ResourceEntry entry("foo");
+  entry.values.push_back(util::make_unique<ResourceConfigValue>(
+      ConfigDescription::DefaultConfig(), ""));
   entry.values.push_back(
-      util::make_unique<ResourceConfigValue>(defaultConfig, ""));
+      util::make_unique<ResourceConfigValue>(sw600dp_v13_config, ""));
   entry.values.push_back(
-      util::make_unique<ResourceConfigValue>(sw600dpV13Config, ""));
-  entry.values.push_back(util::make_unique<ResourceConfigValue>(v21Config, ""));
+      util::make_unique<ResourceConfigValue>(v21_config, ""));
 
-  EXPECT_TRUE(shouldGenerateVersionedResource(&entry, defaultConfig, 17));
-  EXPECT_FALSE(shouldGenerateVersionedResource(&entry, defaultConfig, 22));
+  EXPECT_TRUE(ShouldGenerateVersionedResource(
+      &entry, ConfigDescription::DefaultConfig(), 17));
+  EXPECT_FALSE(ShouldGenerateVersionedResource(
+      &entry, ConfigDescription::DefaultConfig(), 22));
 }
 
 TEST(AutoVersionerTest, VersionStylesForTable) {
   std::unique_ptr<ResourceTable> table =
       test::ResourceTableBuilder()
-          .setPackageId("app", 0x7f)
-          .addValue(
-              "app:style/Foo", test::parseConfigOrDie("v4"),
+          .SetPackageId("app", 0x7f)
+          .AddValue(
+              "app:style/Foo", test::ParseConfigOrDie("v4"),
               ResourceId(0x7f020000),
               test::StyleBuilder()
-                  .addItem("android:attr/onClick", ResourceId(0x0101026f),
+                  .AddItem("android:attr/onClick", ResourceId(0x0101026f),
                            util::make_unique<Id>())
-                  .addItem("android:attr/paddingStart", ResourceId(0x010103b3),
+                  .AddItem("android:attr/paddingStart", ResourceId(0x010103b3),
                            util::make_unique<Id>())
-                  .addItem("android:attr/requiresSmallestWidthDp",
+                  .AddItem("android:attr/requiresSmallestWidthDp",
                            ResourceId(0x01010364), util::make_unique<Id>())
-                  .addItem("android:attr/colorAccent", ResourceId(0x01010435),
+                  .AddItem("android:attr/colorAccent", ResourceId(0x01010435),
                            util::make_unique<Id>())
-                  .build())
-          .addValue(
-              "app:style/Foo", test::parseConfigOrDie("v21"),
+                  .Build())
+          .AddValue(
+              "app:style/Foo", test::ParseConfigOrDie("v21"),
               ResourceId(0x7f020000),
               test::StyleBuilder()
-                  .addItem("android:attr/paddingEnd", ResourceId(0x010103b4),
+                  .AddItem("android:attr/paddingEnd", ResourceId(0x010103b4),
                            util::make_unique<Id>())
-                  .build())
-          .build();
+                  .Build())
+          .Build();
 
   std::unique_ptr<IAaptContext> context = test::ContextBuilder()
-                                              .setCompilationPackage("app")
-                                              .setPackageId(0x7f)
-                                              .build();
+                                              .SetCompilationPackage("app")
+                                              .SetPackageId(0x7f)
+                                              .Build();
 
   AutoVersioner versioner;
-  ASSERT_TRUE(versioner.consume(context.get(), table.get()));
+  ASSERT_TRUE(versioner.Consume(context.get(), table.get()));
 
-  Style* style = test::getValueForConfig<Style>(table.get(), "app:style/Foo",
-                                                test::parseConfigOrDie("v4"));
+  Style* style = test::GetValueForConfig<Style>(table.get(), "app:style/Foo",
+                                                test::ParseConfigOrDie("v4"));
   ASSERT_NE(style, nullptr);
   ASSERT_EQ(style->entries.size(), 1u);
   AAPT_ASSERT_TRUE(style->entries.front().key.name);
   EXPECT_EQ(style->entries.front().key.name.value(),
-            test::parseNameOrDie("android:attr/onClick"));
+            test::ParseNameOrDie("android:attr/onClick"));
 
-  style = test::getValueForConfig<Style>(table.get(), "app:style/Foo",
-                                         test::parseConfigOrDie("v13"));
+  style = test::GetValueForConfig<Style>(table.get(), "app:style/Foo",
+                                         test::ParseConfigOrDie("v13"));
   ASSERT_NE(style, nullptr);
   ASSERT_EQ(style->entries.size(), 2u);
   AAPT_ASSERT_TRUE(style->entries[0].key.name);
   EXPECT_EQ(style->entries[0].key.name.value(),
-            test::parseNameOrDie("android:attr/onClick"));
+            test::ParseNameOrDie("android:attr/onClick"));
   AAPT_ASSERT_TRUE(style->entries[1].key.name);
   EXPECT_EQ(style->entries[1].key.name.value(),
-            test::parseNameOrDie("android:attr/requiresSmallestWidthDp"));
+            test::ParseNameOrDie("android:attr/requiresSmallestWidthDp"));
 
-  style = test::getValueForConfig<Style>(table.get(), "app:style/Foo",
-                                         test::parseConfigOrDie("v17"));
+  style = test::GetValueForConfig<Style>(table.get(), "app:style/Foo",
+                                         test::ParseConfigOrDie("v17"));
   ASSERT_NE(style, nullptr);
   ASSERT_EQ(style->entries.size(), 3u);
   AAPT_ASSERT_TRUE(style->entries[0].key.name);
   EXPECT_EQ(style->entries[0].key.name.value(),
-            test::parseNameOrDie("android:attr/onClick"));
+            test::ParseNameOrDie("android:attr/onClick"));
   AAPT_ASSERT_TRUE(style->entries[1].key.name);
   EXPECT_EQ(style->entries[1].key.name.value(),
-            test::parseNameOrDie("android:attr/requiresSmallestWidthDp"));
+            test::ParseNameOrDie("android:attr/requiresSmallestWidthDp"));
   AAPT_ASSERT_TRUE(style->entries[2].key.name);
   EXPECT_EQ(style->entries[2].key.name.value(),
-            test::parseNameOrDie("android:attr/paddingStart"));
+            test::ParseNameOrDie("android:attr/paddingStart"));
 
-  style = test::getValueForConfig<Style>(table.get(), "app:style/Foo",
-                                         test::parseConfigOrDie("v21"));
+  style = test::GetValueForConfig<Style>(table.get(), "app:style/Foo",
+                                         test::ParseConfigOrDie("v21"));
   ASSERT_NE(style, nullptr);
   ASSERT_EQ(style->entries.size(), 1u);
   AAPT_ASSERT_TRUE(style->entries.front().key.name);
   EXPECT_EQ(style->entries.front().key.name.value(),
-            test::parseNameOrDie("android:attr/paddingEnd"));
+            test::ParseNameOrDie("android:attr/paddingEnd"));
 }
 
 }  // namespace aapt
diff --git a/tools/aapt2/link/Link.cpp b/tools/aapt2/link/Link.cpp
index 6dd34e3e5f11f..717978eaa2262 100644
--- a/tools/aapt2/link/Link.cpp
+++ b/tools/aapt2/link/Link.cpp
@@ -14,6 +14,17 @@
  * limitations under the License.
  */
 
+#include <sys/stat.h>
+
+#include <fstream>
+#include <queue>
+#include <unordered_map>
+#include <vector>
+
+#include "android-base/errors.h"
+#include "android-base/file.h"
+#include "google/protobuf/io/coded_stream.h"
+
 #include "AppInfo.h"
 #include "Debug.h"
 #include "Flags.h"
@@ -32,7 +43,6 @@
 #include "java/ProguardRules.h"
 #include "link/Linkers.h"
 #include "link/ManifestFixer.h"
-#include "link/ProductFilter.h"
 #include "link/ReferenceLinker.h"
 #include "link/TableMerger.h"
 #include "process/IResourceTableConsumer.h"
@@ -44,179 +54,179 @@
 #include "util/StringPiece.h"
 #include "xml/XmlDom.h"
 
-#include <android-base/file.h>
-#include <google/protobuf/io/coded_stream.h>
-
-#include <sys/stat.h>
-#include <fstream>
-#include <queue>
-#include <unordered_map>
-#include <vector>
-
-using google::protobuf::io::CopyingOutputStreamAdaptor;
+using ::google::protobuf::io::CopyingOutputStreamAdaptor;
 
 namespace aapt {
 
 struct LinkOptions {
-  std::string outputPath;
-  std::string manifestPath;
-  std::vector<std::string> includePaths;
-  std::vector<std::string> overlayFiles;
+  std::string output_path;
+  std::string manifest_path;
+  std::vector<std::string> include_paths;
+  std::vector<std::string> overlay_files;
+  bool output_to_directory = false;
+  bool auto_add_overlay = false;
 
   // Java/Proguard options.
-  Maybe<std::string> generateJavaClassPath;
-  Maybe<std::string> customJavaPackage;
-  std::set<std::string> extraJavaPackages;
-  Maybe<std::string> generateProguardRulesPath;
-  Maybe<std::string> generateMainDexProguardRulesPath;
+  Maybe<std::string> generate_java_class_path;
+  Maybe<std::string> custom_java_package;
+  std::set<std::string> extra_java_packages;
+  Maybe<std::string> generate_proguard_rules_path;
+  Maybe<std::string> generate_main_dex_proguard_rules_path;
+  bool generate_non_final_ids = false;
+  std::vector<std::string> javadoc_annotations;
+  Maybe<std::string> private_symbols;
 
-  bool noAutoVersion = false;
-  bool noVersionVectors = false;
-  bool noResourceDeduping = false;
-  bool staticLib = false;
-  bool noStaticLibPackages = false;
-  bool generateNonFinalIds = false;
-  std::vector<std::string> javadocAnnotations;
-  bool outputToDirectory = false;
-  bool noXmlNamespaces = false;
-  bool autoAddOverlay = false;
-  bool doNotCompressAnything = false;
-  std::unordered_set<std::string> extensionsToNotCompress;
-  Maybe<std::string> privateSymbols;
-  ManifestFixerOptions manifestFixerOptions;
+  // Optimizations/features.
+  bool no_auto_version = false;
+  bool no_version_vectors = false;
+  bool no_resource_deduping = false;
+  bool no_xml_namespaces = false;
+  bool do_not_compress_anything = false;
+  std::unordered_set<std::string> extensions_to_not_compress;
+
+  // Static lib options.
+  bool static_lib = false;
+  bool no_static_lib_packages = false;
+
+  // AndroidManifest.xml massaging options.
+  ManifestFixerOptions manifest_fixer_options;
+
+  // Products to use/filter on.
   std::unordered_set<std::string> products;
 
   // Split APK options.
-  TableSplitterOptions tableSplitterOptions;
-  std::vector<SplitConstraints> splitConstraints;
-  std::vector<std::string> splitPaths;
+  TableSplitterOptions table_splitter_options;
+  std::vector<SplitConstraints> split_constraints;
+  std::vector<std::string> split_paths;
 
   // Stable ID options.
-  std::unordered_map<ResourceName, ResourceId> stableIdMap;
-  Maybe<std::string> resourceIdMapPath;
+  std::unordered_map<ResourceName, ResourceId> stable_id_map;
+  Maybe<std::string> resource_id_map_path;
 };
 
 class LinkContext : public IAaptContext {
  public:
-  LinkContext() : mNameMangler({}) {}
+  LinkContext() : name_mangler_({}) {}
 
-  IDiagnostics* getDiagnostics() override { return &mDiagnostics; }
+  IDiagnostics* GetDiagnostics() override { return &diagnostics_; }
 
-  NameMangler* getNameMangler() override { return &mNameMangler; }
+  NameMangler* GetNameMangler() override { return &name_mangler_; }
 
-  void setNameManglerPolicy(const NameManglerPolicy& policy) {
-    mNameMangler = NameMangler(policy);
+  void SetNameManglerPolicy(const NameManglerPolicy& policy) {
+    name_mangler_ = NameMangler(policy);
   }
 
-  const std::string& getCompilationPackage() override {
-    return mCompilationPackage;
+  const std::string& GetCompilationPackage() override {
+    return compilation_package_;
   }
 
-  void setCompilationPackage(const StringPiece& packageName) {
-    mCompilationPackage = packageName.toString();
+  void SetCompilationPackage(const StringPiece& package_name) {
+    compilation_package_ = package_name.ToString();
   }
 
-  uint8_t getPackageId() override { return mPackageId; }
+  uint8_t GetPackageId() override { return package_id_; }
 
-  void setPackageId(uint8_t id) { mPackageId = id; }
+  void SetPackageId(uint8_t id) { package_id_ = id; }
 
-  SymbolTable* getExternalSymbols() override { return &mSymbols; }
+  SymbolTable* GetExternalSymbols() override { return &symbols_; }
 
-  bool verbose() override { return mVerbose; }
+  bool IsVerbose() override { return verbose_; }
 
-  void setVerbose(bool val) { mVerbose = val; }
+  void SetVerbose(bool val) { verbose_ = val; }
 
-  int getMinSdkVersion() override { return mMinSdkVersion; }
+  int GetMinSdkVersion() override { return min_sdk_version_; }
 
-  void setMinSdkVersion(int minSdk) { mMinSdkVersion = minSdk; }
+  void SetMinSdkVersion(int minSdk) { min_sdk_version_ = minSdk; }
 
  private:
-  StdErrDiagnostics mDiagnostics;
-  NameMangler mNameMangler;
-  std::string mCompilationPackage;
-  uint8_t mPackageId = 0x0;
-  SymbolTable mSymbols;
-  bool mVerbose = false;
-  int mMinSdkVersion = 0;
+  DISALLOW_COPY_AND_ASSIGN(LinkContext);
+
+  StdErrDiagnostics diagnostics_;
+  NameMangler name_mangler_;
+  std::string compilation_package_;
+  uint8_t package_id_ = 0x0;
+  SymbolTable symbols_;
+  bool verbose_ = false;
+  int min_sdk_version_ = 0;
 };
 
-static bool copyFileToArchive(io::IFile* file, const std::string& outPath,
-                              uint32_t compressionFlags, IArchiveWriter* writer,
-                              IAaptContext* context) {
-  std::unique_ptr<io::IData> data = file->openAsData();
+static bool CopyFileToArchive(io::IFile* file, const std::string& out_path,
+                              uint32_t compression_flags,
+                              IArchiveWriter* writer, IAaptContext* context) {
+  std::unique_ptr<io::IData> data = file->OpenAsData();
   if (!data) {
-    context->getDiagnostics()->error(DiagMessage(file->getSource())
+    context->GetDiagnostics()->Error(DiagMessage(file->GetSource())
                                      << "failed to open file");
     return false;
   }
 
   const uint8_t* buffer = reinterpret_cast<const uint8_t*>(data->data());
-  const size_t bufferSize = data->size();
+  const size_t buffer_size = data->size();
 
-  if (context->verbose()) {
-    context->getDiagnostics()->note(DiagMessage() << "writing " << outPath
+  if (context->IsVerbose()) {
+    context->GetDiagnostics()->Note(DiagMessage() << "writing " << out_path
                                                   << " to archive");
   }
 
-  if (writer->startEntry(outPath, compressionFlags)) {
-    if (writer->writeEntry(buffer, bufferSize)) {
-      if (writer->finishEntry()) {
+  if (writer->StartEntry(out_path, compression_flags)) {
+    if (writer->WriteEntry(buffer, buffer_size)) {
+      if (writer->FinishEntry()) {
         return true;
       }
     }
   }
 
-  context->getDiagnostics()->error(DiagMessage() << "failed to write file "
-                                                 << outPath);
+  context->GetDiagnostics()->Error(DiagMessage() << "failed to write file "
+                                                 << out_path);
   return false;
 }
 
-static bool flattenXml(xml::XmlResource* xmlRes, const StringPiece& path,
-                       Maybe<size_t> maxSdkLevel, bool keepRawValues,
+static bool FlattenXml(xml::XmlResource* xml_res, const StringPiece& path,
+                       Maybe<size_t> max_sdk_level, bool keep_raw_values,
                        IArchiveWriter* writer, IAaptContext* context) {
   BigBuffer buffer(1024);
   XmlFlattenerOptions options = {};
-  options.keepRawValues = keepRawValues;
-  options.maxSdkLevel = maxSdkLevel;
+  options.keep_raw_values = keep_raw_values;
+  options.max_sdk_level = max_sdk_level;
   XmlFlattener flattener(&buffer, options);
-  if (!flattener.consume(context, xmlRes)) {
+  if (!flattener.Consume(context, xml_res)) {
     return false;
   }
 
-  if (context->verbose()) {
+  if (context->IsVerbose()) {
     DiagMessage msg;
     msg << "writing " << path << " to archive";
-    if (maxSdkLevel) {
-      msg << " maxSdkLevel=" << maxSdkLevel.value()
-          << " keepRawValues=" << keepRawValues;
+    if (max_sdk_level) {
+      msg << " maxSdkLevel=" << max_sdk_level.value()
+          << " keepRawValues=" << keep_raw_values;
     }
-    context->getDiagnostics()->note(msg);
+    context->GetDiagnostics()->Note(msg);
   }
 
-  if (writer->startEntry(path, ArchiveEntry::kCompress)) {
-    if (writer->writeEntry(buffer)) {
-      if (writer->finishEntry()) {
+  if (writer->StartEntry(path, ArchiveEntry::kCompress)) {
+    if (writer->WriteEntry(buffer)) {
+      if (writer->FinishEntry()) {
         return true;
       }
     }
   }
-  context->getDiagnostics()->error(DiagMessage() << "failed to write " << path
+  context->GetDiagnostics()->Error(DiagMessage() << "failed to write " << path
                                                  << " to archive");
   return false;
 }
 
-static std::unique_ptr<ResourceTable> loadTableFromPb(const Source& source,
+static std::unique_ptr<ResourceTable> LoadTableFromPb(const Source& source,
                                                       const void* data,
                                                       size_t len,
                                                       IDiagnostics* diag) {
-  pb::ResourceTable pbTable;
-  if (!pbTable.ParseFromArray(data, len)) {
-    diag->error(DiagMessage(source) << "invalid compiled table");
+  pb::ResourceTable pb_table;
+  if (!pb_table.ParseFromArray(data, len)) {
+    diag->Error(DiagMessage(source) << "invalid compiled table");
     return {};
   }
 
   std::unique_ptr<ResourceTable> table =
-      deserializeTableFromPb(pbTable, source, diag);
+      DeserializeTableFromPb(pb_table, source, diag);
   if (!table) {
     return {};
   }
@@ -226,33 +236,33 @@ static std::unique_ptr<ResourceTable> loadTableFromPb(const Source& source,
 /**
  * Inflates an XML file from the source path.
  */
-static std::unique_ptr<xml::XmlResource> loadXml(const std::string& path,
+static std::unique_ptr<xml::XmlResource> LoadXml(const std::string& path,
                                                  IDiagnostics* diag) {
   std::ifstream fin(path, std::ifstream::binary);
   if (!fin) {
-    diag->error(DiagMessage(path) << strerror(errno));
+    diag->Error(DiagMessage(path) << strerror(errno));
     return {};
   }
-  return xml::inflate(&fin, diag, Source(path));
+  return xml::Inflate(&fin, diag, Source(path));
 }
 
 struct ResourceFileFlattenerOptions {
-  bool noAutoVersion = false;
-  bool noVersionVectors = false;
-  bool noXmlNamespaces = false;
-  bool keepRawValues = false;
-  bool doNotCompressAnything = false;
-  bool updateProguardSpec = false;
-  std::unordered_set<std::string> extensionsToNotCompress;
+  bool no_auto_version = false;
+  bool no_version_vectors = false;
+  bool no_xml_namespaces = false;
+  bool keep_raw_values = false;
+  bool do_not_compress_anything = false;
+  bool update_proguard_spec = false;
+  std::unordered_set<std::string> extensions_to_not_compress;
 };
 
 class ResourceFileFlattener {
  public:
   ResourceFileFlattener(const ResourceFileFlattenerOptions& options,
-                        IAaptContext* context, proguard::KeepSet* keepSet)
-      : mOptions(options), mContext(context), mKeepSet(keepSet) {}
+                        IAaptContext* context, proguard::KeepSet* keep_set)
+      : options_(options), context_(context), keep_set_(keep_set) {}
 
-  bool flatten(ResourceTable* table, IArchiveWriter* archiveWriter);
+  bool Flatten(ResourceTable* table, IArchiveWriter* archive_writer);
 
  private:
   struct FileOperation {
@@ -262,118 +272,119 @@ class ResourceFileFlattener {
     const ResourceEntry* entry;
 
     // The file to copy as-is.
-    io::IFile* fileToCopy;
+    io::IFile* file_to_copy;
 
     // The XML to process and flatten.
-    std::unique_ptr<xml::XmlResource> xmlToFlatten;
+    std::unique_ptr<xml::XmlResource> xml_to_flatten;
 
     // The destination to write this file to.
-    std::string dstPath;
-    bool skipVersion = false;
+    std::string dst_path;
+    bool skip_version = false;
   };
 
-  uint32_t getCompressionFlags(const StringPiece& str);
+  uint32_t GetCompressionFlags(const StringPiece& str);
 
-  bool linkAndVersionXmlFile(ResourceTable* table, FileOperation* fileOp,
-                             std::queue<FileOperation>* outFileOpQueue);
+  bool LinkAndVersionXmlFile(ResourceTable* table, FileOperation* file_op,
+                             std::queue<FileOperation>* out_file_op_queue);
 
-  ResourceFileFlattenerOptions mOptions;
-  IAaptContext* mContext;
-  proguard::KeepSet* mKeepSet;
+  ResourceFileFlattenerOptions options_;
+  IAaptContext* context_;
+  proguard::KeepSet* keep_set_;
 };
 
-uint32_t ResourceFileFlattener::getCompressionFlags(const StringPiece& str) {
-  if (mOptions.doNotCompressAnything) {
+uint32_t ResourceFileFlattener::GetCompressionFlags(const StringPiece& str) {
+  if (options_.do_not_compress_anything) {
     return 0;
   }
 
-  for (const std::string& extension : mOptions.extensionsToNotCompress) {
-    if (util::stringEndsWith(str, extension)) {
+  for (const std::string& extension : options_.extensions_to_not_compress) {
+    if (util::EndsWith(str, extension)) {
       return 0;
     }
   }
   return ArchiveEntry::kCompress;
 }
 
-bool ResourceFileFlattener::linkAndVersionXmlFile(
-    ResourceTable* table, FileOperation* fileOp,
-    std::queue<FileOperation>* outFileOpQueue) {
-  xml::XmlResource* doc = fileOp->xmlToFlatten.get();
+bool ResourceFileFlattener::LinkAndVersionXmlFile(
+    ResourceTable* table, FileOperation* file_op,
+    std::queue<FileOperation>* out_file_op_queue) {
+  xml::XmlResource* doc = file_op->xml_to_flatten.get();
   const Source& src = doc->file.source;
 
-  if (mContext->verbose()) {
-    mContext->getDiagnostics()->note(DiagMessage() << "linking " << src.path);
+  if (context_->IsVerbose()) {
+    context_->GetDiagnostics()->Note(DiagMessage() << "linking " << src.path);
   }
 
-  XmlReferenceLinker xmlLinker;
-  if (!xmlLinker.consume(mContext, doc)) {
+  XmlReferenceLinker xml_linker;
+  if (!xml_linker.Consume(context_, doc)) {
     return false;
   }
 
-  if (mOptions.updateProguardSpec &&
-      !proguard::collectProguardRules(src, doc, mKeepSet)) {
+  if (options_.update_proguard_spec &&
+      !proguard::CollectProguardRules(src, doc, keep_set_)) {
     return false;
   }
 
-  if (mOptions.noXmlNamespaces) {
-    XmlNamespaceRemover namespaceRemover;
-    if (!namespaceRemover.consume(mContext, doc)) {
+  if (options_.no_xml_namespaces) {
+    XmlNamespaceRemover namespace_remover;
+    if (!namespace_remover.Consume(context_, doc)) {
       return false;
     }
   }
 
-  if (!mOptions.noAutoVersion) {
-    if (mOptions.noVersionVectors) {
+  if (!options_.no_auto_version) {
+    if (options_.no_version_vectors) {
       // Skip this if it is a vector or animated-vector.
-      xml::Element* el = xml::findRootElement(doc);
-      if (el && el->namespaceUri.empty()) {
+      xml::Element* el = xml::FindRootElement(doc);
+      if (el && el->namespace_uri.empty()) {
         if (el->name == "vector" || el->name == "animated-vector") {
           // We are NOT going to version this file.
-          fileOp->skipVersion = true;
+          file_op->skip_version = true;
           return true;
         }
       }
     }
 
-    const ConfigDescription& config = fileOp->config;
+    const ConfigDescription& config = file_op->config;
 
     // Find the first SDK level used that is higher than this defined config and
     // not superseded by a lower or equal SDK level resource.
-    const int minSdkVersion = mContext->getMinSdkVersion();
-    for (int sdkLevel : xmlLinker.getSdkLevels()) {
-      if (sdkLevel > minSdkVersion && sdkLevel > config.sdkVersion) {
-        if (!shouldGenerateVersionedResource(fileOp->entry, config, sdkLevel)) {
+    const int min_sdk_version = context_->GetMinSdkVersion();
+    for (int sdk_level : xml_linker.sdk_levels()) {
+      if (sdk_level > min_sdk_version && sdk_level > config.sdkVersion) {
+        if (!ShouldGenerateVersionedResource(file_op->entry, config,
+                                             sdk_level)) {
           // If we shouldn't generate a versioned resource, stop checking.
           break;
         }
 
-        ResourceFile versionedFileDesc = doc->file;
-        versionedFileDesc.config.sdkVersion = (uint16_t)sdkLevel;
+        ResourceFile versioned_file_desc = doc->file;
+        versioned_file_desc.config.sdkVersion = (uint16_t)sdk_level;
 
-        FileOperation newFileOp;
-        newFileOp.xmlToFlatten = util::make_unique<xml::XmlResource>(
-            versionedFileDesc, doc->root->clone());
-        newFileOp.config = versionedFileDesc.config;
-        newFileOp.entry = fileOp->entry;
-        newFileOp.dstPath = ResourceUtils::buildResourceFileName(
-            versionedFileDesc, mContext->getNameMangler());
+        FileOperation new_file_op;
+        new_file_op.xml_to_flatten = util::make_unique<xml::XmlResource>(
+            versioned_file_desc, doc->root->Clone());
+        new_file_op.config = versioned_file_desc.config;
+        new_file_op.entry = file_op->entry;
+        new_file_op.dst_path = ResourceUtils::BuildResourceFileName(
+            versioned_file_desc, context_->GetNameMangler());
 
-        if (mContext->verbose()) {
-          mContext->getDiagnostics()->note(
-              DiagMessage(versionedFileDesc.source)
+        if (context_->IsVerbose()) {
+          context_->GetDiagnostics()->Note(
+              DiagMessage(versioned_file_desc.source)
               << "auto-versioning resource from config '" << config << "' -> '"
-              << versionedFileDesc.config << "'");
+              << versioned_file_desc.config << "'");
         }
 
-        bool added = table->addFileReferenceAllowMangled(
-            versionedFileDesc.name, versionedFileDesc.config,
-            versionedFileDesc.source, newFileOp.dstPath, nullptr,
-            mContext->getDiagnostics());
+        bool added = table->AddFileReferenceAllowMangled(
+            versioned_file_desc.name, versioned_file_desc.config,
+            versioned_file_desc.source, new_file_op.dst_path, nullptr,
+            context_->GetDiagnostics());
         if (!added) {
           return false;
         }
 
-        outFileOpQueue->push(std::move(newFileOp));
+        out_file_op_queue->push(std::move(new_file_op));
         break;
       }
     }
@@ -386,100 +397,96 @@ bool ResourceFileFlattener::linkAndVersionXmlFile(
  * will
  * corrupt the iteration order.
  */
-bool ResourceFileFlattener::flatten(ResourceTable* table,
-                                    IArchiveWriter* archiveWriter) {
+bool ResourceFileFlattener::Flatten(ResourceTable* table,
+                                    IArchiveWriter* archive_writer) {
   bool error = false;
   std::map<std::pair<ConfigDescription, StringPiece>, FileOperation>
-      configSortedFiles;
+      config_sorted_files;
 
   for (auto& pkg : table->packages) {
     for (auto& type : pkg->types) {
       // Sort by config and name, so that we get better locality in the zip
       // file.
-      configSortedFiles.clear();
-      std::queue<FileOperation> fileOperations;
+      config_sorted_files.clear();
+      std::queue<FileOperation> file_operations;
 
       // Populate the queue with all files in the ResourceTable.
       for (auto& entry : type->entries) {
-        for (auto& configValue : entry->values) {
-          FileReference* fileRef =
-              valueCast<FileReference>(configValue->value.get());
-          if (!fileRef) {
+        for (auto& config_value : entry->values) {
+          FileReference* file_ref =
+              ValueCast<FileReference>(config_value->value.get());
+          if (!file_ref) {
             continue;
           }
 
-          io::IFile* file = fileRef->file;
+          io::IFile* file = file_ref->file;
           if (!file) {
-            mContext->getDiagnostics()->error(DiagMessage(fileRef->getSource())
+            context_->GetDiagnostics()->Error(DiagMessage(file_ref->GetSource())
                                               << "file not found");
             return false;
           }
 
-          FileOperation fileOp;
-          fileOp.entry = entry.get();
-          fileOp.dstPath = *fileRef->path;
-          fileOp.config = configValue->config;
+          FileOperation file_op;
+          file_op.entry = entry.get();
+          file_op.dst_path = *file_ref->path;
+          file_op.config = config_value->config;
 
-          const StringPiece srcPath = file->getSource().path;
+          const StringPiece src_path = file->GetSource().path;
           if (type->type != ResourceType::kRaw &&
-              (util::stringEndsWith(srcPath, ".xml.flat") ||
-               util::stringEndsWith(srcPath, ".xml"))) {
-            std::unique_ptr<io::IData> data = file->openAsData();
+              (util::EndsWith(src_path, ".xml.flat") ||
+               util::EndsWith(src_path, ".xml"))) {
+            std::unique_ptr<io::IData> data = file->OpenAsData();
             if (!data) {
-              mContext->getDiagnostics()->error(DiagMessage(file->getSource())
+              context_->GetDiagnostics()->Error(DiagMessage(file->GetSource())
                                                 << "failed to open file");
               return false;
             }
 
-            fileOp.xmlToFlatten =
-                xml::inflate(data->data(), data->size(),
-                             mContext->getDiagnostics(), file->getSource());
+            file_op.xml_to_flatten =
+                xml::Inflate(data->data(), data->size(),
+                             context_->GetDiagnostics(), file->GetSource());
 
-            if (!fileOp.xmlToFlatten) {
+            if (!file_op.xml_to_flatten) {
               return false;
             }
 
-            fileOp.xmlToFlatten->file.config = configValue->config;
-            fileOp.xmlToFlatten->file.source = fileRef->getSource();
-            fileOp.xmlToFlatten->file.name =
+            file_op.xml_to_flatten->file.config = config_value->config;
+            file_op.xml_to_flatten->file.source = file_ref->GetSource();
+            file_op.xml_to_flatten->file.name =
                 ResourceName(pkg->name, type->type, entry->name);
 
             // Enqueue the XML files to be processed.
-            fileOperations.push(std::move(fileOp));
+            file_operations.push(std::move(file_op));
           } else {
-            fileOp.fileToCopy = file;
+            file_op.file_to_copy = file;
 
             // NOTE(adamlesinski): Explicitly construct a StringPiece here, or
-            // else
-            // we end up copying the string in the std::make_pair() method, then
-            // creating a StringPiece from the copy, which would cause us to end
-            // up
-            // referencing garbage in the map.
-            const StringPiece entryName(entry->name);
-            configSortedFiles[std::make_pair(configValue->config, entryName)] =
-                std::move(fileOp);
+            // else we end up copying the string in the std::make_pair() method,
+            // then creating a StringPiece from the copy, which would cause us
+            // to end up referencing garbage in the map.
+            const StringPiece entry_name(entry->name);
+            config_sorted_files[std::make_pair(
+                config_value->config, entry_name)] = std::move(file_op);
           }
         }
       }
 
       // Now process the XML queue
-      for (; !fileOperations.empty(); fileOperations.pop()) {
-        FileOperation& fileOp = fileOperations.front();
+      for (; !file_operations.empty(); file_operations.pop()) {
+        FileOperation& file_op = file_operations.front();
 
-        if (!linkAndVersionXmlFile(table, &fileOp, &fileOperations)) {
+        if (!LinkAndVersionXmlFile(table, &file_op, &file_operations)) {
           error = true;
           continue;
         }
 
         // NOTE(adamlesinski): Explicitly construct a StringPiece here, or else
         // we end up copying the string in the std::make_pair() method, then
-        // creating
-        // a StringPiece from the copy, which would cause us to end up
-        // referencing
-        // garbage in the map.
-        const StringPiece entryName(fileOp.entry->name);
-        configSortedFiles[std::make_pair(fileOp.config, entryName)] =
-            std::move(fileOp);
+        // creating a StringPiece from the copy, which would cause us to end up
+        // referencing garbage in the map.
+        const StringPiece entry_name(file_op.entry->name);
+        config_sorted_files[std::make_pair(file_op.config, entry_name)] =
+            std::move(file_op);
       }
 
       if (error) {
@@ -487,28 +494,28 @@ bool ResourceFileFlattener::flatten(ResourceTable* table,
       }
 
       // Now flatten the sorted values.
-      for (auto& mapEntry : configSortedFiles) {
-        const ConfigDescription& config = mapEntry.first.first;
-        const FileOperation& fileOp = mapEntry.second;
+      for (auto& map_entry : config_sorted_files) {
+        const ConfigDescription& config = map_entry.first.first;
+        const FileOperation& file_op = map_entry.second;
 
-        if (fileOp.xmlToFlatten) {
-          Maybe<size_t> maxSdkLevel;
-          if (!mOptions.noAutoVersion && !fileOp.skipVersion) {
-            maxSdkLevel =
+        if (file_op.xml_to_flatten) {
+          Maybe<size_t> max_sdk_level;
+          if (!options_.no_auto_version && !file_op.skip_version) {
+            max_sdk_level =
                 std::max<size_t>(std::max<size_t>(config.sdkVersion, 1u),
-                                 mContext->getMinSdkVersion());
+                                 context_->GetMinSdkVersion());
           }
 
-          bool result =
-              flattenXml(fileOp.xmlToFlatten.get(), fileOp.dstPath, maxSdkLevel,
-                         mOptions.keepRawValues, archiveWriter, mContext);
+          bool result = FlattenXml(
+              file_op.xml_to_flatten.get(), file_op.dst_path, max_sdk_level,
+              options_.keep_raw_values, archive_writer, context_);
           if (!result) {
             error = true;
           }
         } else {
-          bool result = copyFileToArchive(fileOp.fileToCopy, fileOp.dstPath,
-                                          getCompressionFlags(fileOp.dstPath),
-                                          archiveWriter, mContext);
+          bool result = CopyFileToArchive(
+              file_op.file_to_copy, file_op.dst_path,
+              GetCompressionFlags(file_op.dst_path), archive_writer, context_);
           if (!result) {
             error = true;
           }
@@ -519,136 +526,136 @@ bool ResourceFileFlattener::flatten(ResourceTable* table,
   return !error;
 }
 
-static bool writeStableIdMapToPath(
+static bool WriteStableIdMapToPath(
     IDiagnostics* diag,
-    const std::unordered_map<ResourceName, ResourceId>& idMap,
-    const std::string& idMapPath) {
-  std::ofstream fout(idMapPath, std::ofstream::binary);
+    const std::unordered_map<ResourceName, ResourceId>& id_map,
+    const std::string& id_map_path) {
+  std::ofstream fout(id_map_path, std::ofstream::binary);
   if (!fout) {
-    diag->error(DiagMessage(idMapPath) << strerror(errno));
+    diag->Error(DiagMessage(id_map_path) << strerror(errno));
     return false;
   }
 
-  for (const auto& entry : idMap) {
+  for (const auto& entry : id_map) {
     const ResourceName& name = entry.first;
     const ResourceId& id = entry.second;
     fout << name << " = " << id << "\n";
   }
 
   if (!fout) {
-    diag->error(DiagMessage(idMapPath) << "failed writing to file: "
-                                       << strerror(errno));
+    diag->Error(DiagMessage(id_map_path)
+                << "failed writing to file: "
+                << android::base::SystemErrorCodeToString(errno));
     return false;
   }
 
   return true;
 }
 
-static bool loadStableIdMap(
+static bool LoadStableIdMap(
     IDiagnostics* diag, const std::string& path,
-    std::unordered_map<ResourceName, ResourceId>* outIdMap) {
+    std::unordered_map<ResourceName, ResourceId>* out_id_map) {
   std::string content;
   if (!android::base::ReadFileToString(path, &content)) {
-    diag->error(DiagMessage(path) << "failed reading stable ID file");
+    diag->Error(DiagMessage(path) << "failed reading stable ID file");
     return false;
   }
 
-  outIdMap->clear();
-  size_t lineNo = 0;
-  for (StringPiece line : util::tokenize(content, '\n')) {
-    lineNo++;
-    line = util::trimWhitespace(line);
+  out_id_map->clear();
+  size_t line_no = 0;
+  for (StringPiece line : util::Tokenize(content, '\n')) {
+    line_no++;
+    line = util::TrimWhitespace(line);
     if (line.empty()) {
       continue;
     }
 
     auto iter = std::find(line.begin(), line.end(), '=');
     if (iter == line.end()) {
-      diag->error(DiagMessage(Source(path, lineNo)) << "missing '='");
+      diag->Error(DiagMessage(Source(path, line_no)) << "missing '='");
       return false;
     }
 
     ResourceNameRef name;
-    StringPiece resNameStr =
-        util::trimWhitespace(line.substr(0, std::distance(line.begin(), iter)));
-    if (!ResourceUtils::parseResourceName(resNameStr, &name)) {
-      diag->error(DiagMessage(Source(path, lineNo)) << "invalid resource name '"
-                                                    << resNameStr << "'");
+    StringPiece res_name_str =
+        util::TrimWhitespace(line.substr(0, std::distance(line.begin(), iter)));
+    if (!ResourceUtils::ParseResourceName(res_name_str, &name)) {
+      diag->Error(DiagMessage(Source(path, line_no))
+                  << "invalid resource name '" << res_name_str << "'");
       return false;
     }
 
-    const size_t resIdStartIdx = std::distance(line.begin(), iter) + 1;
-    const size_t resIdStrLen = line.size() - resIdStartIdx;
-    StringPiece resIdStr =
-        util::trimWhitespace(line.substr(resIdStartIdx, resIdStrLen));
+    const size_t res_id_start_idx = std::distance(line.begin(), iter) + 1;
+    const size_t res_id_str_len = line.size() - res_id_start_idx;
+    StringPiece res_id_str =
+        util::TrimWhitespace(line.substr(res_id_start_idx, res_id_str_len));
 
-    Maybe<ResourceId> maybeId = ResourceUtils::parseResourceId(resIdStr);
-    if (!maybeId) {
-      diag->error(DiagMessage(Source(path, lineNo)) << "invalid resource ID '"
-                                                    << resIdStr << "'");
+    Maybe<ResourceId> maybe_id = ResourceUtils::ParseResourceId(res_id_str);
+    if (!maybe_id) {
+      diag->Error(DiagMessage(Source(path, line_no)) << "invalid resource ID '"
+                                                     << res_id_str << "'");
       return false;
     }
 
-    (*outIdMap)[name.toResourceName()] = maybeId.value();
+    (*out_id_map)[name.ToResourceName()] = maybe_id.value();
   }
   return true;
 }
 
-static bool parseSplitParameter(const StringPiece& arg, IDiagnostics* diag,
-                                std::string* outPath,
-                                SplitConstraints* outSplit) {
-  std::vector<std::string> parts = util::split(arg, ':');
+static bool ParseSplitParameter(const StringPiece& arg, IDiagnostics* diag,
+                                std::string* out_path,
+                                SplitConstraints* out_split) {
+  std::vector<std::string> parts = util::Split(arg, ':');
   if (parts.size() != 2) {
-    diag->error(DiagMessage() << "invalid split parameter '" << arg << "'");
-    diag->note(
+    diag->Error(DiagMessage() << "invalid split parameter '" << arg << "'");
+    diag->Note(
         DiagMessage()
         << "should be --split path/to/output.apk:<config>[,<config>...]");
     return false;
   }
-  *outPath = parts[0];
+  *out_path = parts[0];
   std::vector<ConfigDescription> configs;
-  for (const StringPiece& configStr : util::tokenize(parts[1], ',')) {
+  for (const StringPiece& config_str : util::Tokenize(parts[1], ',')) {
     configs.push_back({});
-    if (!ConfigDescription::parse(configStr, &configs.back())) {
-      diag->error(DiagMessage() << "invalid config '" << configStr
+    if (!ConfigDescription::Parse(config_str, &configs.back())) {
+      diag->Error(DiagMessage() << "invalid config '" << config_str
                                 << "' in split parameter '" << arg << "'");
       return false;
     }
   }
-  outSplit->configs.insert(configs.begin(), configs.end());
+  out_split->configs.insert(configs.begin(), configs.end());
   return true;
 }
 
 class LinkCommand {
  public:
   LinkCommand(LinkContext* context, const LinkOptions& options)
-      : mOptions(options),
-        mContext(context),
-        mFinalTable(),
-        mFileCollection(util::make_unique<io::FileCollection>()) {}
+      : options_(options),
+        context_(context),
+        final_table_(),
+        file_collection_(util::make_unique<io::FileCollection>()) {}
 
   /**
    * Creates a SymbolTable that loads symbols from the various APKs and caches
-   * the
-   * results for faster lookup.
+   * the results for faster lookup.
    */
-  bool loadSymbolsFromIncludePaths() {
-    std::unique_ptr<AssetManagerSymbolSource> assetSource =
+  bool LoadSymbolsFromIncludePaths() {
+    std::unique_ptr<AssetManagerSymbolSource> asset_source =
         util::make_unique<AssetManagerSymbolSource>();
-    for (const std::string& path : mOptions.includePaths) {
-      if (mContext->verbose()) {
-        mContext->getDiagnostics()->note(DiagMessage(path)
+    for (const std::string& path : options_.include_paths) {
+      if (context_->IsVerbose()) {
+        context_->GetDiagnostics()->Note(DiagMessage(path)
                                          << "loading include path");
       }
 
       // First try to load the file as a static lib.
-      std::string errorStr;
-      std::unique_ptr<ResourceTable> staticInclude =
-          loadStaticLibrary(path, &errorStr);
-      if (staticInclude) {
-        if (!mOptions.staticLib) {
+      std::string error_str;
+      std::unique_ptr<ResourceTable> static_include =
+          LoadStaticLibrary(path, &error_str);
+      if (static_include) {
+        if (!options_.static_lib) {
           // Can't include static libraries when not building a static library.
-          mContext->getDiagnostics()->error(
+          context_->GetDiagnostics()->Error(
               DiagMessage(path)
               << "can't include static library when building app");
           return false;
@@ -657,92 +664,92 @@ class LinkCommand {
         // If we are using --no-static-lib-packages, we need to rename the
         // package of this
         // table to our compilation package.
-        if (mOptions.noStaticLibPackages) {
+        if (options_.no_static_lib_packages) {
           if (ResourceTablePackage* pkg =
-                  staticInclude->findPackageById(0x7f)) {
-            pkg->name = mContext->getCompilationPackage();
+                  static_include->FindPackageById(0x7f)) {
+            pkg->name = context_->GetCompilationPackage();
           }
         }
 
-        mContext->getExternalSymbols()->appendSource(
-            util::make_unique<ResourceTableSymbolSource>(staticInclude.get()));
+        context_->GetExternalSymbols()->AppendSource(
+            util::make_unique<ResourceTableSymbolSource>(static_include.get()));
 
-        mStaticTableIncludes.push_back(std::move(staticInclude));
+        static_table_includes_.push_back(std::move(static_include));
 
-      } else if (!errorStr.empty()) {
+      } else if (!error_str.empty()) {
         // We had an error with reading, so fail.
-        mContext->getDiagnostics()->error(DiagMessage(path) << errorStr);
+        context_->GetDiagnostics()->Error(DiagMessage(path) << error_str);
         return false;
       }
 
-      if (!assetSource->addAssetPath(path)) {
-        mContext->getDiagnostics()->error(DiagMessage(path)
+      if (!asset_source->AddAssetPath(path)) {
+        context_->GetDiagnostics()->Error(DiagMessage(path)
                                           << "failed to load include path");
         return false;
       }
     }
 
-    mContext->getExternalSymbols()->appendSource(std::move(assetSource));
+    context_->GetExternalSymbols()->AppendSource(std::move(asset_source));
     return true;
   }
 
-  Maybe<AppInfo> extractAppInfoFromManifest(xml::XmlResource* xmlRes,
+  Maybe<AppInfo> ExtractAppInfoFromManifest(xml::XmlResource* xml_res,
                                             IDiagnostics* diag) {
     // Make sure the first element is <manifest> with package attribute.
-    if (xml::Element* manifestEl = xml::findRootElement(xmlRes->root.get())) {
-      AppInfo appInfo;
+    if (xml::Element* manifest_el = xml::FindRootElement(xml_res->root.get())) {
+      AppInfo app_info;
 
-      if (!manifestEl->namespaceUri.empty() || manifestEl->name != "manifest") {
-        diag->error(DiagMessage(xmlRes->file.source)
+      if (!manifest_el->namespace_uri.empty() ||
+          manifest_el->name != "manifest") {
+        diag->Error(DiagMessage(xml_res->file.source)
                     << "root tag must be <manifest>");
         return {};
       }
 
-      xml::Attribute* packageAttr = manifestEl->findAttribute({}, "package");
-      if (!packageAttr) {
-        diag->error(DiagMessage(xmlRes->file.source)
+      xml::Attribute* package_attr = manifest_el->FindAttribute({}, "package");
+      if (!package_attr) {
+        diag->Error(DiagMessage(xml_res->file.source)
                     << "<manifest> must have a 'package' attribute");
         return {};
       }
 
-      appInfo.package = packageAttr->value;
+      app_info.package = package_attr->value;
 
-      if (xml::Attribute* versionCodeAttr =
-              manifestEl->findAttribute(xml::kSchemaAndroid, "versionCode")) {
-        Maybe<uint32_t> maybeCode =
-            ResourceUtils::parseInt(versionCodeAttr->value);
-        if (!maybeCode) {
-          diag->error(
-              DiagMessage(xmlRes->file.source.withLine(manifestEl->lineNumber))
-              << "invalid android:versionCode '" << versionCodeAttr->value
-              << "'");
+      if (xml::Attribute* version_code_attr =
+              manifest_el->FindAttribute(xml::kSchemaAndroid, "versionCode")) {
+        Maybe<uint32_t> maybe_code =
+            ResourceUtils::ParseInt(version_code_attr->value);
+        if (!maybe_code) {
+          diag->Error(DiagMessage(xml_res->file.source.WithLine(
+                          manifest_el->line_number))
+                      << "invalid android:versionCode '"
+                      << version_code_attr->value << "'");
           return {};
         }
-        appInfo.versionCode = maybeCode.value();
+        app_info.version_code = maybe_code.value();
       }
 
-      if (xml::Attribute* revisionCodeAttr =
-              manifestEl->findAttribute(xml::kSchemaAndroid, "revisionCode")) {
-        Maybe<uint32_t> maybeCode =
-            ResourceUtils::parseInt(revisionCodeAttr->value);
-        if (!maybeCode) {
-          diag->error(
-              DiagMessage(xmlRes->file.source.withLine(manifestEl->lineNumber))
-              << "invalid android:revisionCode '" << revisionCodeAttr->value
-              << "'");
+      if (xml::Attribute* revision_code_attr =
+              manifest_el->FindAttribute(xml::kSchemaAndroid, "revisionCode")) {
+        Maybe<uint32_t> maybe_code =
+            ResourceUtils::ParseInt(revision_code_attr->value);
+        if (!maybe_code) {
+          diag->Error(DiagMessage(xml_res->file.source.WithLine(
+                          manifest_el->line_number))
+                      << "invalid android:revisionCode '"
+                      << revision_code_attr->value << "'");
           return {};
         }
-        appInfo.revisionCode = maybeCode.value();
+        app_info.revision_code = maybe_code.value();
       }
 
-      if (xml::Element* usesSdkEl = manifestEl->findChild({}, "uses-sdk")) {
-        if (xml::Attribute* minSdk = usesSdkEl->findAttribute(
+      if (xml::Element* uses_sdk_el = manifest_el->FindChild({}, "uses-sdk")) {
+        if (xml::Attribute* min_sdk = uses_sdk_el->FindAttribute(
                 xml::kSchemaAndroid, "minSdkVersion")) {
-          appInfo.minSdkVersion = minSdk->value;
+          app_info.min_sdk_version = min_sdk->value;
         }
       }
-
-      return appInfo;
+      return app_info;
     }
     return {};
   }
@@ -751,38 +758,36 @@ class LinkCommand {
    * Precondition: ResourceTable doesn't have any IDs assigned yet, nor is it
    * linked.
    * Postcondition: ResourceTable has only one package left. All others are
-   * stripped, or there
-   *                is an error and false is returned.
+   * stripped, or there is an error and false is returned.
    */
-  bool verifyNoExternalPackages() {
-    auto isExtPackageFunc =
+  bool VerifyNoExternalPackages() {
+    auto is_ext_package_func =
         [&](const std::unique_ptr<ResourceTablePackage>& pkg) -> bool {
-      return mContext->getCompilationPackage() != pkg->name || !pkg->id ||
-             pkg->id.value() != mContext->getPackageId();
+      return context_->GetCompilationPackage() != pkg->name || !pkg->id ||
+             pkg->id.value() != context_->GetPackageId();
     };
 
     bool error = false;
-    for (const auto& package : mFinalTable.packages) {
-      if (isExtPackageFunc(package)) {
+    for (const auto& package : final_table_.packages) {
+      if (is_ext_package_func(package)) {
         // We have a package that is not related to the one we're building!
         for (const auto& type : package->types) {
           for (const auto& entry : type->entries) {
-            ResourceNameRef resName(package->name, type->type, entry->name);
+            ResourceNameRef res_name(package->name, type->type, entry->name);
 
-            for (const auto& configValue : entry->values) {
+            for (const auto& config_value : entry->values) {
               // Special case the occurrence of an ID that is being generated
-              // for the
-              // 'android' package. This is due to legacy reasons.
-              if (valueCast<Id>(configValue->value.get()) &&
+              // for the 'android' package. This is due to legacy reasons.
+              if (ValueCast<Id>(config_value->value.get()) &&
                   package->name == "android") {
-                mContext->getDiagnostics()->warn(
-                    DiagMessage(configValue->value->getSource())
-                    << "generated id '" << resName << "' for external package '"
-                    << package->name << "'");
+                context_->GetDiagnostics()->Warn(
+                    DiagMessage(config_value->value->GetSource())
+                    << "generated id '" << res_name
+                    << "' for external package '" << package->name << "'");
               } else {
-                mContext->getDiagnostics()->error(
-                    DiagMessage(configValue->value->getSource())
-                    << "defined resource '" << resName
+                context_->GetDiagnostics()->Error(
+                    DiagMessage(config_value->value->GetSource())
+                    << "defined resource '" << res_name
                     << "' for external package '" << package->name << "'");
                 error = true;
               }
@@ -792,21 +797,21 @@ class LinkCommand {
       }
     }
 
-    auto newEndIter =
-        std::remove_if(mFinalTable.packages.begin(), mFinalTable.packages.end(),
-                       isExtPackageFunc);
-    mFinalTable.packages.erase(newEndIter, mFinalTable.packages.end());
+    auto new_end_iter =
+        std::remove_if(final_table_.packages.begin(),
+                       final_table_.packages.end(), is_ext_package_func);
+    final_table_.packages.erase(new_end_iter, final_table_.packages.end());
     return !error;
   }
 
   /**
    * Returns true if no IDs have been set, false otherwise.
    */
-  bool verifyNoIdsSet() {
-    for (const auto& package : mFinalTable.packages) {
+  bool VerifyNoIdsSet() {
+    for (const auto& package : final_table_.packages) {
       for (const auto& type : package->types) {
         if (type->id) {
-          mContext->getDiagnostics()->error(
+          context_->GetDiagnostics()->Error(
               DiagMessage() << "type " << type->type << " has ID " << std::hex
                             << (int)type->id.value() << std::dec
                             << " assigned");
@@ -815,9 +820,9 @@ class LinkCommand {
 
         for (const auto& entry : type->entries) {
           if (entry->id) {
-            ResourceNameRef resName(package->name, type->type, entry->name);
-            mContext->getDiagnostics()->error(
-                DiagMessage() << "entry " << resName << " has ID " << std::hex
+            ResourceNameRef res_name(package->name, type->type, entry->name);
+            context_->GetDiagnostics()->Error(
+                DiagMessage() << "entry " << res_name << " has ID " << std::hex
                               << (int)entry->id.value() << std::dec
                               << " assigned");
             return false;
@@ -828,265 +833,261 @@ class LinkCommand {
     return true;
   }
 
-  std::unique_ptr<IArchiveWriter> makeArchiveWriter(const StringPiece& out) {
-    if (mOptions.outputToDirectory) {
-      return createDirectoryArchiveWriter(mContext->getDiagnostics(), out);
+  std::unique_ptr<IArchiveWriter> MakeArchiveWriter(const StringPiece& out) {
+    if (options_.output_to_directory) {
+      return CreateDirectoryArchiveWriter(context_->GetDiagnostics(), out);
     } else {
-      return createZipFileArchiveWriter(mContext->getDiagnostics(), out);
+      return CreateZipFileArchiveWriter(context_->GetDiagnostics(), out);
     }
   }
 
-  bool flattenTable(ResourceTable* table, IArchiveWriter* writer) {
+  bool FlattenTable(ResourceTable* table, IArchiveWriter* writer) {
     BigBuffer buffer(1024);
     TableFlattener flattener(&buffer);
-    if (!flattener.consume(mContext, table)) {
+    if (!flattener.Consume(context_, table)) {
       return false;
     }
 
-    if (writer->startEntry("resources.arsc", ArchiveEntry::kAlign)) {
-      if (writer->writeEntry(buffer)) {
-        if (writer->finishEntry()) {
+    if (writer->StartEntry("resources.arsc", ArchiveEntry::kAlign)) {
+      if (writer->WriteEntry(buffer)) {
+        if (writer->FinishEntry()) {
           return true;
         }
       }
     }
 
-    mContext->getDiagnostics()->error(
+    context_->GetDiagnostics()->Error(
         DiagMessage() << "failed to write resources.arsc to archive");
     return false;
   }
 
-  bool flattenTableToPb(ResourceTable* table, IArchiveWriter* writer) {
+  bool FlattenTableToPb(ResourceTable* table, IArchiveWriter* writer) {
     // Create the file/zip entry.
-    if (!writer->startEntry("resources.arsc.flat", 0)) {
-      mContext->getDiagnostics()->error(DiagMessage() << "failed to open");
+    if (!writer->StartEntry("resources.arsc.flat", 0)) {
+      context_->GetDiagnostics()->Error(DiagMessage() << "failed to open");
       return false;
     }
 
     // Make sure CopyingOutputStreamAdaptor is deleted before we call
-    // writer->finishEntry().
+    // writer->FinishEntry().
     {
       // Wrap our IArchiveWriter with an adaptor that implements the
-      // ZeroCopyOutputStream
-      // interface.
+      // ZeroCopyOutputStream interface.
       CopyingOutputStreamAdaptor adaptor(writer);
 
-      std::unique_ptr<pb::ResourceTable> pbTable = serializeTableToPb(table);
-      if (!pbTable->SerializeToZeroCopyStream(&adaptor)) {
-        mContext->getDiagnostics()->error(DiagMessage() << "failed to write");
+      std::unique_ptr<pb::ResourceTable> pb_table = SerializeTableToPb(table);
+      if (!pb_table->SerializeToZeroCopyStream(&adaptor)) {
+        context_->GetDiagnostics()->Error(DiagMessage() << "failed to write");
         return false;
       }
     }
 
-    if (!writer->finishEntry()) {
-      mContext->getDiagnostics()->error(DiagMessage()
+    if (!writer->FinishEntry()) {
+      context_->GetDiagnostics()->Error(DiagMessage()
                                         << "failed to finish entry");
       return false;
     }
     return true;
   }
 
-  bool writeJavaFile(ResourceTable* table,
-                     const StringPiece& packageNameToGenerate,
-                     const StringPiece& outPackage,
-                     const JavaClassGeneratorOptions& javaOptions) {
-    if (!mOptions.generateJavaClassPath) {
+  bool WriteJavaFile(ResourceTable* table,
+                     const StringPiece& package_name_to_generate,
+                     const StringPiece& out_package,
+                     const JavaClassGeneratorOptions& java_options) {
+    if (!options_.generate_java_class_path) {
       return true;
     }
 
-    std::string outPath = mOptions.generateJavaClassPath.value();
-    file::appendPath(&outPath, file::packageToPath(outPackage));
-    if (!file::mkdirs(outPath)) {
-      mContext->getDiagnostics()->error(
-          DiagMessage() << "failed to create directory '" << outPath << "'");
+    std::string out_path = options_.generate_java_class_path.value();
+    file::AppendPath(&out_path, file::PackageToPath(out_package));
+    if (!file::mkdirs(out_path)) {
+      context_->GetDiagnostics()->Error(
+          DiagMessage() << "failed to create directory '" << out_path << "'");
       return false;
     }
 
-    file::appendPath(&outPath, "R.java");
+    file::AppendPath(&out_path, "R.java");
 
-    std::ofstream fout(outPath, std::ofstream::binary);
+    std::ofstream fout(out_path, std::ofstream::binary);
     if (!fout) {
-      mContext->getDiagnostics()->error(DiagMessage()
-                                        << "failed writing to '" << outPath
-                                        << "': " << strerror(errno));
+      context_->GetDiagnostics()->Error(
+          DiagMessage() << "failed writing to '" << out_path << "': "
+                        << android::base::SystemErrorCodeToString(errno));
       return false;
     }
 
-    JavaClassGenerator generator(mContext, table, javaOptions);
-    if (!generator.generate(packageNameToGenerate, outPackage, &fout)) {
-      mContext->getDiagnostics()->error(DiagMessage(outPath)
+    JavaClassGenerator generator(context_, table, java_options);
+    if (!generator.Generate(package_name_to_generate, out_package, &fout)) {
+      context_->GetDiagnostics()->Error(DiagMessage(out_path)
                                         << generator.getError());
       return false;
     }
 
     if (!fout) {
-      mContext->getDiagnostics()->error(DiagMessage()
-                                        << "failed writing to '" << outPath
-                                        << "': " << strerror(errno));
+      context_->GetDiagnostics()->Error(
+          DiagMessage() << "failed writing to '" << out_path << "': "
+                        << android::base::SystemErrorCodeToString(errno));
     }
     return true;
   }
 
-  bool writeManifestJavaFile(xml::XmlResource* manifestXml) {
-    if (!mOptions.generateJavaClassPath) {
+  bool WriteManifestJavaFile(xml::XmlResource* manifest_xml) {
+    if (!options_.generate_java_class_path) {
       return true;
     }
 
-    std::unique_ptr<ClassDefinition> manifestClass =
-        generateManifestClass(mContext->getDiagnostics(), manifestXml);
+    std::unique_ptr<ClassDefinition> manifest_class =
+        GenerateManifestClass(context_->GetDiagnostics(), manifest_xml);
 
-    if (!manifestClass) {
+    if (!manifest_class) {
       // Something bad happened, but we already logged it, so exit.
       return false;
     }
 
-    if (manifestClass->empty()) {
+    if (manifest_class->empty()) {
       // Empty Manifest class, no need to generate it.
       return true;
     }
 
     // Add any JavaDoc annotations to the generated class.
-    for (const std::string& annotation : mOptions.javadocAnnotations) {
-      std::string properAnnotation = "@";
-      properAnnotation += annotation;
-      manifestClass->getCommentBuilder()->appendComment(properAnnotation);
+    for (const std::string& annotation : options_.javadoc_annotations) {
+      std::string proper_annotation = "@";
+      proper_annotation += annotation;
+      manifest_class->GetCommentBuilder()->AppendComment(proper_annotation);
     }
 
-    const std::string& packageUtf8 = mContext->getCompilationPackage();
+    const std::string& package_utf8 = context_->GetCompilationPackage();
 
-    std::string outPath = mOptions.generateJavaClassPath.value();
-    file::appendPath(&outPath, file::packageToPath(packageUtf8));
+    std::string out_path = options_.generate_java_class_path.value();
+    file::AppendPath(&out_path, file::PackageToPath(package_utf8));
 
-    if (!file::mkdirs(outPath)) {
-      mContext->getDiagnostics()->error(
-          DiagMessage() << "failed to create directory '" << outPath << "'");
+    if (!file::mkdirs(out_path)) {
+      context_->GetDiagnostics()->Error(
+          DiagMessage() << "failed to create directory '" << out_path << "'");
       return false;
     }
 
-    file::appendPath(&outPath, "Manifest.java");
+    file::AppendPath(&out_path, "Manifest.java");
 
-    std::ofstream fout(outPath, std::ofstream::binary);
+    std::ofstream fout(out_path, std::ofstream::binary);
     if (!fout) {
-      mContext->getDiagnostics()->error(DiagMessage()
-                                        << "failed writing to '" << outPath
-                                        << "': " << strerror(errno));
+      context_->GetDiagnostics()->Error(
+          DiagMessage() << "failed writing to '" << out_path << "': "
+                        << android::base::SystemErrorCodeToString(errno));
       return false;
     }
 
-    if (!ClassDefinition::writeJavaFile(manifestClass.get(), packageUtf8, true,
-                                        &fout)) {
-      mContext->getDiagnostics()->error(DiagMessage()
-                                        << "failed writing to '" << outPath
-                                        << "': " << strerror(errno));
+    if (!ClassDefinition::WriteJavaFile(manifest_class.get(), package_utf8,
+                                        true, &fout)) {
+      context_->GetDiagnostics()->Error(
+          DiagMessage() << "failed writing to '" << out_path << "': "
+                        << android::base::SystemErrorCodeToString(errno));
       return false;
     }
     return true;
   }
 
-  bool writeProguardFile(const Maybe<std::string>& out,
-                         const proguard::KeepSet& keepSet) {
+  bool WriteProguardFile(const Maybe<std::string>& out,
+                         const proguard::KeepSet& keep_set) {
     if (!out) {
       return true;
     }
 
-    const std::string& outPath = out.value();
-    std::ofstream fout(outPath, std::ofstream::binary);
+    const std::string& out_path = out.value();
+    std::ofstream fout(out_path, std::ofstream::binary);
     if (!fout) {
-      mContext->getDiagnostics()->error(DiagMessage()
-                                        << "failed to open '" << outPath
-                                        << "': " << strerror(errno));
+      context_->GetDiagnostics()->Error(
+          DiagMessage() << "failed to open '" << out_path << "': "
+                        << android::base::SystemErrorCodeToString(errno));
       return false;
     }
 
-    proguard::writeKeepSet(&fout, keepSet);
+    proguard::WriteKeepSet(&fout, keep_set);
     if (!fout) {
-      mContext->getDiagnostics()->error(DiagMessage()
-                                        << "failed writing to '" << outPath
-                                        << "': " << strerror(errno));
+      context_->GetDiagnostics()->Error(
+          DiagMessage() << "failed writing to '" << out_path << "': "
+                        << android::base::SystemErrorCodeToString(errno));
       return false;
     }
     return true;
   }
 
-  std::unique_ptr<ResourceTable> loadStaticLibrary(const std::string& input,
-                                                   std::string* outError) {
+  std::unique_ptr<ResourceTable> LoadStaticLibrary(const std::string& input,
+                                                   std::string* out_error) {
     std::unique_ptr<io::ZipFileCollection> collection =
-        io::ZipFileCollection::create(input, outError);
+        io::ZipFileCollection::Create(input, out_error);
     if (!collection) {
       return {};
     }
-    return loadTablePbFromCollection(collection.get());
+    return LoadTablePbFromCollection(collection.get());
   }
 
-  std::unique_ptr<ResourceTable> loadTablePbFromCollection(
+  std::unique_ptr<ResourceTable> LoadTablePbFromCollection(
       io::IFileCollection* collection) {
-    io::IFile* file = collection->findFile("resources.arsc.flat");
+    io::IFile* file = collection->FindFile("resources.arsc.flat");
     if (!file) {
       return {};
     }
 
-    std::unique_ptr<io::IData> data = file->openAsData();
-    return loadTableFromPb(file->getSource(), data->data(), data->size(),
-                           mContext->getDiagnostics());
+    std::unique_ptr<io::IData> data = file->OpenAsData();
+    return LoadTableFromPb(file->GetSource(), data->data(), data->size(),
+                           context_->GetDiagnostics());
   }
 
-  bool mergeStaticLibrary(const std::string& input, bool override) {
-    if (mContext->verbose()) {
-      mContext->getDiagnostics()->note(DiagMessage()
+  bool MergeStaticLibrary(const std::string& input, bool override) {
+    if (context_->IsVerbose()) {
+      context_->GetDiagnostics()->Note(DiagMessage()
                                        << "merging static library " << input);
     }
 
-    std::string errorStr;
+    std::string error_str;
     std::unique_ptr<io::ZipFileCollection> collection =
-        io::ZipFileCollection::create(input, &errorStr);
+        io::ZipFileCollection::Create(input, &error_str);
     if (!collection) {
-      mContext->getDiagnostics()->error(DiagMessage(input) << errorStr);
+      context_->GetDiagnostics()->Error(DiagMessage(input) << error_str);
       return false;
     }
 
     std::unique_ptr<ResourceTable> table =
-        loadTablePbFromCollection(collection.get());
+        LoadTablePbFromCollection(collection.get());
     if (!table) {
-      mContext->getDiagnostics()->error(DiagMessage(input)
+      context_->GetDiagnostics()->Error(DiagMessage(input)
                                         << "invalid static library");
       return false;
     }
 
-    ResourceTablePackage* pkg = table->findPackageById(0x7f);
+    ResourceTablePackage* pkg = table->FindPackageById(0x7f);
     if (!pkg) {
-      mContext->getDiagnostics()->error(DiagMessage(input)
+      context_->GetDiagnostics()->Error(DiagMessage(input)
                                         << "static library has no package");
       return false;
     }
 
     bool result;
-    if (mOptions.noStaticLibPackages) {
+    if (options_.no_static_lib_packages) {
       // Merge all resources as if they were in the compilation package. This is
-      // the old
-      // behaviour of aapt.
+      // the old behavior of aapt.
 
       // Add the package to the set of --extra-packages so we emit an R.java for
-      // each
-      // library package.
+      // each library package.
       if (!pkg->name.empty()) {
-        mOptions.extraJavaPackages.insert(pkg->name);
+        options_.extra_java_packages.insert(pkg->name);
       }
 
       pkg->name = "";
       if (override) {
-        result = mTableMerger->mergeOverlay(Source(input), table.get(),
-                                            collection.get());
+        result = table_merger_->MergeOverlay(Source(input), table.get(),
+                                             collection.get());
       } else {
         result =
-            mTableMerger->merge(Source(input), table.get(), collection.get());
+            table_merger_->Merge(Source(input), table.get(), collection.get());
       }
 
     } else {
       // This is the proper way to merge libraries, where the package name is
-      // preserved
-      // and resource names are mangled.
-      result = mTableMerger->mergeAndMangle(Source(input), pkg->name,
-                                            table.get(), collection.get());
+      // preserved and resource names are mangled.
+      result = table_merger_->MergeAndMangle(Source(input), pkg->name,
+                                             table.get(), collection.get());
     }
 
     if (!result) {
@@ -1094,52 +1095,52 @@ class LinkCommand {
     }
 
     // Make sure to move the collection into the set of IFileCollections.
-    mCollections.push_back(std::move(collection));
+    collections_.push_back(std::move(collection));
     return true;
   }
 
-  bool mergeResourceTable(io::IFile* file, bool override) {
-    if (mContext->verbose()) {
-      mContext->getDiagnostics()->note(
-          DiagMessage() << "merging resource table " << file->getSource());
+  bool MergeResourceTable(io::IFile* file, bool override) {
+    if (context_->IsVerbose()) {
+      context_->GetDiagnostics()->Note(
+          DiagMessage() << "merging resource table " << file->GetSource());
     }
 
-    std::unique_ptr<io::IData> data = file->openAsData();
+    std::unique_ptr<io::IData> data = file->OpenAsData();
     if (!data) {
-      mContext->getDiagnostics()->error(DiagMessage(file->getSource())
+      context_->GetDiagnostics()->Error(DiagMessage(file->GetSource())
                                         << "failed to open file");
       return false;
     }
 
     std::unique_ptr<ResourceTable> table =
-        loadTableFromPb(file->getSource(), data->data(), data->size(),
-                        mContext->getDiagnostics());
+        LoadTableFromPb(file->GetSource(), data->data(), data->size(),
+                        context_->GetDiagnostics());
     if (!table) {
       return false;
     }
 
     bool result = false;
     if (override) {
-      result = mTableMerger->mergeOverlay(file->getSource(), table.get());
+      result = table_merger_->MergeOverlay(file->GetSource(), table.get());
     } else {
-      result = mTableMerger->merge(file->getSource(), table.get());
+      result = table_merger_->Merge(file->GetSource(), table.get());
     }
     return result;
   }
 
-  bool mergeCompiledFile(io::IFile* file, ResourceFile* fileDesc,
+  bool MergeCompiledFile(io::IFile* file, ResourceFile* file_desc,
                          bool override) {
-    if (mContext->verbose()) {
-      mContext->getDiagnostics()->note(
-          DiagMessage() << "merging '" << fileDesc->name
-                        << "' from compiled file " << file->getSource());
+    if (context_->IsVerbose()) {
+      context_->GetDiagnostics()->Note(
+          DiagMessage() << "merging '" << file_desc->name
+                        << "' from compiled file " << file->GetSource());
     }
 
     bool result = false;
     if (override) {
-      result = mTableMerger->mergeFileOverlay(*fileDesc, file);
+      result = table_merger_->MergeFileOverlay(*file_desc, file);
     } else {
-      result = mTableMerger->mergeFile(*fileDesc, file);
+      result = table_merger_->MergeFile(*file_desc, file);
     }
 
     if (!result) {
@@ -1147,24 +1148,24 @@ class LinkCommand {
     }
 
     // Add the exports of this file to the table.
-    for (SourcedResourceName& exportedSymbol : fileDesc->exportedSymbols) {
-      if (exportedSymbol.name.package.empty()) {
-        exportedSymbol.name.package = mContext->getCompilationPackage();
+    for (SourcedResourceName& exported_symbol : file_desc->exported_symbols) {
+      if (exported_symbol.name.package.empty()) {
+        exported_symbol.name.package = context_->GetCompilationPackage();
       }
 
-      ResourceNameRef resName = exportedSymbol.name;
+      ResourceNameRef res_name = exported_symbol.name;
 
-      Maybe<ResourceName> mangledName =
-          mContext->getNameMangler()->mangleName(exportedSymbol.name);
-      if (mangledName) {
-        resName = mangledName.value();
+      Maybe<ResourceName> mangled_name =
+          context_->GetNameMangler()->MangleName(exported_symbol.name);
+      if (mangled_name) {
+        res_name = mangled_name.value();
       }
 
       std::unique_ptr<Id> id = util::make_unique<Id>();
-      id->setSource(fileDesc->source.withLine(exportedSymbol.line));
-      bool result = mFinalTable.addResourceAllowMangled(
-          resName, ConfigDescription::defaultConfig(), std::string(),
-          std::move(id), mContext->getDiagnostics());
+      id->SetSource(file_desc->source.WithLine(exported_symbol.line));
+      bool result = final_table_.AddResourceAllowMangled(
+          res_name, ConfigDescription::DefaultConfig(), std::string(),
+          std::move(id), context_->GetDiagnostics());
       if (!result) {
         return false;
       }
@@ -1176,35 +1177,34 @@ class LinkCommand {
    * Takes a path to load as a ZIP file and merges the files within into the
    * master ResourceTable.
    * If override is true, conflicting resources are allowed to override each
-   * other, in order of
-   * last seen.
+   * other, in order of last seen.
    *
    * An io::IFileCollection is created from the ZIP file and added to the set of
    * io::IFileCollections that are open.
    */
-  bool mergeArchive(const std::string& input, bool override) {
-    if (mContext->verbose()) {
-      mContext->getDiagnostics()->note(DiagMessage() << "merging archive "
+  bool MergeArchive(const std::string& input, bool override) {
+    if (context_->IsVerbose()) {
+      context_->GetDiagnostics()->Note(DiagMessage() << "merging archive "
                                                      << input);
     }
 
-    std::string errorStr;
+    std::string error_str;
     std::unique_ptr<io::ZipFileCollection> collection =
-        io::ZipFileCollection::create(input, &errorStr);
+        io::ZipFileCollection::Create(input, &error_str);
     if (!collection) {
-      mContext->getDiagnostics()->error(DiagMessage(input) << errorStr);
+      context_->GetDiagnostics()->Error(DiagMessage(input) << error_str);
       return false;
     }
 
     bool error = false;
-    for (auto iter = collection->iterator(); iter->hasNext();) {
-      if (!mergeFile(iter->next(), override)) {
+    for (auto iter = collection->Iterator(); iter->HasNext();) {
+      if (!MergeFile(iter->Next(), override)) {
         error = true;
       }
     }
 
     // Make sure to move the collection into the set of IFileCollections.
-    mCollections.push_back(std::move(collection));
+    collections_.push_back(std::move(collection));
     return !error;
   }
 
@@ -1220,18 +1220,16 @@ class LinkCommand {
    *
    * Otherwise the files is processed on its own.
    */
-  bool mergePath(const std::string& path, bool override) {
-    if (util::stringEndsWith(path, ".flata") ||
-        util::stringEndsWith(path, ".jar") ||
-        util::stringEndsWith(path, ".jack") ||
-        util::stringEndsWith(path, ".zip")) {
-      return mergeArchive(path, override);
-    } else if (util::stringEndsWith(path, ".apk")) {
-      return mergeStaticLibrary(path, override);
+  bool MergePath(const std::string& path, bool override) {
+    if (util::EndsWith(path, ".flata") || util::EndsWith(path, ".jar") ||
+        util::EndsWith(path, ".jack") || util::EndsWith(path, ".zip")) {
+      return MergeArchive(path, override);
+    } else if (util::EndsWith(path, ".apk")) {
+      return MergeStaticLibrary(path, override);
     }
 
-    io::IFile* file = mFileCollection->insertFile(path);
-    return mergeFile(file, override);
+    io::IFile* file = file_collection_->InsertFile(path);
+    return MergeFile(file, override);
   }
 
   /**
@@ -1250,63 +1248,63 @@ class LinkCommand {
    * coming from a zip,
    * where we could have other files like classes.dex.
    */
-  bool mergeFile(io::IFile* file, bool override) {
-    const Source& src = file->getSource();
-    if (util::stringEndsWith(src.path, ".arsc.flat")) {
-      return mergeResourceTable(file, override);
+  bool MergeFile(io::IFile* file, bool override) {
+    const Source& src = file->GetSource();
+    if (util::EndsWith(src.path, ".arsc.flat")) {
+      return MergeResourceTable(file, override);
 
-    } else if (util::stringEndsWith(src.path, ".flat")) {
+    } else if (util::EndsWith(src.path, ".flat")) {
       // Try opening the file and looking for an Export header.
-      std::unique_ptr<io::IData> data = file->openAsData();
+      std::unique_ptr<io::IData> data = file->OpenAsData();
       if (!data) {
-        mContext->getDiagnostics()->error(DiagMessage(src) << "failed to open");
+        context_->GetDiagnostics()->Error(DiagMessage(src) << "failed to open");
         return false;
       }
 
-      CompiledFileInputStream inputStream(data->data(), data->size());
-      uint32_t numFiles = 0;
-      if (!inputStream.ReadLittleEndian32(&numFiles)) {
-        mContext->getDiagnostics()->error(DiagMessage(src)
+      CompiledFileInputStream input_stream(data->data(), data->size());
+      uint32_t num_files = 0;
+      if (!input_stream.ReadLittleEndian32(&num_files)) {
+        context_->GetDiagnostics()->Error(DiagMessage(src)
                                           << "failed read num files");
         return false;
       }
 
-      for (uint32_t i = 0; i < numFiles; i++) {
-        pb::CompiledFile compiledFile;
-        if (!inputStream.ReadCompiledFile(&compiledFile)) {
-          mContext->getDiagnostics()->error(
+      for (uint32_t i = 0; i < num_files; i++) {
+        pb::CompiledFile compiled_file;
+        if (!input_stream.ReadCompiledFile(&compiled_file)) {
+          context_->GetDiagnostics()->Error(
               DiagMessage(src) << "failed to read compiled file header");
           return false;
         }
 
         uint64_t offset, len;
-        if (!inputStream.ReadDataMetaData(&offset, &len)) {
-          mContext->getDiagnostics()->error(DiagMessage(src)
+        if (!input_stream.ReadDataMetaData(&offset, &len)) {
+          context_->GetDiagnostics()->Error(DiagMessage(src)
                                             << "failed to read data meta data");
           return false;
         }
 
-        std::unique_ptr<ResourceFile> resourceFile =
-            deserializeCompiledFileFromPb(compiledFile, file->getSource(),
-                                          mContext->getDiagnostics());
-        if (!resourceFile) {
+        std::unique_ptr<ResourceFile> resource_file =
+            DeserializeCompiledFileFromPb(compiled_file, file->GetSource(),
+                                          context_->GetDiagnostics());
+        if (!resource_file) {
           return false;
         }
 
-        if (!mergeCompiledFile(file->createFileSegment(offset, len),
-                               resourceFile.get(), override)) {
+        if (!MergeCompiledFile(file->CreateFileSegment(offset, len),
+                               resource_file.get(), override)) {
           return false;
         }
       }
       return true;
-    } else if (util::stringEndsWith(src.path, ".xml") ||
-               util::stringEndsWith(src.path, ".png")) {
+    } else if (util::EndsWith(src.path, ".xml") ||
+               util::EndsWith(src.path, ".png")) {
       // Since AAPT compiles these file types and appends .flat to them, seeing
       // their raw extensions is a sign that they weren't compiled.
-      const StringPiece fileType =
-          util::stringEndsWith(src.path, ".xml") ? "XML" : "PNG";
-      mContext->getDiagnostics()->error(DiagMessage(src)
-                                        << "uncompiled " << fileType
+      const StringPiece file_type =
+          util::EndsWith(src.path, ".xml") ? "XML" : "PNG";
+      context_->GetDiagnostics()->Error(DiagMessage(src)
+                                        << "uncompiled " << file_type
                                         << " file passed as argument. Must be "
                                            "compiled first into .flat file.");
       return false;
@@ -1318,95 +1316,95 @@ class LinkCommand {
     return true;
   }
 
-  std::unique_ptr<xml::XmlResource> generateSplitManifest(
-      const AppInfo& appInfo, const SplitConstraints& constraints) {
+  std::unique_ptr<xml::XmlResource> GenerateSplitManifest(
+      const AppInfo& app_info, const SplitConstraints& constraints) {
     std::unique_ptr<xml::XmlResource> doc =
         util::make_unique<xml::XmlResource>();
 
-    std::unique_ptr<xml::Namespace> namespaceAndroid =
+    std::unique_ptr<xml::Namespace> namespace_android =
         util::make_unique<xml::Namespace>();
-    namespaceAndroid->namespaceUri = xml::kSchemaAndroid;
-    namespaceAndroid->namespacePrefix = "android";
+    namespace_android->namespace_uri = xml::kSchemaAndroid;
+    namespace_android->namespace_prefix = "android";
 
-    std::unique_ptr<xml::Element> manifestEl =
+    std::unique_ptr<xml::Element> manifest_el =
         util::make_unique<xml::Element>();
-    manifestEl->name = "manifest";
-    manifestEl->attributes.push_back(
-        xml::Attribute{"", "package", appInfo.package});
+    manifest_el->name = "manifest";
+    manifest_el->attributes.push_back(
+        xml::Attribute{"", "package", app_info.package});
 
-    if (appInfo.versionCode) {
-      manifestEl->attributes.push_back(
+    if (app_info.version_code) {
+      manifest_el->attributes.push_back(
           xml::Attribute{xml::kSchemaAndroid, "versionCode",
-                         std::to_string(appInfo.versionCode.value())});
+                         std::to_string(app_info.version_code.value())});
     }
 
-    if (appInfo.revisionCode) {
-      manifestEl->attributes.push_back(
+    if (app_info.revision_code) {
+      manifest_el->attributes.push_back(
           xml::Attribute{xml::kSchemaAndroid, "revisionCode",
-                         std::to_string(appInfo.revisionCode.value())});
+                         std::to_string(app_info.revision_code.value())});
     }
 
-    std::stringstream splitName;
-    splitName << "config." << util::joiner(constraints.configs, "_");
+    std::stringstream split_name;
+    split_name << "config." << util::Joiner(constraints.configs, "_");
 
-    manifestEl->attributes.push_back(
-        xml::Attribute{"", "split", splitName.str()});
+    manifest_el->attributes.push_back(
+        xml::Attribute{"", "split", split_name.str()});
 
-    std::unique_ptr<xml::Element> applicationEl =
+    std::unique_ptr<xml::Element> application_el =
         util::make_unique<xml::Element>();
-    applicationEl->name = "application";
-    applicationEl->attributes.push_back(
+    application_el->name = "application";
+    application_el->attributes.push_back(
         xml::Attribute{xml::kSchemaAndroid, "hasCode", "false"});
 
-    manifestEl->addChild(std::move(applicationEl));
-    namespaceAndroid->addChild(std::move(manifestEl));
-    doc->root = std::move(namespaceAndroid);
+    manifest_el->AddChild(std::move(application_el));
+    namespace_android->AddChild(std::move(manifest_el));
+    doc->root = std::move(namespace_android);
     return doc;
   }
 
   /**
    * Writes the AndroidManifest, ResourceTable, and all XML files referenced by
-   * the ResourceTable
-   * to the IArchiveWriter.
+   * the ResourceTable to the IArchiveWriter.
    */
-  bool writeApk(IArchiveWriter* writer, proguard::KeepSet* keepSet,
+  bool WriteApk(IArchiveWriter* writer, proguard::KeepSet* keep_set,
                 xml::XmlResource* manifest, ResourceTable* table) {
-    const bool keepRawValues = mOptions.staticLib;
-    bool result = flattenXml(manifest, "AndroidManifest.xml", {}, keepRawValues,
-                             writer, mContext);
+    const bool keep_raw_values = options_.static_lib;
+    bool result = FlattenXml(manifest, "AndroidManifest.xml", {},
+                             keep_raw_values, writer, context_);
     if (!result) {
       return false;
     }
 
-    ResourceFileFlattenerOptions fileFlattenerOptions;
-    fileFlattenerOptions.keepRawValues = keepRawValues;
-    fileFlattenerOptions.doNotCompressAnything = mOptions.doNotCompressAnything;
-    fileFlattenerOptions.extensionsToNotCompress =
-        mOptions.extensionsToNotCompress;
-    fileFlattenerOptions.noAutoVersion = mOptions.noAutoVersion;
-    fileFlattenerOptions.noVersionVectors = mOptions.noVersionVectors;
-    fileFlattenerOptions.noXmlNamespaces = mOptions.noXmlNamespaces;
-    fileFlattenerOptions.updateProguardSpec =
-        static_cast<bool>(mOptions.generateProguardRulesPath);
+    ResourceFileFlattenerOptions file_flattener_options;
+    file_flattener_options.keep_raw_values = keep_raw_values;
+    file_flattener_options.do_not_compress_anything =
+        options_.do_not_compress_anything;
+    file_flattener_options.extensions_to_not_compress =
+        options_.extensions_to_not_compress;
+    file_flattener_options.no_auto_version = options_.no_auto_version;
+    file_flattener_options.no_version_vectors = options_.no_version_vectors;
+    file_flattener_options.no_xml_namespaces = options_.no_xml_namespaces;
+    file_flattener_options.update_proguard_spec =
+        static_cast<bool>(options_.generate_proguard_rules_path);
 
-    ResourceFileFlattener fileFlattener(fileFlattenerOptions, mContext,
-                                        keepSet);
+    ResourceFileFlattener file_flattener(file_flattener_options, context_,
+                                         keep_set);
 
-    if (!fileFlattener.flatten(table, writer)) {
-      mContext->getDiagnostics()->error(DiagMessage()
+    if (!file_flattener.Flatten(table, writer)) {
+      context_->GetDiagnostics()->Error(DiagMessage()
                                         << "failed linking file resources");
       return false;
     }
 
-    if (mOptions.staticLib) {
-      if (!flattenTableToPb(table, writer)) {
-        mContext->getDiagnostics()->error(
+    if (options_.static_lib) {
+      if (!FlattenTableToPb(table, writer)) {
+        context_->GetDiagnostics()->Error(
             DiagMessage() << "failed to write resources.arsc.flat");
         return false;
       }
     } else {
-      if (!flattenTable(table, writer)) {
-        mContext->getDiagnostics()->error(DiagMessage()
+      if (!FlattenTable(table, writer)) {
+        context_->GetDiagnostics()->Error(DiagMessage()
                                           << "failed to write resources.arsc");
         return false;
       }
@@ -1414,118 +1412,118 @@ class LinkCommand {
     return true;
   }
 
-  int run(const std::vector<std::string>& inputFiles) {
+  int Run(const std::vector<std::string>& input_files) {
     // Load the AndroidManifest.xml
-    std::unique_ptr<xml::XmlResource> manifestXml =
-        loadXml(mOptions.manifestPath, mContext->getDiagnostics());
-    if (!manifestXml) {
+    std::unique_ptr<xml::XmlResource> manifest_xml =
+        LoadXml(options_.manifest_path, context_->GetDiagnostics());
+    if (!manifest_xml) {
       return 1;
     }
 
     // First extract the Package name without modifying it (via
     // --rename-manifest-package).
-    if (Maybe<AppInfo> maybeAppInfo = extractAppInfoFromManifest(
-            manifestXml.get(), mContext->getDiagnostics())) {
-      const AppInfo& appInfo = maybeAppInfo.value();
-      mContext->setCompilationPackage(appInfo.package);
+    if (Maybe<AppInfo> maybe_app_info = ExtractAppInfoFromManifest(
+            manifest_xml.get(), context_->GetDiagnostics())) {
+      const AppInfo& app_info = maybe_app_info.value();
+      context_->SetCompilationPackage(app_info.package);
     }
 
-    ManifestFixer manifestFixer(mOptions.manifestFixerOptions);
-    if (!manifestFixer.consume(mContext, manifestXml.get())) {
+    ManifestFixer manifest_fixer(options_.manifest_fixer_options);
+    if (!manifest_fixer.Consume(context_, manifest_xml.get())) {
       return 1;
     }
 
-    Maybe<AppInfo> maybeAppInfo = extractAppInfoFromManifest(
-        manifestXml.get(), mContext->getDiagnostics());
-    if (!maybeAppInfo) {
+    Maybe<AppInfo> maybe_app_info = ExtractAppInfoFromManifest(
+        manifest_xml.get(), context_->GetDiagnostics());
+    if (!maybe_app_info) {
       return 1;
     }
 
-    const AppInfo& appInfo = maybeAppInfo.value();
-    if (appInfo.minSdkVersion) {
-      if (Maybe<int> maybeMinSdkVersion =
-              ResourceUtils::parseSdkVersion(appInfo.minSdkVersion.value())) {
-        mContext->setMinSdkVersion(maybeMinSdkVersion.value());
+    const AppInfo& app_info = maybe_app_info.value();
+    if (app_info.min_sdk_version) {
+      if (Maybe<int> maybe_min_sdk_version = ResourceUtils::ParseSdkVersion(
+              app_info.min_sdk_version.value())) {
+        context_->SetMinSdkVersion(maybe_min_sdk_version.value());
       }
     }
 
-    mContext->setNameManglerPolicy(
-        NameManglerPolicy{mContext->getCompilationPackage()});
-    if (mContext->getCompilationPackage() == "android") {
-      mContext->setPackageId(0x01);
+    context_->SetNameManglerPolicy(
+        NameManglerPolicy{context_->GetCompilationPackage()});
+    if (context_->GetCompilationPackage() == "android") {
+      context_->SetPackageId(0x01);
     } else {
-      mContext->setPackageId(0x7f);
+      context_->SetPackageId(0x7f);
     }
 
-    if (!loadSymbolsFromIncludePaths()) {
+    if (!LoadSymbolsFromIncludePaths()) {
       return 1;
     }
 
-    TableMergerOptions tableMergerOptions;
-    tableMergerOptions.autoAddOverlay = mOptions.autoAddOverlay;
-    mTableMerger = util::make_unique<TableMerger>(mContext, &mFinalTable,
-                                                  tableMergerOptions);
+    TableMergerOptions table_merger_options;
+    table_merger_options.auto_add_overlay = options_.auto_add_overlay;
+    table_merger_ = util::make_unique<TableMerger>(context_, &final_table_,
+                                                   table_merger_options);
 
-    if (mContext->verbose()) {
-      mContext->getDiagnostics()->note(DiagMessage()
+    if (context_->IsVerbose()) {
+      context_->GetDiagnostics()->Note(DiagMessage()
                                        << "linking package '"
-                                       << mContext->getCompilationPackage()
+                                       << context_->GetCompilationPackage()
                                        << "' with package ID " << std::hex
-                                       << (int)mContext->getPackageId());
+                                       << (int)context_->GetPackageId());
     }
 
-    for (const std::string& input : inputFiles) {
-      if (!mergePath(input, false)) {
-        mContext->getDiagnostics()->error(DiagMessage()
+    for (const std::string& input : input_files) {
+      if (!MergePath(input, false)) {
+        context_->GetDiagnostics()->Error(DiagMessage()
                                           << "failed parsing input");
         return 1;
       }
     }
 
-    for (const std::string& input : mOptions.overlayFiles) {
-      if (!mergePath(input, true)) {
-        mContext->getDiagnostics()->error(DiagMessage()
+    for (const std::string& input : options_.overlay_files) {
+      if (!MergePath(input, true)) {
+        context_->GetDiagnostics()->Error(DiagMessage()
                                           << "failed parsing overlays");
         return 1;
       }
     }
 
-    if (!verifyNoExternalPackages()) {
+    if (!VerifyNoExternalPackages()) {
       return 1;
     }
 
-    if (!mOptions.staticLib) {
+    if (!options_.static_lib) {
       PrivateAttributeMover mover;
-      if (!mover.consume(mContext, &mFinalTable)) {
-        mContext->getDiagnostics()->error(
+      if (!mover.Consume(context_, &final_table_)) {
+        context_->GetDiagnostics()->Error(
             DiagMessage() << "failed moving private attributes");
         return 1;
       }
 
       // Assign IDs if we are building a regular app.
-      IdAssigner idAssigner(&mOptions.stableIdMap);
-      if (!idAssigner.consume(mContext, &mFinalTable)) {
-        mContext->getDiagnostics()->error(DiagMessage()
+      IdAssigner id_assigner(&options_.stable_id_map);
+      if (!id_assigner.Consume(context_, &final_table_)) {
+        context_->GetDiagnostics()->Error(DiagMessage()
                                           << "failed assigning IDs");
         return 1;
       }
 
       // Now grab each ID and emit it as a file.
-      if (mOptions.resourceIdMapPath) {
-        for (auto& package : mFinalTable.packages) {
+      if (options_.resource_id_map_path) {
+        for (auto& package : final_table_.packages) {
           for (auto& type : package->types) {
             for (auto& entry : type->entries) {
               ResourceName name(package->name, type->type, entry->name);
               // The IDs are guaranteed to exist.
-              mOptions.stableIdMap[std::move(name)] = ResourceId(
+              options_.stable_id_map[std::move(name)] = ResourceId(
                   package->id.value(), type->id.value(), entry->id.value());
             }
           }
         }
 
-        if (!writeStableIdMapToPath(mContext->getDiagnostics(),
-                                    mOptions.stableIdMap,
-                                    mOptions.resourceIdMapPath.value())) {
+        if (!WriteStableIdMapToPath(context_->GetDiagnostics(),
+                                    options_.stable_id_map,
+                                    options_.resource_id_map_path.value())) {
           return 1;
         }
       }
@@ -1533,80 +1531,80 @@ class LinkCommand {
       // Static libs are merged with other apps, and ID collisions are bad, so
       // verify that
       // no IDs have been set.
-      if (!verifyNoIdsSet()) {
+      if (!VerifyNoIdsSet()) {
         return 1;
       }
     }
 
     // Add the names to mangle based on our source merge earlier.
-    mContext->setNameManglerPolicy(NameManglerPolicy{
-        mContext->getCompilationPackage(), mTableMerger->getMergedPackages()});
+    context_->SetNameManglerPolicy(NameManglerPolicy{
+        context_->GetCompilationPackage(), table_merger_->merged_packages()});
 
     // Add our table to the symbol table.
-    mContext->getExternalSymbols()->prependSource(
-        util::make_unique<ResourceTableSymbolSource>(&mFinalTable));
+    context_->GetExternalSymbols()->PrependSource(
+        util::make_unique<ResourceTableSymbolSource>(&final_table_));
 
     ReferenceLinker linker;
-    if (!linker.consume(mContext, &mFinalTable)) {
-      mContext->getDiagnostics()->error(DiagMessage()
+    if (!linker.Consume(context_, &final_table_)) {
+      context_->GetDiagnostics()->Error(DiagMessage()
                                         << "failed linking references");
       return 1;
     }
 
-    if (mOptions.staticLib) {
-      if (!mOptions.products.empty()) {
-        mContext->getDiagnostics()
-            ->warn(DiagMessage()
+    if (options_.static_lib) {
+      if (!options_.products.empty()) {
+        context_->GetDiagnostics()
+            ->Warn(DiagMessage()
                    << "can't select products when building static library");
       }
     } else {
-      ProductFilter productFilter(mOptions.products);
-      if (!productFilter.consume(mContext, &mFinalTable)) {
-        mContext->getDiagnostics()->error(DiagMessage()
+      ProductFilter product_filter(options_.products);
+      if (!product_filter.Consume(context_, &final_table_)) {
+        context_->GetDiagnostics()->Error(DiagMessage()
                                           << "failed stripping products");
         return 1;
       }
     }
 
-    if (!mOptions.noAutoVersion) {
+    if (!options_.no_auto_version) {
       AutoVersioner versioner;
-      if (!versioner.consume(mContext, &mFinalTable)) {
-        mContext->getDiagnostics()->error(DiagMessage()
+      if (!versioner.Consume(context_, &final_table_)) {
+        context_->GetDiagnostics()->Error(DiagMessage()
                                           << "failed versioning styles");
         return 1;
       }
     }
 
-    if (!mOptions.staticLib && mContext->getMinSdkVersion() > 0) {
-      if (mContext->verbose()) {
-        mContext->getDiagnostics()->note(
+    if (!options_.static_lib && context_->GetMinSdkVersion() > 0) {
+      if (context_->IsVerbose()) {
+        context_->GetDiagnostics()->Note(
             DiagMessage() << "collapsing resource versions for minimum SDK "
-                          << mContext->getMinSdkVersion());
+                          << context_->GetMinSdkVersion());
       }
 
       VersionCollapser collapser;
-      if (!collapser.consume(mContext, &mFinalTable)) {
+      if (!collapser.Consume(context_, &final_table_)) {
         return 1;
       }
     }
 
-    if (!mOptions.noResourceDeduping) {
+    if (!options_.no_resource_deduping) {
       ResourceDeduper deduper;
-      if (!deduper.consume(mContext, &mFinalTable)) {
-        mContext->getDiagnostics()->error(DiagMessage()
+      if (!deduper.Consume(context_, &final_table_)) {
+        context_->GetDiagnostics()->Error(DiagMessage()
                                           << "failed deduping resources");
         return 1;
       }
     }
 
-    proguard::KeepSet proguardKeepSet;
-    proguard::KeepSet proguardMainDexKeepSet;
+    proguard::KeepSet proguard_keep_set;
+    proguard::KeepSet proguard_main_dex_keep_set;
 
-    if (mOptions.staticLib) {
-      if (mOptions.tableSplitterOptions.configFilter != nullptr ||
-          mOptions.tableSplitterOptions.preferredDensity) {
-        mContext->getDiagnostics()
-            ->warn(DiagMessage()
+    if (options_.static_lib) {
+      if (options_.table_splitter_options.config_filter != nullptr ||
+          options_.table_splitter_options.preferred_density) {
+        context_->GetDiagnostics()
+            ->Warn(DiagMessage()
                    << "can't strip resources when building static library");
       }
     } else {
@@ -1615,73 +1613,73 @@ class LinkCommand {
       // than or equal to the minSdk. Otherwise the resources that have had
       // their SDK version
       // stripped due to minSdk won't ever match.
-      std::vector<SplitConstraints> adjustedConstraintsList;
-      adjustedConstraintsList.reserve(mOptions.splitConstraints.size());
-      for (const SplitConstraints& constraints : mOptions.splitConstraints) {
-        SplitConstraints adjustedConstraints;
+      std::vector<SplitConstraints> adjusted_constraints_list;
+      adjusted_constraints_list.reserve(options_.split_constraints.size());
+      for (const SplitConstraints& constraints : options_.split_constraints) {
+        SplitConstraints adjusted_constraints;
         for (const ConfigDescription& config : constraints.configs) {
-          if (config.sdkVersion <= mContext->getMinSdkVersion()) {
-            adjustedConstraints.configs.insert(config.copyWithoutSdkVersion());
+          if (config.sdkVersion <= context_->GetMinSdkVersion()) {
+            adjusted_constraints.configs.insert(config.CopyWithoutSdkVersion());
           } else {
-            adjustedConstraints.configs.insert(config);
+            adjusted_constraints.configs.insert(config);
           }
         }
-        adjustedConstraintsList.push_back(std::move(adjustedConstraints));
+        adjusted_constraints_list.push_back(std::move(adjusted_constraints));
       }
 
-      TableSplitter tableSplitter(adjustedConstraintsList,
-                                  mOptions.tableSplitterOptions);
-      if (!tableSplitter.verifySplitConstraints(mContext)) {
+      TableSplitter table_splitter(adjusted_constraints_list,
+                                   options_.table_splitter_options);
+      if (!table_splitter.VerifySplitConstraints(context_)) {
         return 1;
       }
-      tableSplitter.splitTable(&mFinalTable);
+      table_splitter.SplitTable(&final_table_);
 
       // Now we need to write out the Split APKs.
-      auto pathIter = mOptions.splitPaths.begin();
-      auto splitConstraintsIter = adjustedConstraintsList.begin();
-      for (std::unique_ptr<ResourceTable>& splitTable :
-           tableSplitter.getSplits()) {
-        if (mContext->verbose()) {
-          mContext->getDiagnostics()->note(
-              DiagMessage(*pathIter)
+      auto path_iter = options_.split_paths.begin();
+      auto split_constraints_iter = adjusted_constraints_list.begin();
+      for (std::unique_ptr<ResourceTable>& split_table :
+           table_splitter.splits()) {
+        if (context_->IsVerbose()) {
+          context_->GetDiagnostics()->Note(
+              DiagMessage(*path_iter)
               << "generating split with configurations '"
-              << util::joiner(splitConstraintsIter->configs, ", ") << "'");
+              << util::Joiner(split_constraints_iter->configs, ", ") << "'");
         }
 
-        std::unique_ptr<IArchiveWriter> archiveWriter =
-            makeArchiveWriter(*pathIter);
-        if (!archiveWriter) {
-          mContext->getDiagnostics()->error(DiagMessage()
+        std::unique_ptr<IArchiveWriter> archive_writer =
+            MakeArchiveWriter(*path_iter);
+        if (!archive_writer) {
+          context_->GetDiagnostics()->Error(DiagMessage()
                                             << "failed to create archive");
           return 1;
         }
 
         // Generate an AndroidManifest.xml for each split.
-        std::unique_ptr<xml::XmlResource> splitManifest =
-            generateSplitManifest(appInfo, *splitConstraintsIter);
+        std::unique_ptr<xml::XmlResource> split_manifest =
+            GenerateSplitManifest(app_info, *split_constraints_iter);
 
         XmlReferenceLinker linker;
-        if (!linker.consume(mContext, splitManifest.get())) {
-          mContext->getDiagnostics()->error(
+        if (!linker.Consume(context_, split_manifest.get())) {
+          context_->GetDiagnostics()->Error(
               DiagMessage() << "failed to create Split AndroidManifest.xml");
           return 1;
         }
 
-        if (!writeApk(archiveWriter.get(), &proguardKeepSet,
-                      splitManifest.get(), splitTable.get())) {
+        if (!WriteApk(archive_writer.get(), &proguard_keep_set,
+                      split_manifest.get(), split_table.get())) {
           return 1;
         }
 
-        ++pathIter;
-        ++splitConstraintsIter;
+        ++path_iter;
+        ++split_constraints_iter;
       }
     }
 
     // Start writing the base APK.
-    std::unique_ptr<IArchiveWriter> archiveWriter =
-        makeArchiveWriter(mOptions.outputPath);
-    if (!archiveWriter) {
-      mContext->getDiagnostics()->error(DiagMessage()
+    std::unique_ptr<IArchiveWriter> archive_writer =
+        MakeArchiveWriter(options_.output_path);
+    if (!archive_writer) {
+      context_->GetDiagnostics()->Error(DiagMessage()
                                         << "failed to create archive");
       return 1;
     }
@@ -1692,35 +1690,35 @@ class LinkCommand {
       // from the name
       // (aka, which package the AndroidManifest.xml is coming from).
       // So we give it a package name so it can see local resources.
-      manifestXml->file.name.package = mContext->getCompilationPackage();
+      manifest_xml->file.name.package = context_->GetCompilationPackage();
 
-      XmlReferenceLinker manifestLinker;
-      if (manifestLinker.consume(mContext, manifestXml.get())) {
-        if (mOptions.generateProguardRulesPath &&
-            !proguard::collectProguardRulesForManifest(
-                Source(mOptions.manifestPath), manifestXml.get(),
-                &proguardKeepSet)) {
+      XmlReferenceLinker manifest_linker;
+      if (manifest_linker.Consume(context_, manifest_xml.get())) {
+        if (options_.generate_proguard_rules_path &&
+            !proguard::CollectProguardRulesForManifest(
+                Source(options_.manifest_path), manifest_xml.get(),
+                &proguard_keep_set)) {
           error = true;
         }
 
-        if (mOptions.generateMainDexProguardRulesPath &&
-            !proguard::collectProguardRulesForManifest(
-                Source(mOptions.manifestPath), manifestXml.get(),
-                &proguardMainDexKeepSet, true)) {
+        if (options_.generate_main_dex_proguard_rules_path &&
+            !proguard::CollectProguardRulesForManifest(
+                Source(options_.manifest_path), manifest_xml.get(),
+                &proguard_main_dex_keep_set, true)) {
           error = true;
         }
 
-        if (mOptions.generateJavaClassPath) {
-          if (!writeManifestJavaFile(manifestXml.get())) {
+        if (options_.generate_java_class_path) {
+          if (!WriteManifestJavaFile(manifest_xml.get())) {
             error = true;
           }
         }
 
-        if (mOptions.noXmlNamespaces) {
+        if (options_.no_xml_namespaces) {
           // PackageParser will fail if URIs are removed from
           // AndroidManifest.xml.
-          XmlNamespaceRemover namespaceRemover(true /* keepUris */);
-          if (!namespaceRemover.consume(mContext, manifestXml.get())) {
+          XmlNamespaceRemover namespace_remover(true /* keepUris */);
+          if (!namespace_remover.Consume(context_, manifest_xml.get())) {
             error = true;
           }
         }
@@ -1730,382 +1728,385 @@ class LinkCommand {
     }
 
     if (error) {
-      mContext->getDiagnostics()->error(DiagMessage()
+      context_->GetDiagnostics()->Error(DiagMessage()
                                         << "failed processing manifest");
       return 1;
     }
 
-    if (!writeApk(archiveWriter.get(), &proguardKeepSet, manifestXml.get(),
-                  &mFinalTable)) {
+    if (!WriteApk(archive_writer.get(), &proguard_keep_set, manifest_xml.get(),
+                  &final_table_)) {
       return 1;
     }
 
-    if (mOptions.generateJavaClassPath) {
+    if (options_.generate_java_class_path) {
       JavaClassGeneratorOptions options;
       options.types = JavaClassGeneratorOptions::SymbolTypes::kAll;
-      options.javadocAnnotations = mOptions.javadocAnnotations;
+      options.javadoc_annotations = options_.javadoc_annotations;
 
-      if (mOptions.staticLib || mOptions.generateNonFinalIds) {
-        options.useFinal = false;
+      if (options_.static_lib || options_.generate_non_final_ids) {
+        options.use_final = false;
       }
 
-      const StringPiece actualPackage = mContext->getCompilationPackage();
-      StringPiece outputPackage = mContext->getCompilationPackage();
-      if (mOptions.customJavaPackage) {
+      const StringPiece actual_package = context_->GetCompilationPackage();
+      StringPiece output_package = context_->GetCompilationPackage();
+      if (options_.custom_java_package) {
         // Override the output java package to the custom one.
-        outputPackage = mOptions.customJavaPackage.value();
+        output_package = options_.custom_java_package.value();
       }
 
-      if (mOptions.privateSymbols) {
+      if (options_.private_symbols) {
         // If we defined a private symbols package, we only emit Public symbols
         // to the original package, and private and public symbols to the
         // private package.
 
         options.types = JavaClassGeneratorOptions::SymbolTypes::kPublic;
-        if (!writeJavaFile(&mFinalTable, mContext->getCompilationPackage(),
-                           outputPackage, options)) {
+        if (!WriteJavaFile(&final_table_, context_->GetCompilationPackage(),
+                           output_package, options)) {
           return 1;
         }
 
         options.types = JavaClassGeneratorOptions::SymbolTypes::kPublicPrivate;
-        outputPackage = mOptions.privateSymbols.value();
+        output_package = options_.private_symbols.value();
       }
 
-      if (!writeJavaFile(&mFinalTable, actualPackage, outputPackage, options)) {
+      if (!WriteJavaFile(&final_table_, actual_package, output_package,
+                         options)) {
         return 1;
       }
 
-      for (const std::string& extraPackage : mOptions.extraJavaPackages) {
-        if (!writeJavaFile(&mFinalTable, actualPackage, extraPackage,
+      for (const std::string& extra_package : options_.extra_java_packages) {
+        if (!WriteJavaFile(&final_table_, actual_package, extra_package,
                            options)) {
           return 1;
         }
       }
     }
 
-    if (!writeProguardFile(mOptions.generateProguardRulesPath,
-                           proguardKeepSet)) {
+    if (!WriteProguardFile(options_.generate_proguard_rules_path,
+                           proguard_keep_set)) {
       return 1;
     }
 
-    if (!writeProguardFile(mOptions.generateMainDexProguardRulesPath,
-                           proguardMainDexKeepSet)) {
+    if (!WriteProguardFile(options_.generate_main_dex_proguard_rules_path,
+                           proguard_main_dex_keep_set)) {
       return 1;
     }
 
-    if (mContext->verbose()) {
-      DebugPrintTableOptions debugPrintTableOptions;
-      debugPrintTableOptions.showSources = true;
-      Debug::printTable(&mFinalTable, debugPrintTableOptions);
+    if (context_->IsVerbose()) {
+      DebugPrintTableOptions debug_print_table_options;
+      debug_print_table_options.show_sources = true;
+      Debug::PrintTable(&final_table_, debug_print_table_options);
     }
     return 0;
   }
 
  private:
-  LinkOptions mOptions;
-  LinkContext* mContext;
-  ResourceTable mFinalTable;
+  LinkOptions options_;
+  LinkContext* context_;
+  ResourceTable final_table_;
 
-  std::unique_ptr<TableMerger> mTableMerger;
+  std::unique_ptr<TableMerger> table_merger_;
 
   // A pointer to the FileCollection representing the filesystem (not archives).
-  std::unique_ptr<io::FileCollection> mFileCollection;
+  std::unique_ptr<io::FileCollection> file_collection_;
 
   // A vector of IFileCollections. This is mainly here to keep ownership of the
   // collections.
-  std::vector<std::unique_ptr<io::IFileCollection>> mCollections;
+  std::vector<std::unique_ptr<io::IFileCollection>> collections_;
 
   // A vector of ResourceTables. This is here to retain ownership, so that the
   // SymbolTable
   // can use these.
-  std::vector<std::unique_ptr<ResourceTable>> mStaticTableIncludes;
+  std::vector<std::unique_ptr<ResourceTable>> static_table_includes_;
 };
 
-int link(const std::vector<StringPiece>& args) {
+int Link(const std::vector<StringPiece>& args) {
   LinkContext context;
   LinkOptions options;
-  std::vector<std::string> overlayArgList;
-  std::vector<std::string> extraJavaPackages;
+  std::vector<std::string> overlay_arg_list;
+  std::vector<std::string> extra_java_packages;
   Maybe<std::string> configs;
-  Maybe<std::string> preferredDensity;
-  Maybe<std::string> productList;
-  bool legacyXFlag = false;
-  bool requireLocalization = false;
+  Maybe<std::string> preferred_density;
+  Maybe<std::string> product_list;
+  bool legacy_x_flag = false;
+  bool require_localization = false;
   bool verbose = false;
-  Maybe<std::string> stableIdFilePath;
-  std::vector<std::string> splitArgs;
+  Maybe<std::string> stable_id_file_path;
+  std::vector<std::string> split_args;
   Flags flags =
       Flags()
-          .requiredFlag("-o", "Output path", &options.outputPath)
-          .requiredFlag("--manifest", "Path to the Android manifest to build",
-                        &options.manifestPath)
-          .optionalFlagList("-I", "Adds an Android APK to link against",
-                            &options.includePaths)
-          .optionalFlagList(
+          .RequiredFlag("-o", "Output path", &options.output_path)
+          .RequiredFlag("--manifest", "Path to the Android manifest to build",
+                        &options.manifest_path)
+          .OptionalFlagList("-I", "Adds an Android APK to link against",
+                            &options.include_paths)
+          .OptionalFlagList(
               "-R",
               "Compilation unit to link, using `overlay` semantics.\n"
               "The last conflicting resource given takes precedence.",
-              &overlayArgList)
-          .optionalFlag("--java", "Directory in which to generate R.java",
-                        &options.generateJavaClassPath)
-          .optionalFlag("--proguard",
+              &overlay_arg_list)
+          .OptionalFlag("--java", "Directory in which to generate R.java",
+                        &options.generate_java_class_path)
+          .OptionalFlag("--proguard",
                         "Output file for generated Proguard rules",
-                        &options.generateProguardRulesPath)
-          .optionalFlag(
+                        &options.generate_proguard_rules_path)
+          .OptionalFlag(
               "--proguard-main-dex",
               "Output file for generated Proguard rules for the main dex",
-              &options.generateMainDexProguardRulesPath)
-          .optionalSwitch("--no-auto-version",
+              &options.generate_main_dex_proguard_rules_path)
+          .OptionalSwitch("--no-auto-version",
                           "Disables automatic style and layout SDK versioning",
-                          &options.noAutoVersion)
-          .optionalSwitch("--no-version-vectors",
+                          &options.no_auto_version)
+          .OptionalSwitch("--no-version-vectors",
                           "Disables automatic versioning of vector drawables. "
                           "Use this only\n"
                           "when building with vector drawable support library",
-                          &options.noVersionVectors)
-          .optionalSwitch("--no-resource-deduping",
+                          &options.no_version_vectors)
+          .OptionalSwitch("--no-resource-deduping",
                           "Disables automatic deduping of resources with\n"
                           "identical values across compatible configurations.",
-                          &options.noResourceDeduping)
-          .optionalSwitch(
+                          &options.no_resource_deduping)
+          .OptionalSwitch(
               "-x",
               "Legacy flag that specifies to use the package identifier 0x01",
-              &legacyXFlag)
-          .optionalSwitch("-z",
+              &legacy_x_flag)
+          .OptionalSwitch("-z",
                           "Require localization of strings marked 'suggested'",
-                          &requireLocalization)
-          .optionalFlag(
+                          &require_localization)
+          .OptionalFlag(
               "-c",
               "Comma separated list of configurations to include. The default\n"
               "is all configurations",
               &configs)
-          .optionalFlag(
+          .OptionalFlag(
               "--preferred-density",
               "Selects the closest matching density and strips out all others.",
-              &preferredDensity)
-          .optionalFlag("--product",
+              &preferred_density)
+          .OptionalFlag("--product",
                         "Comma separated list of product names to keep",
-                        &productList)
-          .optionalSwitch("--output-to-dir",
+                        &product_list)
+          .OptionalSwitch("--output-to-dir",
                           "Outputs the APK contents to a directory specified "
                           "by -o",
-                          &options.outputToDirectory)
-          .optionalSwitch("--no-xml-namespaces",
+                          &options.output_to_directory)
+          .OptionalSwitch("--no-xml-namespaces",
                           "Removes XML namespace prefix and URI "
                           "information from AndroidManifest.xml\nand XML "
                           "binaries in res/*.",
-                          &options.noXmlNamespaces)
-          .optionalFlag("--min-sdk-version",
+                          &options.no_xml_namespaces)
+          .OptionalFlag("--min-sdk-version",
                         "Default minimum SDK version to use for "
                         "AndroidManifest.xml",
-                        &options.manifestFixerOptions.minSdkVersionDefault)
-          .optionalFlag("--target-sdk-version",
-                        "Default target SDK version to use for "
-                        "AndroidManifest.xml",
-                        &options.manifestFixerOptions.targetSdkVersionDefault)
-          .optionalFlag("--version-code",
+                        &options.manifest_fixer_options.min_sdk_version_default)
+          .OptionalFlag(
+              "--target-sdk-version",
+              "Default target SDK version to use for "
+              "AndroidManifest.xml",
+              &options.manifest_fixer_options.target_sdk_version_default)
+          .OptionalFlag("--version-code",
                         "Version code (integer) to inject into the "
                         "AndroidManifest.xml if none is present",
-                        &options.manifestFixerOptions.versionCodeDefault)
-          .optionalFlag("--version-name",
+                        &options.manifest_fixer_options.version_code_default)
+          .OptionalFlag("--version-name",
                         "Version name to inject into the AndroidManifest.xml "
                         "if none is present",
-                        &options.manifestFixerOptions.versionNameDefault)
-          .optionalSwitch("--static-lib", "Generate a static Android library",
-                          &options.staticLib)
-          .optionalSwitch("--no-static-lib-packages",
+                        &options.manifest_fixer_options.version_name_default)
+          .OptionalSwitch("--static-lib", "Generate a static Android library",
+                          &options.static_lib)
+          .OptionalSwitch("--no-static-lib-packages",
                           "Merge all library resources under the app's package",
-                          &options.noStaticLibPackages)
-          .optionalSwitch("--non-final-ids",
+                          &options.no_static_lib_packages)
+          .OptionalSwitch("--non-final-ids",
                           "Generates R.java without the final modifier.\n"
                           "This is implied when --static-lib is specified.",
-                          &options.generateNonFinalIds)
-          .optionalFlag("--stable-ids",
+                          &options.generate_non_final_ids)
+          .OptionalFlag("--stable-ids",
                         "File containing a list of name to ID mapping.",
-                        &stableIdFilePath)
-          .optionalFlag(
+                        &stable_id_file_path)
+          .OptionalFlag(
               "--emit-ids",
               "Emit a file at the given path with a list of name to ID\n"
               "mappings, suitable for use with --stable-ids.",
-              &options.resourceIdMapPath)
-          .optionalFlag("--private-symbols",
+              &options.resource_id_map_path)
+          .OptionalFlag("--private-symbols",
                         "Package name to use when generating R.java for "
                         "private symbols.\n"
                         "If not specified, public and private symbols will use "
                         "the application's "
                         "package name",
-                        &options.privateSymbols)
-          .optionalFlag("--custom-package",
+                        &options.private_symbols)
+          .OptionalFlag("--custom-package",
                         "Custom Java package under which to generate R.java",
-                        &options.customJavaPackage)
-          .optionalFlagList("--extra-packages",
+                        &options.custom_java_package)
+          .OptionalFlagList("--extra-packages",
                             "Generate the same R.java but with different "
                             "package names",
-                            &extraJavaPackages)
-          .optionalFlagList("--add-javadoc-annotation",
+                            &extra_java_packages)
+          .OptionalFlagList("--add-javadoc-annotation",
                             "Adds a JavaDoc annotation to all "
                             "generated Java classes",
-                            &options.javadocAnnotations)
-          .optionalSwitch("--auto-add-overlay",
+                            &options.javadoc_annotations)
+          .OptionalSwitch("--auto-add-overlay",
                           "Allows the addition of new resources in "
                           "overlays without <add-resource> tags",
-                          &options.autoAddOverlay)
-          .optionalFlag("--rename-manifest-package",
+                          &options.auto_add_overlay)
+          .OptionalFlag("--rename-manifest-package",
                         "Renames the package in AndroidManifest.xml",
-                        &options.manifestFixerOptions.renameManifestPackage)
-          .optionalFlag(
+                        &options.manifest_fixer_options.rename_manifest_package)
+          .OptionalFlag(
               "--rename-instrumentation-target-package",
               "Changes the name of the target package for instrumentation. "
               "Most useful "
               "when used\nin conjunction with --rename-manifest-package",
-              &options.manifestFixerOptions.renameInstrumentationTargetPackage)
-          .optionalFlagList("-0", "File extensions not to compress",
-                            &options.extensionsToNotCompress)
-          .optionalFlagList(
+              &options.manifest_fixer_options
+                   .rename_instrumentation_target_package)
+          .OptionalFlagList("-0", "File extensions not to compress",
+                            &options.extensions_to_not_compress)
+          .OptionalFlagList(
               "--split",
               "Split resources matching a set of configs out to a "
               "Split APK.\nSyntax: path/to/output.apk:<config>[,<config>[...]]",
-              &splitArgs)
-          .optionalSwitch("-v", "Enables verbose logging", &verbose);
+              &split_args)
+          .OptionalSwitch("-v", "Enables verbose logging", &verbose);
 
-  if (!flags.parse("aapt2 link", args, &std::cerr)) {
+  if (!flags.Parse("aapt2 link", args, &std::cerr)) {
     return 1;
   }
 
   // Expand all argument-files passed into the command line. These start with
   // '@'.
-  std::vector<std::string> argList;
-  for (const std::string& arg : flags.getArgs()) {
-    if (util::stringStartsWith(arg, "@")) {
+  std::vector<std::string> arg_list;
+  for (const std::string& arg : flags.GetArgs()) {
+    if (util::StartsWith(arg, "@")) {
       const std::string path = arg.substr(1, arg.size() - 1);
       std::string error;
-      if (!file::appendArgsFromFile(path, &argList, &error)) {
-        context.getDiagnostics()->error(DiagMessage(path) << error);
+      if (!file::AppendArgsFromFile(path, &arg_list, &error)) {
+        context.GetDiagnostics()->Error(DiagMessage(path) << error);
         return 1;
       }
     } else {
-      argList.push_back(arg);
+      arg_list.push_back(arg);
     }
   }
 
   // Expand all argument-files passed to -R.
-  for (const std::string& arg : overlayArgList) {
-    if (util::stringStartsWith(arg, "@")) {
+  for (const std::string& arg : overlay_arg_list) {
+    if (util::StartsWith(arg, "@")) {
       const std::string path = arg.substr(1, arg.size() - 1);
       std::string error;
-      if (!file::appendArgsFromFile(path, &options.overlayFiles, &error)) {
-        context.getDiagnostics()->error(DiagMessage(path) << error);
+      if (!file::AppendArgsFromFile(path, &options.overlay_files, &error)) {
+        context.GetDiagnostics()->Error(DiagMessage(path) << error);
         return 1;
       }
     } else {
-      options.overlayFiles.push_back(arg);
+      options.overlay_files.push_back(arg);
     }
   }
 
   if (verbose) {
-    context.setVerbose(verbose);
+    context.SetVerbose(verbose);
   }
 
   // Populate the set of extra packages for which to generate R.java.
-  for (std::string& extraPackage : extraJavaPackages) {
+  for (std::string& extra_package : extra_java_packages) {
     // A given package can actually be a colon separated list of packages.
-    for (StringPiece package : util::split(extraPackage, ':')) {
-      options.extraJavaPackages.insert(package.toString());
+    for (StringPiece package : util::Split(extra_package, ':')) {
+      options.extra_java_packages.insert(package.ToString());
     }
   }
 
-  if (productList) {
-    for (StringPiece product : util::tokenize(productList.value(), ',')) {
+  if (product_list) {
+    for (StringPiece product : util::Tokenize(product_list.value(), ',')) {
       if (product != "" && product != "default") {
-        options.products.insert(product.toString());
+        options.products.insert(product.ToString());
       }
     }
   }
 
   AxisConfigFilter filter;
   if (configs) {
-    for (const StringPiece& configStr : util::tokenize(configs.value(), ',')) {
+    for (const StringPiece& config_str : util::Tokenize(configs.value(), ',')) {
       ConfigDescription config;
       LocaleValue lv;
-      if (lv.initFromFilterString(configStr)) {
-        lv.writeTo(&config);
-      } else if (!ConfigDescription::parse(configStr, &config)) {
-        context.getDiagnostics()->error(DiagMessage() << "invalid config '"
-                                                      << configStr
+      if (lv.InitFromFilterString(config_str)) {
+        lv.WriteTo(&config);
+      } else if (!ConfigDescription::Parse(config_str, &config)) {
+        context.GetDiagnostics()->Error(DiagMessage() << "invalid config '"
+                                                      << config_str
                                                       << "' for -c option");
         return 1;
       }
 
       if (config.density != 0) {
-        context.getDiagnostics()->warn(DiagMessage() << "ignoring density '"
+        context.GetDiagnostics()->Warn(DiagMessage() << "ignoring density '"
                                                      << config
                                                      << "' for -c option");
       } else {
-        filter.addConfig(config);
+        filter.AddConfig(config);
       }
     }
 
-    options.tableSplitterOptions.configFilter = &filter;
+    options.table_splitter_options.config_filter = &filter;
   }
 
-  if (preferredDensity) {
-    ConfigDescription preferredDensityConfig;
-    if (!ConfigDescription::parse(preferredDensity.value(),
-                                  &preferredDensityConfig)) {
-      context.getDiagnostics()->error(
-          DiagMessage() << "invalid density '" << preferredDensity.value()
+  if (preferred_density) {
+    ConfigDescription preferred_density_config;
+    if (!ConfigDescription::Parse(preferred_density.value(),
+                                  &preferred_density_config)) {
+      context.GetDiagnostics()->Error(
+          DiagMessage() << "invalid density '" << preferred_density.value()
                         << "' for --preferred-density option");
       return 1;
     }
 
     // Clear the version that can be automatically added.
-    preferredDensityConfig.sdkVersion = 0;
+    preferred_density_config.sdkVersion = 0;
 
-    if (preferredDensityConfig.diff(ConfigDescription::defaultConfig()) !=
+    if (preferred_density_config.diff(ConfigDescription::DefaultConfig()) !=
         ConfigDescription::CONFIG_DENSITY) {
-      context.getDiagnostics()->error(
+      context.GetDiagnostics()->Error(
           DiagMessage() << "invalid preferred density '"
-                        << preferredDensity.value() << "'. "
+                        << preferred_density.value() << "'. "
                         << "Preferred density must only be a density value");
       return 1;
     }
-    options.tableSplitterOptions.preferredDensity =
-        preferredDensityConfig.density;
+    options.table_splitter_options.preferred_density =
+        preferred_density_config.density;
   }
 
-  if (!options.staticLib && stableIdFilePath) {
-    if (!loadStableIdMap(context.getDiagnostics(), stableIdFilePath.value(),
-                         &options.stableIdMap)) {
+  if (!options.static_lib && stable_id_file_path) {
+    if (!LoadStableIdMap(context.GetDiagnostics(), stable_id_file_path.value(),
+                         &options.stable_id_map)) {
       return 1;
     }
   }
 
   // Populate some default no-compress extensions that are already compressed.
-  options.extensionsToNotCompress.insert(
+  options.extensions_to_not_compress.insert(
       {".jpg",   ".jpeg", ".png",  ".gif", ".wav",  ".mp2",  ".mp3",  ".ogg",
        ".aac",   ".mpg",  ".mpeg", ".mid", ".midi", ".smf",  ".jet",  ".rtttl",
        ".imy",   ".xmf",  ".mp4",  ".m4a", ".m4v",  ".3gp",  ".3gpp", ".3g2",
        ".3gpp2", ".amr",  ".awb",  ".wma", ".wmv",  ".webm", ".mkv"});
 
   // Parse the split parameters.
-  for (const std::string& splitArg : splitArgs) {
-    options.splitPaths.push_back({});
-    options.splitConstraints.push_back({});
-    if (!parseSplitParameter(splitArg, context.getDiagnostics(),
-                             &options.splitPaths.back(),
-                             &options.splitConstraints.back())) {
+  for (const std::string& split_arg : split_args) {
+    options.split_paths.push_back({});
+    options.split_constraints.push_back({});
+    if (!ParseSplitParameter(split_arg, context.GetDiagnostics(),
+                             &options.split_paths.back(),
+                             &options.split_constraints.back())) {
       return 1;
     }
   }
 
   // Turn off auto versioning for static-libs.
-  if (options.staticLib) {
-    options.noAutoVersion = true;
-    options.noVersionVectors = true;
+  if (options.static_lib) {
+    options.no_auto_version = true;
+    options.no_version_vectors = true;
   }
 
   LinkCommand cmd(&context, options);
-  return cmd.run(argList);
+  return cmd.Run(arg_list);
 }
 
 }  // namespace aapt
diff --git a/tools/aapt2/link/Linkers.h b/tools/aapt2/link/Linkers.h
index f40c0e863d722..4687d2c01d68a 100644
--- a/tools/aapt2/link/Linkers.h
+++ b/tools/aapt2/link/Linkers.h
@@ -17,12 +17,15 @@
 #ifndef AAPT_LINKER_LINKERS_H
 #define AAPT_LINKER_LINKERS_H
 
+#include <set>
+#include <unordered_set>
+
+#include "android-base/macros.h"
+
 #include "Resource.h"
 #include "process/IResourceTableConsumer.h"
 #include "xml/XmlDom.h"
 
-#include <set>
-
 namespace aapt {
 
 class ResourceTable;
@@ -31,8 +34,7 @@ struct ConfigDescription;
 
 /**
  * Defines the location in which a value exists. This determines visibility of
- * other
- * package's private symbols.
+ * other package's private symbols.
  */
 struct CallSite {
   ResourceNameRef resource;
@@ -40,26 +42,30 @@ struct CallSite {
 
 /**
  * Determines whether a versioned resource should be created. If a versioned
- * resource already
- * exists, it takes precedence.
+ * resource already exists, it takes precedence.
  */
-bool shouldGenerateVersionedResource(const ResourceEntry* entry,
+bool ShouldGenerateVersionedResource(const ResourceEntry* entry,
                                      const ConfigDescription& config,
-                                     const int sdkVersionToGenerate);
+                                     const int sdk_version_to_generate);
 
 class AutoVersioner : public IResourceTableConsumer {
  public:
-  bool consume(IAaptContext* context, ResourceTable* table) override;
-};
+  AutoVersioner() = default;
 
-class XmlAutoVersioner : public IXmlResourceConsumer {
- public:
-  bool consume(IAaptContext* context, xml::XmlResource* resource) override;
+  bool Consume(IAaptContext* context, ResourceTable* table) override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(AutoVersioner);
 };
 
 class VersionCollapser : public IResourceTableConsumer {
  public:
-  bool consume(IAaptContext* context, ResourceTable* table) override;
+  VersionCollapser() = default;
+
+  bool Consume(IAaptContext* context, ResourceTable* table) override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(VersionCollapser);
 };
 
 /**
@@ -67,7 +73,12 @@ class VersionCollapser : public IResourceTableConsumer {
  */
 class ResourceDeduper : public IResourceTableConsumer {
  public:
-  bool consume(IAaptContext* context, ResourceTable* table) override;
+  ResourceDeduper() = default;
+
+  bool Consume(IAaptContext* context, ResourceTable* table) override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ResourceDeduper);
 };
 
 /**
@@ -103,8 +114,46 @@ class ResourceDeduper : public IResourceTableConsumer {
  * conflict will never
  * occur.
  */
-struct PrivateAttributeMover : public IResourceTableConsumer {
-  bool consume(IAaptContext* context, ResourceTable* table) override;
+class PrivateAttributeMover : public IResourceTableConsumer {
+ public:
+  PrivateAttributeMover() = default;
+
+  bool Consume(IAaptContext* context, ResourceTable* table) override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(PrivateAttributeMover);
+};
+
+class ResourceConfigValue;
+
+class ProductFilter : public IResourceTableConsumer {
+ public:
+  using ResourceConfigValueIter =
+      std::vector<std::unique_ptr<ResourceConfigValue>>::iterator;
+
+  explicit ProductFilter(std::unordered_set<std::string> products)
+      : products_(products) {}
+
+  ResourceConfigValueIter SelectProductToKeep(
+      const ResourceNameRef& name, const ResourceConfigValueIter begin,
+      const ResourceConfigValueIter end, IDiagnostics* diag);
+
+  bool Consume(IAaptContext* context, ResourceTable* table) override;
+
+ private:
+  std::unordered_set<std::string> products_;
+
+  DISALLOW_COPY_AND_ASSIGN(ProductFilter);
+};
+
+class XmlAutoVersioner : public IXmlResourceConsumer {
+ public:
+  XmlAutoVersioner() = default;
+
+  bool Consume(IAaptContext* context, xml::XmlResource* resource) override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(XmlAutoVersioner);
 };
 
 /**
@@ -116,13 +165,16 @@ struct PrivateAttributeMover : public IResourceTableConsumer {
  * XmlReferenceLinker.
  */
 class XmlNamespaceRemover : public IXmlResourceConsumer {
- private:
-  bool mKeepUris;
-
  public:
-  XmlNamespaceRemover(bool keepUris = false) : mKeepUris(keepUris){};
+  explicit XmlNamespaceRemover(bool keep_uris = false)
+      : keep_uris_(keep_uris){};
 
-  bool consume(IAaptContext* context, xml::XmlResource* resource) override;
+  bool Consume(IAaptContext* context, xml::XmlResource* resource) override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(XmlNamespaceRemover);
+
+  bool keep_uris_;
 };
 
 /**
@@ -131,18 +183,22 @@ class XmlNamespaceRemover : public IXmlResourceConsumer {
  * Once an XmlResource is processed by this linker, it is ready to be flattened.
  */
 class XmlReferenceLinker : public IXmlResourceConsumer {
- private:
-  std::set<int> mSdkLevelsFound;
-
  public:
-  bool consume(IAaptContext* context, xml::XmlResource* resource) override;
+  XmlReferenceLinker() = default;
+
+  bool Consume(IAaptContext* context, xml::XmlResource* resource) override;
 
   /**
    * Once the XmlResource has been consumed, this returns the various SDK levels
    * in which
    * framework attributes used within the XML document were defined.
    */
-  inline const std::set<int>& getSdkLevels() const { return mSdkLevelsFound; }
+  inline const std::set<int>& sdk_levels() const { return sdk_levels_found_; }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(XmlReferenceLinker);
+
+  std::set<int> sdk_levels_found_;
 };
 
 }  // namespace aapt
diff --git a/tools/aapt2/link/ManifestFixer.cpp b/tools/aapt2/link/ManifestFixer.cpp
index 3c9298bb63013..a418fc815d495 100644
--- a/tools/aapt2/link/ManifestFixer.cpp
+++ b/tools/aapt2/link/ManifestFixer.cpp
@@ -15,32 +15,36 @@
  */
 
 #include "link/ManifestFixer.h"
+
+#include <unordered_set>
+
+#include "android-base/logging.h"
+
 #include "ResourceUtils.h"
 #include "util/Util.h"
 #include "xml/XmlActionExecutor.h"
 #include "xml/XmlDom.h"
 
-#include <unordered_set>
-
 namespace aapt {
 
 /**
  * This is how PackageManager builds class names from AndroidManifest.xml
  * entries.
  */
-static bool nameIsJavaClassName(xml::Element* el, xml::Attribute* attr,
+static bool NameIsJavaClassName(xml::Element* el, xml::Attribute* attr,
                                 SourcePathDiagnostics* diag) {
   // We allow unqualified class names (ie: .HelloActivity)
   // Since we don't know the package name, we can just make a fake one here and
   // the test will be identical as long as the real package name is valid too.
-  Maybe<std::string> fullyQualifiedClassName =
-      util::getFullyQualifiedClassName("a", attr->value);
+  Maybe<std::string> fully_qualified_class_name =
+      util::GetFullyQualifiedClassName("a", attr->value);
 
-  StringPiece qualifiedClassName =
-      fullyQualifiedClassName ? fullyQualifiedClassName.value() : attr->value;
+  StringPiece qualified_class_name = fully_qualified_class_name
+                                         ? fully_qualified_class_name.value()
+                                         : attr->value;
 
-  if (!util::isJavaClassName(qualifiedClassName)) {
-    diag->error(DiagMessage(el->lineNumber)
+  if (!util::IsJavaClassName(qualified_class_name)) {
+    diag->Error(DiagMessage(el->line_number)
                 << "attribute 'android:name' in <" << el->name
                 << "> tag must be a valid Java class name");
     return false;
@@ -48,37 +52,37 @@ static bool nameIsJavaClassName(xml::Element* el, xml::Attribute* attr,
   return true;
 }
 
-static bool optionalNameIsJavaClassName(xml::Element* el,
+static bool OptionalNameIsJavaClassName(xml::Element* el,
                                         SourcePathDiagnostics* diag) {
-  if (xml::Attribute* attr = el->findAttribute(xml::kSchemaAndroid, "name")) {
-    return nameIsJavaClassName(el, attr, diag);
+  if (xml::Attribute* attr = el->FindAttribute(xml::kSchemaAndroid, "name")) {
+    return NameIsJavaClassName(el, attr, diag);
   }
   return true;
 }
 
-static bool requiredNameIsJavaClassName(xml::Element* el,
+static bool RequiredNameIsJavaClassName(xml::Element* el,
                                         SourcePathDiagnostics* diag) {
-  if (xml::Attribute* attr = el->findAttribute(xml::kSchemaAndroid, "name")) {
-    return nameIsJavaClassName(el, attr, diag);
+  if (xml::Attribute* attr = el->FindAttribute(xml::kSchemaAndroid, "name")) {
+    return NameIsJavaClassName(el, attr, diag);
   }
-  diag->error(DiagMessage(el->lineNumber)
+  diag->Error(DiagMessage(el->line_number)
               << "<" << el->name << "> is missing attribute 'android:name'");
   return false;
 }
 
-static bool verifyManifest(xml::Element* el, SourcePathDiagnostics* diag) {
-  xml::Attribute* attr = el->findAttribute({}, "package");
+static bool VerifyManifest(xml::Element* el, SourcePathDiagnostics* diag) {
+  xml::Attribute* attr = el->FindAttribute({}, "package");
   if (!attr) {
-    diag->error(DiagMessage(el->lineNumber)
+    diag->Error(DiagMessage(el->line_number)
                 << "<manifest> tag is missing 'package' attribute");
     return false;
-  } else if (ResourceUtils::isReference(attr->value)) {
-    diag->error(
-        DiagMessage(el->lineNumber)
+  } else if (ResourceUtils::IsReference(attr->value)) {
+    diag->Error(
+        DiagMessage(el->line_number)
         << "attribute 'package' in <manifest> tag must not be a reference");
     return false;
-  } else if (!util::isJavaPackageName(attr->value)) {
-    diag->error(DiagMessage(el->lineNumber)
+  } else if (!util::IsJavaPackageName(attr->value)) {
+    diag->Error(DiagMessage(el->line_number)
                 << "attribute 'package' in <manifest> tag is not a valid Java "
                    "package name: '"
                 << attr->value << "'");
@@ -89,242 +93,243 @@ static bool verifyManifest(xml::Element* el, SourcePathDiagnostics* diag) {
 
 /**
  * The coreApp attribute in <manifest> is not a regular AAPT attribute, so type
- * checking on it
- * is manual.
+ * checking on it is manual.
  */
-static bool fixCoreAppAttribute(xml::Element* el, SourcePathDiagnostics* diag) {
-  if (xml::Attribute* attr = el->findAttribute("", "coreApp")) {
+static bool FixCoreAppAttribute(xml::Element* el, SourcePathDiagnostics* diag) {
+  if (xml::Attribute* attr = el->FindAttribute("", "coreApp")) {
     std::unique_ptr<BinaryPrimitive> result =
-        ResourceUtils::tryParseBool(attr->value);
+        ResourceUtils::TryParseBool(attr->value);
     if (!result) {
-      diag->error(DiagMessage(el->lineNumber)
+      diag->Error(DiagMessage(el->line_number)
                   << "attribute coreApp must be a boolean");
       return false;
     }
-    attr->compiledValue = std::move(result);
+    attr->compiled_value = std::move(result);
   }
   return true;
 }
 
-bool ManifestFixer::buildRules(xml::XmlActionExecutor* executor,
+bool ManifestFixer::BuildRules(xml::XmlActionExecutor* executor,
                                IDiagnostics* diag) {
   // First verify some options.
-  if (mOptions.renameManifestPackage) {
-    if (!util::isJavaPackageName(mOptions.renameManifestPackage.value())) {
-      diag->error(DiagMessage() << "invalid manifest package override '"
-                                << mOptions.renameManifestPackage.value()
+  if (options_.rename_manifest_package) {
+    if (!util::IsJavaPackageName(options_.rename_manifest_package.value())) {
+      diag->Error(DiagMessage() << "invalid manifest package override '"
+                                << options_.rename_manifest_package.value()
                                 << "'");
       return false;
     }
   }
 
-  if (mOptions.renameInstrumentationTargetPackage) {
-    if (!util::isJavaPackageName(
-            mOptions.renameInstrumentationTargetPackage.value())) {
-      diag->error(DiagMessage()
+  if (options_.rename_instrumentation_target_package) {
+    if (!util::IsJavaPackageName(
+            options_.rename_instrumentation_target_package.value())) {
+      diag->Error(DiagMessage()
                   << "invalid instrumentation target package override '"
-                  << mOptions.renameInstrumentationTargetPackage.value()
+                  << options_.rename_instrumentation_target_package.value()
                   << "'");
       return false;
     }
   }
 
   // Common intent-filter actions.
-  xml::XmlNodeAction intentFilterAction;
-  intentFilterAction["action"];
-  intentFilterAction["category"];
-  intentFilterAction["data"];
+  xml::XmlNodeAction intent_filter_action;
+  intent_filter_action["action"];
+  intent_filter_action["category"];
+  intent_filter_action["data"];
 
   // Common meta-data actions.
-  xml::XmlNodeAction metaDataAction;
+  xml::XmlNodeAction meta_data_action;
 
   // Manifest actions.
-  xml::XmlNodeAction& manifestAction = (*executor)["manifest"];
-  manifestAction.action(verifyManifest);
-  manifestAction.action(fixCoreAppAttribute);
-  manifestAction.action([&](xml::Element* el) -> bool {
-    if (mOptions.versionNameDefault) {
-      if (el->findAttribute(xml::kSchemaAndroid, "versionName") == nullptr) {
+  xml::XmlNodeAction& manifest_action = (*executor)["manifest"];
+  manifest_action.Action(VerifyManifest);
+  manifest_action.Action(FixCoreAppAttribute);
+  manifest_action.Action([&](xml::Element* el) -> bool {
+    if (options_.version_name_default) {
+      if (el->FindAttribute(xml::kSchemaAndroid, "versionName") == nullptr) {
         el->attributes.push_back(
             xml::Attribute{xml::kSchemaAndroid, "versionName",
-                           mOptions.versionNameDefault.value()});
+                           options_.version_name_default.value()});
       }
     }
 
-    if (mOptions.versionCodeDefault) {
-      if (el->findAttribute(xml::kSchemaAndroid, "versionCode") == nullptr) {
+    if (options_.version_code_default) {
+      if (el->FindAttribute(xml::kSchemaAndroid, "versionCode") == nullptr) {
         el->attributes.push_back(
             xml::Attribute{xml::kSchemaAndroid, "versionCode",
-                           mOptions.versionCodeDefault.value()});
+                           options_.version_code_default.value()});
       }
     }
     return true;
   });
 
   // Meta tags.
-  manifestAction["eat-comment"];
+  manifest_action["eat-comment"];
 
   // Uses-sdk actions.
-  manifestAction["uses-sdk"].action([&](xml::Element* el) -> bool {
-    if (mOptions.minSdkVersionDefault &&
-        el->findAttribute(xml::kSchemaAndroid, "minSdkVersion") == nullptr) {
+  manifest_action["uses-sdk"].Action([&](xml::Element* el) -> bool {
+    if (options_.min_sdk_version_default &&
+        el->FindAttribute(xml::kSchemaAndroid, "minSdkVersion") == nullptr) {
       // There was no minSdkVersion defined and we have a default to assign.
       el->attributes.push_back(
           xml::Attribute{xml::kSchemaAndroid, "minSdkVersion",
-                         mOptions.minSdkVersionDefault.value()});
+                         options_.min_sdk_version_default.value()});
     }
 
-    if (mOptions.targetSdkVersionDefault &&
-        el->findAttribute(xml::kSchemaAndroid, "targetSdkVersion") == nullptr) {
+    if (options_.target_sdk_version_default &&
+        el->FindAttribute(xml::kSchemaAndroid, "targetSdkVersion") == nullptr) {
       // There was no targetSdkVersion defined and we have a default to assign.
       el->attributes.push_back(
           xml::Attribute{xml::kSchemaAndroid, "targetSdkVersion",
-                         mOptions.targetSdkVersionDefault.value()});
+                         options_.target_sdk_version_default.value()});
     }
     return true;
   });
 
   // Instrumentation actions.
-  manifestAction["instrumentation"].action([&](xml::Element* el) -> bool {
-    if (!mOptions.renameInstrumentationTargetPackage) {
+  manifest_action["instrumentation"].Action([&](xml::Element* el) -> bool {
+    if (!options_.rename_instrumentation_target_package) {
       return true;
     }
 
     if (xml::Attribute* attr =
-            el->findAttribute(xml::kSchemaAndroid, "targetPackage")) {
-      attr->value = mOptions.renameInstrumentationTargetPackage.value();
+            el->FindAttribute(xml::kSchemaAndroid, "targetPackage")) {
+      attr->value = options_.rename_instrumentation_target_package.value();
     }
     return true;
   });
 
-  manifestAction["original-package"];
-  manifestAction["protected-broadcast"];
-  manifestAction["uses-permission"];
-  manifestAction["permission"];
-  manifestAction["permission-tree"];
-  manifestAction["permission-group"];
+  manifest_action["original-package"];
+  manifest_action["protected-broadcast"];
+  manifest_action["uses-permission"];
+  manifest_action["permission"];
+  manifest_action["permission-tree"];
+  manifest_action["permission-group"];
 
-  manifestAction["uses-configuration"];
-  manifestAction["uses-feature"];
-  manifestAction["supports-screens"];
+  manifest_action["uses-configuration"];
+  manifest_action["uses-feature"];
+  manifest_action["supports-screens"];
 
-  manifestAction["compatible-screens"];
-  manifestAction["compatible-screens"]["screen"];
+  manifest_action["compatible-screens"];
+  manifest_action["compatible-screens"]["screen"];
 
-  manifestAction["supports-gl-texture"];
+  manifest_action["supports-gl-texture"];
 
   // Application actions.
-  xml::XmlNodeAction& applicationAction = manifestAction["application"];
-  applicationAction.action(optionalNameIsJavaClassName);
+  xml::XmlNodeAction& application_action = manifest_action["application"];
+  application_action.Action(OptionalNameIsJavaClassName);
 
   // Uses library actions.
-  applicationAction["uses-library"];
+  application_action["uses-library"];
 
   // Meta-data.
-  applicationAction["meta-data"] = metaDataAction;
+  application_action["meta-data"] = meta_data_action;
 
   // Activity actions.
-  applicationAction["activity"].action(requiredNameIsJavaClassName);
-  applicationAction["activity"]["intent-filter"] = intentFilterAction;
-  applicationAction["activity"]["meta-data"] = metaDataAction;
+  application_action["activity"].Action(RequiredNameIsJavaClassName);
+  application_action["activity"]["intent-filter"] = intent_filter_action;
+  application_action["activity"]["meta-data"] = meta_data_action;
 
   // Activity alias actions.
-  applicationAction["activity-alias"]["intent-filter"] = intentFilterAction;
-  applicationAction["activity-alias"]["meta-data"] = metaDataAction;
+  application_action["activity-alias"]["intent-filter"] = intent_filter_action;
+  application_action["activity-alias"]["meta-data"] = meta_data_action;
 
   // Service actions.
-  applicationAction["service"].action(requiredNameIsJavaClassName);
-  applicationAction["service"]["intent-filter"] = intentFilterAction;
-  applicationAction["service"]["meta-data"] = metaDataAction;
+  application_action["service"].Action(RequiredNameIsJavaClassName);
+  application_action["service"]["intent-filter"] = intent_filter_action;
+  application_action["service"]["meta-data"] = meta_data_action;
 
   // Receiver actions.
-  applicationAction["receiver"].action(requiredNameIsJavaClassName);
-  applicationAction["receiver"]["intent-filter"] = intentFilterAction;
-  applicationAction["receiver"]["meta-data"] = metaDataAction;
+  application_action["receiver"].Action(RequiredNameIsJavaClassName);
+  application_action["receiver"]["intent-filter"] = intent_filter_action;
+  application_action["receiver"]["meta-data"] = meta_data_action;
 
   // Provider actions.
-  applicationAction["provider"].action(requiredNameIsJavaClassName);
-  applicationAction["provider"]["intent-filter"] = intentFilterAction;
-  applicationAction["provider"]["meta-data"] = metaDataAction;
-  applicationAction["provider"]["grant-uri-permissions"];
-  applicationAction["provider"]["path-permissions"];
+  application_action["provider"].Action(RequiredNameIsJavaClassName);
+  application_action["provider"]["intent-filter"] = intent_filter_action;
+  application_action["provider"]["meta-data"] = meta_data_action;
+  application_action["provider"]["grant-uri-permissions"];
+  application_action["provider"]["path-permissions"];
 
   return true;
 }
 
 class FullyQualifiedClassNameVisitor : public xml::Visitor {
  public:
-  using xml::Visitor::visit;
+  using xml::Visitor::Visit;
 
   explicit FullyQualifiedClassNameVisitor(const StringPiece& package)
-      : mPackage(package) {}
+      : package_(package) {}
 
-  void visit(xml::Element* el) override {
+  void Visit(xml::Element* el) override {
     for (xml::Attribute& attr : el->attributes) {
-      if (attr.namespaceUri == xml::kSchemaAndroid &&
-          mClassAttributes.find(attr.name) != mClassAttributes.end()) {
-        if (Maybe<std::string> newValue =
-                util::getFullyQualifiedClassName(mPackage, attr.value)) {
-          attr.value = std::move(newValue.value());
+      if (attr.namespace_uri == xml::kSchemaAndroid &&
+          class_attributes_.find(attr.name) != class_attributes_.end()) {
+        if (Maybe<std::string> new_value =
+                util::GetFullyQualifiedClassName(package_, attr.value)) {
+          attr.value = std::move(new_value.value());
         }
       }
     }
 
     // Super implementation to iterate over the children.
-    xml::Visitor::visit(el);
+    xml::Visitor::Visit(el);
   }
 
  private:
-  StringPiece mPackage;
-  std::unordered_set<StringPiece> mClassAttributes = {"name"};
+  StringPiece package_;
+  std::unordered_set<StringPiece> class_attributes_ = {"name"};
 };
 
-static bool renameManifestPackage(const StringPiece& packageOverride,
-                                  xml::Element* manifestEl) {
-  xml::Attribute* attr = manifestEl->findAttribute({}, "package");
+static bool RenameManifestPackage(const StringPiece& package_override,
+                                  xml::Element* manifest_el) {
+  xml::Attribute* attr = manifest_el->FindAttribute({}, "package");
 
   // We've already verified that the manifest element is present, with a package
   // name specified.
-  assert(attr);
+  CHECK(attr != nullptr);
 
-  std::string originalPackage = std::move(attr->value);
-  attr->value = packageOverride.toString();
+  std::string original_package = std::move(attr->value);
+  attr->value = package_override.ToString();
 
-  FullyQualifiedClassNameVisitor visitor(originalPackage);
-  manifestEl->accept(&visitor);
+  FullyQualifiedClassNameVisitor visitor(original_package);
+  manifest_el->Accept(&visitor);
   return true;
 }
 
-bool ManifestFixer::consume(IAaptContext* context, xml::XmlResource* doc) {
-  xml::Element* root = xml::findRootElement(doc->root.get());
-  if (!root || !root->namespaceUri.empty() || root->name != "manifest") {
-    context->getDiagnostics()->error(DiagMessage(doc->file.source)
+bool ManifestFixer::Consume(IAaptContext* context, xml::XmlResource* doc) {
+  xml::Element* root = xml::FindRootElement(doc->root.get());
+  if (!root || !root->namespace_uri.empty() || root->name != "manifest") {
+    context->GetDiagnostics()->Error(DiagMessage(doc->file.source)
                                      << "root tag must be <manifest>");
     return false;
   }
 
-  if ((mOptions.minSdkVersionDefault || mOptions.targetSdkVersionDefault) &&
-      root->findChild({}, "uses-sdk") == nullptr) {
+  if ((options_.min_sdk_version_default ||
+       options_.target_sdk_version_default) &&
+      root->FindChild({}, "uses-sdk") == nullptr) {
     // Auto insert a <uses-sdk> element.
-    std::unique_ptr<xml::Element> usesSdk = util::make_unique<xml::Element>();
-    usesSdk->name = "uses-sdk";
-    root->addChild(std::move(usesSdk));
+    std::unique_ptr<xml::Element> uses_sdk = util::make_unique<xml::Element>();
+    uses_sdk->name = "uses-sdk";
+    root->AddChild(std::move(uses_sdk));
   }
 
   xml::XmlActionExecutor executor;
-  if (!buildRules(&executor, context->getDiagnostics())) {
+  if (!BuildRules(&executor, context->GetDiagnostics())) {
     return false;
   }
 
-  if (!executor.execute(xml::XmlActionExecutorPolicy::Whitelist,
-                        context->getDiagnostics(), doc)) {
+  if (!executor.Execute(xml::XmlActionExecutorPolicy::kWhitelist,
+                        context->GetDiagnostics(), doc)) {
     return false;
   }
 
-  if (mOptions.renameManifestPackage) {
+  if (options_.rename_manifest_package) {
     // Rename manifest package outside of the XmlActionExecutor.
     // We need to extract the old package name and FullyQualify all class names.
-    if (!renameManifestPackage(mOptions.renameManifestPackage.value(), root)) {
+    if (!RenameManifestPackage(options_.rename_manifest_package.value(),
+                               root)) {
       return false;
     }
   }
diff --git a/tools/aapt2/link/ManifestFixer.h b/tools/aapt2/link/ManifestFixer.h
index c3a114be3eb05..470f65eb01c48 100644
--- a/tools/aapt2/link/ManifestFixer.h
+++ b/tools/aapt2/link/ManifestFixer.h
@@ -17,22 +17,24 @@
 #ifndef AAPT_LINK_MANIFESTFIXER_H
 #define AAPT_LINK_MANIFESTFIXER_H
 
+#include <string>
+
+#include "android-base/macros.h"
+
 #include "process/IResourceTableConsumer.h"
 #include "util/Maybe.h"
 #include "xml/XmlActionExecutor.h"
 #include "xml/XmlDom.h"
 
-#include <string>
-
 namespace aapt {
 
 struct ManifestFixerOptions {
-  Maybe<std::string> minSdkVersionDefault;
-  Maybe<std::string> targetSdkVersionDefault;
-  Maybe<std::string> renameManifestPackage;
-  Maybe<std::string> renameInstrumentationTargetPackage;
-  Maybe<std::string> versionNameDefault;
-  Maybe<std::string> versionCodeDefault;
+  Maybe<std::string> min_sdk_version_default;
+  Maybe<std::string> target_sdk_version_default;
+  Maybe<std::string> rename_manifest_package;
+  Maybe<std::string> rename_instrumentation_target_package;
+  Maybe<std::string> version_name_default;
+  Maybe<std::string> version_code_default;
 };
 
 /**
@@ -42,14 +44,16 @@ struct ManifestFixerOptions {
 class ManifestFixer : public IXmlResourceConsumer {
  public:
   explicit ManifestFixer(const ManifestFixerOptions& options)
-      : mOptions(options) {}
+      : options_(options) {}
 
-  bool consume(IAaptContext* context, xml::XmlResource* doc) override;
+  bool Consume(IAaptContext* context, xml::XmlResource* doc) override;
 
  private:
-  bool buildRules(xml::XmlActionExecutor* executor, IDiagnostics* diag);
+  DISALLOW_COPY_AND_ASSIGN(ManifestFixer);
 
-  ManifestFixerOptions mOptions;
+  bool BuildRules(xml::XmlActionExecutor* executor, IDiagnostics* diag);
+
+  ManifestFixerOptions options_;
 };
 
 }  // namespace aapt
diff --git a/tools/aapt2/link/ManifestFixer_test.cpp b/tools/aapt2/link/ManifestFixer_test.cpp
index dc78d98aaed64..0e29ba6b6071e 100644
--- a/tools/aapt2/link/ManifestFixer_test.cpp
+++ b/tools/aapt2/link/ManifestFixer_test.cpp
@@ -15,10 +15,8 @@
  */
 
 #include "link/ManifestFixer.h"
-#include "test/Builders.h"
-#include "test/Context.h"
 
-#include <gtest/gtest.h>
+#include "test/Test.h"
 
 namespace aapt {
 
@@ -28,42 +26,42 @@ struct ManifestFixerTest : public ::testing::Test {
   void SetUp() override {
     mContext =
         test::ContextBuilder()
-            .setCompilationPackage("android")
-            .setPackageId(0x01)
-            .setNameManglerPolicy(NameManglerPolicy{"android"})
-            .addSymbolSource(
+            .SetCompilationPackage("android")
+            .SetPackageId(0x01)
+            .SetNameManglerPolicy(NameManglerPolicy{"android"})
+            .AddSymbolSource(
                 test::StaticSymbolSourceBuilder()
-                    .addSymbol(
+                    .AddSymbol(
                         "android:attr/package", ResourceId(0x01010000),
                         test::AttributeBuilder()
-                            .setTypeMask(android::ResTable_map::TYPE_STRING)
-                            .build())
-                    .addSymbol(
+                            .SetTypeMask(android::ResTable_map::TYPE_STRING)
+                            .Build())
+                    .AddSymbol(
                         "android:attr/minSdkVersion", ResourceId(0x01010001),
                         test::AttributeBuilder()
-                            .setTypeMask(android::ResTable_map::TYPE_STRING |
+                            .SetTypeMask(android::ResTable_map::TYPE_STRING |
                                          android::ResTable_map::TYPE_INTEGER)
-                            .build())
-                    .addSymbol(
+                            .Build())
+                    .AddSymbol(
                         "android:attr/targetSdkVersion", ResourceId(0x01010002),
                         test::AttributeBuilder()
-                            .setTypeMask(android::ResTable_map::TYPE_STRING |
+                            .SetTypeMask(android::ResTable_map::TYPE_STRING |
                                          android::ResTable_map::TYPE_INTEGER)
-                            .build())
-                    .addSymbol("android:string/str", ResourceId(0x01060000))
-                    .build())
-            .build();
+                            .Build())
+                    .AddSymbol("android:string/str", ResourceId(0x01060000))
+                    .Build())
+            .Build();
   }
 
-  std::unique_ptr<xml::XmlResource> verify(const StringPiece& str) {
-    return verifyWithOptions(str, {});
+  std::unique_ptr<xml::XmlResource> Verify(const StringPiece& str) {
+    return VerifyWithOptions(str, {});
   }
 
-  std::unique_ptr<xml::XmlResource> verifyWithOptions(
+  std::unique_ptr<xml::XmlResource> VerifyWithOptions(
       const StringPiece& str, const ManifestFixerOptions& options) {
-    std::unique_ptr<xml::XmlResource> doc = test::buildXmlDom(str);
+    std::unique_ptr<xml::XmlResource> doc = test::BuildXmlDom(str);
     ManifestFixer fixer(options);
-    if (fixer.consume(mContext.get(), doc.get())) {
+    if (fixer.Consume(mContext.get(), doc.get())) {
       return doc;
     }
     return {};
@@ -71,28 +69,28 @@ struct ManifestFixerTest : public ::testing::Test {
 };
 
 TEST_F(ManifestFixerTest, EnsureManifestIsRootTag) {
-  EXPECT_EQ(nullptr, verify("<other-tag />"));
-  EXPECT_EQ(nullptr, verify("<ns:manifest xmlns:ns=\"com\" />"));
-  EXPECT_NE(nullptr, verify("<manifest package=\"android\"></manifest>"));
+  EXPECT_EQ(nullptr, Verify("<other-tag />"));
+  EXPECT_EQ(nullptr, Verify("<ns:manifest xmlns:ns=\"com\" />"));
+  EXPECT_NE(nullptr, Verify("<manifest package=\"android\"></manifest>"));
 }
 
 TEST_F(ManifestFixerTest, EnsureManifestHasPackage) {
-  EXPECT_NE(nullptr, verify("<manifest package=\"android\" />"));
-  EXPECT_NE(nullptr, verify("<manifest package=\"com.android\" />"));
-  EXPECT_NE(nullptr, verify("<manifest package=\"com.android.google\" />"));
+  EXPECT_NE(nullptr, Verify("<manifest package=\"android\" />"));
+  EXPECT_NE(nullptr, Verify("<manifest package=\"com.android\" />"));
+  EXPECT_NE(nullptr, Verify("<manifest package=\"com.android.google\" />"));
   EXPECT_EQ(nullptr,
-            verify("<manifest package=\"com.android.google.Class$1\" />"));
-  EXPECT_EQ(nullptr, verify("<manifest "
+            Verify("<manifest package=\"com.android.google.Class$1\" />"));
+  EXPECT_EQ(nullptr, Verify("<manifest "
                             "xmlns:android=\"http://schemas.android.com/apk/"
                             "res/android\" "
                             "android:package=\"com.android\" />"));
-  EXPECT_EQ(nullptr, verify("<manifest package=\"@string/str\" />"));
+  EXPECT_EQ(nullptr, Verify("<manifest package=\"@string/str\" />"));
 }
 
 TEST_F(ManifestFixerTest, UseDefaultSdkVersionsIfNonePresent) {
   ManifestFixerOptions options = {std::string("8"), std::string("22")};
 
-  std::unique_ptr<xml::XmlResource> doc = verifyWithOptions(R"EOF(
+  std::unique_ptr<xml::XmlResource> doc = VerifyWithOptions(R"EOF(
       <manifest xmlns:android="http://schemas.android.com/apk/res/android"
                 package="android">
         <uses-sdk android:minSdkVersion="7" android:targetSdkVersion="21" />
@@ -103,18 +101,18 @@ TEST_F(ManifestFixerTest, UseDefaultSdkVersionsIfNonePresent) {
   xml::Element* el;
   xml::Attribute* attr;
 
-  el = xml::findRootElement(doc.get());
+  el = xml::FindRootElement(doc.get());
   ASSERT_NE(nullptr, el);
-  el = el->findChild({}, "uses-sdk");
+  el = el->FindChild({}, "uses-sdk");
   ASSERT_NE(nullptr, el);
-  attr = el->findAttribute(xml::kSchemaAndroid, "minSdkVersion");
+  attr = el->FindAttribute(xml::kSchemaAndroid, "minSdkVersion");
   ASSERT_NE(nullptr, attr);
   EXPECT_EQ("7", attr->value);
-  attr = el->findAttribute(xml::kSchemaAndroid, "targetSdkVersion");
+  attr = el->FindAttribute(xml::kSchemaAndroid, "targetSdkVersion");
   ASSERT_NE(nullptr, attr);
   EXPECT_EQ("21", attr->value);
 
-  doc = verifyWithOptions(R"EOF(
+  doc = VerifyWithOptions(R"EOF(
       <manifest xmlns:android="http://schemas.android.com/apk/res/android"
                 package="android">
         <uses-sdk android:targetSdkVersion="21" />
@@ -122,18 +120,18 @@ TEST_F(ManifestFixerTest, UseDefaultSdkVersionsIfNonePresent) {
                           options);
   ASSERT_NE(nullptr, doc);
 
-  el = xml::findRootElement(doc.get());
+  el = xml::FindRootElement(doc.get());
   ASSERT_NE(nullptr, el);
-  el = el->findChild({}, "uses-sdk");
+  el = el->FindChild({}, "uses-sdk");
   ASSERT_NE(nullptr, el);
-  attr = el->findAttribute(xml::kSchemaAndroid, "minSdkVersion");
+  attr = el->FindAttribute(xml::kSchemaAndroid, "minSdkVersion");
   ASSERT_NE(nullptr, attr);
   EXPECT_EQ("8", attr->value);
-  attr = el->findAttribute(xml::kSchemaAndroid, "targetSdkVersion");
+  attr = el->FindAttribute(xml::kSchemaAndroid, "targetSdkVersion");
   ASSERT_NE(nullptr, attr);
   EXPECT_EQ("21", attr->value);
 
-  doc = verifyWithOptions(R"EOF(
+  doc = VerifyWithOptions(R"EOF(
       <manifest xmlns:android="http://schemas.android.com/apk/res/android"
                 package="android">
         <uses-sdk />
@@ -141,40 +139,40 @@ TEST_F(ManifestFixerTest, UseDefaultSdkVersionsIfNonePresent) {
                           options);
   ASSERT_NE(nullptr, doc);
 
-  el = xml::findRootElement(doc.get());
+  el = xml::FindRootElement(doc.get());
   ASSERT_NE(nullptr, el);
-  el = el->findChild({}, "uses-sdk");
+  el = el->FindChild({}, "uses-sdk");
   ASSERT_NE(nullptr, el);
-  attr = el->findAttribute(xml::kSchemaAndroid, "minSdkVersion");
+  attr = el->FindAttribute(xml::kSchemaAndroid, "minSdkVersion");
   ASSERT_NE(nullptr, attr);
   EXPECT_EQ("8", attr->value);
-  attr = el->findAttribute(xml::kSchemaAndroid, "targetSdkVersion");
+  attr = el->FindAttribute(xml::kSchemaAndroid, "targetSdkVersion");
   ASSERT_NE(nullptr, attr);
   EXPECT_EQ("22", attr->value);
 
-  doc = verifyWithOptions(R"EOF(
+  doc = VerifyWithOptions(R"EOF(
       <manifest xmlns:android="http://schemas.android.com/apk/res/android"
                 package="android" />)EOF",
                           options);
   ASSERT_NE(nullptr, doc);
 
-  el = xml::findRootElement(doc.get());
+  el = xml::FindRootElement(doc.get());
   ASSERT_NE(nullptr, el);
-  el = el->findChild({}, "uses-sdk");
+  el = el->FindChild({}, "uses-sdk");
   ASSERT_NE(nullptr, el);
-  attr = el->findAttribute(xml::kSchemaAndroid, "minSdkVersion");
+  attr = el->FindAttribute(xml::kSchemaAndroid, "minSdkVersion");
   ASSERT_NE(nullptr, attr);
   EXPECT_EQ("8", attr->value);
-  attr = el->findAttribute(xml::kSchemaAndroid, "targetSdkVersion");
+  attr = el->FindAttribute(xml::kSchemaAndroid, "targetSdkVersion");
   ASSERT_NE(nullptr, attr);
   EXPECT_EQ("22", attr->value);
 }
 
 TEST_F(ManifestFixerTest, RenameManifestPackageAndFullyQualifyClasses) {
   ManifestFixerOptions options;
-  options.renameManifestPackage = std::string("com.android");
+  options.rename_manifest_package = std::string("com.android");
 
-  std::unique_ptr<xml::XmlResource> doc = verifyWithOptions(R"EOF(
+  std::unique_ptr<xml::XmlResource> doc = VerifyWithOptions(R"EOF(
       <manifest xmlns:android="http://schemas.android.com/apk/res/android"
                 package="android">
         <application android:name=".MainApplication" text="hello">
@@ -185,38 +183,38 @@ TEST_F(ManifestFixerTest, RenameManifestPackageAndFullyQualifyClasses) {
                                                             options);
   ASSERT_NE(nullptr, doc);
 
-  xml::Element* manifestEl = xml::findRootElement(doc.get());
+  xml::Element* manifestEl = xml::FindRootElement(doc.get());
   ASSERT_NE(nullptr, manifestEl);
 
   xml::Attribute* attr = nullptr;
 
-  attr = manifestEl->findAttribute({}, "package");
+  attr = manifestEl->FindAttribute({}, "package");
   ASSERT_NE(nullptr, attr);
   EXPECT_EQ(std::string("com.android"), attr->value);
 
-  xml::Element* applicationEl = manifestEl->findChild({}, "application");
+  xml::Element* applicationEl = manifestEl->FindChild({}, "application");
   ASSERT_NE(nullptr, applicationEl);
 
-  attr = applicationEl->findAttribute(xml::kSchemaAndroid, "name");
+  attr = applicationEl->FindAttribute(xml::kSchemaAndroid, "name");
   ASSERT_NE(nullptr, attr);
   EXPECT_EQ(std::string("android.MainApplication"), attr->value);
 
-  attr = applicationEl->findAttribute({}, "text");
+  attr = applicationEl->FindAttribute({}, "text");
   ASSERT_NE(nullptr, attr);
   EXPECT_EQ(std::string("hello"), attr->value);
 
   xml::Element* el;
-  el = applicationEl->findChild({}, "activity");
+  el = applicationEl->FindChild({}, "activity");
   ASSERT_NE(nullptr, el);
 
-  attr = el->findAttribute(xml::kSchemaAndroid, "name");
+  attr = el->FindAttribute(xml::kSchemaAndroid, "name");
   ASSERT_NE(nullptr, el);
   EXPECT_EQ(std::string("android.activity.Start"), attr->value);
 
-  el = applicationEl->findChild({}, "receiver");
+  el = applicationEl->FindChild({}, "receiver");
   ASSERT_NE(nullptr, el);
 
-  attr = el->findAttribute(xml::kSchemaAndroid, "name");
+  attr = el->FindAttribute(xml::kSchemaAndroid, "name");
   ASSERT_NE(nullptr, el);
   EXPECT_EQ(std::string("com.google.android.Receiver"), attr->value);
 }
@@ -224,9 +222,9 @@ TEST_F(ManifestFixerTest, RenameManifestPackageAndFullyQualifyClasses) {
 TEST_F(ManifestFixerTest,
        RenameManifestInstrumentationPackageAndFullyQualifyTarget) {
   ManifestFixerOptions options;
-  options.renameInstrumentationTargetPackage = std::string("com.android");
+  options.rename_instrumentation_target_package = std::string("com.android");
 
-  std::unique_ptr<xml::XmlResource> doc = verifyWithOptions(R"EOF(
+  std::unique_ptr<xml::XmlResource> doc = VerifyWithOptions(R"EOF(
       <manifest xmlns:android="http://schemas.android.com/apk/res/android"
                 package="android">
         <instrumentation android:targetPackage="android" />
@@ -234,63 +232,63 @@ TEST_F(ManifestFixerTest,
                                                             options);
   ASSERT_NE(nullptr, doc);
 
-  xml::Element* manifestEl = xml::findRootElement(doc.get());
-  ASSERT_NE(nullptr, manifestEl);
+  xml::Element* manifest_el = xml::FindRootElement(doc.get());
+  ASSERT_NE(nullptr, manifest_el);
 
-  xml::Element* instrumentationEl =
-      manifestEl->findChild({}, "instrumentation");
-  ASSERT_NE(nullptr, instrumentationEl);
+  xml::Element* instrumentation_el =
+      manifest_el->FindChild({}, "instrumentation");
+  ASSERT_NE(nullptr, instrumentation_el);
 
   xml::Attribute* attr =
-      instrumentationEl->findAttribute(xml::kSchemaAndroid, "targetPackage");
+      instrumentation_el->FindAttribute(xml::kSchemaAndroid, "targetPackage");
   ASSERT_NE(nullptr, attr);
   EXPECT_EQ(std::string("com.android"), attr->value);
 }
 
 TEST_F(ManifestFixerTest, UseDefaultVersionNameAndCode) {
   ManifestFixerOptions options;
-  options.versionNameDefault = std::string("Beta");
-  options.versionCodeDefault = std::string("0x10000000");
+  options.version_name_default = std::string("Beta");
+  options.version_code_default = std::string("0x10000000");
 
-  std::unique_ptr<xml::XmlResource> doc = verifyWithOptions(R"EOF(
+  std::unique_ptr<xml::XmlResource> doc = VerifyWithOptions(R"EOF(
       <manifest xmlns:android="http://schemas.android.com/apk/res/android"
                 package="android" />)EOF",
                                                             options);
   ASSERT_NE(nullptr, doc);
 
-  xml::Element* manifestEl = xml::findRootElement(doc.get());
-  ASSERT_NE(nullptr, manifestEl);
+  xml::Element* manifest_el = xml::FindRootElement(doc.get());
+  ASSERT_NE(nullptr, manifest_el);
 
   xml::Attribute* attr =
-      manifestEl->findAttribute(xml::kSchemaAndroid, "versionName");
+      manifest_el->FindAttribute(xml::kSchemaAndroid, "versionName");
   ASSERT_NE(nullptr, attr);
   EXPECT_EQ(std::string("Beta"), attr->value);
 
-  attr = manifestEl->findAttribute(xml::kSchemaAndroid, "versionCode");
+  attr = manifest_el->FindAttribute(xml::kSchemaAndroid, "versionCode");
   ASSERT_NE(nullptr, attr);
   EXPECT_EQ(std::string("0x10000000"), attr->value);
 }
 
 TEST_F(ManifestFixerTest, EnsureManifestAttributesAreTyped) {
   EXPECT_EQ(nullptr,
-            verify("<manifest package=\"android\" coreApp=\"hello\" />"));
+            Verify("<manifest package=\"android\" coreApp=\"hello\" />"));
   EXPECT_EQ(nullptr,
-            verify("<manifest package=\"android\" coreApp=\"1dp\" />"));
+            Verify("<manifest package=\"android\" coreApp=\"1dp\" />"));
 
   std::unique_ptr<xml::XmlResource> doc =
-      verify("<manifest package=\"android\" coreApp=\"true\" />");
+      Verify("<manifest package=\"android\" coreApp=\"true\" />");
   ASSERT_NE(nullptr, doc);
 
-  xml::Element* el = xml::findRootElement(doc.get());
+  xml::Element* el = xml::FindRootElement(doc.get());
   ASSERT_NE(nullptr, el);
 
   EXPECT_EQ("manifest", el->name);
 
-  xml::Attribute* attr = el->findAttribute("", "coreApp");
+  xml::Attribute* attr = el->FindAttribute("", "coreApp");
   ASSERT_NE(nullptr, attr);
 
-  EXPECT_NE(nullptr, attr->compiledValue);
-  EXPECT_NE(nullptr, valueCast<BinaryPrimitive>(attr->compiledValue.get()));
+  EXPECT_NE(nullptr, attr->compiled_value);
+  EXPECT_NE(nullptr, ValueCast<BinaryPrimitive>(attr->compiled_value.get()));
 }
 
 }  // namespace aapt
diff --git a/tools/aapt2/link/PrivateAttributeMover.cpp b/tools/aapt2/link/PrivateAttributeMover.cpp
index 174b41f20d5e9..cc07a6e1925bc 100644
--- a/tools/aapt2/link/PrivateAttributeMover.cpp
+++ b/tools/aapt2/link/PrivateAttributeMover.cpp
@@ -14,27 +14,30 @@
  * limitations under the License.
  */
 
-#include "ResourceTable.h"
 #include "link/Linkers.h"
 
 #include <algorithm>
 #include <iterator>
 
+#include "android-base/logging.h"
+
+#include "ResourceTable.h"
+
 namespace aapt {
 
 template <typename InputContainer, typename OutputIterator, typename Predicate>
-OutputIterator moveIf(InputContainer& inputContainer, OutputIterator result,
-                      Predicate pred) {
-  const auto last = inputContainer.end();
-  auto newEnd =
-      std::find_if(inputContainer.begin(), inputContainer.end(), pred);
-  if (newEnd == last) {
+OutputIterator move_if(InputContainer& input_container, OutputIterator result,
+                       Predicate pred) {
+  const auto last = input_container.end();
+  auto new_end =
+      std::find_if(input_container.begin(), input_container.end(), pred);
+  if (new_end == last) {
     return result;
   }
 
-  *result = std::move(*newEnd);
+  *result = std::move(*new_end);
 
-  auto first = newEnd;
+  auto first = new_end;
   ++first;
 
   for (; first != last; ++first) {
@@ -44,39 +47,38 @@ OutputIterator moveIf(InputContainer& inputContainer, OutputIterator result,
       ++result;
     } else {
       // We want to keep this guy, but we will need to move it up the list to
-      // replace
-      // missing items.
-      *newEnd = std::move(*first);
-      ++newEnd;
+      // replace missing items.
+      *new_end = std::move(*first);
+      ++new_end;
     }
   }
 
-  inputContainer.erase(newEnd, last);
+  input_container.erase(new_end, last);
   return result;
 }
 
-bool PrivateAttributeMover::consume(IAaptContext* context,
+bool PrivateAttributeMover::Consume(IAaptContext* context,
                                     ResourceTable* table) {
   for (auto& package : table->packages) {
-    ResourceTableType* type = package->findType(ResourceType::kAttr);
+    ResourceTableType* type = package->FindType(ResourceType::kAttr);
     if (!type) {
       continue;
     }
 
-    if (type->symbolStatus.state != SymbolState::kPublic) {
+    if (type->symbol_status.state != SymbolState::kPublic) {
       // No public attributes, so we can safely leave these private attributes
       // where they are.
       return true;
     }
 
-    ResourceTableType* privAttrType =
-        package->findOrCreateType(ResourceType::kAttrPrivate);
-    assert(privAttrType->entries.empty());
+    ResourceTableType* priv_attr_type =
+        package->FindOrCreateType(ResourceType::kAttrPrivate);
+    CHECK(priv_attr_type->entries.empty());
 
-    moveIf(type->entries, std::back_inserter(privAttrType->entries),
-           [](const std::unique_ptr<ResourceEntry>& entry) -> bool {
-             return entry->symbolStatus.state != SymbolState::kPublic;
-           });
+    move_if(type->entries, std::back_inserter(priv_attr_type->entries),
+            [](const std::unique_ptr<ResourceEntry>& entry) -> bool {
+              return entry->symbol_status.state != SymbolState::kPublic;
+            });
     break;
   }
   return true;
diff --git a/tools/aapt2/link/PrivateAttributeMover_test.cpp b/tools/aapt2/link/PrivateAttributeMover_test.cpp
index a7a1013fd8095..90c4922625be0 100644
--- a/tools/aapt2/link/PrivateAttributeMover_test.cpp
+++ b/tools/aapt2/link/PrivateAttributeMover_test.cpp
@@ -15,64 +15,65 @@
  */
 
 #include "link/Linkers.h"
+
 #include "test/Test.h"
 
 namespace aapt {
 
 TEST(PrivateAttributeMoverTest, MovePrivateAttributes) {
-  std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
+  std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
 
   std::unique_ptr<ResourceTable> table =
       test::ResourceTableBuilder()
-          .addSimple("android:attr/publicA")
-          .addSimple("android:attr/privateA")
-          .addSimple("android:attr/publicB")
-          .addSimple("android:attr/privateB")
-          .setSymbolState("android:attr/publicA", ResourceId(0x01010000),
+          .AddSimple("android:attr/publicA")
+          .AddSimple("android:attr/privateA")
+          .AddSimple("android:attr/publicB")
+          .AddSimple("android:attr/privateB")
+          .SetSymbolState("android:attr/publicA", ResourceId(0x01010000),
                           SymbolState::kPublic)
-          .setSymbolState("android:attr/publicB", ResourceId(0x01010000),
+          .SetSymbolState("android:attr/publicB", ResourceId(0x01010000),
                           SymbolState::kPublic)
-          .build();
+          .Build();
 
   PrivateAttributeMover mover;
-  ASSERT_TRUE(mover.consume(context.get(), table.get()));
+  ASSERT_TRUE(mover.Consume(context.get(), table.get()));
 
-  ResourceTablePackage* package = table->findPackage("android");
+  ResourceTablePackage* package = table->FindPackage("android");
   ASSERT_NE(package, nullptr);
 
-  ResourceTableType* type = package->findType(ResourceType::kAttr);
+  ResourceTableType* type = package->FindType(ResourceType::kAttr);
   ASSERT_NE(type, nullptr);
   ASSERT_EQ(type->entries.size(), 2u);
-  EXPECT_NE(type->findEntry("publicA"), nullptr);
-  EXPECT_NE(type->findEntry("publicB"), nullptr);
+  EXPECT_NE(type->FindEntry("publicA"), nullptr);
+  EXPECT_NE(type->FindEntry("publicB"), nullptr);
 
-  type = package->findType(ResourceType::kAttrPrivate);
+  type = package->FindType(ResourceType::kAttrPrivate);
   ASSERT_NE(type, nullptr);
   ASSERT_EQ(type->entries.size(), 2u);
-  EXPECT_NE(type->findEntry("privateA"), nullptr);
-  EXPECT_NE(type->findEntry("privateB"), nullptr);
+  EXPECT_NE(type->FindEntry("privateA"), nullptr);
+  EXPECT_NE(type->FindEntry("privateB"), nullptr);
 }
 
 TEST(PrivateAttributeMoverTest,
      LeavePrivateAttributesWhenNoPublicAttributesDefined) {
-  std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
+  std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
 
   std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
-                                             .addSimple("android:attr/privateA")
-                                             .addSimple("android:attr/privateB")
-                                             .build();
+                                             .AddSimple("android:attr/privateA")
+                                             .AddSimple("android:attr/privateB")
+                                             .Build();
 
   PrivateAttributeMover mover;
-  ASSERT_TRUE(mover.consume(context.get(), table.get()));
+  ASSERT_TRUE(mover.Consume(context.get(), table.get()));
 
-  ResourceTablePackage* package = table->findPackage("android");
+  ResourceTablePackage* package = table->FindPackage("android");
   ASSERT_NE(package, nullptr);
 
-  ResourceTableType* type = package->findType(ResourceType::kAttr);
+  ResourceTableType* type = package->FindType(ResourceType::kAttr);
   ASSERT_NE(type, nullptr);
   ASSERT_EQ(type->entries.size(), 2u);
 
-  type = package->findType(ResourceType::kAttrPrivate);
+  type = package->FindType(ResourceType::kAttrPrivate);
   ASSERT_EQ(type, nullptr);
 }
 
diff --git a/tools/aapt2/link/ProductFilter.cpp b/tools/aapt2/link/ProductFilter.cpp
index d59b6820fdefc..c1a95ee1bcece 100644
--- a/tools/aapt2/link/ProductFilter.cpp
+++ b/tools/aapt2/link/ProductFilter.cpp
@@ -14,103 +14,106 @@
  * limitations under the License.
  */
 
-#include "link/ProductFilter.h"
+#include "link/Linkers.h"
+
+#include "ResourceTable.h"
 
 namespace aapt {
 
-ProductFilter::ResourceConfigValueIter ProductFilter::selectProductToKeep(
+ProductFilter::ResourceConfigValueIter ProductFilter::SelectProductToKeep(
     const ResourceNameRef& name, const ResourceConfigValueIter begin,
     const ResourceConfigValueIter end, IDiagnostics* diag) {
-  ResourceConfigValueIter defaultProductIter = end;
-  ResourceConfigValueIter selectedProductIter = end;
+  ResourceConfigValueIter default_product_iter = end;
+  ResourceConfigValueIter selected_product_iter = end;
 
   for (ResourceConfigValueIter iter = begin; iter != end; ++iter) {
-    ResourceConfigValue* configValue = iter->get();
-    if (mProducts.find(configValue->product) != mProducts.end()) {
-      if (selectedProductIter != end) {
+    ResourceConfigValue* config_value = iter->get();
+    if (products_.find(config_value->product) != products_.end()) {
+      if (selected_product_iter != end) {
         // We have two possible values for this product!
-        diag->error(DiagMessage(configValue->value->getSource())
-                    << "selection of product '" << configValue->product
+        diag->Error(DiagMessage(config_value->value->GetSource())
+                    << "selection of product '" << config_value->product
                     << "' for resource " << name << " is ambiguous");
 
-        ResourceConfigValue* previouslySelectedConfigValue =
-            selectedProductIter->get();
-        diag->note(
-            DiagMessage(previouslySelectedConfigValue->value->getSource())
-            << "product '" << previouslySelectedConfigValue->product
+        ResourceConfigValue* previously_selected_config_value =
+            selected_product_iter->get();
+        diag->Note(
+            DiagMessage(previously_selected_config_value->value->GetSource())
+            << "product '" << previously_selected_config_value->product
             << "' is also a candidate");
         return end;
       }
 
       // Select this product.
-      selectedProductIter = iter;
+      selected_product_iter = iter;
     }
 
-    if (configValue->product.empty() || configValue->product == "default") {
-      if (defaultProductIter != end) {
+    if (config_value->product.empty() || config_value->product == "default") {
+      if (default_product_iter != end) {
         // We have two possible default values.
-        diag->error(DiagMessage(configValue->value->getSource())
+        diag->Error(DiagMessage(config_value->value->GetSource())
                     << "multiple default products defined for resource "
                     << name);
 
-        ResourceConfigValue* previouslyDefaultConfigValue =
-            defaultProductIter->get();
-        diag->note(DiagMessage(previouslyDefaultConfigValue->value->getSource())
-                   << "default product also defined here");
+        ResourceConfigValue* previously_default_config_value =
+            default_product_iter->get();
+        diag->Note(
+            DiagMessage(previously_default_config_value->value->GetSource())
+            << "default product also defined here");
         return end;
       }
 
       // Mark the default.
-      defaultProductIter = iter;
+      default_product_iter = iter;
     }
   }
 
-  if (defaultProductIter == end) {
-    diag->error(DiagMessage() << "no default product defined for resource "
+  if (default_product_iter == end) {
+    diag->Error(DiagMessage() << "no default product defined for resource "
                               << name);
     return end;
   }
 
-  if (selectedProductIter == end) {
-    selectedProductIter = defaultProductIter;
+  if (selected_product_iter == end) {
+    selected_product_iter = default_product_iter;
   }
-  return selectedProductIter;
+  return selected_product_iter;
 }
 
-bool ProductFilter::consume(IAaptContext* context, ResourceTable* table) {
+bool ProductFilter::Consume(IAaptContext* context, ResourceTable* table) {
   bool error = false;
   for (auto& pkg : table->packages) {
     for (auto& type : pkg->types) {
       for (auto& entry : type->entries) {
-        std::vector<std::unique_ptr<ResourceConfigValue>> newValues;
+        std::vector<std::unique_ptr<ResourceConfigValue>> new_values;
 
         ResourceConfigValueIter iter = entry->values.begin();
-        ResourceConfigValueIter startRangeIter = iter;
+        ResourceConfigValueIter start_range_iter = iter;
         while (iter != entry->values.end()) {
           ++iter;
           if (iter == entry->values.end() ||
-              (*iter)->config != (*startRangeIter)->config) {
+              (*iter)->config != (*start_range_iter)->config) {
             // End of the array, or we saw a different config,
             // so this must be the end of a range of products.
             // Select the product to keep from the set of products defined.
             ResourceNameRef name(pkg->name, type->type, entry->name);
-            auto valueToKeep = selectProductToKeep(name, startRangeIter, iter,
-                                                   context->getDiagnostics());
-            if (valueToKeep == iter) {
+            auto value_to_keep = SelectProductToKeep(
+                name, start_range_iter, iter, context->GetDiagnostics());
+            if (value_to_keep == iter) {
               // An error occurred, we could not pick a product.
               error = true;
             } else {
               // We selected a product to keep. Move it to the new array.
-              newValues.push_back(std::move(*valueToKeep));
+              new_values.push_back(std::move(*value_to_keep));
             }
 
             // Start the next range of products.
-            startRangeIter = iter;
+            start_range_iter = iter;
           }
         }
 
         // Now move the new values in to place.
-        entry->values = std::move(newValues);
+        entry->values = std::move(new_values);
       }
     }
   }
diff --git a/tools/aapt2/link/ProductFilter.h b/tools/aapt2/link/ProductFilter.h
deleted file mode 100644
index cc8b8c2792084..0000000000000
--- a/tools/aapt2/link/ProductFilter.h
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * Copyright (C) 2016 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef AAPT_LINK_PRODUCTFILTER_H
-#define AAPT_LINK_PRODUCTFILTER_H
-
-#include "ResourceTable.h"
-#include "process/IResourceTableConsumer.h"
-
-#include <android-base/macros.h>
-#include <unordered_set>
-
-namespace aapt {
-
-class ProductFilter {
- public:
-  using ResourceConfigValueIter =
-      std::vector<std::unique_ptr<ResourceConfigValue>>::iterator;
-
-  explicit ProductFilter(std::unordered_set<std::string> products)
-      : mProducts(products) {}
-
-  ResourceConfigValueIter selectProductToKeep(
-      const ResourceNameRef& name, const ResourceConfigValueIter begin,
-      const ResourceConfigValueIter end, IDiagnostics* diag);
-
-  bool consume(IAaptContext* context, ResourceTable* table);
-
- private:
-  std::unordered_set<std::string> mProducts;
-
-  DISALLOW_COPY_AND_ASSIGN(ProductFilter);
-};
-
-}  // namespace aapt
-
-#endif /* AAPT_LINK_PRODUCTFILTER_H */
diff --git a/tools/aapt2/link/ProductFilter_test.cpp b/tools/aapt2/link/ProductFilter_test.cpp
index 7f78f8bd46939..379ad26836e8d 100644
--- a/tools/aapt2/link/ProductFilter_test.cpp
+++ b/tools/aapt2/link/ProductFilter_test.cpp
@@ -14,116 +14,117 @@
  * limitations under the License.
  */
 
-#include "link/ProductFilter.h"
+#include "link/Linkers.h"
+
 #include "test/Test.h"
 
 namespace aapt {
 
 TEST(ProductFilterTest, SelectTwoProducts) {
-  std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
+  std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
 
-  const ConfigDescription land = test::parseConfigOrDie("land");
-  const ConfigDescription port = test::parseConfigOrDie("port");
+  const ConfigDescription land = test::ParseConfigOrDie("land");
+  const ConfigDescription port = test::ParseConfigOrDie("port");
 
   ResourceTable table;
-  ASSERT_TRUE(table.addResource(
-      test::parseNameOrDie("android:string/one"), land, "",
-      test::ValueBuilder<Id>().setSource(Source("land/default.xml")).build(),
-      context->getDiagnostics()));
-  ASSERT_TRUE(table.addResource(
-      test::parseNameOrDie("android:string/one"), land, "tablet",
-      test::ValueBuilder<Id>().setSource(Source("land/tablet.xml")).build(),
-      context->getDiagnostics()));
+  ASSERT_TRUE(table.AddResource(
+      test::ParseNameOrDie("android:string/one"), land, "",
+      test::ValueBuilder<Id>().SetSource(Source("land/default.xml")).Build(),
+      context->GetDiagnostics()));
+  ASSERT_TRUE(table.AddResource(
+      test::ParseNameOrDie("android:string/one"), land, "tablet",
+      test::ValueBuilder<Id>().SetSource(Source("land/tablet.xml")).Build(),
+      context->GetDiagnostics()));
 
-  ASSERT_TRUE(table.addResource(
-      test::parseNameOrDie("android:string/one"), port, "",
-      test::ValueBuilder<Id>().setSource(Source("port/default.xml")).build(),
-      context->getDiagnostics()));
-  ASSERT_TRUE(table.addResource(
-      test::parseNameOrDie("android:string/one"), port, "tablet",
-      test::ValueBuilder<Id>().setSource(Source("port/tablet.xml")).build(),
-      context->getDiagnostics()));
+  ASSERT_TRUE(table.AddResource(
+      test::ParseNameOrDie("android:string/one"), port, "",
+      test::ValueBuilder<Id>().SetSource(Source("port/default.xml")).Build(),
+      context->GetDiagnostics()));
+  ASSERT_TRUE(table.AddResource(
+      test::ParseNameOrDie("android:string/one"), port, "tablet",
+      test::ValueBuilder<Id>().SetSource(Source("port/tablet.xml")).Build(),
+      context->GetDiagnostics()));
 
   ProductFilter filter({"tablet"});
-  ASSERT_TRUE(filter.consume(context.get(), &table));
+  ASSERT_TRUE(filter.Consume(context.get(), &table));
 
-  EXPECT_EQ(nullptr, test::getValueForConfigAndProduct<Id>(
+  EXPECT_EQ(nullptr, test::GetValueForConfigAndProduct<Id>(
                          &table, "android:string/one", land, ""));
-  EXPECT_NE(nullptr, test::getValueForConfigAndProduct<Id>(
+  EXPECT_NE(nullptr, test::GetValueForConfigAndProduct<Id>(
                          &table, "android:string/one", land, "tablet"));
-  EXPECT_EQ(nullptr, test::getValueForConfigAndProduct<Id>(
+  EXPECT_EQ(nullptr, test::GetValueForConfigAndProduct<Id>(
                          &table, "android:string/one", port, ""));
-  EXPECT_NE(nullptr, test::getValueForConfigAndProduct<Id>(
+  EXPECT_NE(nullptr, test::GetValueForConfigAndProduct<Id>(
                          &table, "android:string/one", port, "tablet"));
 }
 
 TEST(ProductFilterTest, SelectDefaultProduct) {
-  std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
+  std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
 
   ResourceTable table;
-  ASSERT_TRUE(table.addResource(
-      test::parseNameOrDie("android:string/one"),
-      ConfigDescription::defaultConfig(), "",
-      test::ValueBuilder<Id>().setSource(Source("default.xml")).build(),
-      context->getDiagnostics()));
-  ASSERT_TRUE(table.addResource(
-      test::parseNameOrDie("android:string/one"),
-      ConfigDescription::defaultConfig(), "tablet",
-      test::ValueBuilder<Id>().setSource(Source("tablet.xml")).build(),
-      context->getDiagnostics()));
+  ASSERT_TRUE(table.AddResource(
+      test::ParseNameOrDie("android:string/one"),
+      ConfigDescription::DefaultConfig(), "",
+      test::ValueBuilder<Id>().SetSource(Source("default.xml")).Build(),
+      context->GetDiagnostics()));
+  ASSERT_TRUE(table.AddResource(
+      test::ParseNameOrDie("android:string/one"),
+      ConfigDescription::DefaultConfig(), "tablet",
+      test::ValueBuilder<Id>().SetSource(Source("tablet.xml")).Build(),
+      context->GetDiagnostics()));
 
   ProductFilter filter({});
-  ASSERT_TRUE(filter.consume(context.get(), &table));
+  ASSERT_TRUE(filter.Consume(context.get(), &table));
 
-  EXPECT_NE(nullptr, test::getValueForConfigAndProduct<Id>(
+  EXPECT_NE(nullptr, test::GetValueForConfigAndProduct<Id>(
                          &table, "android:string/one",
-                         ConfigDescription::defaultConfig(), ""));
-  EXPECT_EQ(nullptr, test::getValueForConfigAndProduct<Id>(
+                         ConfigDescription::DefaultConfig(), ""));
+  EXPECT_EQ(nullptr, test::GetValueForConfigAndProduct<Id>(
                          &table, "android:string/one",
-                         ConfigDescription::defaultConfig(), "tablet"));
+                         ConfigDescription::DefaultConfig(), "tablet"));
 }
 
 TEST(ProductFilterTest, FailOnAmbiguousProduct) {
-  std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
+  std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
 
   ResourceTable table;
-  ASSERT_TRUE(table.addResource(
-      test::parseNameOrDie("android:string/one"),
-      ConfigDescription::defaultConfig(), "",
-      test::ValueBuilder<Id>().setSource(Source("default.xml")).build(),
-      context->getDiagnostics()));
-  ASSERT_TRUE(table.addResource(
-      test::parseNameOrDie("android:string/one"),
-      ConfigDescription::defaultConfig(), "tablet",
-      test::ValueBuilder<Id>().setSource(Source("tablet.xml")).build(),
-      context->getDiagnostics()));
-  ASSERT_TRUE(table.addResource(
-      test::parseNameOrDie("android:string/one"),
-      ConfigDescription::defaultConfig(), "no-sdcard",
-      test::ValueBuilder<Id>().setSource(Source("no-sdcard.xml")).build(),
-      context->getDiagnostics()));
+  ASSERT_TRUE(table.AddResource(
+      test::ParseNameOrDie("android:string/one"),
+      ConfigDescription::DefaultConfig(), "",
+      test::ValueBuilder<Id>().SetSource(Source("default.xml")).Build(),
+      context->GetDiagnostics()));
+  ASSERT_TRUE(table.AddResource(
+      test::ParseNameOrDie("android:string/one"),
+      ConfigDescription::DefaultConfig(), "tablet",
+      test::ValueBuilder<Id>().SetSource(Source("tablet.xml")).Build(),
+      context->GetDiagnostics()));
+  ASSERT_TRUE(table.AddResource(
+      test::ParseNameOrDie("android:string/one"),
+      ConfigDescription::DefaultConfig(), "no-sdcard",
+      test::ValueBuilder<Id>().SetSource(Source("no-sdcard.xml")).Build(),
+      context->GetDiagnostics()));
 
   ProductFilter filter({"tablet", "no-sdcard"});
-  ASSERT_FALSE(filter.consume(context.get(), &table));
+  ASSERT_FALSE(filter.Consume(context.get(), &table));
 }
 
 TEST(ProductFilterTest, FailOnMultipleDefaults) {
-  std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
+  std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
 
   ResourceTable table;
-  ASSERT_TRUE(table.addResource(
-      test::parseNameOrDie("android:string/one"),
-      ConfigDescription::defaultConfig(), "",
-      test::ValueBuilder<Id>().setSource(Source(".xml")).build(),
-      context->getDiagnostics()));
-  ASSERT_TRUE(table.addResource(
-      test::parseNameOrDie("android:string/one"),
-      ConfigDescription::defaultConfig(), "default",
-      test::ValueBuilder<Id>().setSource(Source("default.xml")).build(),
-      context->getDiagnostics()));
+  ASSERT_TRUE(table.AddResource(
+      test::ParseNameOrDie("android:string/one"),
+      ConfigDescription::DefaultConfig(), "",
+      test::ValueBuilder<Id>().SetSource(Source(".xml")).Build(),
+      context->GetDiagnostics()));
+  ASSERT_TRUE(table.AddResource(
+      test::ParseNameOrDie("android:string/one"),
+      ConfigDescription::DefaultConfig(), "default",
+      test::ValueBuilder<Id>().SetSource(Source("default.xml")).Build(),
+      context->GetDiagnostics()));
 
   ProductFilter filter({});
-  ASSERT_FALSE(filter.consume(context.get(), &table));
+  ASSERT_FALSE(filter.Consume(context.get(), &table));
 }
 
 }  // namespace aapt
diff --git a/tools/aapt2/link/ReferenceLinker.cpp b/tools/aapt2/link/ReferenceLinker.cpp
index 7fe09565816a1..be787b2727ad0 100644
--- a/tools/aapt2/link/ReferenceLinker.cpp
+++ b/tools/aapt2/link/ReferenceLinker.cpp
@@ -14,7 +14,11 @@
  * limitations under the License.
  */
 
-#include "ReferenceLinker.h"
+#include "link/ReferenceLinker.h"
+
+#include "android-base/logging.h"
+#include "androidfw/ResourceTypes.h"
+
 #include "Diagnostics.h"
 #include "ResourceTable.h"
 #include "ResourceUtils.h"
@@ -26,9 +30,6 @@
 #include "util/Util.h"
 #include "xml/XmlUtil.h"
 
-#include <androidfw/ResourceTypes.h>
-#include <cassert>
-
 namespace aapt {
 
 namespace {
@@ -46,21 +47,21 @@ namespace {
  */
 class ReferenceLinkerVisitor : public ValueVisitor {
  public:
-  using ValueVisitor::visit;
+  using ValueVisitor::Visit;
 
   ReferenceLinkerVisitor(IAaptContext* context, SymbolTable* symbols,
-                         StringPool* stringPool, xml::IPackageDeclStack* decl,
-                         CallSite* callSite)
-      : mContext(context),
-        mSymbols(symbols),
-        mPackageDecls(decl),
-        mStringPool(stringPool),
-        mCallSite(callSite) {}
+                         StringPool* string_pool, xml::IPackageDeclStack* decl,
+                         CallSite* callsite)
+      : context_(context),
+        symbols_(symbols),
+        package_decls_(decl),
+        string_pool_(string_pool),
+        callsite_(callsite) {}
 
-  void visit(Reference* ref) override {
-    if (!ReferenceLinker::linkReference(ref, mContext, mSymbols, mPackageDecls,
-                                        mCallSite)) {
-      mError = true;
+  void Visit(Reference* ref) override {
+    if (!ReferenceLinker::LinkReference(ref, context_, symbols_, package_decls_,
+                                        callsite_)) {
+      error_ = true;
     }
   }
 
@@ -72,13 +73,13 @@ class ReferenceLinkerVisitor : public ValueVisitor {
    * lookup the attributes to find out which types are allowed for the
    * attributes' values.
    */
-  void visit(Style* style) override {
+  void Visit(Style* style) override {
     if (style->parent) {
-      visit(&style->parent.value());
+      Visit(&style->parent.value());
     }
 
     for (Style::Entry& entry : style->entries) {
-      std::string errStr;
+      std::string err_str;
 
       // Transform the attribute reference so that it is using the fully
       // qualified package
@@ -86,17 +87,17 @@ class ReferenceLinkerVisitor : public ValueVisitor {
       // resources if
       // there was a '*' in the reference or if the package came from the
       // private namespace.
-      Reference transformedReference = entry.key;
-      transformReferenceFromNamespace(mPackageDecls,
-                                      mContext->getCompilationPackage(),
-                                      &transformedReference);
+      Reference transformed_reference = entry.key;
+      TransformReferenceFromNamespace(package_decls_,
+                                      context_->GetCompilationPackage(),
+                                      &transformed_reference);
 
       // Find the attribute in the symbol table and check if it is visible from
       // this callsite.
       const SymbolTable::Symbol* symbol =
-          ReferenceLinker::resolveAttributeCheckVisibility(
-              transformedReference, mContext->getNameMangler(), mSymbols,
-              mCallSite, &errStr);
+          ReferenceLinker::ResolveAttributeCheckVisibility(
+              transformed_reference, context_->GetNameMangler(), symbols_,
+              callsite_, &err_str);
       if (symbol) {
         // Assign our style key the correct ID.
         // The ID may not exist.
@@ -104,11 +105,11 @@ class ReferenceLinkerVisitor : public ValueVisitor {
 
         // Try to convert the value to a more specific, typed value based on the
         // attribute it is set to.
-        entry.value = parseValueWithAttribute(std::move(entry.value),
+        entry.value = ParseValueWithAttribute(std::move(entry.value),
                                               symbol->attribute.get());
 
         // Link/resolve the final value (mostly if it's a reference).
-        entry.value->accept(this);
+        entry.value->Accept(this);
 
         // Now verify that the type of this item is compatible with the
         // attribute it
@@ -116,39 +117,34 @@ class ReferenceLinkerVisitor : public ValueVisitor {
         // check is
         // fast and we avoid creating a DiagMessage when the match is
         // successful.
-        if (!symbol->attribute->matches(entry.value.get(), nullptr)) {
+        if (!symbol->attribute->Matches(entry.value.get(), nullptr)) {
           // The actual type of this item is incompatible with the attribute.
-          DiagMessage msg(entry.key.getSource());
+          DiagMessage msg(entry.key.GetSource());
 
           // Call the matches method again, this time with a DiagMessage so we
           // fill
           // in the actual error message.
-          symbol->attribute->matches(entry.value.get(), &msg);
-          mContext->getDiagnostics()->error(msg);
-          mError = true;
+          symbol->attribute->Matches(entry.value.get(), &msg);
+          context_->GetDiagnostics()->Error(msg);
+          error_ = true;
         }
 
       } else {
-        DiagMessage msg(entry.key.getSource());
+        DiagMessage msg(entry.key.GetSource());
         msg << "style attribute '";
-        ReferenceLinker::writeResourceName(&msg, entry.key,
-                                           transformedReference);
-        msg << "' " << errStr;
-        mContext->getDiagnostics()->error(msg);
-        mError = true;
+        ReferenceLinker::WriteResourceName(&msg, entry.key,
+                                           transformed_reference);
+        msg << "' " << err_str;
+        context_->GetDiagnostics()->Error(msg);
+        error_ = true;
       }
     }
   }
 
-  bool hasError() { return mError; }
+  bool HasError() { return error_; }
 
  private:
-  IAaptContext* mContext;
-  SymbolTable* mSymbols;
-  xml::IPackageDeclStack* mPackageDecls;
-  StringPool* mStringPool;
-  CallSite* mCallSite;
-  bool mError = false;
+  DISALLOW_COPY_AND_ASSIGN(ReferenceLinkerVisitor);
 
   /**
    * Transform a RawString value into a more specific, appropriate value, based
@@ -156,20 +152,20 @@ class ReferenceLinkerVisitor : public ValueVisitor {
    * Attribute. If a non RawString value is passed in, this is an identity
    * transform.
    */
-  std::unique_ptr<Item> parseValueWithAttribute(std::unique_ptr<Item> value,
+  std::unique_ptr<Item> ParseValueWithAttribute(std::unique_ptr<Item> value,
                                                 const Attribute* attr) {
-    if (RawString* rawString = valueCast<RawString>(value.get())) {
+    if (RawString* raw_string = ValueCast<RawString>(value.get())) {
       std::unique_ptr<Item> transformed =
-          ResourceUtils::tryParseItemForAttribute(*rawString->value, attr);
+          ResourceUtils::TryParseItemForAttribute(*raw_string->value, attr);
 
       // If we could not parse as any specific type, try a basic STRING.
       if (!transformed &&
-          (attr->typeMask & android::ResTable_map::TYPE_STRING)) {
-        util::StringBuilder stringBuilder;
-        stringBuilder.append(*rawString->value);
-        if (stringBuilder) {
+          (attr->type_mask & android::ResTable_map::TYPE_STRING)) {
+        util::StringBuilder string_builder;
+        string_builder.Append(*raw_string->value);
+        if (string_builder) {
           transformed = util::make_unique<String>(
-              mStringPool->makeRef(stringBuilder.str()));
+              string_pool_->MakeRef(string_builder.ToString()));
         }
       }
 
@@ -179,6 +175,31 @@ class ReferenceLinkerVisitor : public ValueVisitor {
     };
     return value;
   }
+
+  IAaptContext* context_;
+  SymbolTable* symbols_;
+  xml::IPackageDeclStack* package_decls_;
+  StringPool* string_pool_;
+  CallSite* callsite_;
+  bool error_ = false;
+};
+
+class EmptyDeclStack : public xml::IPackageDeclStack {
+ public:
+  EmptyDeclStack() = default;
+
+  Maybe<xml::ExtractedPackage> TransformPackageAlias(
+      const StringPiece& alias,
+      const StringPiece& local_package) const override {
+    if (alias.empty()) {
+      return xml::ExtractedPackage{local_package.ToString(),
+                                   true /* private */};
+    }
+    return {};
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(EmptyDeclStack);
 };
 
 }  // namespace
@@ -188,14 +209,14 @@ class ReferenceLinkerVisitor : public ValueVisitor {
  * requesting private access
  * or if the callsite comes from the same package.
  */
-bool ReferenceLinker::isSymbolVisible(const SymbolTable::Symbol& symbol,
+bool ReferenceLinker::IsSymbolVisible(const SymbolTable::Symbol& symbol,
                                       const Reference& ref,
-                                      const CallSite& callSite) {
-  if (!symbol.isPublic && !ref.privateReference) {
+                                      const CallSite& callsite) {
+  if (!symbol.is_public && !ref.private_reference) {
     if (ref.name) {
-      return callSite.resource.package == ref.name.value().package;
+      return callsite.resource.package == ref.name.value().package;
     } else if (ref.id && symbol.id) {
-      return ref.id.value().packageId() == symbol.id.value().packageId();
+      return ref.id.value().package_id() == symbol.id.value().package_id();
     } else {
       return false;
     }
@@ -203,160 +224,144 @@ bool ReferenceLinker::isSymbolVisible(const SymbolTable::Symbol& symbol,
   return true;
 }
 
-const SymbolTable::Symbol* ReferenceLinker::resolveSymbol(
+const SymbolTable::Symbol* ReferenceLinker::ResolveSymbol(
     const Reference& reference, NameMangler* mangler, SymbolTable* symbols) {
   if (reference.name) {
-    Maybe<ResourceName> mangled = mangler->mangleName(reference.name.value());
-    return symbols->findByName(mangled ? mangled.value()
+    Maybe<ResourceName> mangled = mangler->MangleName(reference.name.value());
+    return symbols->FindByName(mangled ? mangled.value()
                                        : reference.name.value());
   } else if (reference.id) {
-    return symbols->findById(reference.id.value());
+    return symbols->FindById(reference.id.value());
   } else {
     return nullptr;
   }
 }
 
-const SymbolTable::Symbol* ReferenceLinker::resolveSymbolCheckVisibility(
-    const Reference& reference, NameMangler* nameMangler, SymbolTable* symbols,
-    CallSite* callSite, std::string* outError) {
+const SymbolTable::Symbol* ReferenceLinker::ResolveSymbolCheckVisibility(
+    const Reference& reference, NameMangler* name_mangler, SymbolTable* symbols,
+    CallSite* callsite, std::string* out_error) {
   const SymbolTable::Symbol* symbol =
-      resolveSymbol(reference, nameMangler, symbols);
+      ResolveSymbol(reference, name_mangler, symbols);
   if (!symbol) {
-    if (outError) *outError = "not found";
+    if (out_error) *out_error = "not found";
     return nullptr;
   }
 
-  if (!isSymbolVisible(*symbol, reference, *callSite)) {
-    if (outError) *outError = "is private";
+  if (!IsSymbolVisible(*symbol, reference, *callsite)) {
+    if (out_error) *out_error = "is private";
     return nullptr;
   }
   return symbol;
 }
 
-const SymbolTable::Symbol* ReferenceLinker::resolveAttributeCheckVisibility(
-    const Reference& reference, NameMangler* nameMangler, SymbolTable* symbols,
-    CallSite* callSite, std::string* outError) {
-  const SymbolTable::Symbol* symbol = resolveSymbolCheckVisibility(
-      reference, nameMangler, symbols, callSite, outError);
+const SymbolTable::Symbol* ReferenceLinker::ResolveAttributeCheckVisibility(
+    const Reference& reference, NameMangler* name_mangler, SymbolTable* symbols,
+    CallSite* callsite, std::string* out_error) {
+  const SymbolTable::Symbol* symbol = ResolveSymbolCheckVisibility(
+      reference, name_mangler, symbols, callsite, out_error);
   if (!symbol) {
     return nullptr;
   }
 
   if (!symbol->attribute) {
-    if (outError) *outError = "is not an attribute";
+    if (out_error) *out_error = "is not an attribute";
     return nullptr;
   }
   return symbol;
 }
 
-Maybe<xml::AaptAttribute> ReferenceLinker::compileXmlAttribute(
-    const Reference& reference, NameMangler* nameMangler, SymbolTable* symbols,
-    CallSite* callSite, std::string* outError) {
+Maybe<xml::AaptAttribute> ReferenceLinker::CompileXmlAttribute(
+    const Reference& reference, NameMangler* name_mangler, SymbolTable* symbols,
+    CallSite* callsite, std::string* out_error) {
   const SymbolTable::Symbol* symbol =
-      resolveSymbol(reference, nameMangler, symbols);
+      ResolveSymbol(reference, name_mangler, symbols);
   if (!symbol) {
-    if (outError) *outError = "not found";
+    if (out_error) *out_error = "not found";
     return {};
   }
 
   if (!symbol->attribute) {
-    if (outError) *outError = "is not an attribute";
+    if (out_error) *out_error = "is not an attribute";
     return {};
   }
   return xml::AaptAttribute{symbol->id, *symbol->attribute};
 }
 
-void ReferenceLinker::writeResourceName(DiagMessage* outMsg,
+void ReferenceLinker::WriteResourceName(DiagMessage* out_msg,
                                         const Reference& orig,
                                         const Reference& transformed) {
-  assert(outMsg);
+  CHECK(out_msg != nullptr);
 
   if (orig.name) {
-    *outMsg << orig.name.value();
+    *out_msg << orig.name.value();
     if (transformed.name.value() != orig.name.value()) {
-      *outMsg << " (aka " << transformed.name.value() << ")";
+      *out_msg << " (aka " << transformed.name.value() << ")";
     }
   } else {
-    *outMsg << orig.id.value();
+    *out_msg << orig.id.value();
   }
 }
 
-bool ReferenceLinker::linkReference(Reference* reference, IAaptContext* context,
+bool ReferenceLinker::LinkReference(Reference* reference, IAaptContext* context,
                                     SymbolTable* symbols,
                                     xml::IPackageDeclStack* decls,
-                                    CallSite* callSite) {
-  assert(reference);
-  assert(reference->name || reference->id);
+                                    CallSite* callsite) {
+  CHECK(reference != nullptr);
+  CHECK(reference->name || reference->id);
 
-  Reference transformedReference = *reference;
-  transformReferenceFromNamespace(decls, context->getCompilationPackage(),
-                                  &transformedReference);
+  Reference transformed_reference = *reference;
+  TransformReferenceFromNamespace(decls, context->GetCompilationPackage(),
+                                  &transformed_reference);
 
-  std::string errStr;
-  const SymbolTable::Symbol* s = resolveSymbolCheckVisibility(
-      transformedReference, context->getNameMangler(), symbols, callSite,
-      &errStr);
+  std::string err_str;
+  const SymbolTable::Symbol* s = ResolveSymbolCheckVisibility(
+      transformed_reference, context->GetNameMangler(), symbols, callsite,
+      &err_str);
   if (s) {
     // The ID may not exist. This is fine because of the possibility of building
-    // against
-    // libraries without assigned IDs.
+    // against libraries without assigned IDs.
     // Ex: Linking against own resources when building a static library.
     reference->id = s->id;
     return true;
   }
 
-  DiagMessage errorMsg(reference->getSource());
-  errorMsg << "resource ";
-  writeResourceName(&errorMsg, *reference, transformedReference);
-  errorMsg << " " << errStr;
-  context->getDiagnostics()->error(errorMsg);
+  DiagMessage error_msg(reference->GetSource());
+  error_msg << "resource ";
+  WriteResourceName(&error_msg, *reference, transformed_reference);
+  error_msg << " " << err_str;
+  context->GetDiagnostics()->Error(error_msg);
   return false;
 }
 
-namespace {
-
-struct EmptyDeclStack : public xml::IPackageDeclStack {
-  Maybe<xml::ExtractedPackage> transformPackageAlias(
-      const StringPiece& alias,
-      const StringPiece& localPackage) const override {
-    if (alias.empty()) {
-      return xml::ExtractedPackage{localPackage.toString(), true /* private */};
-    }
-    return {};
-  }
-};
-
-}  // namespace
-
-bool ReferenceLinker::consume(IAaptContext* context, ResourceTable* table) {
-  EmptyDeclStack declStack;
+bool ReferenceLinker::Consume(IAaptContext* context, ResourceTable* table) {
+  EmptyDeclStack decl_stack;
   bool error = false;
   for (auto& package : table->packages) {
     for (auto& type : package->types) {
       for (auto& entry : type->entries) {
         // Symbol state information may be lost if there is no value for the
         // resource.
-        if (entry->symbolStatus.state != SymbolState::kUndefined &&
+        if (entry->symbol_status.state != SymbolState::kUndefined &&
             entry->values.empty()) {
-          context->getDiagnostics()->error(
-              DiagMessage(entry->symbolStatus.source)
+          context->GetDiagnostics()->Error(
+              DiagMessage(entry->symbol_status.source)
               << "no definition for declared symbol '"
               << ResourceNameRef(package->name, type->type, entry->name)
               << "'");
           error = true;
         }
 
-        CallSite callSite = {
+        CallSite callsite = {
             ResourceNameRef(package->name, type->type, entry->name)};
-        ReferenceLinkerVisitor visitor(context, context->getExternalSymbols(),
-                                       &table->stringPool, &declStack,
-                                       &callSite);
+        ReferenceLinkerVisitor visitor(context, context->GetExternalSymbols(),
+                                       &table->string_pool, &decl_stack,
+                                       &callsite);
 
-        for (auto& configValue : entry->values) {
-          configValue->value->accept(&visitor);
+        for (auto& config_value : entry->values) {
+          config_value->value->Accept(&visitor);
         }
 
-        if (visitor.hasError()) {
+        if (visitor.HasError()) {
           error = true;
         }
       }
diff --git a/tools/aapt2/link/ReferenceLinker.h b/tools/aapt2/link/ReferenceLinker.h
index 8f6604f8d9d6b..bdabf249709d1 100644
--- a/tools/aapt2/link/ReferenceLinker.h
+++ b/tools/aapt2/link/ReferenceLinker.h
@@ -17,6 +17,8 @@
 #ifndef AAPT_LINKER_REFERENCELINKER_H
 #define AAPT_LINKER_REFERENCELINKER_H
 
+#include "android-base/macros.h"
+
 #include "Resource.h"
 #include "ResourceValues.h"
 #include "ValueVisitor.h"
@@ -25,8 +27,6 @@
 #include "process/SymbolTable.h"
 #include "xml/XmlDom.h"
 
-#include <cassert>
-
 namespace aapt {
 
 /**
@@ -36,33 +36,33 @@ namespace aapt {
  * Once the ResourceTable is processed by this linker, it is ready to be
  * flattened.
  */
-struct ReferenceLinker : public IResourceTableConsumer {
+class ReferenceLinker : public IResourceTableConsumer {
+ public:
+  ReferenceLinker() = default;
+
   /**
    * Returns true if the symbol is visible by the reference and from the
    * callsite.
    */
-  static bool isSymbolVisible(const SymbolTable::Symbol& symbol,
-                              const Reference& ref, const CallSite& callSite);
+  static bool IsSymbolVisible(const SymbolTable::Symbol& symbol,
+                              const Reference& ref, const CallSite& callsite);
 
   /**
    * Performs name mangling and looks up the resource in the symbol table.
-   * Returns nullptr
-   * if the symbol was not found.
+   * Returns nullptr if the symbol was not found.
    */
-  static const SymbolTable::Symbol* resolveSymbol(const Reference& reference,
+  static const SymbolTable::Symbol* ResolveSymbol(const Reference& reference,
                                                   NameMangler* mangler,
                                                   SymbolTable* symbols);
 
   /**
    * Performs name mangling and looks up the resource in the symbol table. If
-   * the symbol is
-   * not visible by the reference at the callsite, nullptr is returned. outError
-   * holds
-   * the error message.
+   * the symbol is not visible by the reference at the callsite, nullptr is
+   * returned. out_error holds the error message.
    */
-  static const SymbolTable::Symbol* resolveSymbolCheckVisibility(
-      const Reference& reference, NameMangler* nameMangler,
-      SymbolTable* symbols, CallSite* callSite, std::string* outError);
+  static const SymbolTable::Symbol* ResolveSymbolCheckVisibility(
+      const Reference& reference, NameMangler* name_mangler,
+      SymbolTable* symbols, CallSite* callsite, std::string* out_error);
 
   /**
    * Same as resolveSymbolCheckVisibility(), but also makes sure the symbol is
@@ -70,25 +70,24 @@ struct ReferenceLinker : public IResourceTableConsumer {
    * That is, the return value will have a non-null value for
    * ISymbolTable::Symbol::attribute.
    */
-  static const SymbolTable::Symbol* resolveAttributeCheckVisibility(
-      const Reference& reference, NameMangler* nameMangler,
-      SymbolTable* symbols, CallSite* callSite, std::string* outError);
+  static const SymbolTable::Symbol* ResolveAttributeCheckVisibility(
+      const Reference& reference, NameMangler* name_mangler,
+      SymbolTable* symbols, CallSite* callsite, std::string* out_error);
 
   /**
    * Resolves the attribute reference and returns an xml::AaptAttribute if
    * successful.
    * If resolution fails, outError holds the error message.
    */
-  static Maybe<xml::AaptAttribute> compileXmlAttribute(
-      const Reference& reference, NameMangler* nameMangler,
-      SymbolTable* symbols, CallSite* callSite, std::string* outError);
+  static Maybe<xml::AaptAttribute> CompileXmlAttribute(
+      const Reference& reference, NameMangler* name_mangler,
+      SymbolTable* symbols, CallSite* callsite, std::string* out_error);
 
   /**
-   * Writes the resource name to the DiagMessage, using the "orig_name (aka
-   * <transformed_name>)"
-   * syntax.
+   * Writes the resource name to the DiagMessage, using the
+   * "orig_name (aka <transformed_name>)" syntax.
    */
-  static void writeResourceName(DiagMessage* outMsg, const Reference& orig,
+  static void WriteResourceName(DiagMessage* out_msg, const Reference& orig,
                                 const Reference& transformed);
 
   /**
@@ -100,14 +99,17 @@ struct ReferenceLinker : public IResourceTableConsumer {
    * Returns false on failure, and an error message is logged to the
    * IDiagnostics in the context.
    */
-  static bool linkReference(Reference* reference, IAaptContext* context,
+  static bool LinkReference(Reference* reference, IAaptContext* context,
                             SymbolTable* symbols, xml::IPackageDeclStack* decls,
-                            CallSite* callSite);
+                            CallSite* callsite);
 
   /**
    * Links all references in the ResourceTable.
    */
-  bool consume(IAaptContext* context, ResourceTable* table) override;
+  bool Consume(IAaptContext* context, ResourceTable* table) override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ReferenceLinker);
 };
 
 }  // namespace aapt
diff --git a/tools/aapt2/link/ReferenceLinker_test.cpp b/tools/aapt2/link/ReferenceLinker_test.cpp
index 8aa3616053842..4ca36a9e2b22e 100644
--- a/tools/aapt2/link/ReferenceLinker_test.cpp
+++ b/tools/aapt2/link/ReferenceLinker_test.cpp
@@ -15,6 +15,7 @@
  */
 
 #include "link/ReferenceLinker.h"
+
 #include "test/Test.h"
 
 using android::ResTable_map;
@@ -24,46 +25,46 @@ namespace aapt {
 TEST(ReferenceLinkerTest, LinkSimpleReferences) {
   std::unique_ptr<ResourceTable> table =
       test::ResourceTableBuilder()
-          .setPackageId("com.app.test", 0x7f)
-          .addReference("com.app.test:string/foo", ResourceId(0x7f020000),
+          .SetPackageId("com.app.test", 0x7f)
+          .AddReference("com.app.test:string/foo", ResourceId(0x7f020000),
                         "com.app.test:string/bar")
 
           // Test use of local reference (w/o package name).
-          .addReference("com.app.test:string/bar", ResourceId(0x7f020001),
+          .AddReference("com.app.test:string/bar", ResourceId(0x7f020001),
                         "string/baz")
 
-          .addReference("com.app.test:string/baz", ResourceId(0x7f020002),
+          .AddReference("com.app.test:string/baz", ResourceId(0x7f020002),
                         "android:string/ok")
-          .build();
+          .Build();
 
   std::unique_ptr<IAaptContext> context =
       test::ContextBuilder()
-          .setCompilationPackage("com.app.test")
-          .setPackageId(0x7f)
-          .setNameManglerPolicy(NameManglerPolicy{"com.app.test"})
-          .addSymbolSource(
+          .SetCompilationPackage("com.app.test")
+          .SetPackageId(0x7f)
+          .SetNameManglerPolicy(NameManglerPolicy{"com.app.test"})
+          .AddSymbolSource(
               util::make_unique<ResourceTableSymbolSource>(table.get()))
-          .addSymbolSource(
+          .AddSymbolSource(
               test::StaticSymbolSourceBuilder()
-                  .addPublicSymbol("android:string/ok", ResourceId(0x01040034))
-                  .build())
-          .build();
+                  .AddPublicSymbol("android:string/ok", ResourceId(0x01040034))
+                  .Build())
+          .Build();
 
   ReferenceLinker linker;
-  ASSERT_TRUE(linker.consume(context.get(), table.get()));
+  ASSERT_TRUE(linker.Consume(context.get(), table.get()));
 
   Reference* ref =
-      test::getValue<Reference>(table.get(), "com.app.test:string/foo");
+      test::GetValue<Reference>(table.get(), "com.app.test:string/foo");
   ASSERT_NE(ref, nullptr);
   AAPT_ASSERT_TRUE(ref->id);
   EXPECT_EQ(ref->id.value(), ResourceId(0x7f020001));
 
-  ref = test::getValue<Reference>(table.get(), "com.app.test:string/bar");
+  ref = test::GetValue<Reference>(table.get(), "com.app.test:string/bar");
   ASSERT_NE(ref, nullptr);
   AAPT_ASSERT_TRUE(ref->id);
   EXPECT_EQ(ref->id.value(), ResourceId(0x7f020002));
 
-  ref = test::getValue<Reference>(table.get(), "com.app.test:string/baz");
+  ref = test::GetValue<Reference>(table.get(), "com.app.test:string/baz");
   ASSERT_NE(ref, nullptr);
   AAPT_ASSERT_TRUE(ref->id);
   EXPECT_EQ(ref->id.value(), ResourceId(0x01040034));
@@ -72,53 +73,53 @@ TEST(ReferenceLinkerTest, LinkSimpleReferences) {
 TEST(ReferenceLinkerTest, LinkStyleAttributes) {
   std::unique_ptr<ResourceTable> table =
       test::ResourceTableBuilder()
-          .setPackageId("com.app.test", 0x7f)
-          .addValue("com.app.test:style/Theme",
+          .SetPackageId("com.app.test", 0x7f)
+          .AddValue("com.app.test:style/Theme",
                     test::StyleBuilder()
-                        .setParent("android:style/Theme.Material")
-                        .addItem("android:attr/foo",
-                                 ResourceUtils::tryParseColor("#ff00ff"))
-                        .addItem("android:attr/bar", {} /* placeholder */)
-                        .build())
-          .build();
+                        .SetParent("android:style/Theme.Material")
+                        .AddItem("android:attr/foo",
+                                 ResourceUtils::TryParseColor("#ff00ff"))
+                        .AddItem("android:attr/bar", {} /* placeholder */)
+                        .Build())
+          .Build();
 
   {
     // We need to fill in the value for the attribute android:attr/bar after we
     // build the
     // table, because we need access to the string pool.
     Style* style =
-        test::getValue<Style>(table.get(), "com.app.test:style/Theme");
+        test::GetValue<Style>(table.get(), "com.app.test:style/Theme");
     ASSERT_NE(style, nullptr);
     style->entries.back().value =
-        util::make_unique<RawString>(table->stringPool.makeRef("one|two"));
+        util::make_unique<RawString>(table->string_pool.MakeRef("one|two"));
   }
 
   std::unique_ptr<IAaptContext> context =
       test::ContextBuilder()
-          .setCompilationPackage("com.app.test")
-          .setPackageId(0x7f)
-          .setNameManglerPolicy(NameManglerPolicy{"com.app.test"})
-          .addSymbolSource(
+          .SetCompilationPackage("com.app.test")
+          .SetPackageId(0x7f)
+          .SetNameManglerPolicy(NameManglerPolicy{"com.app.test"})
+          .AddSymbolSource(
               test::StaticSymbolSourceBuilder()
-                  .addPublicSymbol("android:style/Theme.Material",
+                  .AddPublicSymbol("android:style/Theme.Material",
                                    ResourceId(0x01060000))
-                  .addPublicSymbol("android:attr/foo", ResourceId(0x01010001),
+                  .AddPublicSymbol("android:attr/foo", ResourceId(0x01010001),
                                    test::AttributeBuilder()
-                                       .setTypeMask(ResTable_map::TYPE_COLOR)
-                                       .build())
-                  .addPublicSymbol("android:attr/bar", ResourceId(0x01010002),
+                                       .SetTypeMask(ResTable_map::TYPE_COLOR)
+                                       .Build())
+                  .AddPublicSymbol("android:attr/bar", ResourceId(0x01010002),
                                    test::AttributeBuilder()
-                                       .setTypeMask(ResTable_map::TYPE_FLAGS)
-                                       .addItem("one", 0x01)
-                                       .addItem("two", 0x02)
-                                       .build())
-                  .build())
-          .build();
+                                       .SetTypeMask(ResTable_map::TYPE_FLAGS)
+                                       .AddItem("one", 0x01)
+                                       .AddItem("two", 0x02)
+                                       .Build())
+                  .Build())
+          .Build();
 
   ReferenceLinker linker;
-  ASSERT_TRUE(linker.consume(context.get(), table.get()));
+  ASSERT_TRUE(linker.Consume(context.get(), table.get()));
 
-  Style* style = test::getValue<Style>(table.get(), "com.app.test:style/Theme");
+  Style* style = test::GetValue<Style>(table.get(), "com.app.test:style/Theme");
   ASSERT_NE(style, nullptr);
   AAPT_ASSERT_TRUE(style->parent);
   AAPT_ASSERT_TRUE(style->parent.value().id);
@@ -128,44 +129,44 @@ TEST(ReferenceLinkerTest, LinkStyleAttributes) {
 
   AAPT_ASSERT_TRUE(style->entries[0].key.id);
   EXPECT_EQ(style->entries[0].key.id.value(), ResourceId(0x01010001));
-  ASSERT_NE(valueCast<BinaryPrimitive>(style->entries[0].value.get()), nullptr);
+  ASSERT_NE(ValueCast<BinaryPrimitive>(style->entries[0].value.get()), nullptr);
 
   AAPT_ASSERT_TRUE(style->entries[1].key.id);
   EXPECT_EQ(style->entries[1].key.id.value(), ResourceId(0x01010002));
-  ASSERT_NE(valueCast<BinaryPrimitive>(style->entries[1].value.get()), nullptr);
+  ASSERT_NE(ValueCast<BinaryPrimitive>(style->entries[1].value.get()), nullptr);
 }
 
 TEST(ReferenceLinkerTest, LinkMangledReferencesAndAttributes) {
   std::unique_ptr<IAaptContext> context =
       test::ContextBuilder()
-          .setCompilationPackage("com.app.test")
-          .setPackageId(0x7f)
-          .setNameManglerPolicy(
+          .SetCompilationPackage("com.app.test")
+          .SetPackageId(0x7f)
+          .SetNameManglerPolicy(
               NameManglerPolicy{"com.app.test", {"com.android.support"}})
-          .addSymbolSource(
+          .AddSymbolSource(
               test::StaticSymbolSourceBuilder()
-                  .addPublicSymbol("com.app.test:attr/com.android.support$foo",
+                  .AddPublicSymbol("com.app.test:attr/com.android.support$foo",
                                    ResourceId(0x7f010000),
                                    test::AttributeBuilder()
-                                       .setTypeMask(ResTable_map::TYPE_COLOR)
-                                       .build())
-                  .build())
-          .build();
+                                       .SetTypeMask(ResTable_map::TYPE_COLOR)
+                                       .Build())
+                  .Build())
+          .Build();
 
   std::unique_ptr<ResourceTable> table =
       test::ResourceTableBuilder()
-          .setPackageId("com.app.test", 0x7f)
-          .addValue("com.app.test:style/Theme", ResourceId(0x7f020000),
+          .SetPackageId("com.app.test", 0x7f)
+          .AddValue("com.app.test:style/Theme", ResourceId(0x7f020000),
                     test::StyleBuilder()
-                        .addItem("com.android.support:attr/foo",
-                                 ResourceUtils::tryParseColor("#ff0000"))
-                        .build())
-          .build();
+                        .AddItem("com.android.support:attr/foo",
+                                 ResourceUtils::TryParseColor("#ff0000"))
+                        .Build())
+          .Build();
 
   ReferenceLinker linker;
-  ASSERT_TRUE(linker.consume(context.get(), table.get()));
+  ASSERT_TRUE(linker.Consume(context.get(), table.get()));
 
-  Style* style = test::getValue<Style>(table.get(), "com.app.test:style/Theme");
+  Style* style = test::GetValue<Style>(table.get(), "com.app.test:style/Theme");
   ASSERT_NE(style, nullptr);
   ASSERT_EQ(1u, style->entries.size());
   AAPT_ASSERT_TRUE(style->entries.front().key.id);
@@ -175,85 +176,85 @@ TEST(ReferenceLinkerTest, LinkMangledReferencesAndAttributes) {
 TEST(ReferenceLinkerTest, FailToLinkPrivateSymbols) {
   std::unique_ptr<ResourceTable> table =
       test::ResourceTableBuilder()
-          .setPackageId("com.app.test", 0x7f)
-          .addReference("com.app.test:string/foo", ResourceId(0x7f020000),
+          .SetPackageId("com.app.test", 0x7f)
+          .AddReference("com.app.test:string/foo", ResourceId(0x7f020000),
                         "android:string/hidden")
-          .build();
+          .Build();
 
   std::unique_ptr<IAaptContext> context =
       test::ContextBuilder()
-          .setCompilationPackage("com.app.test")
-          .setPackageId(0x7f)
-          .setNameManglerPolicy(NameManglerPolicy{"com.app.test"})
-          .addSymbolSource(
+          .SetCompilationPackage("com.app.test")
+          .SetPackageId(0x7f)
+          .SetNameManglerPolicy(NameManglerPolicy{"com.app.test"})
+          .AddSymbolSource(
               util::make_unique<ResourceTableSymbolSource>(table.get()))
-          .addSymbolSource(
+          .AddSymbolSource(
               test::StaticSymbolSourceBuilder()
-                  .addSymbol("android:string/hidden", ResourceId(0x01040034))
-                  .build())
-          .build();
+                  .AddSymbol("android:string/hidden", ResourceId(0x01040034))
+                  .Build())
+          .Build();
 
   ReferenceLinker linker;
-  ASSERT_FALSE(linker.consume(context.get(), table.get()));
+  ASSERT_FALSE(linker.Consume(context.get(), table.get()));
 }
 
 TEST(ReferenceLinkerTest, FailToLinkPrivateMangledSymbols) {
   std::unique_ptr<ResourceTable> table =
       test::ResourceTableBuilder()
-          .setPackageId("com.app.test", 0x7f)
-          .addReference("com.app.test:string/foo", ResourceId(0x7f020000),
+          .SetPackageId("com.app.test", 0x7f)
+          .AddReference("com.app.test:string/foo", ResourceId(0x7f020000),
                         "com.app.lib:string/hidden")
-          .build();
+          .Build();
 
   std::unique_ptr<IAaptContext> context =
       test::ContextBuilder()
-          .setCompilationPackage("com.app.test")
-          .setPackageId(0x7f)
-          .setNameManglerPolicy(
+          .SetCompilationPackage("com.app.test")
+          .SetPackageId(0x7f)
+          .SetNameManglerPolicy(
               NameManglerPolicy{"com.app.test", {"com.app.lib"}})
-          .addSymbolSource(
+          .AddSymbolSource(
               util::make_unique<ResourceTableSymbolSource>(table.get()))
-          .addSymbolSource(
+          .AddSymbolSource(
               test::StaticSymbolSourceBuilder()
-                  .addSymbol("com.app.test:string/com.app.lib$hidden",
+                  .AddSymbol("com.app.test:string/com.app.lib$hidden",
                              ResourceId(0x7f040034))
-                  .build())
+                  .Build())
 
-          .build();
+          .Build();
 
   ReferenceLinker linker;
-  ASSERT_FALSE(linker.consume(context.get(), table.get()));
+  ASSERT_FALSE(linker.Consume(context.get(), table.get()));
 }
 
 TEST(ReferenceLinkerTest, FailToLinkPrivateStyleAttributes) {
   std::unique_ptr<ResourceTable> table =
       test::ResourceTableBuilder()
-          .setPackageId("com.app.test", 0x7f)
-          .addValue("com.app.test:style/Theme",
+          .SetPackageId("com.app.test", 0x7f)
+          .AddValue("com.app.test:style/Theme",
                     test::StyleBuilder()
-                        .addItem("android:attr/hidden",
-                                 ResourceUtils::tryParseColor("#ff00ff"))
-                        .build())
-          .build();
+                        .AddItem("android:attr/hidden",
+                                 ResourceUtils::TryParseColor("#ff00ff"))
+                        .Build())
+          .Build();
 
   std::unique_ptr<IAaptContext> context =
       test::ContextBuilder()
-          .setCompilationPackage("com.app.test")
-          .setPackageId(0x7f)
-          .setNameManglerPolicy(NameManglerPolicy{"com.app.test"})
-          .addSymbolSource(
+          .SetCompilationPackage("com.app.test")
+          .SetPackageId(0x7f)
+          .SetNameManglerPolicy(NameManglerPolicy{"com.app.test"})
+          .AddSymbolSource(
               util::make_unique<ResourceTableSymbolSource>(table.get()))
-          .addSymbolSource(
+          .AddSymbolSource(
               test::StaticSymbolSourceBuilder()
-                  .addSymbol("android:attr/hidden", ResourceId(0x01010001),
+                  .AddSymbol("android:attr/hidden", ResourceId(0x01010001),
                              test::AttributeBuilder()
-                                 .setTypeMask(android::ResTable_map::TYPE_COLOR)
-                                 .build())
-                  .build())
-          .build();
+                                 .SetTypeMask(android::ResTable_map::TYPE_COLOR)
+                                 .Build())
+                  .Build())
+          .Build();
 
   ReferenceLinker linker;
-  ASSERT_FALSE(linker.consume(context.get(), table.get()));
+  ASSERT_FALSE(linker.Consume(context.get(), table.get()));
 }
 
 }  // namespace aapt
diff --git a/tools/aapt2/link/ResourceDeduper.cpp b/tools/aapt2/link/ResourceDeduper.cpp
index f565359daacab..9431dcee9714e 100644
--- a/tools/aapt2/link/ResourceDeduper.cpp
+++ b/tools/aapt2/link/ResourceDeduper.cpp
@@ -14,12 +14,13 @@
  * limitations under the License.
  */
 
-#include "DominatorTree.h"
-#include "ResourceTable.h"
 #include "link/Linkers.h"
 
 #include <algorithm>
 
+#include "DominatorTree.h"
+#include "ResourceTable.h"
+
 namespace aapt {
 
 namespace {
@@ -40,55 +41,57 @@ class DominatedKeyValueRemover : public DominatorTree::BottomUpVisitor {
   using Node = DominatorTree::Node;
 
   explicit DominatedKeyValueRemover(IAaptContext* context, ResourceEntry* entry)
-      : mContext(context), mEntry(entry) {}
+      : context_(context), entry_(entry) {}
 
-  void visitConfig(Node* node) {
+  void VisitConfig(Node* node) {
     Node* parent = node->parent();
     if (!parent) {
       return;
     }
-    ResourceConfigValue* nodeValue = node->value();
-    ResourceConfigValue* parentValue = parent->value();
-    if (!nodeValue || !parentValue) {
+    ResourceConfigValue* node_value = node->value();
+    ResourceConfigValue* parent_value = parent->value();
+    if (!node_value || !parent_value) {
       return;
     }
-    if (!nodeValue->value->equals(parentValue->value.get())) {
+    if (!node_value->value->Equals(parent_value->value.get())) {
       return;
     }
 
     // Compare compatible configs for this entry and ensure the values are
     // equivalent.
-    const ConfigDescription& nodeConfiguration = nodeValue->config;
-    for (const auto& sibling : mEntry->values) {
+    const ConfigDescription& node_configuration = node_value->config;
+    for (const auto& sibling : entry_->values) {
       if (!sibling->value) {
         // Sibling was already removed.
         continue;
       }
-      if (nodeConfiguration.isCompatibleWith(sibling->config) &&
-          !nodeValue->value->equals(sibling->value.get())) {
+      if (node_configuration.IsCompatibleWith(sibling->config) &&
+          !node_value->value->Equals(sibling->value.get())) {
         // The configurations are compatible, but the value is
         // different, so we can't remove this value.
         return;
       }
     }
-    if (mContext->verbose()) {
-      mContext->getDiagnostics()->note(
-          DiagMessage(nodeValue->value->getSource())
+    if (context_->IsVerbose()) {
+      context_->GetDiagnostics()->Note(
+          DiagMessage(node_value->value->GetSource())
           << "removing dominated duplicate resource with name \""
-          << mEntry->name << "\"");
+          << entry_->name << "\"");
     }
-    nodeValue->value = {};
+    node_value->value = {};
   }
 
  private:
-  IAaptContext* mContext;
-  ResourceEntry* mEntry;
+  DISALLOW_COPY_AND_ASSIGN(DominatedKeyValueRemover);
+
+  IAaptContext* context_;
+  ResourceEntry* entry_;
 };
 
-static void dedupeEntry(IAaptContext* context, ResourceEntry* entry) {
+static void DedupeEntry(IAaptContext* context, ResourceEntry* entry) {
   DominatorTree tree(entry->values);
   DominatedKeyValueRemover remover(context, entry);
-  tree.accept(&remover);
+  tree.Accept(&remover);
 
   // Erase the values that were removed.
   entry->values.erase(
@@ -102,15 +105,15 @@ static void dedupeEntry(IAaptContext* context, ResourceEntry* entry) {
 
 }  // namespace
 
-bool ResourceDeduper::consume(IAaptContext* context, ResourceTable* table) {
+bool ResourceDeduper::Consume(IAaptContext* context, ResourceTable* table) {
   for (auto& package : table->packages) {
     for (auto& type : package->types) {
       for (auto& entry : type->entries) {
-        dedupeEntry(context, entry.get());
+        DedupeEntry(context, entry.get());
       }
     }
   }
   return true;
 }
 
-}  // aapt
+}  // namespace aapt
diff --git a/tools/aapt2/link/ResourceDeduper_test.cpp b/tools/aapt2/link/ResourceDeduper_test.cpp
index 7e2d47665c85b..d38059ddd3917 100644
--- a/tools/aapt2/link/ResourceDeduper_test.cpp
+++ b/tools/aapt2/link/ResourceDeduper_test.cpp
@@ -14,70 +14,74 @@
  * limitations under the License.
  */
 
-#include "ResourceTable.h"
 #include "link/Linkers.h"
+
+#include "ResourceTable.h"
 #include "test/Test.h"
 
 namespace aapt {
 
 TEST(ResourceDeduperTest, SameValuesAreDeduped) {
-  std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
-  const ConfigDescription defaultConfig = {};
-  const ConfigDescription enConfig = test::parseConfigOrDie("en");
-  const ConfigDescription enV21Config = test::parseConfigOrDie("en-v21");
+  std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
+  const ConfigDescription default_config = {};
+  const ConfigDescription en_config = test::ParseConfigOrDie("en");
+  const ConfigDescription en_v21_config = test::ParseConfigOrDie("en-v21");
   // Chosen because this configuration is compatible with en.
-  const ConfigDescription landConfig = test::parseConfigOrDie("land");
+  const ConfigDescription land_config = test::ParseConfigOrDie("land");
 
   std::unique_ptr<ResourceTable> table =
       test::ResourceTableBuilder()
-          .addString("android:string/dedupe", ResourceId{}, defaultConfig,
+          .AddString("android:string/dedupe", ResourceId{}, default_config,
                      "dedupe")
-          .addString("android:string/dedupe", ResourceId{}, enConfig, "dedupe")
-          .addString("android:string/dedupe", ResourceId{}, landConfig,
+          .AddString("android:string/dedupe", ResourceId{}, en_config, "dedupe")
+          .AddString("android:string/dedupe", ResourceId{}, land_config,
                      "dedupe")
-          .addString("android:string/dedupe2", ResourceId{}, defaultConfig,
+          .AddString("android:string/dedupe2", ResourceId{}, default_config,
                      "dedupe")
-          .addString("android:string/dedupe2", ResourceId{}, enConfig, "dedupe")
-          .addString("android:string/dedupe2", ResourceId{}, enV21Config,
+          .AddString("android:string/dedupe2", ResourceId{}, en_config,
+                     "dedupe")
+          .AddString("android:string/dedupe2", ResourceId{}, en_v21_config,
                      "keep")
-          .addString("android:string/dedupe2", ResourceId{}, landConfig,
+          .AddString("android:string/dedupe2", ResourceId{}, land_config,
                      "dedupe")
-          .build();
+          .Build();
 
-  ASSERT_TRUE(ResourceDeduper().consume(context.get(), table.get()));
-  EXPECT_EQ(nullptr, test::getValueForConfig<String>(
-                         table.get(), "android:string/dedupe", enConfig));
-  EXPECT_EQ(nullptr, test::getValueForConfig<String>(
-                         table.get(), "android:string/dedupe", landConfig));
-  EXPECT_EQ(nullptr, test::getValueForConfig<String>(
-                         table.get(), "android:string/dedupe2", enConfig));
-  EXPECT_NE(nullptr, test::getValueForConfig<String>(
-                         table.get(), "android:string/dedupe2", enV21Config));
+  ASSERT_TRUE(ResourceDeduper().Consume(context.get(), table.get()));
+  EXPECT_EQ(nullptr, test::GetValueForConfig<String>(
+                         table.get(), "android:string/dedupe", en_config));
+  EXPECT_EQ(nullptr, test::GetValueForConfig<String>(
+                         table.get(), "android:string/dedupe", land_config));
+  EXPECT_EQ(nullptr, test::GetValueForConfig<String>(
+                         table.get(), "android:string/dedupe2", en_config));
+  EXPECT_NE(nullptr, test::GetValueForConfig<String>(
+                         table.get(), "android:string/dedupe2", en_v21_config));
 }
 
 TEST(ResourceDeduperTest, DifferentValuesAreKept) {
-  std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
-  const ConfigDescription defaultConfig = {};
-  const ConfigDescription enConfig = test::parseConfigOrDie("en");
-  const ConfigDescription enV21Config = test::parseConfigOrDie("en-v21");
+  std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
+  const ConfigDescription default_config = {};
+  const ConfigDescription en_config = test::ParseConfigOrDie("en");
+  const ConfigDescription en_v21_config = test::ParseConfigOrDie("en-v21");
   // Chosen because this configuration is compatible with en.
-  const ConfigDescription landConfig = test::parseConfigOrDie("land");
+  const ConfigDescription land_config = test::ParseConfigOrDie("land");
 
   std::unique_ptr<ResourceTable> table =
       test::ResourceTableBuilder()
-          .addString("android:string/keep", ResourceId{}, defaultConfig, "keep")
-          .addString("android:string/keep", ResourceId{}, enConfig, "keep")
-          .addString("android:string/keep", ResourceId{}, enV21Config, "keep2")
-          .addString("android:string/keep", ResourceId{}, landConfig, "keep2")
-          .build();
+          .AddString("android:string/keep", ResourceId{}, default_config,
+                     "keep")
+          .AddString("android:string/keep", ResourceId{}, en_config, "keep")
+          .AddString("android:string/keep", ResourceId{}, en_v21_config,
+                     "keep2")
+          .AddString("android:string/keep", ResourceId{}, land_config, "keep2")
+          .Build();
 
-  ASSERT_TRUE(ResourceDeduper().consume(context.get(), table.get()));
-  EXPECT_NE(nullptr, test::getValueForConfig<String>(
-                         table.get(), "android:string/keep", enConfig));
-  EXPECT_NE(nullptr, test::getValueForConfig<String>(
-                         table.get(), "android:string/keep", enV21Config));
-  EXPECT_NE(nullptr, test::getValueForConfig<String>(
-                         table.get(), "android:string/keep", landConfig));
+  ASSERT_TRUE(ResourceDeduper().Consume(context.get(), table.get()));
+  EXPECT_NE(nullptr, test::GetValueForConfig<String>(
+                         table.get(), "android:string/keep", en_config));
+  EXPECT_NE(nullptr, test::GetValueForConfig<String>(
+                         table.get(), "android:string/keep", en_v21_config));
+  EXPECT_NE(nullptr, test::GetValueForConfig<String>(
+                         table.get(), "android:string/keep", land_config));
 }
 
 }  // namespace aapt
diff --git a/tools/aapt2/link/TableMerger.cpp b/tools/aapt2/link/TableMerger.cpp
index adf83a468cccc..d808da31d3b36 100644
--- a/tools/aapt2/link/TableMerger.cpp
+++ b/tools/aapt2/link/TableMerger.cpp
@@ -15,51 +15,52 @@
  */
 
 #include "link/TableMerger.h"
+
+#include "android-base/logging.h"
+
 #include "ResourceTable.h"
 #include "ResourceUtils.h"
 #include "ResourceValues.h"
 #include "ValueVisitor.h"
 #include "util/Util.h"
 
-#include <cassert>
-
 namespace aapt {
 
-TableMerger::TableMerger(IAaptContext* context, ResourceTable* outTable,
+TableMerger::TableMerger(IAaptContext* context, ResourceTable* out_table,
                          const TableMergerOptions& options)
-    : mContext(context), mMasterTable(outTable), mOptions(options) {
+    : context_(context), master_table_(out_table), options_(options) {
   // Create the desired package that all tables will be merged into.
-  mMasterPackage = mMasterTable->createPackage(
-      mContext->getCompilationPackage(), mContext->getPackageId());
-  assert(mMasterPackage && "package name or ID already taken");
+  master_package_ = master_table_->CreatePackage(
+      context_->GetCompilationPackage(), context_->GetPackageId());
+  CHECK(master_package_ != nullptr) << "package name or ID already taken";
 }
 
-bool TableMerger::merge(const Source& src, ResourceTable* table,
+bool TableMerger::Merge(const Source& src, ResourceTable* table,
                         io::IFileCollection* collection) {
-  return mergeImpl(src, table, collection, false /* overlay */,
+  return MergeImpl(src, table, collection, false /* overlay */,
                    true /* allow new */);
 }
 
-bool TableMerger::mergeOverlay(const Source& src, ResourceTable* table,
+bool TableMerger::MergeOverlay(const Source& src, ResourceTable* table,
                                io::IFileCollection* collection) {
-  return mergeImpl(src, table, collection, true /* overlay */,
-                   mOptions.autoAddOverlay);
+  return MergeImpl(src, table, collection, true /* overlay */,
+                   options_.auto_add_overlay);
 }
 
 /**
  * This will merge packages with the same package name (or no package name).
  */
-bool TableMerger::mergeImpl(const Source& src, ResourceTable* table,
+bool TableMerger::MergeImpl(const Source& src, ResourceTable* table,
                             io::IFileCollection* collection, bool overlay,
-                            bool allowNew) {
-  const uint8_t desiredPackageId = mContext->getPackageId();
+                            bool allow_new) {
+  const uint8_t desired_package_id = context_->GetPackageId();
 
   bool error = false;
   for (auto& package : table->packages) {
     // Warn of packages with an unrelated ID.
     const Maybe<ResourceId>& id = package->id;
-    if (id && id.value() != 0x0 && id.value() != desiredPackageId) {
-      mContext->getDiagnostics()->warn(DiagMessage(src) << "ignoring package "
+    if (id && id.value() != 0x0 && id.value() != desired_package_id) {
+      context_->GetDiagnostics()->Warn(DiagMessage(src) << "ignoring package "
                                                         << package->name);
       continue;
     }
@@ -70,22 +71,22 @@ bool TableMerger::mergeImpl(const Source& src, ResourceTable* table,
     // simply
     // uses of the attribute or definitions.
     if (package->name.empty() ||
-        mContext->getCompilationPackage() == package->name) {
+        context_->GetCompilationPackage() == package->name) {
       FileMergeCallback callback;
       if (collection) {
         callback = [&](const ResourceNameRef& name,
-                       const ConfigDescription& config, FileReference* newFile,
-                       FileReference* oldFile) -> bool {
+                       const ConfigDescription& config, FileReference* new_file,
+                       FileReference* old_file) -> bool {
           // The old file's path points inside the APK, so we can use it as is.
-          io::IFile* f = collection->findFile(*oldFile->path);
+          io::IFile* f = collection->FindFile(*old_file->path);
           if (!f) {
-            mContext->getDiagnostics()->error(DiagMessage(src)
-                                              << "file '" << *oldFile->path
+            context_->GetDiagnostics()->Error(DiagMessage(src)
+                                              << "file '" << *old_file->path
                                               << "' not found");
             return false;
           }
 
-          newFile->file = f;
+          new_file->file = f;
           return true;
         };
       }
@@ -95,8 +96,8 @@ bool TableMerger::mergeImpl(const Source& src, ResourceTable* table,
       // mangled, then looked up at resolution time.
       // Also, when linking, we convert references with no package name to use
       // the compilation package name.
-      error |= !doMerge(src, table, package.get(), false /* mangle */, overlay,
-                        allowNew, callback);
+      error |= !DoMerge(src, table, package.get(), false /* mangle */, overlay,
+                        allow_new, callback);
     }
   }
   return !error;
@@ -105,86 +106,87 @@ bool TableMerger::mergeImpl(const Source& src, ResourceTable* table,
 /**
  * This will merge and mangle resources from a static library.
  */
-bool TableMerger::mergeAndMangle(const Source& src,
-                                 const StringPiece& packageName,
+bool TableMerger::MergeAndMangle(const Source& src,
+                                 const StringPiece& package_name,
                                  ResourceTable* table,
                                  io::IFileCollection* collection) {
   bool error = false;
   for (auto& package : table->packages) {
     // Warn of packages with an unrelated ID.
-    if (packageName != package->name) {
-      mContext->getDiagnostics()->warn(DiagMessage(src) << "ignoring package "
+    if (package_name != package->name) {
+      context_->GetDiagnostics()->Warn(DiagMessage(src) << "ignoring package "
                                                         << package->name);
       continue;
     }
 
-    bool mangle = packageName != mContext->getCompilationPackage();
-    mMergedPackages.insert(package->name);
+    bool mangle = package_name != context_->GetCompilationPackage();
+    merged_packages_.insert(package->name);
 
-    auto callback = [&](const ResourceNameRef& name,
-                        const ConfigDescription& config, FileReference* newFile,
-                        FileReference* oldFile) -> bool {
+    auto callback = [&](
+        const ResourceNameRef& name, const ConfigDescription& config,
+        FileReference* new_file, FileReference* old_file) -> bool {
       // The old file's path points inside the APK, so we can use it as is.
-      io::IFile* f = collection->findFile(*oldFile->path);
+      io::IFile* f = collection->FindFile(*old_file->path);
       if (!f) {
-        mContext->getDiagnostics()->error(
-            DiagMessage(src) << "file '" << *oldFile->path << "' not found");
+        context_->GetDiagnostics()->Error(
+            DiagMessage(src) << "file '" << *old_file->path << "' not found");
         return false;
       }
 
-      newFile->file = f;
+      new_file->file = f;
       return true;
     };
 
-    error |= !doMerge(src, table, package.get(), mangle, false /* overlay */,
+    error |= !DoMerge(src, table, package.get(), mangle, false /* overlay */,
                       true /* allow new */, callback);
   }
   return !error;
 }
 
-static bool mergeType(IAaptContext* context, const Source& src,
-                      ResourceTableType* dstType, ResourceTableType* srcType) {
-  if (dstType->symbolStatus.state < srcType->symbolStatus.state) {
+static bool MergeType(IAaptContext* context, const Source& src,
+                      ResourceTableType* dst_type,
+                      ResourceTableType* src_type) {
+  if (dst_type->symbol_status.state < src_type->symbol_status.state) {
     // The incoming type's visibility is stronger, so we should override
     // the visibility.
-    if (srcType->symbolStatus.state == SymbolState::kPublic) {
+    if (src_type->symbol_status.state == SymbolState::kPublic) {
       // Only copy the ID if the source is public, or else the ID is
       // meaningless.
-      dstType->id = srcType->id;
+      dst_type->id = src_type->id;
     }
-    dstType->symbolStatus = std::move(srcType->symbolStatus);
-  } else if (dstType->symbolStatus.state == SymbolState::kPublic &&
-             srcType->symbolStatus.state == SymbolState::kPublic &&
-             dstType->id && srcType->id &&
-             dstType->id.value() != srcType->id.value()) {
+    dst_type->symbol_status = std::move(src_type->symbol_status);
+  } else if (dst_type->symbol_status.state == SymbolState::kPublic &&
+             src_type->symbol_status.state == SymbolState::kPublic &&
+             dst_type->id && src_type->id &&
+             dst_type->id.value() != src_type->id.value()) {
     // Both types are public and have different IDs.
-    context->getDiagnostics()->error(DiagMessage(src)
-                                     << "cannot merge type '" << srcType->type
+    context->GetDiagnostics()->Error(DiagMessage(src)
+                                     << "cannot merge type '" << src_type->type
                                      << "': conflicting public IDs");
     return false;
   }
   return true;
 }
 
-static bool mergeEntry(IAaptContext* context, const Source& src,
-                       ResourceEntry* dstEntry, ResourceEntry* srcEntry) {
-  if (dstEntry->symbolStatus.state < srcEntry->symbolStatus.state) {
+static bool MergeEntry(IAaptContext* context, const Source& src,
+                       ResourceEntry* dst_entry, ResourceEntry* src_entry) {
+  if (dst_entry->symbol_status.state < src_entry->symbol_status.state) {
     // The incoming type's visibility is stronger, so we should override
     // the visibility.
-    if (srcEntry->symbolStatus.state == SymbolState::kPublic) {
+    if (src_entry->symbol_status.state == SymbolState::kPublic) {
       // Only copy the ID if the source is public, or else the ID is
       // meaningless.
-      dstEntry->id = srcEntry->id;
+      dst_entry->id = src_entry->id;
     }
-    dstEntry->symbolStatus = std::move(srcEntry->symbolStatus);
-  } else if (srcEntry->symbolStatus.state == SymbolState::kPublic &&
-             dstEntry->symbolStatus.state == SymbolState::kPublic &&
-             dstEntry->id && srcEntry->id &&
-             dstEntry->id.value() != srcEntry->id.value()) {
+    dst_entry->symbol_status = std::move(src_entry->symbol_status);
+  } else if (src_entry->symbol_status.state == SymbolState::kPublic &&
+             dst_entry->symbol_status.state == SymbolState::kPublic &&
+             dst_entry->id && src_entry->id &&
+             dst_entry->id.value() != src_entry->id.value()) {
     // Both entries are public and have different IDs.
-    context->getDiagnostics()->error(DiagMessage(src)
-                                     << "cannot merge entry '" << srcEntry->name
-                                     << "': conflicting public IDs");
+    context->GetDiagnostics()->Error(
+        DiagMessage(src) << "cannot merge entry '" << src_entry->name
+                         << "': conflicting public IDs");
     return false;
   }
   return true;
@@ -199,141 +201,145 @@ static bool mergeEntry(IAaptContext* context, const Source& src,
  * and accumulate. If both values are Styleables, we just merge them into the
  * existing value.
  */
-static ResourceTable::CollisionResult resolveMergeCollision(Value* existing,
+static ResourceTable::CollisionResult ResolveMergeCollision(Value* existing,
                                                             Value* incoming) {
-  if (Styleable* existingStyleable = valueCast<Styleable>(existing)) {
-    if (Styleable* incomingStyleable = valueCast<Styleable>(incoming)) {
+  if (Styleable* existing_styleable = ValueCast<Styleable>(existing)) {
+    if (Styleable* incoming_styleable = ValueCast<Styleable>(incoming)) {
       // Styleables get merged.
-      existingStyleable->mergeWith(incomingStyleable);
+      existing_styleable->MergeWith(incoming_styleable);
       return ResourceTable::CollisionResult::kKeepOriginal;
     }
   }
   // Delegate to the default handler.
-  return ResourceTable::resolveValueCollision(existing, incoming);
+  return ResourceTable::ResolveValueCollision(existing, incoming);
 }
 
-static ResourceTable::CollisionResult mergeConfigValue(
-    IAaptContext* context, const ResourceNameRef& resName, const bool overlay,
-    ResourceConfigValue* dstConfigValue, ResourceConfigValue* srcConfigValue) {
+static ResourceTable::CollisionResult MergeConfigValue(
+    IAaptContext* context, const ResourceNameRef& res_name, const bool overlay,
+    ResourceConfigValue* dst_config_value,
+    ResourceConfigValue* src_config_value) {
   using CollisionResult = ResourceTable::CollisionResult;
 
-  Value* dstValue = dstConfigValue->value.get();
-  Value* srcValue = srcConfigValue->value.get();
+  Value* dst_value = dst_config_value->value.get();
+  Value* src_value = src_config_value->value.get();
 
-  CollisionResult collisionResult;
+  CollisionResult collision_result;
   if (overlay) {
-    collisionResult = resolveMergeCollision(dstValue, srcValue);
+    collision_result = ResolveMergeCollision(dst_value, src_value);
   } else {
-    collisionResult = ResourceTable::resolveValueCollision(dstValue, srcValue);
+    collision_result =
+        ResourceTable::ResolveValueCollision(dst_value, src_value);
   }
 
-  if (collisionResult == CollisionResult::kConflict) {
+  if (collision_result == CollisionResult::kConflict) {
     if (overlay) {
       return CollisionResult::kTakeNew;
     }
 
     // Error!
-    context->getDiagnostics()->error(
-        DiagMessage(srcValue->getSource())
-        << "resource '" << resName << "' has a conflicting value for "
-        << "configuration (" << srcConfigValue->config << ")");
-    context->getDiagnostics()->note(DiagMessage(dstValue->getSource())
+    context->GetDiagnostics()->Error(
+        DiagMessage(src_value->GetSource())
+        << "resource '" << res_name << "' has a conflicting value for "
+        << "configuration (" << src_config_value->config << ")");
+    context->GetDiagnostics()->Note(DiagMessage(dst_value->GetSource())
                                     << "originally defined here");
     return CollisionResult::kConflict;
   }
-  return collisionResult;
+  return collision_result;
 }
 
-bool TableMerger::doMerge(const Source& src, ResourceTable* srcTable,
-                          ResourceTablePackage* srcPackage,
-                          const bool manglePackage, const bool overlay,
-                          const bool allowNewResources,
+bool TableMerger::DoMerge(const Source& src, ResourceTable* src_table,
+                          ResourceTablePackage* src_package,
+                          const bool mangle_package, const bool overlay,
+                          const bool allow_new_resources,
                           const FileMergeCallback& callback) {
   bool error = false;
 
-  for (auto& srcType : srcPackage->types) {
-    ResourceTableType* dstType =
-        mMasterPackage->findOrCreateType(srcType->type);
-    if (!mergeType(mContext, src, dstType, srcType.get())) {
+  for (auto& src_type : src_package->types) {
+    ResourceTableType* dst_type =
+        master_package_->FindOrCreateType(src_type->type);
+    if (!MergeType(context_, src, dst_type, src_type.get())) {
       error = true;
       continue;
     }
 
-    for (auto& srcEntry : srcType->entries) {
-      std::string entryName = srcEntry->name;
-      if (manglePackage) {
-        entryName = NameMangler::mangleEntry(srcPackage->name, srcEntry->name);
+    for (auto& src_entry : src_type->entries) {
+      std::string entry_name = src_entry->name;
+      if (mangle_package) {
+        entry_name =
+            NameMangler::MangleEntry(src_package->name, src_entry->name);
       }
 
-      ResourceEntry* dstEntry;
-      if (allowNewResources) {
-        dstEntry = dstType->findOrCreateEntry(entryName);
+      ResourceEntry* dst_entry;
+      if (allow_new_resources) {
+        dst_entry = dst_type->FindOrCreateEntry(entry_name);
       } else {
-        dstEntry = dstType->findEntry(entryName);
+        dst_entry = dst_type->FindEntry(entry_name);
       }
 
-      const ResourceNameRef resName(srcPackage->name, srcType->type,
-                                    srcEntry->name);
+      const ResourceNameRef res_name(src_package->name, src_type->type,
+                                     src_entry->name);
 
-      if (!dstEntry) {
-        mContext->getDiagnostics()->error(
-            DiagMessage(src) << "resource " << resName
+      if (!dst_entry) {
+        context_->GetDiagnostics()->Error(
+            DiagMessage(src) << "resource " << res_name
                              << " does not override an existing resource");
-        mContext->getDiagnostics()->note(
+        context_->GetDiagnostics()->Note(
             DiagMessage(src) << "define an <add-resource> tag or use "
                              << "--auto-add-overlay");
         error = true;
         continue;
       }
 
-      if (!mergeEntry(mContext, src, dstEntry, srcEntry.get())) {
+      if (!MergeEntry(context_, src, dst_entry, src_entry.get())) {
         error = true;
         continue;
       }
 
-      for (auto& srcConfigValue : srcEntry->values) {
+      for (auto& src_config_value : src_entry->values) {
         using CollisionResult = ResourceTable::CollisionResult;
 
-        ResourceConfigValue* dstConfigValue = dstEntry->findValue(
-            srcConfigValue->config, srcConfigValue->product);
-        if (dstConfigValue) {
-          CollisionResult collisionResult = mergeConfigValue(
-              mContext, resName, overlay, dstConfigValue, srcConfigValue.get());
-          if (collisionResult == CollisionResult::kConflict) {
+        ResourceConfigValue* dst_config_value = dst_entry->FindValue(
+            src_config_value->config, src_config_value->product);
+        if (dst_config_value) {
+          CollisionResult collision_result =
+              MergeConfigValue(context_, res_name, overlay, dst_config_value,
+                               src_config_value.get());
+          if (collision_result == CollisionResult::kConflict) {
             error = true;
             continue;
-          } else if (collisionResult == CollisionResult::kKeepOriginal) {
+          } else if (collision_result == CollisionResult::kKeepOriginal) {
             continue;
           }
         } else {
-          dstConfigValue = dstEntry->findOrCreateValue(srcConfigValue->config,
-                                                       srcConfigValue->product);
+          dst_config_value = dst_entry->FindOrCreateValue(
+              src_config_value->config, src_config_value->product);
         }
 
         // Continue if we're taking the new resource.
 
         if (FileReference* f =
-                valueCast<FileReference>(srcConfigValue->value.get())) {
-          std::unique_ptr<FileReference> newFileRef;
-          if (manglePackage) {
-            newFileRef = cloneAndMangleFile(srcPackage->name, *f);
+                ValueCast<FileReference>(src_config_value->value.get())) {
+          std::unique_ptr<FileReference> new_file_ref;
+          if (mangle_package) {
+            new_file_ref = CloneAndMangleFile(src_package->name, *f);
           } else {
-            newFileRef = std::unique_ptr<FileReference>(
-                f->clone(&mMasterTable->stringPool));
+            new_file_ref = std::unique_ptr<FileReference>(
+                f->Clone(&master_table_->string_pool));
           }
 
           if (callback) {
-            if (!callback(resName, srcConfigValue->config, newFileRef.get(),
-                          f)) {
+            if (!callback(res_name, src_config_value->config,
+                          new_file_ref.get(), f)) {
               error = true;
               continue;
             }
           }
-          dstConfigValue->value = std::move(newFileRef);
+          dst_config_value->value = std::move(new_file_ref);
 
         } else {
-          dstConfigValue->value = std::unique_ptr<Value>(
-              srcConfigValue->value->clone(&mMasterTable->stringPool));
+          dst_config_value->value = std::unique_ptr<Value>(
+              src_config_value->value->Clone(&master_table_->string_pool));
         }
       }
     }
@@ -341,50 +347,50 @@ bool TableMerger::doMerge(const Source& src, ResourceTable* srcTable,
   return !error;
 }
 
-std::unique_ptr<FileReference> TableMerger::cloneAndMangleFile(
-    const std::string& package, const FileReference& fileRef) {
+std::unique_ptr<FileReference> TableMerger::CloneAndMangleFile(
+    const std::string& package, const FileReference& file_ref) {
   StringPiece prefix, entry, suffix;
-  if (util::extractResFilePathParts(*fileRef.path, &prefix, &entry, &suffix)) {
-    std::string mangledEntry =
-        NameMangler::mangleEntry(package, entry.toString());
-    std::string newPath = prefix.toString() + mangledEntry + suffix.toString();
-    std::unique_ptr<FileReference> newFileRef =
+  if (util::ExtractResFilePathParts(*file_ref.path, &prefix, &entry, &suffix)) {
+    std::string mangled_entry =
+        NameMangler::MangleEntry(package, entry.ToString());
+    std::string newPath = prefix.ToString() + mangled_entry + suffix.ToString();
+    std::unique_ptr<FileReference> new_file_ref =
         util::make_unique<FileReference>(
-            mMasterTable->stringPool.makeRef(newPath));
-    newFileRef->setComment(fileRef.getComment());
-    newFileRef->setSource(fileRef.getSource());
-    return newFileRef;
+            master_table_->string_pool.MakeRef(newPath));
+    new_file_ref->SetComment(file_ref.GetComment());
+    new_file_ref->SetSource(file_ref.GetSource());
+    return new_file_ref;
   }
   return std::unique_ptr<FileReference>(
-      fileRef.clone(&mMasterTable->stringPool));
+      file_ref.Clone(&master_table_->string_pool));
 }
 
-bool TableMerger::mergeFileImpl(const ResourceFile& fileDesc, io::IFile* file,
+bool TableMerger::MergeFileImpl(const ResourceFile& file_desc, io::IFile* file,
                                 bool overlay) {
   ResourceTable table;
-  std::string path = ResourceUtils::buildResourceFileName(fileDesc, nullptr);
-  std::unique_ptr<FileReference> fileRef =
-      util::make_unique<FileReference>(table.stringPool.makeRef(path));
-  fileRef->setSource(fileDesc.source);
-  fileRef->file = file;
+  std::string path = ResourceUtils::BuildResourceFileName(file_desc);
+  std::unique_ptr<FileReference> file_ref =
+      util::make_unique<FileReference>(table.string_pool.MakeRef(path));
+  file_ref->SetSource(file_desc.source);
+  file_ref->file = file;
 
-  ResourceTablePackage* pkg = table.createPackage(fileDesc.name.package, 0x0);
-  pkg->findOrCreateType(fileDesc.name.type)
-      ->findOrCreateEntry(fileDesc.name.entry)
-      ->findOrCreateValue(fileDesc.config, {})
-      ->value = std::move(fileRef);
+  ResourceTablePackage* pkg = table.CreatePackage(file_desc.name.package, 0x0);
+  pkg->FindOrCreateType(file_desc.name.type)
+      ->FindOrCreateEntry(file_desc.name.entry)
+      ->FindOrCreateValue(file_desc.config, {})
+      ->value = std::move(file_ref);
 
-  return doMerge(file->getSource(), &table, pkg, false /* mangle */,
-                 overlay /* overlay */, true /* allow new */, {});
+  return DoMerge(file->GetSource(), &table, pkg, false /* mangle */,
+                 overlay /* overlay */, true /* allow_new */, {});
 }
 
-bool TableMerger::mergeFile(const ResourceFile& fileDesc, io::IFile* file) {
-  return mergeFileImpl(fileDesc, file, false /* overlay */);
+bool TableMerger::MergeFile(const ResourceFile& file_desc, io::IFile* file) {
+  return MergeFileImpl(file_desc, file, false /* overlay */);
 }
 
-bool TableMerger::mergeFileOverlay(const ResourceFile& fileDesc,
+bool TableMerger::MergeFileOverlay(const ResourceFile& file_desc,
                                    io::IFile* file) {
-  return mergeFileImpl(fileDesc, file, true /* overlay */);
+  return MergeFileImpl(file_desc, file, true /* overlay */);
 }
 
 }  // namespace aapt
diff --git a/tools/aapt2/link/TableMerger.h b/tools/aapt2/link/TableMerger.h
index c2e7181692d44..4ab83c3f2de36 100644
--- a/tools/aapt2/link/TableMerger.h
+++ b/tools/aapt2/link/TableMerger.h
@@ -17,6 +17,11 @@
 #ifndef AAPT_TABLEMERGER_H
 #define AAPT_TABLEMERGER_H
 
+#include <functional>
+#include <map>
+
+#include "android-base/macros.h"
+
 #include "Resource.h"
 #include "ResourceTable.h"
 #include "ResourceValues.h"
@@ -25,9 +30,6 @@
 #include "process/IResourceTableConsumer.h"
 #include "util/Util.h"
 
-#include <functional>
-#include <map>
-
 namespace aapt {
 
 struct TableMergerOptions {
@@ -35,7 +37,7 @@ struct TableMergerOptions {
    * If true, resources in overlays can be added without previously having
    * existed.
    */
-  bool autoAddOverlay = false;
+  bool auto_add_overlay = false;
 };
 
 /**
@@ -62,15 +64,14 @@ struct TableMergerOptions {
 class TableMerger {
  public:
   /**
-   * Note: The outTable ResourceTable must live longer than this TableMerger.
-   * References
-   * are made to this ResourceTable for efficiency reasons.
+   * Note: The out_table ResourceTable must live longer than this TableMerger.
+   * References are made to this ResourceTable for efficiency reasons.
    */
-  TableMerger(IAaptContext* context, ResourceTable* outTable,
+  TableMerger(IAaptContext* context, ResourceTable* out_table,
               const TableMergerOptions& options);
 
-  const std::set<std::string>& getMergedPackages() const {
-    return mMergedPackages;
+  const std::set<std::string>& merged_packages() const {
+    return merged_packages_;
   }
 
   /**
@@ -78,7 +79,7 @@ class TableMerger {
    * An io::IFileCollection is optional and used to find the referenced Files
    * and process them.
    */
-  bool merge(const Source& src, ResourceTable* table,
+  bool Merge(const Source& src, ResourceTable* table,
              io::IFileCollection* collection = nullptr);
 
   /**
@@ -86,7 +87,7 @@ class TableMerger {
    * An io::IFileCollection is optional and used to find the referenced Files
    * and process them.
    */
-  bool mergeOverlay(const Source& src, ResourceTable* table,
+  bool MergeOverlay(const Source& src, ResourceTable* table,
                     io::IFileCollection* collection = nullptr);
 
   /**
@@ -95,44 +96,45 @@ class TableMerger {
    * An io::IFileCollection is needed in order to find the referenced Files and
    * process them.
    */
-  bool mergeAndMangle(const Source& src, const StringPiece& package,
+  bool MergeAndMangle(const Source& src, const StringPiece& package,
                       ResourceTable* table, io::IFileCollection* collection);
 
   /**
    * Merges a compiled file that belongs to this same or empty package. This is
    * for local sources.
    */
-  bool mergeFile(const ResourceFile& fileDesc, io::IFile* file);
+  bool MergeFile(const ResourceFile& fileDesc, io::IFile* file);
 
   /**
    * Merges a compiled file from an overlay, overriding an existing definition.
    */
-  bool mergeFileOverlay(const ResourceFile& fileDesc, io::IFile* file);
+  bool MergeFileOverlay(const ResourceFile& fileDesc, io::IFile* file);
 
  private:
+  DISALLOW_COPY_AND_ASSIGN(TableMerger);
+
   using FileMergeCallback = std::function<bool(const ResourceNameRef&,
                                                const ConfigDescription& config,
                                                FileReference*, FileReference*)>;
 
-  IAaptContext* mContext;
-  ResourceTable* mMasterTable;
-  TableMergerOptions mOptions;
-  ResourceTablePackage* mMasterPackage;
+  IAaptContext* context_;
+  ResourceTable* master_table_;
+  TableMergerOptions options_;
+  ResourceTablePackage* master_package_;
+  std::set<std::string> merged_packages_;
 
-  std::set<std::string> mMergedPackages;
-
-  bool mergeFileImpl(const ResourceFile& fileDesc, io::IFile* file,
+  bool MergeFileImpl(const ResourceFile& file_desc, io::IFile* file,
                      bool overlay);
 
-  bool mergeImpl(const Source& src, ResourceTable* srcTable,
-                 io::IFileCollection* collection, bool overlay, bool allowNew);
+  bool MergeImpl(const Source& src, ResourceTable* src_table,
+                 io::IFileCollection* collection, bool overlay, bool allow_new);
 
-  bool doMerge(const Source& src, ResourceTable* srcTable,
-               ResourceTablePackage* srcPackage, const bool manglePackage,
-               const bool overlay, const bool allowNewResources,
+  bool DoMerge(const Source& src, ResourceTable* src_table,
+               ResourceTablePackage* src_package, const bool mangle_package,
+               const bool overlay, const bool allow_new_resources,
                const FileMergeCallback& callback);
 
-  std::unique_ptr<FileReference> cloneAndMangleFile(const std::string& package,
+  std::unique_ptr<FileReference> CloneAndMangleFile(const std::string& package,
                                                     const FileReference& value);
 };
 
diff --git a/tools/aapt2/link/TableMerger_test.cpp b/tools/aapt2/link/TableMerger_test.cpp
index e0b2b6615d288..742f5a7a570a7 100644
--- a/tools/aapt2/link/TableMerger_test.cpp
+++ b/tools/aapt2/link/TableMerger_test.cpp
@@ -15,139 +15,137 @@
  */
 
 #include "link/TableMerger.h"
+
 #include "filter/ConfigFilter.h"
 #include "io/FileSystem.h"
-#include "test/Builders.h"
-#include "test/Context.h"
-
-#include <gtest/gtest.h>
+#include "test/Test.h"
 
 namespace aapt {
 
 struct TableMergerTest : public ::testing::Test {
-  std::unique_ptr<IAaptContext> mContext;
+  std::unique_ptr<IAaptContext> context_;
 
   void SetUp() override {
-    mContext =
+    context_ =
         test::ContextBuilder()
             // We are compiling this package.
-            .setCompilationPackage("com.app.a")
+            .SetCompilationPackage("com.app.a")
 
             // Merge all packages that have this package ID.
-            .setPackageId(0x7f)
+            .SetPackageId(0x7f)
 
             // Mangle all packages that do not have this package name.
-            .setNameManglerPolicy(NameManglerPolicy{"com.app.a", {"com.app.b"}})
+            .SetNameManglerPolicy(NameManglerPolicy{"com.app.a", {"com.app.b"}})
 
-            .build();
+            .Build();
   }
 };
 
 TEST_F(TableMergerTest, SimpleMerge) {
-  std::unique_ptr<ResourceTable> tableA =
+  std::unique_ptr<ResourceTable> table_a =
       test::ResourceTableBuilder()
-          .setPackageId("com.app.a", 0x7f)
-          .addReference("com.app.a:id/foo", "com.app.a:id/bar")
-          .addReference("com.app.a:id/bar", "com.app.b:id/foo")
-          .addValue(
+          .SetPackageId("com.app.a", 0x7f)
+          .AddReference("com.app.a:id/foo", "com.app.a:id/bar")
+          .AddReference("com.app.a:id/bar", "com.app.b:id/foo")
+          .AddValue(
               "com.app.a:styleable/view",
-              test::StyleableBuilder().addItem("com.app.b:id/foo").build())
-          .build();
+              test::StyleableBuilder().AddItem("com.app.b:id/foo").Build())
+          .Build();
 
-  std::unique_ptr<ResourceTable> tableB = test::ResourceTableBuilder()
-                                              .setPackageId("com.app.b", 0x7f)
-                                              .addSimple("com.app.b:id/foo")
-                                              .build();
+  std::unique_ptr<ResourceTable> table_b = test::ResourceTableBuilder()
+                                               .SetPackageId("com.app.b", 0x7f)
+                                               .AddSimple("com.app.b:id/foo")
+                                               .Build();
 
-  ResourceTable finalTable;
-  TableMerger merger(mContext.get(), &finalTable, TableMergerOptions{});
+  ResourceTable final_table;
+  TableMerger merger(context_.get(), &final_table, TableMergerOptions{});
   io::FileCollection collection;
 
-  ASSERT_TRUE(merger.merge({}, tableA.get()));
+  ASSERT_TRUE(merger.Merge({}, table_a.get()));
   ASSERT_TRUE(
-      merger.mergeAndMangle({}, "com.app.b", tableB.get(), &collection));
+      merger.MergeAndMangle({}, "com.app.b", table_b.get(), &collection));
 
-  EXPECT_TRUE(merger.getMergedPackages().count("com.app.b") != 0);
+  EXPECT_TRUE(merger.merged_packages().count("com.app.b") != 0);
 
   // Entries from com.app.a should not be mangled.
   AAPT_EXPECT_TRUE(
-      finalTable.findResource(test::parseNameOrDie("com.app.a:id/foo")));
+      final_table.FindResource(test::ParseNameOrDie("com.app.a:id/foo")));
   AAPT_EXPECT_TRUE(
-      finalTable.findResource(test::parseNameOrDie("com.app.a:id/bar")));
-  AAPT_EXPECT_TRUE(finalTable.findResource(
-      test::parseNameOrDie("com.app.a:styleable/view")));
+      final_table.FindResource(test::ParseNameOrDie("com.app.a:id/bar")));
+  AAPT_EXPECT_TRUE(final_table.FindResource(
+      test::ParseNameOrDie("com.app.a:styleable/view")));
 
   // The unmangled name should not be present.
   AAPT_EXPECT_FALSE(
-      finalTable.findResource(test::parseNameOrDie("com.app.b:id/foo")));
+      final_table.FindResource(test::ParseNameOrDie("com.app.b:id/foo")));
 
   // Look for the mangled name.
-  AAPT_EXPECT_TRUE(finalTable.findResource(
-      test::parseNameOrDie("com.app.a:id/com.app.b$foo")));
+  AAPT_EXPECT_TRUE(final_table.FindResource(
+      test::ParseNameOrDie("com.app.a:id/com.app.b$foo")));
 }
 
 TEST_F(TableMergerTest, MergeFile) {
-  ResourceTable finalTable;
+  ResourceTable final_table;
   TableMergerOptions options;
-  options.autoAddOverlay = false;
-  TableMerger merger(mContext.get(), &finalTable, options);
+  options.auto_add_overlay = false;
+  TableMerger merger(context_.get(), &final_table, options);
 
-  ResourceFile fileDesc;
-  fileDesc.config = test::parseConfigOrDie("hdpi-v4");
-  fileDesc.name = test::parseNameOrDie("layout/main");
-  fileDesc.source = Source("res/layout-hdpi/main.xml");
-  test::TestFile testFile("path/to/res/layout-hdpi/main.xml.flat");
+  ResourceFile file_desc;
+  file_desc.config = test::ParseConfigOrDie("hdpi-v4");
+  file_desc.name = test::ParseNameOrDie("layout/main");
+  file_desc.source = Source("res/layout-hdpi/main.xml");
+  test::TestFile test_file("path/to/res/layout-hdpi/main.xml.flat");
 
-  ASSERT_TRUE(merger.mergeFile(fileDesc, &testFile));
+  ASSERT_TRUE(merger.MergeFile(file_desc, &test_file));
 
-  FileReference* file = test::getValueForConfig<FileReference>(
-      &finalTable, "com.app.a:layout/main", test::parseConfigOrDie("hdpi-v4"));
+  FileReference* file = test::GetValueForConfig<FileReference>(
+      &final_table, "com.app.a:layout/main", test::ParseConfigOrDie("hdpi-v4"));
   ASSERT_NE(nullptr, file);
   EXPECT_EQ(std::string("res/layout-hdpi-v4/main.xml"), *file->path);
 }
 
 TEST_F(TableMergerTest, MergeFileOverlay) {
-  ResourceTable finalTable;
-  TableMergerOptions tableMergerOptions;
-  tableMergerOptions.autoAddOverlay = false;
-  TableMerger merger(mContext.get(), &finalTable, tableMergerOptions);
+  ResourceTable final_table;
+  TableMergerOptions options;
+  options.auto_add_overlay = false;
+  TableMerger merger(context_.get(), &final_table, options);
 
-  ResourceFile fileDesc;
-  fileDesc.name = test::parseNameOrDie("xml/foo");
-  test::TestFile fileA("path/to/fileA.xml.flat");
-  test::TestFile fileB("path/to/fileB.xml.flat");
+  ResourceFile file_desc;
+  file_desc.name = test::ParseNameOrDie("xml/foo");
+  test::TestFile file_a("path/to/fileA.xml.flat");
+  test::TestFile file_b("path/to/fileB.xml.flat");
 
-  ASSERT_TRUE(merger.mergeFile(fileDesc, &fileA));
-  ASSERT_TRUE(merger.mergeFileOverlay(fileDesc, &fileB));
+  ASSERT_TRUE(merger.MergeFile(file_desc, &file_a));
+  ASSERT_TRUE(merger.MergeFileOverlay(file_desc, &file_b));
 }
 
 TEST_F(TableMergerTest, MergeFileReferences) {
-  std::unique_ptr<ResourceTable> tableA =
+  std::unique_ptr<ResourceTable> table_a =
       test::ResourceTableBuilder()
-          .setPackageId("com.app.a", 0x7f)
-          .addFileReference("com.app.a:xml/file", "res/xml/file.xml")
-          .build();
-  std::unique_ptr<ResourceTable> tableB =
+          .SetPackageId("com.app.a", 0x7f)
+          .AddFileReference("com.app.a:xml/file", "res/xml/file.xml")
+          .Build();
+  std::unique_ptr<ResourceTable> table_b =
       test::ResourceTableBuilder()
-          .setPackageId("com.app.b", 0x7f)
-          .addFileReference("com.app.b:xml/file", "res/xml/file.xml")
-          .build();
+          .SetPackageId("com.app.b", 0x7f)
+          .AddFileReference("com.app.b:xml/file", "res/xml/file.xml")
+          .Build();
 
-  ResourceTable finalTable;
-  TableMerger merger(mContext.get(), &finalTable, TableMergerOptions{});
+  ResourceTable final_table;
+  TableMerger merger(context_.get(), &final_table, TableMergerOptions{});
   io::FileCollection collection;
-  collection.insertFile("res/xml/file.xml");
+  collection.InsertFile("res/xml/file.xml");
 
-  ASSERT_TRUE(merger.merge({}, tableA.get()));
+  ASSERT_TRUE(merger.Merge({}, table_a.get()));
   ASSERT_TRUE(
-      merger.mergeAndMangle({}, "com.app.b", tableB.get(), &collection));
+      merger.MergeAndMangle({}, "com.app.b", table_b.get(), &collection));
 
   FileReference* f =
-      test::getValue<FileReference>(&finalTable, "com.app.a:xml/file");
+      test::GetValue<FileReference>(&final_table, "com.app.a:xml/file");
   ASSERT_NE(f, nullptr);
   EXPECT_EQ(std::string("res/xml/file.xml"), *f->path);
 
-  f = test::getValue<FileReference>(&finalTable,
+  f = test::GetValue<FileReference>(&final_table,
                                     "com.app.a:xml/com.app.b$file");
   ASSERT_NE(f, nullptr);
   EXPECT_EQ(std::string("res/xml/com.app.b$file.xml"), *f->path);
@@ -156,25 +154,25 @@ TEST_F(TableMergerTest, MergeFileReferences) {
 TEST_F(TableMergerTest, OverrideResourceWithOverlay) {
   std::unique_ptr<ResourceTable> base =
       test::ResourceTableBuilder()
-          .setPackageId("", 0x00)
-          .addValue("bool/foo", ResourceUtils::tryParseBool("true"))
-          .build();
+          .SetPackageId("", 0x00)
+          .AddValue("bool/foo", ResourceUtils::TryParseBool("true"))
+          .Build();
   std::unique_ptr<ResourceTable> overlay =
       test::ResourceTableBuilder()
-          .setPackageId("", 0x00)
-          .addValue("bool/foo", ResourceUtils::tryParseBool("false"))
-          .build();
+          .SetPackageId("", 0x00)
+          .AddValue("bool/foo", ResourceUtils::TryParseBool("false"))
+          .Build();
 
-  ResourceTable finalTable;
-  TableMergerOptions tableMergerOptions;
-  tableMergerOptions.autoAddOverlay = false;
-  TableMerger merger(mContext.get(), &finalTable, tableMergerOptions);
+  ResourceTable final_table;
+  TableMergerOptions options;
+  options.auto_add_overlay = false;
+  TableMerger merger(context_.get(), &final_table, options);
 
-  ASSERT_TRUE(merger.merge({}, base.get()));
-  ASSERT_TRUE(merger.mergeOverlay({}, overlay.get()));
+  ASSERT_TRUE(merger.Merge({}, base.get()));
+  ASSERT_TRUE(merger.MergeOverlay({}, overlay.get()));
 
   BinaryPrimitive* foo =
-      test::getValue<BinaryPrimitive>(&finalTable, "com.app.a:bool/foo");
+      test::GetValue<BinaryPrimitive>(&final_table, "com.app.a:bool/foo");
   ASSERT_NE(nullptr, foo);
   EXPECT_EQ(0x0u, foo->value.data);
 }
@@ -182,170 +180,168 @@ TEST_F(TableMergerTest, OverrideResourceWithOverlay) {
 TEST_F(TableMergerTest, OverrideSameResourceIdsWithOverlay) {
   std::unique_ptr<ResourceTable> base =
       test::ResourceTableBuilder()
-          .setPackageId("", 0x7f)
-          .setSymbolState("bool/foo", ResourceId(0x7f, 0x01, 0x0001),
+          .SetPackageId("", 0x7f)
+          .SetSymbolState("bool/foo", ResourceId(0x7f, 0x01, 0x0001),
                           SymbolState::kPublic)
-          .build();
+          .Build();
   std::unique_ptr<ResourceTable> overlay =
       test::ResourceTableBuilder()
-          .setPackageId("", 0x7f)
-          .setSymbolState("bool/foo", ResourceId(0x7f, 0x01, 0x0001),
+          .SetPackageId("", 0x7f)
+          .SetSymbolState("bool/foo", ResourceId(0x7f, 0x01, 0x0001),
                           SymbolState::kPublic)
-          .build();
+          .Build();
 
-  ResourceTable finalTable;
-  TableMergerOptions tableMergerOptions;
-  tableMergerOptions.autoAddOverlay = false;
-  TableMerger merger(mContext.get(), &finalTable, tableMergerOptions);
+  ResourceTable final_table;
+  TableMergerOptions options;
+  options.auto_add_overlay = false;
+  TableMerger merger(context_.get(), &final_table, options);
 
-  ASSERT_TRUE(merger.merge({}, base.get()));
-  ASSERT_TRUE(merger.mergeOverlay({}, overlay.get()));
+  ASSERT_TRUE(merger.Merge({}, base.get()));
+  ASSERT_TRUE(merger.MergeOverlay({}, overlay.get()));
 }
 
 TEST_F(TableMergerTest, FailToOverrideConflictingTypeIdsWithOverlay) {
   std::unique_ptr<ResourceTable> base =
       test::ResourceTableBuilder()
-          .setPackageId("", 0x7f)
-          .setSymbolState("bool/foo", ResourceId(0x7f, 0x01, 0x0001),
+          .SetPackageId("", 0x7f)
+          .SetSymbolState("bool/foo", ResourceId(0x7f, 0x01, 0x0001),
                           SymbolState::kPublic)
-          .build();
+          .Build();
   std::unique_ptr<ResourceTable> overlay =
       test::ResourceTableBuilder()
-          .setPackageId("", 0x7f)
-          .setSymbolState("bool/foo", ResourceId(0x7f, 0x02, 0x0001),
+          .SetPackageId("", 0x7f)
+          .SetSymbolState("bool/foo", ResourceId(0x7f, 0x02, 0x0001),
                           SymbolState::kPublic)
-          .build();
+          .Build();
 
-  ResourceTable finalTable;
-  TableMergerOptions tableMergerOptions;
-  tableMergerOptions.autoAddOverlay = false;
-  TableMerger merger(mContext.get(), &finalTable, tableMergerOptions);
+  ResourceTable final_table;
+  TableMergerOptions options;
+  options.auto_add_overlay = false;
+  TableMerger merger(context_.get(), &final_table, options);
 
-  ASSERT_TRUE(merger.merge({}, base.get()));
-  ASSERT_FALSE(merger.mergeOverlay({}, overlay.get()));
+  ASSERT_TRUE(merger.Merge({}, base.get()));
+  ASSERT_FALSE(merger.MergeOverlay({}, overlay.get()));
 }
 
 TEST_F(TableMergerTest, FailToOverrideConflictingEntryIdsWithOverlay) {
   std::unique_ptr<ResourceTable> base =
       test::ResourceTableBuilder()
-          .setPackageId("", 0x7f)
-          .setSymbolState("bool/foo", ResourceId(0x7f, 0x01, 0x0001),
+          .SetPackageId("", 0x7f)
+          .SetSymbolState("bool/foo", ResourceId(0x7f, 0x01, 0x0001),
                           SymbolState::kPublic)
-          .build();
+          .Build();
   std::unique_ptr<ResourceTable> overlay =
       test::ResourceTableBuilder()
-          .setPackageId("", 0x7f)
-          .setSymbolState("bool/foo", ResourceId(0x7f, 0x01, 0x0002),
+          .SetPackageId("", 0x7f)
+          .SetSymbolState("bool/foo", ResourceId(0x7f, 0x01, 0x0002),
                           SymbolState::kPublic)
-          .build();
+          .Build();
 
-  ResourceTable finalTable;
-  TableMergerOptions tableMergerOptions;
-  tableMergerOptions.autoAddOverlay = false;
-  TableMerger merger(mContext.get(), &finalTable, tableMergerOptions);
+  ResourceTable final_table;
+  TableMergerOptions options;
+  options.auto_add_overlay = false;
+  TableMerger merger(context_.get(), &final_table, options);
 
-  ASSERT_TRUE(merger.merge({}, base.get()));
-  ASSERT_FALSE(merger.mergeOverlay({}, overlay.get()));
+  ASSERT_TRUE(merger.Merge({}, base.get()));
+  ASSERT_FALSE(merger.MergeOverlay({}, overlay.get()));
 }
 
 TEST_F(TableMergerTest, MergeAddResourceFromOverlay) {
-  std::unique_ptr<ResourceTable> tableA =
+  std::unique_ptr<ResourceTable> table_a =
       test::ResourceTableBuilder()
-          .setPackageId("", 0x7f)
-          .setSymbolState("bool/foo", {}, SymbolState::kUndefined)
-          .build();
-  std::unique_ptr<ResourceTable> tableB =
+          .SetPackageId("", 0x7f)
+          .SetSymbolState("bool/foo", {}, SymbolState::kUndefined)
+          .Build();
+  std::unique_ptr<ResourceTable> table_b =
       test::ResourceTableBuilder()
-          .setPackageId("", 0x7f)
-          .addValue("bool/foo", ResourceUtils::tryParseBool("true"))
-          .build();
+          .SetPackageId("", 0x7f)
+          .AddValue("bool/foo", ResourceUtils::TryParseBool("true"))
+          .Build();
 
-  ResourceTable finalTable;
-  TableMerger merger(mContext.get(), &finalTable, TableMergerOptions{});
+  ResourceTable final_table;
+  TableMerger merger(context_.get(), &final_table, TableMergerOptions{});
 
-  ASSERT_TRUE(merger.merge({}, tableA.get()));
-  ASSERT_TRUE(merger.mergeOverlay({}, tableB.get()));
+  ASSERT_TRUE(merger.Merge({}, table_a.get()));
+  ASSERT_TRUE(merger.MergeOverlay({}, table_b.get()));
 }
 
 TEST_F(TableMergerTest, MergeAddResourceFromOverlayWithAutoAddOverlay) {
-  std::unique_ptr<ResourceTable> tableA =
-      test::ResourceTableBuilder().setPackageId("", 0x7f).build();
-  std::unique_ptr<ResourceTable> tableB =
+  std::unique_ptr<ResourceTable> table_a =
+      test::ResourceTableBuilder().SetPackageId("", 0x7f).Build();
+  std::unique_ptr<ResourceTable> table_b =
       test::ResourceTableBuilder()
-          .setPackageId("", 0x7f)
-          .addValue("bool/foo", ResourceUtils::tryParseBool("true"))
-          .build();
+          .SetPackageId("", 0x7f)
+          .AddValue("bool/foo", ResourceUtils::TryParseBool("true"))
+          .Build();
 
-  ResourceTable finalTable;
+  ResourceTable final_table;
   TableMergerOptions options;
-  options.autoAddOverlay = true;
-  TableMerger merger(mContext.get(), &finalTable, options);
+  options.auto_add_overlay = true;
+  TableMerger merger(context_.get(), &final_table, options);
 
-  ASSERT_TRUE(merger.merge({}, tableA.get()));
-  ASSERT_TRUE(merger.mergeOverlay({}, tableB.get()));
+  ASSERT_TRUE(merger.Merge({}, table_a.get()));
+  ASSERT_TRUE(merger.MergeOverlay({}, table_b.get()));
 }
 
 TEST_F(TableMergerTest, FailToMergeNewResourceWithoutAutoAddOverlay) {
-  std::unique_ptr<ResourceTable> tableA =
-      test::ResourceTableBuilder().setPackageId("", 0x7f).build();
-  std::unique_ptr<ResourceTable> tableB =
+  std::unique_ptr<ResourceTable> table_a =
+      test::ResourceTableBuilder().SetPackageId("", 0x7f).Build();
+  std::unique_ptr<ResourceTable> table_b =
       test::ResourceTableBuilder()
-          .setPackageId("", 0x7f)
-          .addValue("bool/foo", ResourceUtils::tryParseBool("true"))
-          .build();
+          .SetPackageId("", 0x7f)
+          .AddValue("bool/foo", ResourceUtils::TryParseBool("true"))
+          .Build();
 
-  ResourceTable finalTable;
+  ResourceTable final_table;
   TableMergerOptions options;
-  options.autoAddOverlay = false;
-  TableMerger merger(mContext.get(), &finalTable, options);
+  options.auto_add_overlay = false;
+  TableMerger merger(context_.get(), &final_table, options);
 
-  ASSERT_TRUE(merger.merge({}, tableA.get()));
-  ASSERT_FALSE(merger.mergeOverlay({}, tableB.get()));
+  ASSERT_TRUE(merger.Merge({}, table_a.get()));
+  ASSERT_FALSE(merger.MergeOverlay({}, table_b.get()));
 }
 
 TEST_F(TableMergerTest, OverlaidStyleablesShouldBeMerged) {
-  std::unique_ptr<ResourceTable> tableA =
+  std::unique_ptr<ResourceTable> table_a =
       test::ResourceTableBuilder()
-          .setPackageId("com.app.a", 0x7f)
-          .addValue("com.app.a:styleable/Foo",
+          .SetPackageId("com.app.a", 0x7f)
+          .AddValue("com.app.a:styleable/Foo",
                     test::StyleableBuilder()
-                        .addItem("com.app.a:attr/bar")
-                        .addItem("com.app.a:attr/foo", ResourceId(0x01010000))
-                        .build())
-          .build();
+                        .AddItem("com.app.a:attr/bar")
+                        .AddItem("com.app.a:attr/foo", ResourceId(0x01010000))
+                        .Build())
+          .Build();
 
-  std::unique_ptr<ResourceTable> tableB =
+  std::unique_ptr<ResourceTable> table_b =
       test::ResourceTableBuilder()
-          .setPackageId("com.app.a", 0x7f)
-          .addValue("com.app.a:styleable/Foo",
+          .SetPackageId("com.app.a", 0x7f)
+          .AddValue("com.app.a:styleable/Foo",
                     test::StyleableBuilder()
-                        .addItem("com.app.a:attr/bat")
-                        .addItem("com.app.a:attr/foo")
-                        .build())
-          .build();
+                        .AddItem("com.app.a:attr/bat")
+                        .AddItem("com.app.a:attr/foo")
+                        .Build())
+          .Build();
 
-  ResourceTable finalTable;
+  ResourceTable final_table;
   TableMergerOptions options;
-  options.autoAddOverlay = true;
-  TableMerger merger(mContext.get(), &finalTable, options);
+  options.auto_add_overlay = true;
+  TableMerger merger(context_.get(), &final_table, options);
 
-  ASSERT_TRUE(merger.merge({}, tableA.get()));
-  ASSERT_TRUE(merger.mergeOverlay({}, tableB.get()));
-
-  Debug::printTable(&finalTable, {});
+  ASSERT_TRUE(merger.Merge({}, table_a.get()));
+  ASSERT_TRUE(merger.MergeOverlay({}, table_b.get()));
 
   Styleable* styleable =
-      test::getValue<Styleable>(&finalTable, "com.app.a:styleable/Foo");
+      test::GetValue<Styleable>(&final_table, "com.app.a:styleable/Foo");
   ASSERT_NE(nullptr, styleable);
 
-  std::vector<Reference> expectedRefs = {
-      Reference(test::parseNameOrDie("com.app.a:attr/bar")),
-      Reference(test::parseNameOrDie("com.app.a:attr/bat")),
-      Reference(test::parseNameOrDie("com.app.a:attr/foo"),
+  std::vector<Reference> expected_refs = {
+      Reference(test::ParseNameOrDie("com.app.a:attr/bar")),
+      Reference(test::ParseNameOrDie("com.app.a:attr/bat")),
+      Reference(test::ParseNameOrDie("com.app.a:attr/foo"),
                 ResourceId(0x01010000)),
   };
 
-  EXPECT_EQ(expectedRefs, styleable->entries);
+  EXPECT_EQ(expected_refs, styleable->entries);
 }
 
 }  // namespace aapt
diff --git a/tools/aapt2/link/VersionCollapser.cpp b/tools/aapt2/link/VersionCollapser.cpp
index 61a1f86028c6d..3df58994333f2 100644
--- a/tools/aapt2/link/VersionCollapser.cpp
+++ b/tools/aapt2/link/VersionCollapser.cpp
@@ -14,50 +14,51 @@
  * limitations under the License.
  */
 
-#include "ResourceTable.h"
 #include "link/Linkers.h"
 
 #include <algorithm>
 #include <vector>
 
+#include "ResourceTable.h"
+
 namespace aapt {
 
 template <typename Iterator, typename Pred>
 class FilterIterator {
  public:
   FilterIterator(Iterator begin, Iterator end, Pred pred = Pred())
-      : mCurrent(begin), mEnd(end), mPred(pred) {
-    advance();
+      : current_(begin), end_(end), pred_(pred) {
+    Advance();
   }
 
-  bool hasNext() { return mCurrent != mEnd; }
+  bool HasNext() { return current_ != end_; }
 
-  Iterator nextIter() {
-    Iterator iter = mCurrent;
-    ++mCurrent;
-    advance();
+  Iterator NextIter() {
+    Iterator iter = current_;
+    ++current_;
+    Advance();
     return iter;
   }
 
-  typename Iterator::reference next() { return *nextIter(); }
+  typename Iterator::reference Next() { return *NextIter(); }
 
  private:
-  void advance() {
-    for (; mCurrent != mEnd; ++mCurrent) {
-      if (mPred(*mCurrent)) {
+  void Advance() {
+    for (; current_ != end_; ++current_) {
+      if (pred_(*current_)) {
         return;
       }
     }
   }
 
-  Iterator mCurrent, mEnd;
-  Pred mPred;
+  Iterator current_, end_;
+  Pred pred_;
 };
 
 template <typename Iterator, typename Pred>
-FilterIterator<Iterator, Pred> makeFilterIterator(Iterator begin,
-                                                  Iterator end = Iterator(),
-                                                  Pred pred = Pred()) {
+FilterIterator<Iterator, Pred> make_filter_iterator(Iterator begin,
+                                                    Iterator end = Iterator(),
+                                                    Pred pred = Pred()) {
   return FilterIterator<Iterator, Pred>(begin, end, pred);
 }
 
@@ -68,7 +69,7 @@ FilterIterator<Iterator, Pred> makeFilterIterator(Iterator begin,
  * next smallest
  * one will be kept.
  */
-static void collapseVersions(int minSdk, ResourceEntry* entry) {
+static void CollapseVersions(int min_sdk, ResourceEntry* entry) {
   // First look for all sdks less than minSdk.
   for (auto iter = entry->values.rbegin(); iter != entry->values.rend();
        ++iter) {
@@ -78,15 +79,14 @@ static void collapseVersions(int minSdk, ResourceEntry* entry) {
     }
 
     const ConfigDescription& config = (*iter)->config;
-    if (config.sdkVersion <= minSdk) {
+    if (config.sdkVersion <= min_sdk) {
       // This is the first configuration we've found with a smaller or equal SDK
       // level
       // to the minimum. We MUST keep this one, but remove all others we find,
       // which get
       // overridden by this one.
 
-      ConfigDescription configWithoutSdk = config;
-      configWithoutSdk.sdkVersion = 0;
+      ConfigDescription config_without_sdk = config.CopyWithoutSdkVersion();
       auto pred = [&](const std::unique_ptr<ResourceConfigValue>& val) -> bool {
         // Check that the value hasn't already been marked for removal.
         if (!val) {
@@ -94,16 +94,16 @@ static void collapseVersions(int minSdk, ResourceEntry* entry) {
         }
 
         // Only return Configs that differ in SDK version.
-        configWithoutSdk.sdkVersion = val->config.sdkVersion;
-        return configWithoutSdk == val->config &&
-               val->config.sdkVersion <= minSdk;
+        config_without_sdk.sdkVersion = val->config.sdkVersion;
+        return config_without_sdk == val->config &&
+               val->config.sdkVersion <= min_sdk;
       };
 
       // Remove the rest that match.
-      auto filterIter =
-          makeFilterIterator(iter + 1, entry->values.rend(), pred);
-      while (filterIter.hasNext()) {
-        filterIter.next() = {};
+      auto filter_iter =
+          make_filter_iterator(iter + 1, entry->values.rend(), pred);
+      while (filter_iter.HasNext()) {
+        filter_iter.Next() = {};
       }
     }
   }
@@ -121,16 +121,16 @@ static void collapseVersions(int minSdk, ResourceEntry* entry) {
   // struct
   // and take up less space in the resources.arsc table.
   bool modified = false;
-  for (std::unique_ptr<ResourceConfigValue>& configValue : entry->values) {
-    if (configValue->config.sdkVersion != 0 &&
-        configValue->config.sdkVersion <= minSdk) {
+  for (std::unique_ptr<ResourceConfigValue>& config_value : entry->values) {
+    if (config_value->config.sdkVersion != 0 &&
+        config_value->config.sdkVersion <= min_sdk) {
       // Override the resource with a Configuration without an SDK.
-      std::unique_ptr<ResourceConfigValue> newValue =
+      std::unique_ptr<ResourceConfigValue> new_value =
           util::make_unique<ResourceConfigValue>(
-              configValue->config.copyWithoutSdkVersion(),
-              configValue->product);
-      newValue->value = std::move(configValue->value);
-      configValue = std::move(newValue);
+              config_value->config.CopyWithoutSdkVersion(),
+              config_value->product);
+      new_value->value = std::move(config_value->value);
+      config_value = std::move(new_value);
 
       modified = true;
     }
@@ -138,8 +138,7 @@ static void collapseVersions(int minSdk, ResourceEntry* entry) {
 
   if (modified) {
     // We've modified the keys (ConfigDescription) by changing the sdkVersion to
-    // 0.
-    // We MUST re-sort to ensure ordering guarantees hold.
+    // 0. We MUST re-sort to ensure ordering guarantees hold.
     std::sort(entry->values.begin(), entry->values.end(),
               [](const std::unique_ptr<ResourceConfigValue>& a,
                  const std::unique_ptr<ResourceConfigValue>& b) -> bool {
@@ -148,12 +147,12 @@ static void collapseVersions(int minSdk, ResourceEntry* entry) {
   }
 }
 
-bool VersionCollapser::consume(IAaptContext* context, ResourceTable* table) {
-  const int minSdk = context->getMinSdkVersion();
+bool VersionCollapser::Consume(IAaptContext* context, ResourceTable* table) {
+  const int min_sdk = context->GetMinSdkVersion();
   for (auto& package : table->packages) {
     for (auto& type : package->types) {
       for (auto& entry : type->entries) {
-        collapseVersions(minSdk, entry.get());
+        CollapseVersions(min_sdk, entry.get());
       }
     }
   }
diff --git a/tools/aapt2/link/VersionCollapser_test.cpp b/tools/aapt2/link/VersionCollapser_test.cpp
index c0e0ddb2d318f..1b5592f717d91 100644
--- a/tools/aapt2/link/VersionCollapser_test.cpp
+++ b/tools/aapt2/link/VersionCollapser_test.cpp
@@ -15,103 +15,103 @@
  */
 
 #include "link/Linkers.h"
+
 #include "test/Test.h"
 
 namespace aapt {
 
-template <typename T>
-using uptr = std::unique_ptr<T>;
-
-static uptr<ResourceTable> buildTableWithConfigs(
+static std::unique_ptr<ResourceTable> BuildTableWithConfigs(
     const StringPiece& name, std::initializer_list<std::string> list) {
   test::ResourceTableBuilder builder;
   for (const std::string& item : list) {
-    builder.addSimple(name, test::parseConfigOrDie(item));
+    builder.AddSimple(name, test::ParseConfigOrDie(item));
   }
-  return builder.build();
+  return builder.Build();
 }
 
 TEST(VersionCollapserTest, CollapseVersions) {
-  uptr<IAaptContext> context =
-      test::ContextBuilder().setMinSdkVersion(7).build();
+  std::unique_ptr<IAaptContext> context =
+      test::ContextBuilder().SetMinSdkVersion(7).Build();
 
-  const StringPiece resName = "@android:string/foo";
+  const StringPiece res_name = "@android:string/foo";
 
-  uptr<ResourceTable> table = buildTableWithConfigs(
-      resName,
+  std::unique_ptr<ResourceTable> table = BuildTableWithConfigs(
+      res_name,
       {"land-v4", "land-v5", "sw600dp", "land-v6", "land-v14", "land-v21"});
 
   VersionCollapser collapser;
-  ASSERT_TRUE(collapser.consume(context.get(), table.get()));
+  ASSERT_TRUE(collapser.Consume(context.get(), table.get()));
 
   // These should be removed.
   EXPECT_EQ(nullptr,
-            test::getValueForConfig<Id>(table.get(), resName,
-                                        test::parseConfigOrDie("land-v4")));
+            test::GetValueForConfig<Id>(table.get(), res_name,
+                                        test::ParseConfigOrDie("land-v4")));
   EXPECT_EQ(nullptr,
-            test::getValueForConfig<Id>(table.get(), resName,
-                                        test::parseConfigOrDie("land-v5")));
+            test::GetValueForConfig<Id>(table.get(), res_name,
+                                        test::ParseConfigOrDie("land-v5")));
   // This one should be removed because it was renamed to 'land', with the
   // version dropped.
   EXPECT_EQ(nullptr,
-            test::getValueForConfig<Id>(table.get(), resName,
-                                        test::parseConfigOrDie("land-v6")));
+            test::GetValueForConfig<Id>(table.get(), res_name,
+                                        test::ParseConfigOrDie("land-v6")));
 
   // These should remain.
   EXPECT_NE(nullptr,
-            test::getValueForConfig<Id>(table.get(), resName,
-                                        test::parseConfigOrDie("sw600dp")));
+            test::GetValueForConfig<Id>(table.get(), res_name,
+                                        test::ParseConfigOrDie("sw600dp")));
 
   // 'land' should be present because it was renamed from 'land-v6'.
-  EXPECT_NE(nullptr, test::getValueForConfig<Id>(
-                         table.get(), resName, test::parseConfigOrDie("land")));
   EXPECT_NE(nullptr,
-            test::getValueForConfig<Id>(table.get(), resName,
-                                        test::parseConfigOrDie("land-v14")));
+            test::GetValueForConfig<Id>(table.get(), res_name,
+                                        test::ParseConfigOrDie("land")));
   EXPECT_NE(nullptr,
-            test::getValueForConfig<Id>(table.get(), resName,
-                                        test::parseConfigOrDie("land-v21")));
+            test::GetValueForConfig<Id>(table.get(), res_name,
+                                        test::ParseConfigOrDie("land-v14")));
+  EXPECT_NE(nullptr,
+            test::GetValueForConfig<Id>(table.get(), res_name,
+                                        test::ParseConfigOrDie("land-v21")));
 }
 
 TEST(VersionCollapserTest, CollapseVersionsWhenMinSdkIsHighest) {
-  uptr<IAaptContext> context =
-      test::ContextBuilder().setMinSdkVersion(21).build();
+  std::unique_ptr<IAaptContext> context =
+      test::ContextBuilder().SetMinSdkVersion(21).Build();
 
-  const StringPiece resName = "@android:string/foo";
+  const StringPiece res_name = "@android:string/foo";
 
-  uptr<ResourceTable> table = buildTableWithConfigs(
-      resName, {"land-v4", "land-v5", "sw600dp", "land-v6", "land-v14",
-                "land-v21", "land-v22"});
+  std::unique_ptr<ResourceTable> table = BuildTableWithConfigs(
+      res_name, {"land-v4", "land-v5", "sw600dp", "land-v6", "land-v14",
+                 "land-v21", "land-v22"});
   VersionCollapser collapser;
-  ASSERT_TRUE(collapser.consume(context.get(), table.get()));
+  ASSERT_TRUE(collapser.Consume(context.get(), table.get()));
 
   // These should all be removed.
   EXPECT_EQ(nullptr,
-            test::getValueForConfig<Id>(table.get(), resName,
-                                        test::parseConfigOrDie("land-v4")));
+            test::GetValueForConfig<Id>(table.get(), res_name,
+                                        test::ParseConfigOrDie("land-v4")));
   EXPECT_EQ(nullptr,
-            test::getValueForConfig<Id>(table.get(), resName,
-                                        test::parseConfigOrDie("land-v5")));
+            test::GetValueForConfig<Id>(table.get(), res_name,
+                                        test::ParseConfigOrDie("land-v5")));
   EXPECT_EQ(nullptr,
-            test::getValueForConfig<Id>(table.get(), resName,
-                                        test::parseConfigOrDie("land-v6")));
+            test::GetValueForConfig<Id>(table.get(), res_name,
+                                        test::ParseConfigOrDie("land-v6")));
   EXPECT_EQ(nullptr,
-            test::getValueForConfig<Id>(table.get(), resName,
-                                        test::parseConfigOrDie("land-v14")));
+            test::GetValueForConfig<Id>(table.get(), res_name,
+                                        test::ParseConfigOrDie("land-v14")));
 
   // These should remain.
   EXPECT_NE(nullptr,
-            test::getValueForConfig<Id>(
-                table.get(), resName,
-                test::parseConfigOrDie("sw600dp").copyWithoutSdkVersion()));
+            test::GetValueForConfig<Id>(
+                table.get(), res_name,
+                test::ParseConfigOrDie("sw600dp").CopyWithoutSdkVersion()));
 
   // land-v21 should have been converted to land.
-  EXPECT_NE(nullptr, test::getValueForConfig<Id>(
-                         table.get(), resName, test::parseConfigOrDie("land")));
+  EXPECT_NE(nullptr,
+            test::GetValueForConfig<Id>(table.get(), res_name,
+                                        test::ParseConfigOrDie("land")));
   // land-v22 should remain as-is.
   EXPECT_NE(nullptr,
-            test::getValueForConfig<Id>(table.get(), resName,
-                                        test::parseConfigOrDie("land-v22")));
+            test::GetValueForConfig<Id>(table.get(), res_name,
+                                        test::ParseConfigOrDie("land-v22")));
 }
 
 }  // namespace aapt
diff --git a/tools/aapt2/link/XmlNamespaceRemover.cpp b/tools/aapt2/link/XmlNamespaceRemover.cpp
index 6e8d80d04e745..24aa5660ae309 100644
--- a/tools/aapt2/link/XmlNamespaceRemover.cpp
+++ b/tools/aapt2/link/XmlNamespaceRemover.cpp
@@ -14,11 +14,12 @@
  * limitations under the License.
  */
 
-#include "ResourceTable.h"
 #include "link/Linkers.h"
 
 #include <algorithm>
 
+#include "ResourceTable.h"
+
 namespace aapt {
 
 namespace {
@@ -28,12 +29,12 @@ namespace {
  */
 class XmlVisitor : public xml::Visitor {
  public:
-  XmlVisitor(bool keepUris) : mKeepUris(keepUris) {}
+  explicit XmlVisitor(bool keep_uris) : keep_uris_(keep_uris) {}
 
-  void visit(xml::Element* el) override {
+  void Visit(xml::Element* el) override {
     // Strip namespaces
     for (auto& child : el->children) {
-      while (child && xml::nodeCast<xml::Namespace>(child.get())) {
+      while (child && xml::NodeCast<xml::Namespace>(child.get())) {
         if (child->children.empty()) {
           child = {};
         } else {
@@ -49,36 +50,38 @@ class XmlVisitor : public xml::Visitor {
                        }),
         el->children.end());
 
-    if (!mKeepUris) {
+    if (!keep_uris_) {
       for (xml::Attribute& attr : el->attributes) {
-        attr.namespaceUri = std::string();
+        attr.namespace_uri = std::string();
       }
-      el->namespaceUri = std::string();
+      el->namespace_uri = std::string();
     }
-    xml::Visitor::visit(el);
+    xml::Visitor::Visit(el);
   }
 
  private:
-  bool mKeepUris;
+  DISALLOW_COPY_AND_ASSIGN(XmlVisitor);
+
+  bool keep_uris_;
 };
 
 }  // namespace
 
-bool XmlNamespaceRemover::consume(IAaptContext* context,
+bool XmlNamespaceRemover::Consume(IAaptContext* context,
                                   xml::XmlResource* resource) {
   if (!resource->root) {
     return false;
   }
   // Replace any root namespaces until the root is a non-namespace node
-  while (xml::nodeCast<xml::Namespace>(resource->root.get())) {
+  while (xml::NodeCast<xml::Namespace>(resource->root.get())) {
     if (resource->root->children.empty()) {
       break;
     }
     resource->root = std::move(resource->root->children.front());
     resource->root->parent = nullptr;
   }
-  XmlVisitor visitor(mKeepUris);
-  resource->root->accept(&visitor);
+  XmlVisitor visitor(keep_uris_);
+  resource->root->Accept(&visitor);
   return true;
 }
 
diff --git a/tools/aapt2/link/XmlNamespaceRemover_test.cpp b/tools/aapt2/link/XmlNamespaceRemover_test.cpp
index d2daaeeca7db8..a176c03a64325 100644
--- a/tools/aapt2/link/XmlNamespaceRemover_test.cpp
+++ b/tools/aapt2/link/XmlNamespaceRemover_test.cpp
@@ -15,83 +15,94 @@
  */
 
 #include "link/Linkers.h"
+
 #include "test/Test.h"
 
 namespace aapt {
 
 class XmlUriTestVisitor : public xml::Visitor {
  public:
-  void visit(xml::Element* el) override {
+  XmlUriTestVisitor() = default;
+
+  void Visit(xml::Element* el) override {
     for (const auto& attr : el->attributes) {
-      EXPECT_EQ(std::string(), attr.namespaceUri);
+      EXPECT_EQ(std::string(), attr.namespace_uri);
     }
-    EXPECT_EQ(std::string(), el->namespaceUri);
-    xml::Visitor::visit(el);
+    EXPECT_EQ(std::string(), el->namespace_uri);
+    xml::Visitor::Visit(el);
   }
 
-  void visit(xml::Namespace* ns) override {
-    EXPECT_EQ(std::string(), ns->namespaceUri);
-    xml::Visitor::visit(ns);
+  void Visit(xml::Namespace* ns) override {
+    EXPECT_EQ(std::string(), ns->namespace_uri);
+    xml::Visitor::Visit(ns);
   }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(XmlUriTestVisitor);
 };
 
 class XmlNamespaceTestVisitor : public xml::Visitor {
  public:
-  void visit(xml::Namespace* ns) override {
-    ADD_FAILURE() << "Detected namespace: " << ns->namespacePrefix << "=\""
-                  << ns->namespaceUri << "\"";
-    xml::Visitor::visit(ns);
+  XmlNamespaceTestVisitor() = default;
+
+  void Visit(xml::Namespace* ns) override {
+    ADD_FAILURE() << "Detected namespace: " << ns->namespace_prefix << "=\""
+                  << ns->namespace_uri << "\"";
+    xml::Visitor::Visit(ns);
   }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(XmlNamespaceTestVisitor);
 };
 
 class XmlNamespaceRemoverTest : public ::testing::Test {
  public:
   void SetUp() override {
-    mContext =
-        test::ContextBuilder().setCompilationPackage("com.app.test").build();
+    context_ =
+        test::ContextBuilder().SetCompilationPackage("com.app.test").Build();
   }
 
  protected:
-  std::unique_ptr<IAaptContext> mContext;
+  std::unique_ptr<IAaptContext> context_;
 };
 
 TEST_F(XmlNamespaceRemoverTest, RemoveUris) {
   std::unique_ptr<xml::XmlResource> doc =
-      test::buildXmlDomForPackageName(mContext.get(), R"EOF(
+      test::BuildXmlDomForPackageName(context_.get(), R"EOF(
             <View xmlns:android="http://schemas.android.com/apk/res/android"
                   android:text="hello" />)EOF");
 
   XmlNamespaceRemover remover;
-  ASSERT_TRUE(remover.consume(mContext.get(), doc.get()));
+  ASSERT_TRUE(remover.Consume(context_.get(), doc.get()));
 
   xml::Node* root = doc.get()->root.get();
   ASSERT_NE(root, nullptr);
 
   XmlUriTestVisitor visitor;
-  root->accept(&visitor);
+  root->Accept(&visitor);
 }
 
 TEST_F(XmlNamespaceRemoverTest, RemoveNamespaces) {
   std::unique_ptr<xml::XmlResource> doc =
-      test::buildXmlDomForPackageName(mContext.get(), R"EOF(
+      test::BuildXmlDomForPackageName(context_.get(), R"EOF(
             <View xmlns:android="http://schemas.android.com/apk/res/android"
                   xmlns:foo="http://schemas.android.com/apk/res/foo"
                   foo:bar="foobar"
                   android:text="hello" />)EOF");
 
   XmlNamespaceRemover remover;
-  ASSERT_TRUE(remover.consume(mContext.get(), doc.get()));
+  ASSERT_TRUE(remover.Consume(context_.get(), doc.get()));
 
   xml::Node* root = doc.get()->root.get();
   ASSERT_NE(root, nullptr);
 
   XmlNamespaceTestVisitor visitor;
-  root->accept(&visitor);
+  root->Accept(&visitor);
 }
 
 TEST_F(XmlNamespaceRemoverTest, RemoveNestedNamespaces) {
   std::unique_ptr<xml::XmlResource> doc =
-      test::buildXmlDomForPackageName(mContext.get(), R"EOF(
+      test::BuildXmlDomForPackageName(context_.get(), R"EOF(
             <View xmlns:android="http://schemas.android.com/apk/res/android"
                   android:text="hello">
               <View xmlns:foo="http://schemas.example.com/foo"
@@ -99,13 +110,13 @@ TEST_F(XmlNamespaceRemoverTest, RemoveNestedNamespaces) {
             </View>)EOF");
 
   XmlNamespaceRemover remover;
-  ASSERT_TRUE(remover.consume(mContext.get(), doc.get()));
+  ASSERT_TRUE(remover.Consume(context_.get(), doc.get()));
 
   xml::Node* root = doc.get()->root.get();
   ASSERT_NE(root, nullptr);
 
   XmlNamespaceTestVisitor visitor;
-  root->accept(&visitor);
+  root->Accept(&visitor);
 }
 
 }  // namespace aapt
diff --git a/tools/aapt2/link/XmlReferenceLinker.cpp b/tools/aapt2/link/XmlReferenceLinker.cpp
index 945f98a955772..a8198318b69eb 100644
--- a/tools/aapt2/link/XmlReferenceLinker.cpp
+++ b/tools/aapt2/link/XmlReferenceLinker.cpp
@@ -14,10 +14,11 @@
  * limitations under the License.
  */
 
+#include "link/Linkers.h"
+
 #include "Diagnostics.h"
 #include "ResourceUtils.h"
 #include "SdkConstants.h"
-#include "link/Linkers.h"
 #include "link/ReferenceLinker.h"
 #include "process/IResourceTableConsumer.h"
 #include "process/SymbolTable.h"
@@ -37,31 +38,33 @@ namespace {
  */
 class ReferenceVisitor : public ValueVisitor {
  public:
-  using ValueVisitor::visit;
+  using ValueVisitor::Visit;
 
   ReferenceVisitor(IAaptContext* context, SymbolTable* symbols,
-                   xml::IPackageDeclStack* decls, CallSite* callSite)
-      : mContext(context),
-        mSymbols(symbols),
-        mDecls(decls),
-        mCallSite(callSite),
-        mError(false) {}
+                   xml::IPackageDeclStack* decls, CallSite* callsite)
+      : context_(context),
+        symbols_(symbols),
+        decls_(decls),
+        callsite_(callsite),
+        error_(false) {}
 
-  void visit(Reference* ref) override {
-    if (!ReferenceLinker::linkReference(ref, mContext, mSymbols, mDecls,
-                                        mCallSite)) {
-      mError = true;
+  void Visit(Reference* ref) override {
+    if (!ReferenceLinker::LinkReference(ref, context_, symbols_, decls_,
+                                        callsite_)) {
+      error_ = true;
     }
   }
 
-  bool hasError() const { return mError; }
+  bool HasError() const { return error_; }
 
  private:
-  IAaptContext* mContext;
-  SymbolTable* mSymbols;
-  xml::IPackageDeclStack* mDecls;
-  CallSite* mCallSite;
-  bool mError;
+  DISALLOW_COPY_AND_ASSIGN(ReferenceVisitor);
+
+  IAaptContext* context_;
+  SymbolTable* symbols_;
+  xml::IPackageDeclStack* decls_;
+  CallSite* callsite_;
+  bool error_;
 };
 
 /**
@@ -69,114 +72,117 @@ class ReferenceVisitor : public ValueVisitor {
  */
 class XmlVisitor : public xml::PackageAwareVisitor {
  public:
-  using xml::PackageAwareVisitor::visit;
+  using xml::PackageAwareVisitor::Visit;
 
   XmlVisitor(IAaptContext* context, SymbolTable* symbols, const Source& source,
-             std::set<int>* sdkLevelsFound, CallSite* callSite)
-      : mContext(context),
-        mSymbols(symbols),
-        mSource(source),
-        mSdkLevelsFound(sdkLevelsFound),
-        mCallSite(callSite),
-        mReferenceVisitor(context, symbols, this, callSite) {}
+             std::set<int>* sdk_levels_found, CallSite* callsite)
+      : context_(context),
+        symbols_(symbols),
+        source_(source),
+        sdk_levels_found_(sdk_levels_found),
+        callsite_(callsite),
+        reference_visitor_(context, symbols, this, callsite) {}
 
-  void visit(xml::Element* el) override {
-    const Source source = mSource.withLine(el->lineNumber);
+  void Visit(xml::Element* el) override {
+    const Source source = source_.WithLine(el->line_number);
     for (xml::Attribute& attr : el->attributes) {
-      Maybe<xml::ExtractedPackage> maybePackage =
-          xml::extractPackageFromNamespace(attr.namespaceUri);
-      if (maybePackage) {
+      Maybe<xml::ExtractedPackage> maybe_package =
+          xml::ExtractPackageFromNamespace(attr.namespace_uri);
+      if (maybe_package) {
         // There is a valid package name for this attribute. We will look this
         // up.
-        StringPiece package = maybePackage.value().package;
+        StringPiece package = maybe_package.value().package;
         if (package.empty()) {
           // Empty package means the 'current' or 'local' package.
-          package = mContext->getCompilationPackage();
+          package = context_->GetCompilationPackage();
         }
 
-        Reference attrRef(
+        Reference attr_ref(
             ResourceNameRef(package, ResourceType::kAttr, attr.name));
-        attrRef.privateReference = maybePackage.value().privateNamespace;
+        attr_ref.private_reference = maybe_package.value().private_namespace;
 
-        std::string errStr;
-        attr.compiledAttribute = ReferenceLinker::compileXmlAttribute(
-            attrRef, mContext->getNameMangler(), mSymbols, mCallSite, &errStr);
+        std::string err_str;
+        attr.compiled_attribute = ReferenceLinker::CompileXmlAttribute(
+            attr_ref, context_->GetNameMangler(), symbols_, callsite_,
+            &err_str);
 
         // Convert the string value into a compiled Value if this is a valid
         // attribute.
-        if (attr.compiledAttribute) {
-          if (attr.compiledAttribute.value().id) {
+        if (attr.compiled_attribute) {
+          if (attr.compiled_attribute.value().id) {
             // Record all SDK levels from which the attributes were defined.
-            const size_t sdkLevel = findAttributeSdkLevel(
-                attr.compiledAttribute.value().id.value());
-            if (sdkLevel > 1) {
-              mSdkLevelsFound->insert(sdkLevel);
+            const size_t sdk_level = FindAttributeSdkLevel(
+                attr.compiled_attribute.value().id.value());
+            if (sdk_level > 1) {
+              sdk_levels_found_->insert(sdk_level);
             }
           }
 
           const Attribute* attribute =
-              &attr.compiledAttribute.value().attribute;
-          attr.compiledValue =
-              ResourceUtils::tryParseItemForAttribute(attr.value, attribute);
-          if (!attr.compiledValue &&
-              !(attribute->typeMask & android::ResTable_map::TYPE_STRING)) {
+              &attr.compiled_attribute.value().attribute;
+          attr.compiled_value =
+              ResourceUtils::TryParseItemForAttribute(attr.value, attribute);
+          if (!attr.compiled_value &&
+              !(attribute->type_mask & android::ResTable_map::TYPE_STRING)) {
             // We won't be able to encode this as a string.
-            mContext->getDiagnostics()->error(
+            context_->GetDiagnostics()->Error(
                 DiagMessage(source) << "'" << attr.value << "' "
                                     << "is incompatible with attribute "
                                     << package << ":" << attr.name << " "
                                     << *attribute);
-            mError = true;
+            error_ = true;
           }
 
         } else {
-          mContext->getDiagnostics()->error(DiagMessage(source)
+          context_->GetDiagnostics()->Error(DiagMessage(source)
                                             << "attribute '" << package << ":"
-                                            << attr.name << "' " << errStr);
-          mError = true;
+                                            << attr.name << "' " << err_str);
+          error_ = true;
         }
-      } else if (!attr.compiledValue) {
+      } else if (!attr.compiled_value) {
         // We still encode references, but only if we haven't manually set this
         // to
         // another compiled value.
-        attr.compiledValue = ResourceUtils::tryParseReference(attr.value);
+        attr.compiled_value = ResourceUtils::TryParseReference(attr.value);
       }
 
-      if (attr.compiledValue) {
+      if (attr.compiled_value) {
         // With a compiledValue, we must resolve the reference and assign it an
         // ID.
-        attr.compiledValue->setSource(source);
-        attr.compiledValue->accept(&mReferenceVisitor);
+        attr.compiled_value->SetSource(source);
+        attr.compiled_value->Accept(&reference_visitor_);
       }
     }
 
     // Call the super implementation.
-    xml::PackageAwareVisitor::visit(el);
+    xml::PackageAwareVisitor::Visit(el);
   }
 
-  bool hasError() { return mError || mReferenceVisitor.hasError(); }
+  bool HasError() { return error_ || reference_visitor_.HasError(); }
 
  private:
-  IAaptContext* mContext;
-  SymbolTable* mSymbols;
-  Source mSource;
-  std::set<int>* mSdkLevelsFound;
-  CallSite* mCallSite;
-  ReferenceVisitor mReferenceVisitor;
-  bool mError = false;
+  DISALLOW_COPY_AND_ASSIGN(XmlVisitor);
+
+  IAaptContext* context_;
+  SymbolTable* symbols_;
+  Source source_;
+  std::set<int>* sdk_levels_found_;
+  CallSite* callsite_;
+  ReferenceVisitor reference_visitor_;
+  bool error_ = false;
 };
 
 }  // namespace
 
-bool XmlReferenceLinker::consume(IAaptContext* context,
+bool XmlReferenceLinker::Consume(IAaptContext* context,
                                  xml::XmlResource* resource) {
-  mSdkLevelsFound.clear();
-  CallSite callSite = {resource->file.name};
-  XmlVisitor visitor(context, context->getExternalSymbols(),
-                     resource->file.source, &mSdkLevelsFound, &callSite);
+  sdk_levels_found_.clear();
+  CallSite callsite = {resource->file.name};
+  XmlVisitor visitor(context, context->GetExternalSymbols(),
+                     resource->file.source, &sdk_levels_found_, &callsite);
   if (resource->root) {
-    resource->root->accept(&visitor);
-    return !visitor.hasError();
+    resource->root->Accept(&visitor);
+    return !visitor.HasError();
   }
   return false;
 }
diff --git a/tools/aapt2/link/XmlReferenceLinker_test.cpp b/tools/aapt2/link/XmlReferenceLinker_test.cpp
index 35d479f48569f..810f63c0410ef 100644
--- a/tools/aapt2/link/XmlReferenceLinker_test.cpp
+++ b/tools/aapt2/link/XmlReferenceLinker_test.cpp
@@ -15,6 +15,7 @@
  */
 
 #include "link/Linkers.h"
+
 #include "test/Test.h"
 
 namespace aapt {
@@ -22,72 +23,72 @@ namespace aapt {
 class XmlReferenceLinkerTest : public ::testing::Test {
  public:
   void SetUp() override {
-    mContext =
+    context_ =
         test::ContextBuilder()
-            .setCompilationPackage("com.app.test")
-            .setNameManglerPolicy(
+            .SetCompilationPackage("com.app.test")
+            .SetNameManglerPolicy(
                 NameManglerPolicy{"com.app.test", {"com.android.support"}})
-            .addSymbolSource(
+            .AddSymbolSource(
                 test::StaticSymbolSourceBuilder()
-                    .addPublicSymbol(
+                    .AddPublicSymbol(
                         "android:attr/layout_width", ResourceId(0x01010000),
                         test::AttributeBuilder()
-                            .setTypeMask(android::ResTable_map::TYPE_ENUM |
+                            .SetTypeMask(android::ResTable_map::TYPE_ENUM |
                                          android::ResTable_map::TYPE_DIMENSION)
-                            .addItem("match_parent", 0xffffffff)
-                            .build())
-                    .addPublicSymbol(
+                            .AddItem("match_parent", 0xffffffff)
+                            .Build())
+                    .AddPublicSymbol(
                         "android:attr/background", ResourceId(0x01010001),
                         test::AttributeBuilder()
-                            .setTypeMask(android::ResTable_map::TYPE_COLOR)
-                            .build())
-                    .addPublicSymbol("android:attr/attr",
+                            .SetTypeMask(android::ResTable_map::TYPE_COLOR)
+                            .Build())
+                    .AddPublicSymbol("android:attr/attr",
                                      ResourceId(0x01010002),
-                                     test::AttributeBuilder().build())
-                    .addPublicSymbol(
+                                     test::AttributeBuilder().Build())
+                    .AddPublicSymbol(
                         "android:attr/text", ResourceId(0x01010003),
                         test::AttributeBuilder()
-                            .setTypeMask(android::ResTable_map::TYPE_STRING)
-                            .build())
+                            .SetTypeMask(android::ResTable_map::TYPE_STRING)
+                            .Build())
 
                     // Add one real symbol that was introduces in v21
-                    .addPublicSymbol("android:attr/colorAccent",
+                    .AddPublicSymbol("android:attr/colorAccent",
                                      ResourceId(0x01010435),
-                                     test::AttributeBuilder().build())
+                                     test::AttributeBuilder().Build())
 
                     // Private symbol.
-                    .addSymbol("android:color/hidden", ResourceId(0x01020001))
+                    .AddSymbol("android:color/hidden", ResourceId(0x01020001))
 
-                    .addPublicSymbol("android:id/id", ResourceId(0x01030000))
-                    .addSymbol("com.app.test:id/id", ResourceId(0x7f030000))
-                    .addSymbol("com.app.test:color/green",
+                    .AddPublicSymbol("android:id/id", ResourceId(0x01030000))
+                    .AddSymbol("com.app.test:id/id", ResourceId(0x7f030000))
+                    .AddSymbol("com.app.test:color/green",
                                ResourceId(0x7f020000))
-                    .addSymbol("com.app.test:color/red", ResourceId(0x7f020001))
-                    .addSymbol(
+                    .AddSymbol("com.app.test:color/red", ResourceId(0x7f020001))
+                    .AddSymbol(
                         "com.app.test:attr/colorAccent", ResourceId(0x7f010000),
                         test::AttributeBuilder()
-                            .setTypeMask(android::ResTable_map::TYPE_COLOR)
-                            .build())
-                    .addPublicSymbol(
+                            .SetTypeMask(android::ResTable_map::TYPE_COLOR)
+                            .Build())
+                    .AddPublicSymbol(
                         "com.app.test:attr/com.android.support$colorAccent",
                         ResourceId(0x7f010001),
                         test::AttributeBuilder()
-                            .setTypeMask(android::ResTable_map::TYPE_COLOR)
-                            .build())
-                    .addPublicSymbol("com.app.test:attr/attr",
+                            .SetTypeMask(android::ResTable_map::TYPE_COLOR)
+                            .Build())
+                    .AddPublicSymbol("com.app.test:attr/attr",
                                      ResourceId(0x7f010002),
-                                     test::AttributeBuilder().build())
-                    .build())
-            .build();
+                                     test::AttributeBuilder().Build())
+                    .Build())
+            .Build();
   }
 
  protected:
-  std::unique_ptr<IAaptContext> mContext;
+  std::unique_ptr<IAaptContext> context_;
 };
 
 TEST_F(XmlReferenceLinkerTest, LinkBasicAttributes) {
   std::unique_ptr<xml::XmlResource> doc =
-      test::buildXmlDomForPackageName(mContext.get(), R"EOF(
+      test::BuildXmlDomForPackageName(context_.get(), R"EOF(
         <View xmlns:android="http://schemas.android.com/apk/res/android"
               android:layout_width="match_parent"
               android:background="@color/green"
@@ -95,123 +96,125 @@ TEST_F(XmlReferenceLinkerTest, LinkBasicAttributes) {
               class="hello" />)EOF");
 
   XmlReferenceLinker linker;
-  ASSERT_TRUE(linker.consume(mContext.get(), doc.get()));
+  ASSERT_TRUE(linker.Consume(context_.get(), doc.get()));
 
-  xml::Element* viewEl = xml::findRootElement(doc.get());
-  ASSERT_NE(viewEl, nullptr);
+  xml::Element* view_el = xml::FindRootElement(doc.get());
+  ASSERT_NE(view_el, nullptr);
 
-  xml::Attribute* xmlAttr =
-      viewEl->findAttribute(xml::kSchemaAndroid, "layout_width");
-  ASSERT_NE(xmlAttr, nullptr);
-  AAPT_ASSERT_TRUE(xmlAttr->compiledAttribute);
-  AAPT_ASSERT_TRUE(xmlAttr->compiledAttribute.value().id);
-  EXPECT_EQ(xmlAttr->compiledAttribute.value().id.value(),
+  xml::Attribute* xml_attr =
+      view_el->FindAttribute(xml::kSchemaAndroid, "layout_width");
+  ASSERT_NE(xml_attr, nullptr);
+  AAPT_ASSERT_TRUE(xml_attr->compiled_attribute);
+  AAPT_ASSERT_TRUE(xml_attr->compiled_attribute.value().id);
+  EXPECT_EQ(xml_attr->compiled_attribute.value().id.value(),
             ResourceId(0x01010000));
-  ASSERT_NE(xmlAttr->compiledValue, nullptr);
-  ASSERT_NE(valueCast<BinaryPrimitive>(xmlAttr->compiledValue.get()), nullptr);
+  ASSERT_NE(xml_attr->compiled_value, nullptr);
+  ASSERT_NE(ValueCast<BinaryPrimitive>(xml_attr->compiled_value.get()),
+            nullptr);
 
-  xmlAttr = viewEl->findAttribute(xml::kSchemaAndroid, "background");
-  ASSERT_NE(xmlAttr, nullptr);
-  AAPT_ASSERT_TRUE(xmlAttr->compiledAttribute);
-  AAPT_ASSERT_TRUE(xmlAttr->compiledAttribute.value().id);
-  EXPECT_EQ(xmlAttr->compiledAttribute.value().id.value(),
+  xml_attr = view_el->FindAttribute(xml::kSchemaAndroid, "background");
+  ASSERT_NE(xml_attr, nullptr);
+  AAPT_ASSERT_TRUE(xml_attr->compiled_attribute);
+  AAPT_ASSERT_TRUE(xml_attr->compiled_attribute.value().id);
+  EXPECT_EQ(xml_attr->compiled_attribute.value().id.value(),
             ResourceId(0x01010001));
-  ASSERT_NE(xmlAttr->compiledValue, nullptr);
-  Reference* ref = valueCast<Reference>(xmlAttr->compiledValue.get());
+  ASSERT_NE(xml_attr->compiled_value, nullptr);
+  Reference* ref = ValueCast<Reference>(xml_attr->compiled_value.get());
   ASSERT_NE(ref, nullptr);
   AAPT_ASSERT_TRUE(ref->name);
   EXPECT_EQ(ref->name.value(),
-            test::parseNameOrDie("color/green"));  // Make sure the name
+            test::ParseNameOrDie("color/green"));  // Make sure the name
                                                    // didn't change.
   AAPT_ASSERT_TRUE(ref->id);
   EXPECT_EQ(ref->id.value(), ResourceId(0x7f020000));
 
-  xmlAttr = viewEl->findAttribute(xml::kSchemaAndroid, "text");
-  ASSERT_NE(xmlAttr, nullptr);
-  AAPT_ASSERT_TRUE(xmlAttr->compiledAttribute);
+  xml_attr = view_el->FindAttribute(xml::kSchemaAndroid, "text");
+  ASSERT_NE(xml_attr, nullptr);
+  AAPT_ASSERT_TRUE(xml_attr->compiled_attribute);
   ASSERT_FALSE(
-      xmlAttr->compiledValue);  // Strings don't get compiled for memory sake.
+      xml_attr->compiled_value);  // Strings don't get compiled for memory sake.
 
-  xmlAttr = viewEl->findAttribute("", "class");
-  ASSERT_NE(xmlAttr, nullptr);
-  AAPT_ASSERT_FALSE(xmlAttr->compiledAttribute);
-  ASSERT_EQ(xmlAttr->compiledValue, nullptr);
+  xml_attr = view_el->FindAttribute("", "class");
+  ASSERT_NE(xml_attr, nullptr);
+  AAPT_ASSERT_FALSE(xml_attr->compiled_attribute);
+  ASSERT_EQ(xml_attr->compiled_value, nullptr);
 }
 
 TEST_F(XmlReferenceLinkerTest, PrivateSymbolsAreNotLinked) {
   std::unique_ptr<xml::XmlResource> doc =
-      test::buildXmlDomForPackageName(mContext.get(), R"EOF(
+      test::BuildXmlDomForPackageName(context_.get(), R"EOF(
         <View xmlns:android="http://schemas.android.com/apk/res/android"
               android:colorAccent="@android:color/hidden" />)EOF");
 
   XmlReferenceLinker linker;
-  ASSERT_FALSE(linker.consume(mContext.get(), doc.get()));
+  ASSERT_FALSE(linker.Consume(context_.get(), doc.get()));
 }
 
 TEST_F(XmlReferenceLinkerTest,
        PrivateSymbolsAreLinkedWhenReferenceHasStarPrefix) {
   std::unique_ptr<xml::XmlResource> doc =
-      test::buildXmlDomForPackageName(mContext.get(), R"EOF(
+      test::BuildXmlDomForPackageName(context_.get(), R"EOF(
     <View xmlns:android="http://schemas.android.com/apk/res/android"
           android:colorAccent="@*android:color/hidden" />)EOF");
 
   XmlReferenceLinker linker;
-  ASSERT_TRUE(linker.consume(mContext.get(), doc.get()));
+  ASSERT_TRUE(linker.Consume(context_.get(), doc.get()));
 }
 
 TEST_F(XmlReferenceLinkerTest, SdkLevelsAreRecorded) {
   std::unique_ptr<xml::XmlResource> doc =
-      test::buildXmlDomForPackageName(mContext.get(), R"EOF(
+      test::BuildXmlDomForPackageName(context_.get(), R"EOF(
         <View xmlns:android="http://schemas.android.com/apk/res/android"
               android:colorAccent="#ffffff" />)EOF");
 
   XmlReferenceLinker linker;
-  ASSERT_TRUE(linker.consume(mContext.get(), doc.get()));
-  EXPECT_TRUE(linker.getSdkLevels().count(21) == 1);
+  ASSERT_TRUE(linker.Consume(context_.get(), doc.get()));
+  EXPECT_TRUE(linker.sdk_levels().count(21) == 1);
 }
 
 TEST_F(XmlReferenceLinkerTest, LinkMangledAttributes) {
   std::unique_ptr<xml::XmlResource> doc =
-      test::buildXmlDomForPackageName(mContext.get(), R"EOF(
+      test::BuildXmlDomForPackageName(context_.get(), R"EOF(
             <View xmlns:support="http://schemas.android.com/apk/res/com.android.support"
                   support:colorAccent="#ff0000" />)EOF");
 
   XmlReferenceLinker linker;
-  ASSERT_TRUE(linker.consume(mContext.get(), doc.get()));
+  ASSERT_TRUE(linker.Consume(context_.get(), doc.get()));
 
-  xml::Element* viewEl = xml::findRootElement(doc.get());
-  ASSERT_NE(viewEl, nullptr);
+  xml::Element* view_el = xml::FindRootElement(doc.get());
+  ASSERT_NE(view_el, nullptr);
 
-  xml::Attribute* xmlAttr = viewEl->findAttribute(
-      xml::buildPackageNamespace("com.android.support"), "colorAccent");
-  ASSERT_NE(xmlAttr, nullptr);
-  AAPT_ASSERT_TRUE(xmlAttr->compiledAttribute);
-  AAPT_ASSERT_TRUE(xmlAttr->compiledAttribute.value().id);
-  EXPECT_EQ(xmlAttr->compiledAttribute.value().id.value(),
+  xml::Attribute* xml_attr = view_el->FindAttribute(
+      xml::BuildPackageNamespace("com.android.support"), "colorAccent");
+  ASSERT_NE(xml_attr, nullptr);
+  AAPT_ASSERT_TRUE(xml_attr->compiled_attribute);
+  AAPT_ASSERT_TRUE(xml_attr->compiled_attribute.value().id);
+  EXPECT_EQ(xml_attr->compiled_attribute.value().id.value(),
             ResourceId(0x7f010001));
-  ASSERT_NE(valueCast<BinaryPrimitive>(xmlAttr->compiledValue.get()), nullptr);
+  ASSERT_NE(ValueCast<BinaryPrimitive>(xml_attr->compiled_value.get()),
+            nullptr);
 }
 
 TEST_F(XmlReferenceLinkerTest, LinkAutoResReference) {
   std::unique_ptr<xml::XmlResource> doc =
-      test::buildXmlDomForPackageName(mContext.get(), R"EOF(
+      test::BuildXmlDomForPackageName(context_.get(), R"EOF(
             <View xmlns:app="http://schemas.android.com/apk/res-auto"
                   app:colorAccent="@app:color/red" />)EOF");
 
   XmlReferenceLinker linker;
-  ASSERT_TRUE(linker.consume(mContext.get(), doc.get()));
+  ASSERT_TRUE(linker.Consume(context_.get(), doc.get()));
 
-  xml::Element* viewEl = xml::findRootElement(doc.get());
-  ASSERT_NE(viewEl, nullptr);
+  xml::Element* view_el = xml::FindRootElement(doc.get());
+  ASSERT_NE(view_el, nullptr);
 
-  xml::Attribute* xmlAttr =
-      viewEl->findAttribute(xml::kSchemaAuto, "colorAccent");
-  ASSERT_NE(xmlAttr, nullptr);
-  AAPT_ASSERT_TRUE(xmlAttr->compiledAttribute);
-  AAPT_ASSERT_TRUE(xmlAttr->compiledAttribute.value().id);
-  EXPECT_EQ(xmlAttr->compiledAttribute.value().id.value(),
+  xml::Attribute* xml_attr =
+      view_el->FindAttribute(xml::kSchemaAuto, "colorAccent");
+  ASSERT_NE(xml_attr, nullptr);
+  AAPT_ASSERT_TRUE(xml_attr->compiled_attribute);
+  AAPT_ASSERT_TRUE(xml_attr->compiled_attribute.value().id);
+  EXPECT_EQ(xml_attr->compiled_attribute.value().id.value(),
             ResourceId(0x7f010000));
-  Reference* ref = valueCast<Reference>(xmlAttr->compiledValue.get());
+  Reference* ref = ValueCast<Reference>(xml_attr->compiled_value.get());
   ASSERT_NE(ref, nullptr);
   AAPT_ASSERT_TRUE(ref->name);
   AAPT_ASSERT_TRUE(ref->id);
@@ -220,7 +223,7 @@ TEST_F(XmlReferenceLinkerTest, LinkAutoResReference) {
 
 TEST_F(XmlReferenceLinkerTest, LinkViewWithShadowedPackageAlias) {
   std::unique_ptr<xml::XmlResource> doc =
-      test::buildXmlDomForPackageName(mContext.get(), R"EOF(
+      test::BuildXmlDomForPackageName(context_.get(), R"EOF(
             <View xmlns:app="http://schemas.android.com/apk/res/android"
                   app:attr="@app:id/id">
               <View xmlns:app="http://schemas.android.com/apk/res/com.app.test"
@@ -228,38 +231,39 @@ TEST_F(XmlReferenceLinkerTest, LinkViewWithShadowedPackageAlias) {
             </View>)EOF");
 
   XmlReferenceLinker linker;
-  ASSERT_TRUE(linker.consume(mContext.get(), doc.get()));
+  ASSERT_TRUE(linker.Consume(context_.get(), doc.get()));
 
-  xml::Element* viewEl = xml::findRootElement(doc.get());
-  ASSERT_NE(viewEl, nullptr);
+  xml::Element* view_el = xml::FindRootElement(doc.get());
+  ASSERT_NE(view_el, nullptr);
 
   // All attributes and references in this element should be referring to
   // "android" (0x01).
-  xml::Attribute* xmlAttr = viewEl->findAttribute(xml::kSchemaAndroid, "attr");
-  ASSERT_NE(xmlAttr, nullptr);
-  AAPT_ASSERT_TRUE(xmlAttr->compiledAttribute);
-  AAPT_ASSERT_TRUE(xmlAttr->compiledAttribute.value().id);
-  EXPECT_EQ(xmlAttr->compiledAttribute.value().id.value(),
+  xml::Attribute* xml_attr =
+      view_el->FindAttribute(xml::kSchemaAndroid, "attr");
+  ASSERT_NE(xml_attr, nullptr);
+  AAPT_ASSERT_TRUE(xml_attr->compiled_attribute);
+  AAPT_ASSERT_TRUE(xml_attr->compiled_attribute.value().id);
+  EXPECT_EQ(xml_attr->compiled_attribute.value().id.value(),
             ResourceId(0x01010002));
-  Reference* ref = valueCast<Reference>(xmlAttr->compiledValue.get());
+  Reference* ref = ValueCast<Reference>(xml_attr->compiled_value.get());
   ASSERT_NE(ref, nullptr);
   AAPT_ASSERT_TRUE(ref->id);
   EXPECT_EQ(ref->id.value(), ResourceId(0x01030000));
 
-  ASSERT_FALSE(viewEl->getChildElements().empty());
-  viewEl = viewEl->getChildElements().front();
-  ASSERT_NE(viewEl, nullptr);
+  ASSERT_FALSE(view_el->GetChildElements().empty());
+  view_el = view_el->GetChildElements().front();
+  ASSERT_NE(view_el, nullptr);
 
   // All attributes and references in this element should be referring to
   // "com.app.test" (0x7f).
-  xmlAttr =
-      viewEl->findAttribute(xml::buildPackageNamespace("com.app.test"), "attr");
-  ASSERT_NE(xmlAttr, nullptr);
-  AAPT_ASSERT_TRUE(xmlAttr->compiledAttribute);
-  AAPT_ASSERT_TRUE(xmlAttr->compiledAttribute.value().id);
-  EXPECT_EQ(xmlAttr->compiledAttribute.value().id.value(),
+  xml_attr = view_el->FindAttribute(xml::BuildPackageNamespace("com.app.test"),
+                                    "attr");
+  ASSERT_NE(xml_attr, nullptr);
+  AAPT_ASSERT_TRUE(xml_attr->compiled_attribute);
+  AAPT_ASSERT_TRUE(xml_attr->compiled_attribute.value().id);
+  EXPECT_EQ(xml_attr->compiled_attribute.value().id.value(),
             ResourceId(0x7f010002));
-  ref = valueCast<Reference>(xmlAttr->compiledValue.get());
+  ref = ValueCast<Reference>(xml_attr->compiled_value.get());
   ASSERT_NE(ref, nullptr);
   AAPT_ASSERT_TRUE(ref->id);
   EXPECT_EQ(ref->id.value(), ResourceId(0x7f030000));
@@ -267,26 +271,26 @@ TEST_F(XmlReferenceLinkerTest, LinkViewWithShadowedPackageAlias) {
 
 TEST_F(XmlReferenceLinkerTest, LinkViewWithLocalPackageAndAliasOfTheSameName) {
   std::unique_ptr<xml::XmlResource> doc =
-      test::buildXmlDomForPackageName(mContext.get(), R"EOF(
+      test::BuildXmlDomForPackageName(context_.get(), R"EOF(
             <View xmlns:android="http://schemas.android.com/apk/res/com.app.test"
                   android:attr="@id/id"/>)EOF");
 
   XmlReferenceLinker linker;
-  ASSERT_TRUE(linker.consume(mContext.get(), doc.get()));
+  ASSERT_TRUE(linker.Consume(context_.get(), doc.get()));
 
-  xml::Element* viewEl = xml::findRootElement(doc.get());
-  ASSERT_NE(viewEl, nullptr);
+  xml::Element* view_el = xml::FindRootElement(doc.get());
+  ASSERT_NE(view_el, nullptr);
 
   // All attributes and references in this element should be referring to
   // "com.app.test" (0x7f).
-  xml::Attribute* xmlAttr =
-      viewEl->findAttribute(xml::buildPackageNamespace("com.app.test"), "attr");
-  ASSERT_NE(xmlAttr, nullptr);
-  AAPT_ASSERT_TRUE(xmlAttr->compiledAttribute);
-  AAPT_ASSERT_TRUE(xmlAttr->compiledAttribute.value().id);
-  EXPECT_EQ(xmlAttr->compiledAttribute.value().id.value(),
+  xml::Attribute* xml_attr = view_el->FindAttribute(
+      xml::BuildPackageNamespace("com.app.test"), "attr");
+  ASSERT_NE(xml_attr, nullptr);
+  AAPT_ASSERT_TRUE(xml_attr->compiled_attribute);
+  AAPT_ASSERT_TRUE(xml_attr->compiled_attribute.value().id);
+  EXPECT_EQ(xml_attr->compiled_attribute.value().id.value(),
             ResourceId(0x7f010002));
-  Reference* ref = valueCast<Reference>(xmlAttr->compiledValue.get());
+  Reference* ref = ValueCast<Reference>(xml_attr->compiled_value.get());
   ASSERT_NE(ref, nullptr);
   AAPT_ASSERT_TRUE(ref->id);
   EXPECT_EQ(ref->id.value(), ResourceId(0x7f030000));
diff --git a/tools/aapt2/process/IResourceTableConsumer.h b/tools/aapt2/process/IResourceTableConsumer.h
index a9bde396cc555..4526a79577d98 100644
--- a/tools/aapt2/process/IResourceTableConsumer.h
+++ b/tools/aapt2/process/IResourceTableConsumer.h
@@ -17,16 +17,16 @@
 #ifndef AAPT_PROCESS_IRESOURCETABLECONSUMER_H
 #define AAPT_PROCESS_IRESOURCETABLECONSUMER_H
 
+#include <iostream>
+#include <list>
+#include <sstream>
+
 #include "Diagnostics.h"
 #include "NameMangler.h"
 #include "Resource.h"
 #include "ResourceValues.h"
 #include "Source.h"
 
-#include <iostream>
-#include <list>
-#include <sstream>
-
 namespace aapt {
 
 class ResourceTable;
@@ -35,19 +35,19 @@ class SymbolTable;
 struct IAaptContext {
   virtual ~IAaptContext() = default;
 
-  virtual SymbolTable* getExternalSymbols() = 0;
-  virtual IDiagnostics* getDiagnostics() = 0;
-  virtual const std::string& getCompilationPackage() = 0;
-  virtual uint8_t getPackageId() = 0;
-  virtual NameMangler* getNameMangler() = 0;
-  virtual bool verbose() = 0;
-  virtual int getMinSdkVersion() = 0;
+  virtual SymbolTable* GetExternalSymbols() = 0;
+  virtual IDiagnostics* GetDiagnostics() = 0;
+  virtual const std::string& GetCompilationPackage() = 0;
+  virtual uint8_t GetPackageId() = 0;
+  virtual NameMangler* GetNameMangler() = 0;
+  virtual bool IsVerbose() = 0;
+  virtual int GetMinSdkVersion() = 0;
 };
 
 struct IResourceTableConsumer {
   virtual ~IResourceTableConsumer() = default;
 
-  virtual bool consume(IAaptContext* context, ResourceTable* table) = 0;
+  virtual bool Consume(IAaptContext* context, ResourceTable* table) = 0;
 };
 
 namespace xml {
@@ -57,7 +57,7 @@ class XmlResource;
 struct IXmlResourceConsumer {
   virtual ~IXmlResourceConsumer() = default;
 
-  virtual bool consume(IAaptContext* context, xml::XmlResource* resource) = 0;
+  virtual bool Consume(IAaptContext* context, xml::XmlResource* resource) = 0;
 };
 
 }  // namespace aapt
diff --git a/tools/aapt2/process/SymbolTable.cpp b/tools/aapt2/process/SymbolTable.cpp
index 00ffeb25c3e16..767384d8d9562 100644
--- a/tools/aapt2/process/SymbolTable.cpp
+++ b/tools/aapt2/process/SymbolTable.cpp
@@ -15,80 +15,81 @@
  */
 
 #include "process/SymbolTable.h"
+
+#include "androidfw/AssetManager.h"
+#include "androidfw/ResourceTypes.h"
+
 #include "ConfigDescription.h"
 #include "Resource.h"
 #include "ResourceUtils.h"
 #include "ValueVisitor.h"
 #include "util/Util.h"
 
-#include <androidfw/AssetManager.h>
-#include <androidfw/ResourceTypes.h>
-
 namespace aapt {
 
-void SymbolTable::appendSource(std::unique_ptr<ISymbolSource> source) {
-  mSources.push_back(std::move(source));
+void SymbolTable::AppendSource(std::unique_ptr<ISymbolSource> source) {
+  sources_.push_back(std::move(source));
 
   // We do not clear the cache, because sources earlier in the list take
   // precedent.
 }
 
-void SymbolTable::prependSource(std::unique_ptr<ISymbolSource> source) {
-  mSources.insert(mSources.begin(), std::move(source));
+void SymbolTable::PrependSource(std::unique_ptr<ISymbolSource> source) {
+  sources_.insert(sources_.begin(), std::move(source));
 
   // We must clear the cache in case we did a lookup before adding this
   // resource.
-  mCache.clear();
+  cache_.clear();
 }
 
-const SymbolTable::Symbol* SymbolTable::findByName(const ResourceName& name) {
-  if (const std::shared_ptr<Symbol>& s = mCache.get(name)) {
+const SymbolTable::Symbol* SymbolTable::FindByName(const ResourceName& name) {
+  if (const std::shared_ptr<Symbol>& s = cache_.get(name)) {
     return s.get();
   }
 
   // We did not find it in the cache, so look through the sources.
-  for (auto& symbolSource : mSources) {
-    std::unique_ptr<Symbol> symbol = symbolSource->findByName(name);
+  for (auto& symbolSource : sources_) {
+    std::unique_ptr<Symbol> symbol = symbolSource->FindByName(name);
     if (symbol) {
       // Take ownership of the symbol into a shared_ptr. We do this because
       // LruCache
       // doesn't support unique_ptr.
-      std::shared_ptr<Symbol> sharedSymbol =
+      std::shared_ptr<Symbol> shared_symbol =
           std::shared_ptr<Symbol>(symbol.release());
-      mCache.put(name, sharedSymbol);
+      cache_.put(name, shared_symbol);
 
-      if (sharedSymbol->id) {
+      if (shared_symbol->id) {
         // The symbol has an ID, so we can also cache this!
-        mIdCache.put(sharedSymbol->id.value(), sharedSymbol);
+        id_cache_.put(shared_symbol->id.value(), shared_symbol);
       }
-      return sharedSymbol.get();
+      return shared_symbol.get();
     }
   }
   return nullptr;
 }
 
-const SymbolTable::Symbol* SymbolTable::findById(const ResourceId& id) {
-  if (const std::shared_ptr<Symbol>& s = mIdCache.get(id)) {
+const SymbolTable::Symbol* SymbolTable::FindById(const ResourceId& id) {
+  if (const std::shared_ptr<Symbol>& s = id_cache_.get(id)) {
     return s.get();
   }
 
   // We did not find it in the cache, so look through the sources.
-  for (auto& symbolSource : mSources) {
-    std::unique_ptr<Symbol> symbol = symbolSource->findById(id);
+  for (auto& symbolSource : sources_) {
+    std::unique_ptr<Symbol> symbol = symbolSource->FindById(id);
     if (symbol) {
       // Take ownership of the symbol into a shared_ptr. We do this because
       // LruCache
       // doesn't support unique_ptr.
-      std::shared_ptr<Symbol> sharedSymbol =
+      std::shared_ptr<Symbol> shared_symbol =
           std::shared_ptr<Symbol>(symbol.release());
-      mIdCache.put(id, sharedSymbol);
-      return sharedSymbol.get();
+      id_cache_.put(id, shared_symbol);
+      return shared_symbol.get();
     }
   }
   return nullptr;
 }
 
-const SymbolTable::Symbol* SymbolTable::findByReference(const Reference& ref) {
+const SymbolTable::Symbol* SymbolTable::FindByReference(const Reference& ref) {
   // First try the ID. This is because when we lookup by ID, we only fill in the
   // ID cache.
   // Looking up by name fills in the name and ID cache. So a cache miss will
@@ -102,22 +103,22 @@ const SymbolTable::Symbol* SymbolTable::findByReference(const Reference& ref) {
   // succeeded to lookup by ID. Subsequent lookups will miss then hit.
   const SymbolTable::Symbol* symbol = nullptr;
   if (ref.id) {
-    symbol = findById(ref.id.value());
+    symbol = FindById(ref.id.value());
   }
 
   if (ref.name && !symbol) {
-    symbol = findByName(ref.name.value());
+    symbol = FindByName(ref.name.value());
   }
   return symbol;
 }
 
-std::unique_ptr<SymbolTable::Symbol> ResourceTableSymbolSource::findByName(
+std::unique_ptr<SymbolTable::Symbol> ResourceTableSymbolSource::FindByName(
     const ResourceName& name) {
-  Maybe<ResourceTable::SearchResult> result = mTable->findResource(name);
+  Maybe<ResourceTable::SearchResult> result = table_->FindResource(name);
   if (!result) {
     if (name.type == ResourceType::kAttr) {
       // Recurse and try looking up a private attribute.
-      return findByName(
+      return FindByName(
           ResourceName(name.package, ResourceType::kAttrPrivate, name.entry));
     }
     return {};
@@ -127,7 +128,7 @@ std::unique_ptr<SymbolTable::Symbol> ResourceTableSymbolSource::findByName(
 
   std::unique_ptr<SymbolTable::Symbol> symbol =
       util::make_unique<SymbolTable::Symbol>();
-  symbol->isPublic = (sr.entry->symbolStatus.state == SymbolState::kPublic);
+  symbol->is_public = (sr.entry->symbol_status.state == SymbolState::kPublic);
 
   if (sr.package->id && sr.type->id && sr.entry->id) {
     symbol->id = ResourceId(sr.package->id.value(), sr.type->id.value(),
@@ -137,10 +138,10 @@ std::unique_ptr<SymbolTable::Symbol> ResourceTableSymbolSource::findByName(
   if (name.type == ResourceType::kAttr ||
       name.type == ResourceType::kAttrPrivate) {
     const ConfigDescription kDefaultConfig;
-    ResourceConfigValue* configValue = sr.entry->findValue(kDefaultConfig);
-    if (configValue) {
+    ResourceConfigValue* config_value = sr.entry->FindValue(kDefaultConfig);
+    if (config_value) {
       // This resource has an Attribute.
-      if (Attribute* attr = valueCast<Attribute>(configValue->value.get())) {
+      if (Attribute* attr = ValueCast<Attribute>(config_value->value.get())) {
         symbol->attribute = std::make_shared<Attribute>(*attr);
       } else {
         return {};
@@ -150,13 +151,13 @@ std::unique_ptr<SymbolTable::Symbol> ResourceTableSymbolSource::findByName(
   return symbol;
 }
 
-bool AssetManagerSymbolSource::addAssetPath(const StringPiece& path) {
+bool AssetManagerSymbolSource::AddAssetPath(const StringPiece& path) {
   int32_t cookie = 0;
-  return mAssets.addAssetPath(android::String8(path.data(), path.size()),
+  return assets_.addAssetPath(android::String8(path.data(), path.size()),
                               &cookie);
 }
 
-static std::unique_ptr<SymbolTable::Symbol> lookupAttributeInTable(
+static std::unique_ptr<SymbolTable::Symbol> LookupAttributeInTable(
     const android::ResTable& table, ResourceId id) {
   // Try as a bag.
   const android::ResTable::bag_entry* entry;
@@ -175,41 +176,42 @@ static std::unique_ptr<SymbolTable::Symbol> lookupAttributeInTable(
   for (size_t i = 0; i < (size_t)count; i++) {
     if (entry[i].map.name.ident == android::ResTable_map::ATTR_TYPE) {
       s->attribute = std::make_shared<Attribute>(false);
-      s->attribute->typeMask = entry[i].map.value.data;
+      s->attribute->type_mask = entry[i].map.value.data;
       break;
     }
   }
 
   if (s->attribute) {
     for (size_t i = 0; i < (size_t)count; i++) {
-      const android::ResTable_map& mapEntry = entry[i].map;
-      if (Res_INTERNALID(mapEntry.name.ident)) {
-        switch (mapEntry.name.ident) {
+      const android::ResTable_map& map_entry = entry[i].map;
+      if (Res_INTERNALID(map_entry.name.ident)) {
+        switch (map_entry.name.ident) {
           case android::ResTable_map::ATTR_MIN:
-            s->attribute->minInt = static_cast<int32_t>(mapEntry.value.data);
+            s->attribute->min_int = static_cast<int32_t>(map_entry.value.data);
             break;
           case android::ResTable_map::ATTR_MAX:
-            s->attribute->maxInt = static_cast<int32_t>(mapEntry.value.data);
+            s->attribute->max_int = static_cast<int32_t>(map_entry.value.data);
             break;
         }
         continue;
       }
 
-      android::ResTable::resource_name entryName;
-      if (!table.getResourceName(mapEntry.name.ident, false, &entryName)) {
+      android::ResTable::resource_name entry_name;
+      if (!table.getResourceName(map_entry.name.ident, false, &entry_name)) {
         table.unlockBag(entry);
         return nullptr;
       }
 
-      Maybe<ResourceName> parsedName = ResourceUtils::toResourceName(entryName);
-      if (!parsedName) {
+      Maybe<ResourceName> parsed_name =
+          ResourceUtils::ToResourceName(entry_name);
+      if (!parsed_name) {
         return nullptr;
       }
 
       Attribute::Symbol symbol;
-      symbol.symbol.name = parsedName.value();
-      symbol.symbol.id = ResourceId(mapEntry.name.ident);
-      symbol.value = mapEntry.value.data;
+      symbol.symbol.name = parsed_name.value();
+      symbol.symbol.id = ResourceId(map_entry.name.ident);
+      symbol.value = map_entry.value.data;
       s->attribute->symbols.push_back(std::move(symbol));
     }
   }
@@ -217,81 +219,81 @@ static std::unique_ptr<SymbolTable::Symbol> lookupAttributeInTable(
   return s;
 }
 
-std::unique_ptr<SymbolTable::Symbol> AssetManagerSymbolSource::findByName(
+std::unique_ptr<SymbolTable::Symbol> AssetManagerSymbolSource::FindByName(
     const ResourceName& name) {
-  const android::ResTable& table = mAssets.getResources(false);
+  const android::ResTable& table = assets_.getResources(false);
 
-  const std::u16string package16 = util::utf8ToUtf16(name.package);
-  const std::u16string type16 = util::utf8ToUtf16(toString(name.type));
-  const std::u16string entry16 = util::utf8ToUtf16(name.entry);
+  const std::u16string package16 = util::Utf8ToUtf16(name.package);
+  const std::u16string type16 = util::Utf8ToUtf16(ToString(name.type));
+  const std::u16string entry16 = util::Utf8ToUtf16(name.entry);
 
-  uint32_t typeSpecFlags = 0;
-  ResourceId resId = table.identifierForName(
+  uint32_t type_spec_flags = 0;
+  ResourceId res_id = table.identifierForName(
       entry16.data(), entry16.size(), type16.data(), type16.size(),
-      package16.data(), package16.size(), &typeSpecFlags);
-  if (!resId.isValid()) {
+      package16.data(), package16.size(), &type_spec_flags);
+  if (!res_id.is_valid()) {
     return {};
   }
 
   std::unique_ptr<SymbolTable::Symbol> s;
   if (name.type == ResourceType::kAttr) {
-    s = lookupAttributeInTable(table, resId);
+    s = LookupAttributeInTable(table, res_id);
   } else {
     s = util::make_unique<SymbolTable::Symbol>();
-    s->id = resId;
+    s->id = res_id;
   }
 
   if (s) {
-    s->isPublic =
-        (typeSpecFlags & android::ResTable_typeSpec::SPEC_PUBLIC) != 0;
+    s->is_public =
+        (type_spec_flags & android::ResTable_typeSpec::SPEC_PUBLIC) != 0;
     return s;
   }
   return {};
 }
 
-static Maybe<ResourceName> getResourceName(const android::ResTable& table,
+static Maybe<ResourceName> GetResourceName(const android::ResTable& table,
                                            ResourceId id) {
-  android::ResTable::resource_name resName = {};
-  if (!table.getResourceName(id.id, true, &resName)) {
+  android::ResTable::resource_name res_name = {};
+  if (!table.getResourceName(id.id, true, &res_name)) {
     return {};
   }
-  return ResourceUtils::toResourceName(resName);
+  return ResourceUtils::ToResourceName(res_name);
 }
 
-std::unique_ptr<SymbolTable::Symbol> AssetManagerSymbolSource::findById(
+std::unique_ptr<SymbolTable::Symbol> AssetManagerSymbolSource::FindById(
     ResourceId id) {
-  const android::ResTable& table = mAssets.getResources(false);
-  Maybe<ResourceName> maybeName = getResourceName(table, id);
-  if (!maybeName) {
+  const android::ResTable& table = assets_.getResources(false);
+  Maybe<ResourceName> maybe_name = GetResourceName(table, id);
+  if (!maybe_name) {
     return {};
   }
 
-  uint32_t typeSpecFlags = 0;
-  table.getResourceFlags(id.id, &typeSpecFlags);
+  uint32_t type_spec_flags = 0;
+  table.getResourceFlags(id.id, &type_spec_flags);
 
   std::unique_ptr<SymbolTable::Symbol> s;
-  if (maybeName.value().type == ResourceType::kAttr) {
-    s = lookupAttributeInTable(table, id);
+  if (maybe_name.value().type == ResourceType::kAttr) {
+    s = LookupAttributeInTable(table, id);
   } else {
     s = util::make_unique<SymbolTable::Symbol>();
     s->id = id;
   }
 
   if (s) {
-    s->isPublic =
-        (typeSpecFlags & android::ResTable_typeSpec::SPEC_PUBLIC) != 0;
+    s->is_public =
+        (type_spec_flags & android::ResTable_typeSpec::SPEC_PUBLIC) != 0;
     return s;
   }
   return {};
 }
 
-std::unique_ptr<SymbolTable::Symbol> AssetManagerSymbolSource::findByReference(
+std::unique_ptr<SymbolTable::Symbol> AssetManagerSymbolSource::FindByReference(
     const Reference& ref) {
   // AssetManager always prefers IDs.
   if (ref.id) {
-    return findById(ref.id.value());
+    return FindById(ref.id.value());
   } else if (ref.name) {
-    return findByName(ref.name.value());
+    return FindByName(ref.name.value());
   }
   return {};
 }
diff --git a/tools/aapt2/process/SymbolTable.h b/tools/aapt2/process/SymbolTable.h
index 89d87dec72698..25f756522580c 100644
--- a/tools/aapt2/process/SymbolTable.h
+++ b/tools/aapt2/process/SymbolTable.h
@@ -17,28 +17,28 @@
 #ifndef AAPT_PROCESS_SYMBOLTABLE_H
 #define AAPT_PROCESS_SYMBOLTABLE_H
 
+#include <algorithm>
+#include <memory>
+#include <vector>
+
+#include "android-base/macros.h"
+#include "androidfw/AssetManager.h"
+#include "utils/JenkinsHash.h"
+#include "utils/LruCache.h"
+
 #include "Resource.h"
 #include "ResourceTable.h"
 #include "ResourceValues.h"
 #include "util/Util.h"
 
-#include <utils/JenkinsHash.h>
-#include <utils/LruCache.h>
-
-#include <android-base/macros.h>
-#include <androidfw/AssetManager.h>
-#include <algorithm>
-#include <memory>
-#include <vector>
-
 namespace aapt {
 
 inline android::hash_t hash_type(const ResourceName& name) {
-  std::hash<std::string> strHash;
+  std::hash<std::string> str_hash;
   android::hash_t hash = 0;
-  hash = android::JenkinsHashMix(hash, (uint32_t)strHash(name.package));
+  hash = android::JenkinsHashMix(hash, (uint32_t)str_hash(name.package));
   hash = android::JenkinsHashMix(hash, (uint32_t)name.type);
-  hash = android::JenkinsHashMix(hash, (uint32_t)strHash(name.entry));
+  hash = android::JenkinsHashMix(hash, (uint32_t)str_hash(name.entry));
   return hash;
 }
 
@@ -60,7 +60,7 @@ class SymbolTable {
 
     Symbol(const Maybe<ResourceId>& i, const std::shared_ptr<Attribute>& attr,
            bool pub)
-        : id(i), attribute(attr), isPublic(pub) {}
+        : id(i), attribute(attr), is_public(pub) {}
 
     Symbol(const Symbol&) = default;
     Symbol(Symbol&&) = default;
@@ -69,36 +69,34 @@ class SymbolTable {
 
     Maybe<ResourceId> id;
     std::shared_ptr<Attribute> attribute;
-    bool isPublic = false;
+    bool is_public = false;
   };
 
-  SymbolTable() : mCache(200), mIdCache(200) {}
+  SymbolTable() : cache_(200), id_cache_(200) {}
 
-  void appendSource(std::unique_ptr<ISymbolSource> source);
-  void prependSource(std::unique_ptr<ISymbolSource> source);
+  void AppendSource(std::unique_ptr<ISymbolSource> source);
+  void PrependSource(std::unique_ptr<ISymbolSource> source);
 
   /**
-   * Never hold on to the result between calls to findByName or findById. The
-   * results
-   * are typically stored in a cache which may evict entries.
+   * Never hold on to the result between calls to FindByName or FindById. The
+   * results stored in a cache which may evict entries.
    */
-  const Symbol* findByName(const ResourceName& name);
-  const Symbol* findById(const ResourceId& id);
+  const Symbol* FindByName(const ResourceName& name);
+  const Symbol* FindById(const ResourceId& id);
 
   /**
    * Let's the ISymbolSource decide whether looking up by name or ID is faster,
-   * if both
-   * are available.
+   * if both are available.
    */
-  const Symbol* findByReference(const Reference& ref);
+  const Symbol* FindByReference(const Reference& ref);
 
  private:
-  std::vector<std::unique_ptr<ISymbolSource>> mSources;
+  std::vector<std::unique_ptr<ISymbolSource>> sources_;
 
   // We use shared_ptr because unique_ptr is not supported and
   // we need automatic deletion.
-  android::LruCache<ResourceName, std::shared_ptr<Symbol>> mCache;
-  android::LruCache<ResourceId, std::shared_ptr<Symbol>> mIdCache;
+  android::LruCache<ResourceName, std::shared_ptr<Symbol>> cache_;
+  android::LruCache<ResourceId, std::shared_ptr<Symbol>> id_cache_;
 
   DISALLOW_COPY_AND_ASSIGN(SymbolTable);
 };
@@ -112,19 +110,19 @@ class ISymbolSource {
  public:
   virtual ~ISymbolSource() = default;
 
-  virtual std::unique_ptr<SymbolTable::Symbol> findByName(
+  virtual std::unique_ptr<SymbolTable::Symbol> FindByName(
       const ResourceName& name) = 0;
-  virtual std::unique_ptr<SymbolTable::Symbol> findById(ResourceId id) = 0;
+  virtual std::unique_ptr<SymbolTable::Symbol> FindById(ResourceId id) = 0;
 
   /**
    * Default implementation tries the name if it exists, else the ID.
    */
-  virtual std::unique_ptr<SymbolTable::Symbol> findByReference(
+  virtual std::unique_ptr<SymbolTable::Symbol> FindByReference(
       const Reference& ref) {
     if (ref.name) {
-      return findByName(ref.name.value());
+      return FindByName(ref.name.value());
     } else if (ref.id) {
-      return findById(ref.id.value());
+      return FindById(ref.id.value());
     }
     return {};
   }
@@ -137,17 +135,17 @@ class ISymbolSource {
  */
 class ResourceTableSymbolSource : public ISymbolSource {
  public:
-  explicit ResourceTableSymbolSource(ResourceTable* table) : mTable(table) {}
+  explicit ResourceTableSymbolSource(ResourceTable* table) : table_(table) {}
 
-  std::unique_ptr<SymbolTable::Symbol> findByName(
+  std::unique_ptr<SymbolTable::Symbol> FindByName(
       const ResourceName& name) override;
 
-  std::unique_ptr<SymbolTable::Symbol> findById(ResourceId id) override {
+  std::unique_ptr<SymbolTable::Symbol> FindById(ResourceId id) override {
     return {};
   }
 
  private:
-  ResourceTable* mTable;
+  ResourceTable* table_;
 
   DISALLOW_COPY_AND_ASSIGN(ResourceTableSymbolSource);
 };
@@ -156,16 +154,16 @@ class AssetManagerSymbolSource : public ISymbolSource {
  public:
   AssetManagerSymbolSource() = default;
 
-  bool addAssetPath(const StringPiece& path);
+  bool AddAssetPath(const StringPiece& path);
 
-  std::unique_ptr<SymbolTable::Symbol> findByName(
+  std::unique_ptr<SymbolTable::Symbol> FindByName(
       const ResourceName& name) override;
-  std::unique_ptr<SymbolTable::Symbol> findById(ResourceId id) override;
-  std::unique_ptr<SymbolTable::Symbol> findByReference(
+  std::unique_ptr<SymbolTable::Symbol> FindById(ResourceId id) override;
+  std::unique_ptr<SymbolTable::Symbol> FindByReference(
       const Reference& ref) override;
 
  private:
-  android::AssetManager mAssets;
+  android::AssetManager assets_;
 
   DISALLOW_COPY_AND_ASSIGN(AssetManagerSymbolSource);
 };
diff --git a/tools/aapt2/process/SymbolTable_test.cpp b/tools/aapt2/process/SymbolTable_test.cpp
index 00474f7d2341a..9ea0786cbc8ec 100644
--- a/tools/aapt2/process/SymbolTable_test.cpp
+++ b/tools/aapt2/process/SymbolTable_test.cpp
@@ -15,6 +15,7 @@
  */
 
 #include "process/SymbolTable.h"
+
 #include "test/Test.h"
 
 namespace aapt {
@@ -22,20 +23,20 @@ namespace aapt {
 TEST(ResourceTableSymbolSourceTest, FindSymbols) {
   std::unique_ptr<ResourceTable> table =
       test::ResourceTableBuilder()
-          .addSimple("android:id/foo", ResourceId(0x01020000))
-          .addSimple("android:id/bar")
-          .addValue("android:attr/foo", ResourceId(0x01010000),
-                    test::AttributeBuilder().build())
-          .build();
+          .AddSimple("android:id/foo", ResourceId(0x01020000))
+          .AddSimple("android:id/bar")
+          .AddValue("android:attr/foo", ResourceId(0x01010000),
+                    test::AttributeBuilder().Build())
+          .Build();
 
-  ResourceTableSymbolSource symbolSource(table.get());
+  ResourceTableSymbolSource symbol_source(table.get());
   EXPECT_NE(nullptr,
-            symbolSource.findByName(test::parseNameOrDie("android:id/foo")));
+            symbol_source.FindByName(test::ParseNameOrDie("android:id/foo")));
   EXPECT_NE(nullptr,
-            symbolSource.findByName(test::parseNameOrDie("android:id/bar")));
+            symbol_source.FindByName(test::ParseNameOrDie("android:id/bar")));
 
   std::unique_ptr<SymbolTable::Symbol> s =
-      symbolSource.findByName(test::parseNameOrDie("android:attr/foo"));
+      symbol_source.FindByName(test::ParseNameOrDie("android:attr/foo"));
   ASSERT_NE(nullptr, s);
   EXPECT_NE(nullptr, s->attribute);
 }
@@ -43,13 +44,13 @@ TEST(ResourceTableSymbolSourceTest, FindSymbols) {
 TEST(ResourceTableSymbolSourceTest, FindPrivateAttrSymbol) {
   std::unique_ptr<ResourceTable> table =
       test::ResourceTableBuilder()
-          .addValue("android:^attr-private/foo", ResourceId(0x01010000),
-                    test::AttributeBuilder().build())
-          .build();
+          .AddValue("android:^attr-private/foo", ResourceId(0x01010000),
+                    test::AttributeBuilder().Build())
+          .Build();
 
-  ResourceTableSymbolSource symbolSource(table.get());
+  ResourceTableSymbolSource symbol_source(table.get());
   std::unique_ptr<SymbolTable::Symbol> s =
-      symbolSource.findByName(test::parseNameOrDie("android:attr/foo"));
+      symbol_source.FindByName(test::ParseNameOrDie("android:attr/foo"));
   ASSERT_NE(nullptr, s);
   EXPECT_NE(nullptr, s->attribute);
 }
diff --git a/tools/aapt2/proto/ProtoHelpers.cpp b/tools/aapt2/proto/ProtoHelpers.cpp
index 2aa8aa5003877..38bf4e3bd8eb9 100644
--- a/tools/aapt2/proto/ProtoHelpers.cpp
+++ b/tools/aapt2/proto/ProtoHelpers.cpp
@@ -18,120 +18,151 @@
 
 namespace aapt {
 
-void serializeStringPoolToPb(const StringPool& pool, pb::StringPool* outPbPool) {
-    BigBuffer buffer(1024);
-    StringPool::flattenUtf8(&buffer, pool);
+void SerializeStringPoolToPb(const StringPool& pool,
+                             pb::StringPool* out_pb_pool) {
+  BigBuffer buffer(1024);
+  StringPool::FlattenUtf8(&buffer, pool);
 
-    std::string* data = outPbPool->mutable_data();
-    data->reserve(buffer.size());
+  std::string* data = out_pb_pool->mutable_data();
+  data->reserve(buffer.size());
 
-    size_t offset = 0;
-    for (const BigBuffer::Block& block : buffer) {
-        data->insert(data->begin() + offset, block.buffer.get(), block.buffer.get() + block.size);
-        offset += block.size;
-    }
+  size_t offset = 0;
+  for (const BigBuffer::Block& block : buffer) {
+    data->insert(data->begin() + offset, block.buffer.get(),
+                 block.buffer.get() + block.size);
+    offset += block.size;
+  }
 }
 
-void serializeSourceToPb(const Source& source, StringPool* srcPool, pb::Source* outPbSource) {
-    StringPool::Ref ref = srcPool->makeRef(source.path);
-    outPbSource->set_path_idx(static_cast<uint32_t>(ref.getIndex()));
-    if (source.line) {
-        outPbSource->set_line_no(static_cast<uint32_t>(source.line.value()));
-    }
+void SerializeSourceToPb(const Source& source, StringPool* src_pool,
+                         pb::Source* out_pb_source) {
+  StringPool::Ref ref = src_pool->MakeRef(source.path);
+  out_pb_source->set_path_idx(static_cast<uint32_t>(ref.index()));
+  if (source.line) {
+    out_pb_source->set_line_no(static_cast<uint32_t>(source.line.value()));
+  }
 }
 
-void deserializeSourceFromPb(const pb::Source& pbSource, const android::ResStringPool& srcPool,
-                             Source* outSource) {
-    if (pbSource.has_path_idx()) {
-        outSource->path = util::getString(srcPool, pbSource.path_idx());
-    }
+void DeserializeSourceFromPb(const pb::Source& pb_source,
+                             const android::ResStringPool& src_pool,
+                             Source* out_source) {
+  if (pb_source.has_path_idx()) {
+    out_source->path = util::GetString(src_pool, pb_source.path_idx());
+  }
 
-    if (pbSource.has_line_no()) {
-        outSource->line = static_cast<size_t>(pbSource.line_no());
-    }
+  if (pb_source.has_line_no()) {
+    out_source->line = static_cast<size_t>(pb_source.line_no());
+  }
 }
 
-pb::SymbolStatus_Visibility serializeVisibilityToPb(SymbolState state) {
-    switch (state) {
-    case SymbolState::kPrivate: return pb::SymbolStatus_Visibility_Private;
-    case SymbolState::kPublic: return pb::SymbolStatus_Visibility_Public;
-    default: break;
-    }
-    return pb::SymbolStatus_Visibility_Unknown;
+pb::SymbolStatus_Visibility SerializeVisibilityToPb(SymbolState state) {
+  switch (state) {
+    case SymbolState::kPrivate:
+      return pb::SymbolStatus_Visibility_Private;
+    case SymbolState::kPublic:
+      return pb::SymbolStatus_Visibility_Public;
+    default:
+      break;
+  }
+  return pb::SymbolStatus_Visibility_Unknown;
 }
 
-SymbolState deserializeVisibilityFromPb(pb::SymbolStatus_Visibility pbVisibility) {
-    switch (pbVisibility) {
-    case pb::SymbolStatus_Visibility_Private: return SymbolState::kPrivate;
-    case pb::SymbolStatus_Visibility_Public: return SymbolState::kPublic;
-    default: break;
-    }
-    return SymbolState::kUndefined;
+SymbolState DeserializeVisibilityFromPb(
+    pb::SymbolStatus_Visibility pb_visibility) {
+  switch (pb_visibility) {
+    case pb::SymbolStatus_Visibility_Private:
+      return SymbolState::kPrivate;
+    case pb::SymbolStatus_Visibility_Public:
+      return SymbolState::kPublic;
+    default:
+      break;
+  }
+  return SymbolState::kUndefined;
 }
 
-void serializeConfig(const ConfigDescription& config, pb::ConfigDescription* outPbConfig) {
-    android::ResTable_config flatConfig = config;
-    flatConfig.size = sizeof(flatConfig);
-    flatConfig.swapHtoD();
-    outPbConfig->set_data(&flatConfig, sizeof(flatConfig));
+void SerializeConfig(const ConfigDescription& config,
+                     pb::ConfigDescription* out_pb_config) {
+  android::ResTable_config flat_config = config;
+  flat_config.size = sizeof(flat_config);
+  flat_config.swapHtoD();
+  out_pb_config->set_data(&flat_config, sizeof(flat_config));
 }
 
-bool deserializeConfigDescriptionFromPb(const pb::ConfigDescription& pbConfig,
-                                        ConfigDescription* outConfig) {
-    if (!pbConfig.has_data()) {
-        return false;
-    }
+bool DeserializeConfigDescriptionFromPb(const pb::ConfigDescription& pb_config,
+                                        ConfigDescription* out_config) {
+  if (!pb_config.has_data()) {
+    return false;
+  }
 
-    const android::ResTable_config* config;
-    if (pbConfig.data().size() > sizeof(*config)) {
-        return false;
-    }
+  const android::ResTable_config* config;
+  if (pb_config.data().size() > sizeof(*config)) {
+    return false;
+  }
 
-    config = reinterpret_cast<const android::ResTable_config*>(pbConfig.data().data());
-    outConfig->copyFromDtoH(*config);
-    return true;
+  config = reinterpret_cast<const android::ResTable_config*>(
+      pb_config.data().data());
+  out_config->copyFromDtoH(*config);
+  return true;
 }
 
-pb::Reference_Type serializeReferenceTypeToPb(Reference::Type type) {
-    switch (type) {
-    case Reference::Type::kResource:  return pb::Reference_Type_Ref;
-    case Reference::Type::kAttribute: return pb::Reference_Type_Attr;
-    default: break;
-    }
-    return pb::Reference_Type_Ref;
+pb::Reference_Type SerializeReferenceTypeToPb(Reference::Type type) {
+  switch (type) {
+    case Reference::Type::kResource:
+      return pb::Reference_Type_Ref;
+    case Reference::Type::kAttribute:
+      return pb::Reference_Type_Attr;
+    default:
+      break;
+  }
+  return pb::Reference_Type_Ref;
 }
 
-Reference::Type deserializeReferenceTypeFromPb(pb::Reference_Type pbType) {
-    switch (pbType) {
-    case pb::Reference_Type_Ref:  return Reference::Type::kResource;
-    case pb::Reference_Type_Attr: return Reference::Type::kAttribute;
-    default: break;
-    }
-    return Reference::Type::kResource;
+Reference::Type DeserializeReferenceTypeFromPb(pb::Reference_Type pb_type) {
+  switch (pb_type) {
+    case pb::Reference_Type_Ref:
+      return Reference::Type::kResource;
+    case pb::Reference_Type_Attr:
+      return Reference::Type::kAttribute;
+    default:
+      break;
+  }
+  return Reference::Type::kResource;
 }
 
-pb::Plural_Arity serializePluralEnumToPb(size_t pluralIdx) {
-    switch (pluralIdx) {
-    case Plural::Zero:  return pb::Plural_Arity_Zero;
-    case Plural::One:   return pb::Plural_Arity_One;
-    case Plural::Two:   return pb::Plural_Arity_Two;
-    case Plural::Few:   return pb::Plural_Arity_Few;
-    case Plural::Many:  return pb::Plural_Arity_Many;
-    default: break;
-    }
-    return pb::Plural_Arity_Other;
+pb::Plural_Arity SerializePluralEnumToPb(size_t plural_idx) {
+  switch (plural_idx) {
+    case Plural::Zero:
+      return pb::Plural_Arity_Zero;
+    case Plural::One:
+      return pb::Plural_Arity_One;
+    case Plural::Two:
+      return pb::Plural_Arity_Two;
+    case Plural::Few:
+      return pb::Plural_Arity_Few;
+    case Plural::Many:
+      return pb::Plural_Arity_Many;
+    default:
+      break;
+  }
+  return pb::Plural_Arity_Other;
 }
 
-size_t deserializePluralEnumFromPb(pb::Plural_Arity arity) {
-    switch (arity) {
-    case pb::Plural_Arity_Zero: return Plural::Zero;
-    case pb::Plural_Arity_One:  return Plural::One;
-    case pb::Plural_Arity_Two:  return Plural::Two;
-    case pb::Plural_Arity_Few:  return Plural::Few;
-    case pb::Plural_Arity_Many: return Plural::Many;
-    default: break;
-    }
-    return Plural::Other;
+size_t DeserializePluralEnumFromPb(pb::Plural_Arity arity) {
+  switch (arity) {
+    case pb::Plural_Arity_Zero:
+      return Plural::Zero;
+    case pb::Plural_Arity_One:
+      return Plural::One;
+    case pb::Plural_Arity_Two:
+      return Plural::Two;
+    case pb::Plural_Arity_Few:
+      return Plural::Few;
+    case pb::Plural_Arity_Many:
+      return Plural::Many;
+    default:
+      break;
+  }
+  return Plural::Other;
 }
 
-} // namespace aapt
+}  // namespace aapt
diff --git a/tools/aapt2/proto/ProtoHelpers.h b/tools/aapt2/proto/ProtoHelpers.h
index 7271e8bd72383..735cda0bde785 100644
--- a/tools/aapt2/proto/ProtoHelpers.h
+++ b/tools/aapt2/proto/ProtoHelpers.h
@@ -17,39 +17,44 @@
 #ifndef AAPT_PROTO_PROTOHELPERS_H
 #define AAPT_PROTO_PROTOHELPERS_H
 
+#include "androidfw/ResourceTypes.h"
+
 #include "ConfigDescription.h"
 #include "ResourceTable.h"
 #include "Source.h"
 #include "StringPool.h"
-
 #include "proto/frameworks/base/tools/aapt2/Format.pb.h"
 
-#include <androidfw/ResourceTypes.h>
-
 namespace aapt {
 
-void serializeStringPoolToPb(const StringPool& pool, pb::StringPool* outPbPool);
+void SerializeStringPoolToPb(const StringPool& pool,
+                             pb::StringPool* out_pb_pool);
 
-void serializeSourceToPb(const Source& source, StringPool* srcPool,
-                         pb::Source* outPbSource);
-void deserializeSourceFromPb(const pb::Source& pbSource,
-                             const android::ResStringPool& srcPool,
-                             Source* outSource);
+void SerializeSourceToPb(const Source& source, StringPool* src_pool,
+                         pb::Source* out_pb_source);
 
-pb::SymbolStatus_Visibility serializeVisibilityToPb(SymbolState state);
-SymbolState deserializeVisibilityFromPb(
-    pb::SymbolStatus_Visibility pbVisibility);
+void DeserializeSourceFromPb(const pb::Source& pb_source,
+                             const android::ResStringPool& src_pool,
+                             Source* out_source);
 
-void serializeConfig(const ConfigDescription& config,
-                     pb::ConfigDescription* outPbConfig);
-bool deserializeConfigDescriptionFromPb(const pb::ConfigDescription& pbConfig,
-                                        ConfigDescription* outConfig);
+pb::SymbolStatus_Visibility SerializeVisibilityToPb(SymbolState state);
 
-pb::Reference_Type serializeReferenceTypeToPb(Reference::Type type);
-Reference::Type deserializeReferenceTypeFromPb(pb::Reference_Type pbType);
+SymbolState DeserializeVisibilityFromPb(
+    pb::SymbolStatus_Visibility pb_visibility);
 
-pb::Plural_Arity serializePluralEnumToPb(size_t pluralIdx);
-size_t deserializePluralEnumFromPb(pb::Plural_Arity arity);
+void SerializeConfig(const ConfigDescription& config,
+                     pb::ConfigDescription* out_pb_config);
+
+bool DeserializeConfigDescriptionFromPb(const pb::ConfigDescription& pb_config,
+                                        ConfigDescription* out_config);
+
+pb::Reference_Type SerializeReferenceTypeToPb(Reference::Type type);
+
+Reference::Type DeserializeReferenceTypeFromPb(pb::Reference_Type pb_type);
+
+pb::Plural_Arity SerializePluralEnumToPb(size_t plural_idx);
+
+size_t DeserializePluralEnumFromPb(pb::Plural_Arity arity);
 
 }  // namespace aapt
 
diff --git a/tools/aapt2/proto/ProtoSerialize.h b/tools/aapt2/proto/ProtoSerialize.h
index 378dafdb4dc63..39c50038d5994 100644
--- a/tools/aapt2/proto/ProtoSerialize.h
+++ b/tools/aapt2/proto/ProtoSerialize.h
@@ -17,15 +17,15 @@
 #ifndef AAPT_FLATTEN_TABLEPROTOSERIALIZER_H
 #define AAPT_FLATTEN_TABLEPROTOSERIALIZER_H
 
+#include "android-base/macros.h"
+#include "google/protobuf/io/coded_stream.h"
+#include "google/protobuf/io/zero_copy_stream_impl_lite.h"
+
 #include "Diagnostics.h"
 #include "ResourceTable.h"
 #include "Source.h"
 #include "proto/ProtoHelpers.h"
 
-#include <android-base/macros.h>
-#include <google/protobuf/io/coded_stream.h>
-#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
-
 namespace aapt {
 
 class CompiledFileOutputStream {
@@ -42,9 +42,9 @@ class CompiledFileOutputStream {
  private:
   DISALLOW_COPY_AND_ASSIGN(CompiledFileOutputStream);
 
-  void ensureAlignedWrite();
+  void EnsureAlignedWrite();
 
-  google::protobuf::io::CodedOutputStream mOut;
+  google::protobuf::io::CodedOutputStream out_;
 };
 
 class CompiledFileInputStream {
@@ -58,18 +58,18 @@ class CompiledFileInputStream {
  private:
   DISALLOW_COPY_AND_ASSIGN(CompiledFileInputStream);
 
-  void ensureAlignedRead();
+  void EnsureAlignedRead();
 
-  google::protobuf::io::CodedInputStream mIn;
+  google::protobuf::io::CodedInputStream in_;
 };
 
-std::unique_ptr<pb::ResourceTable> serializeTableToPb(ResourceTable* table);
-std::unique_ptr<ResourceTable> deserializeTableFromPb(
+std::unique_ptr<pb::ResourceTable> SerializeTableToPb(ResourceTable* table);
+std::unique_ptr<ResourceTable> DeserializeTableFromPb(
     const pb::ResourceTable& pbTable, const Source& source, IDiagnostics* diag);
 
-std::unique_ptr<pb::CompiledFile> serializeCompiledFileToPb(
+std::unique_ptr<pb::CompiledFile> SerializeCompiledFileToPb(
     const ResourceFile& file);
-std::unique_ptr<ResourceFile> deserializeCompiledFileFromPb(
+std::unique_ptr<ResourceFile> DeserializeCompiledFileFromPb(
     const pb::CompiledFile& pbFile, const Source& source, IDiagnostics* diag);
 
 }  // namespace aapt
diff --git a/tools/aapt2/proto/TableProtoDeserializer.cpp b/tools/aapt2/proto/TableProtoDeserializer.cpp
index 0dfb01c181c68..d93d495b106fe 100644
--- a/tools/aapt2/proto/TableProtoDeserializer.cpp
+++ b/tools/aapt2/proto/TableProtoDeserializer.cpp
@@ -14,13 +14,15 @@
  * limitations under the License.
  */
 
+#include "proto/ProtoSerialize.h"
+
+#include "android-base/logging.h"
+#include "androidfw/ResourceTypes.h"
+
 #include "ResourceTable.h"
 #include "ResourceUtils.h"
 #include "ValueVisitor.h"
 #include "proto/ProtoHelpers.h"
-#include "proto/ProtoSerialize.h"
-
-#include <androidfw/ResourceTypes.h>
 
 namespace aapt {
 
@@ -28,28 +30,28 @@ namespace {
 
 class ReferenceIdToNameVisitor : public ValueVisitor {
  public:
-  using ValueVisitor::visit;
+  using ValueVisitor::Visit;
 
   explicit ReferenceIdToNameVisitor(
       const std::map<ResourceId, ResourceNameRef>* mapping)
-      : mMapping(mapping) {
-    assert(mMapping);
+      : mapping_(mapping) {
+    CHECK(mapping_ != nullptr);
   }
 
-  void visit(Reference* reference) override {
-    if (!reference->id || !reference->id.value().isValid()) {
+  void Visit(Reference* reference) override {
+    if (!reference->id || !reference->id.value().is_valid()) {
       return;
     }
 
     ResourceId id = reference->id.value();
-    auto cacheIter = mMapping->find(id);
-    if (cacheIter != mMapping->end()) {
-      reference->name = cacheIter->second.toResourceName();
+    auto cache_iter = mapping_->find(id);
+    if (cache_iter != mapping_->end()) {
+      reference->name = cache_iter->second.ToResourceName();
     }
   }
 
  private:
-  const std::map<ResourceId, ResourceNameRef>* mMapping;
+  const std::map<ResourceId, ResourceNameRef>* mapping_;
 };
 
 class PackagePbDeserializer {
@@ -58,14 +60,14 @@ class PackagePbDeserializer {
                         const android::ResStringPool* sourcePool,
                         const android::ResStringPool* symbolPool,
                         const Source& source, IDiagnostics* diag)
-      : mValuePool(valuePool),
-        mSourcePool(sourcePool),
-        mSymbolPool(symbolPool),
-        mSource(source),
-        mDiag(diag) {}
+      : value_pool_(valuePool),
+        source_pool_(sourcePool),
+        symbol_pool_(symbolPool),
+        source_(source),
+        diag_(diag) {}
 
  public:
-  bool deserializeFromPb(const pb::Package& pbPackage, ResourceTable* table) {
+  bool DeserializeFromPb(const pb::Package& pbPackage, ResourceTable* table) {
     Maybe<uint8_t> id;
     if (pbPackage.has_package_id()) {
       id = static_cast<uint8_t>(pbPackage.package_id());
@@ -74,36 +76,36 @@ class PackagePbDeserializer {
     std::map<ResourceId, ResourceNameRef> idIndex;
 
     ResourceTablePackage* pkg =
-        table->createPackage(pbPackage.package_name(), id);
+        table->CreatePackage(pbPackage.package_name(), id);
     for (const pb::Type& pbType : pbPackage.types()) {
-      const ResourceType* resType = parseResourceType(pbType.name());
+      const ResourceType* resType = ParseResourceType(pbType.name());
       if (!resType) {
-        mDiag->error(DiagMessage(mSource) << "unknown type '" << pbType.name()
+        diag_->Error(DiagMessage(source_) << "unknown type '" << pbType.name()
                                           << "'");
         return {};
       }
 
-      ResourceTableType* type = pkg->findOrCreateType(*resType);
+      ResourceTableType* type = pkg->FindOrCreateType(*resType);
 
       for (const pb::Entry& pbEntry : pbType.entries()) {
-        ResourceEntry* entry = type->findOrCreateEntry(pbEntry.name());
+        ResourceEntry* entry = type->FindOrCreateEntry(pbEntry.name());
 
         // Deserialize the symbol status (public/private with source and
         // comments).
         if (pbEntry.has_symbol_status()) {
           const pb::SymbolStatus& pbStatus = pbEntry.symbol_status();
           if (pbStatus.has_source()) {
-            deserializeSourceFromPb(pbStatus.source(), *mSourcePool,
-                                    &entry->symbolStatus.source);
+            DeserializeSourceFromPb(pbStatus.source(), *source_pool_,
+                                    &entry->symbol_status.source);
           }
 
           if (pbStatus.has_comment()) {
-            entry->symbolStatus.comment = pbStatus.comment();
+            entry->symbol_status.comment = pbStatus.comment();
           }
 
           SymbolState visibility =
-              deserializeVisibilityFromPb(pbStatus.visibility());
-          entry->symbolStatus.state = visibility;
+              DeserializeVisibilityFromPb(pbStatus.visibility());
+          entry->symbol_status.state = visibility;
 
           if (visibility == SymbolState::kPublic) {
             // This is a public symbol, we must encode the ID now if there is
@@ -112,22 +114,22 @@ class PackagePbDeserializer {
               entry->id = static_cast<uint16_t>(pbEntry.id());
             }
 
-            if (type->symbolStatus.state != SymbolState::kPublic) {
+            if (type->symbol_status.state != SymbolState::kPublic) {
               // If the type has not been made public, do so now.
-              type->symbolStatus.state = SymbolState::kPublic;
+              type->symbol_status.state = SymbolState::kPublic;
               if (pbType.has_id()) {
                 type->id = static_cast<uint8_t>(pbType.id());
               }
             }
           } else if (visibility == SymbolState::kPrivate) {
-            if (type->symbolStatus.state == SymbolState::kUndefined) {
-              type->symbolStatus.state = SymbolState::kPrivate;
+            if (type->symbol_status.state == SymbolState::kUndefined) {
+              type->symbol_status.state = SymbolState::kPrivate;
             }
           }
         }
 
         ResourceId resId(pbPackage.package_id(), pbType.id(), pbEntry.id());
-        if (resId.isValid()) {
+        if (resId.is_valid()) {
           idIndex[resId] = ResourceNameRef(pkg->name, type->type, entry->name);
         }
 
@@ -135,21 +137,21 @@ class PackagePbDeserializer {
           const pb::ConfigDescription& pbConfig = pbConfigValue.config();
 
           ConfigDescription config;
-          if (!deserializeConfigDescriptionFromPb(pbConfig, &config)) {
-            mDiag->error(DiagMessage(mSource) << "invalid configuration");
+          if (!DeserializeConfigDescriptionFromPb(pbConfig, &config)) {
+            diag_->Error(DiagMessage(source_) << "invalid configuration");
             return {};
           }
 
           ResourceConfigValue* configValue =
-              entry->findOrCreateValue(config, pbConfig.product());
+              entry->FindOrCreateValue(config, pbConfig.product());
           if (configValue->value) {
             // Duplicate config.
-            mDiag->error(DiagMessage(mSource) << "duplicate configuration");
+            diag_->Error(DiagMessage(source_) << "duplicate configuration");
             return {};
           }
 
-          configValue->value = deserializeValueFromPb(
-              pbConfigValue.value(), config, &table->stringPool);
+          configValue->value = DeserializeValueFromPb(
+              pbConfigValue.value(), config, &table->string_pool);
           if (!configValue->value) {
             return {};
           }
@@ -158,247 +160,247 @@ class PackagePbDeserializer {
     }
 
     ReferenceIdToNameVisitor visitor(&idIndex);
-    visitAllValuesInPackage(pkg, &visitor);
+    VisitAllValuesInPackage(pkg, &visitor);
     return true;
   }
 
  private:
-  std::unique_ptr<Item> deserializeItemFromPb(const pb::Item& pbItem,
+  std::unique_ptr<Item> DeserializeItemFromPb(const pb::Item& pb_item,
                                               const ConfigDescription& config,
                                               StringPool* pool) {
-    if (pbItem.has_ref()) {
-      const pb::Reference& pbRef = pbItem.ref();
+    if (pb_item.has_ref()) {
+      const pb::Reference& pb_ref = pb_item.ref();
       std::unique_ptr<Reference> ref = util::make_unique<Reference>();
-      if (!deserializeReferenceFromPb(pbRef, ref.get())) {
+      if (!DeserializeReferenceFromPb(pb_ref, ref.get())) {
         return {};
       }
       return std::move(ref);
 
-    } else if (pbItem.has_prim()) {
-      const pb::Primitive& pbPrim = pbItem.prim();
+    } else if (pb_item.has_prim()) {
+      const pb::Primitive& pb_prim = pb_item.prim();
       android::Res_value prim = {};
-      prim.dataType = static_cast<uint8_t>(pbPrim.type());
-      prim.data = pbPrim.data();
+      prim.dataType = static_cast<uint8_t>(pb_prim.type());
+      prim.data = pb_prim.data();
       return util::make_unique<BinaryPrimitive>(prim);
 
-    } else if (pbItem.has_id()) {
+    } else if (pb_item.has_id()) {
       return util::make_unique<Id>();
 
-    } else if (pbItem.has_str()) {
-      const uint32_t idx = pbItem.str().idx();
-      const std::string str = util::getString(*mValuePool, idx);
+    } else if (pb_item.has_str()) {
+      const uint32_t idx = pb_item.str().idx();
+      const std::string str = util::GetString(*value_pool_, idx);
 
-      const android::ResStringPool_span* spans = mValuePool->styleAt(idx);
+      const android::ResStringPool_span* spans = value_pool_->styleAt(idx);
       if (spans && spans->name.index != android::ResStringPool_span::END) {
-        StyleString styleStr = {str};
+        StyleString style_str = {str};
         while (spans->name.index != android::ResStringPool_span::END) {
-          styleStr.spans.push_back(
-              Span{util::getString(*mValuePool, spans->name.index),
+          style_str.spans.push_back(
+              Span{util::GetString(*value_pool_, spans->name.index),
                    spans->firstChar, spans->lastChar});
           spans++;
         }
-        return util::make_unique<StyledString>(pool->makeRef(
-            styleStr,
+        return util::make_unique<StyledString>(pool->MakeRef(
+            style_str,
             StringPool::Context(StringPool::Context::kStylePriority, config)));
       }
       return util::make_unique<String>(
-          pool->makeRef(str, StringPool::Context(config)));
+          pool->MakeRef(str, StringPool::Context(config)));
 
-    } else if (pbItem.has_raw_str()) {
-      const uint32_t idx = pbItem.raw_str().idx();
-      const std::string str = util::getString(*mValuePool, idx);
+    } else if (pb_item.has_raw_str()) {
+      const uint32_t idx = pb_item.raw_str().idx();
+      const std::string str = util::GetString(*value_pool_, idx);
       return util::make_unique<RawString>(
-          pool->makeRef(str, StringPool::Context(config)));
+          pool->MakeRef(str, StringPool::Context(config)));
 
-    } else if (pbItem.has_file()) {
-      const uint32_t idx = pbItem.file().path_idx();
-      const std::string str = util::getString(*mValuePool, idx);
-      return util::make_unique<FileReference>(pool->makeRef(
+    } else if (pb_item.has_file()) {
+      const uint32_t idx = pb_item.file().path_idx();
+      const std::string str = util::GetString(*value_pool_, idx);
+      return util::make_unique<FileReference>(pool->MakeRef(
           str,
           StringPool::Context(StringPool::Context::kHighPriority, config)));
 
     } else {
-      mDiag->error(DiagMessage(mSource) << "unknown item");
+      diag_->Error(DiagMessage(source_) << "unknown item");
     }
     return {};
   }
 
-  std::unique_ptr<Value> deserializeValueFromPb(const pb::Value& pbValue,
+  std::unique_ptr<Value> DeserializeValueFromPb(const pb::Value& pb_value,
                                                 const ConfigDescription& config,
                                                 StringPool* pool) {
-    const bool isWeak = pbValue.has_weak() ? pbValue.weak() : false;
+    const bool is_weak = pb_value.has_weak() ? pb_value.weak() : false;
 
     std::unique_ptr<Value> value;
-    if (pbValue.has_item()) {
-      value = deserializeItemFromPb(pbValue.item(), config, pool);
+    if (pb_value.has_item()) {
+      value = DeserializeItemFromPb(pb_value.item(), config, pool);
       if (!value) {
         return {};
       }
 
-    } else if (pbValue.has_compound_value()) {
-      const pb::CompoundValue& pbCompoundValue = pbValue.compound_value();
-      if (pbCompoundValue.has_attr()) {
-        const pb::Attribute& pbAttr = pbCompoundValue.attr();
-        std::unique_ptr<Attribute> attr = util::make_unique<Attribute>(isWeak);
-        attr->typeMask = pbAttr.format_flags();
-        attr->minInt = pbAttr.min_int();
-        attr->maxInt = pbAttr.max_int();
-        for (const pb::Attribute_Symbol& pbSymbol : pbAttr.symbols()) {
+    } else if (pb_value.has_compound_value()) {
+      const pb::CompoundValue& pb_compound_value = pb_value.compound_value();
+      if (pb_compound_value.has_attr()) {
+        const pb::Attribute& pb_attr = pb_compound_value.attr();
+        std::unique_ptr<Attribute> attr = util::make_unique<Attribute>(is_weak);
+        attr->type_mask = pb_attr.format_flags();
+        attr->min_int = pb_attr.min_int();
+        attr->max_int = pb_attr.max_int();
+        for (const pb::Attribute_Symbol& pb_symbol : pb_attr.symbols()) {
           Attribute::Symbol symbol;
-          deserializeItemCommon(pbSymbol, &symbol.symbol);
-          if (!deserializeReferenceFromPb(pbSymbol.name(), &symbol.symbol)) {
+          DeserializeItemCommon(pb_symbol, &symbol.symbol);
+          if (!DeserializeReferenceFromPb(pb_symbol.name(), &symbol.symbol)) {
             return {};
           }
-          symbol.value = pbSymbol.value();
+          symbol.value = pb_symbol.value();
           attr->symbols.push_back(std::move(symbol));
         }
         value = std::move(attr);
 
-      } else if (pbCompoundValue.has_style()) {
-        const pb::Style& pbStyle = pbCompoundValue.style();
+      } else if (pb_compound_value.has_style()) {
+        const pb::Style& pb_style = pb_compound_value.style();
         std::unique_ptr<Style> style = util::make_unique<Style>();
-        if (pbStyle.has_parent()) {
+        if (pb_style.has_parent()) {
           style->parent = Reference();
-          if (!deserializeReferenceFromPb(pbStyle.parent(),
+          if (!DeserializeReferenceFromPb(pb_style.parent(),
                                           &style->parent.value())) {
             return {};
           }
 
-          if (pbStyle.has_parent_source()) {
-            Source parentSource;
-            deserializeSourceFromPb(pbStyle.parent_source(), *mSourcePool,
-                                    &parentSource);
-            style->parent.value().setSource(std::move(parentSource));
+          if (pb_style.has_parent_source()) {
+            Source parent_source;
+            DeserializeSourceFromPb(pb_style.parent_source(), *source_pool_,
+                                    &parent_source);
+            style->parent.value().SetSource(std::move(parent_source));
           }
         }
 
-        for (const pb::Style_Entry& pbEntry : pbStyle.entries()) {
+        for (const pb::Style_Entry& pb_entry : pb_style.entries()) {
           Style::Entry entry;
-          deserializeItemCommon(pbEntry, &entry.key);
-          if (!deserializeReferenceFromPb(pbEntry.key(), &entry.key)) {
+          DeserializeItemCommon(pb_entry, &entry.key);
+          if (!DeserializeReferenceFromPb(pb_entry.key(), &entry.key)) {
             return {};
           }
 
-          entry.value = deserializeItemFromPb(pbEntry.item(), config, pool);
+          entry.value = DeserializeItemFromPb(pb_entry.item(), config, pool);
           if (!entry.value) {
             return {};
           }
 
-          deserializeItemCommon(pbEntry, entry.value.get());
+          DeserializeItemCommon(pb_entry, entry.value.get());
           style->entries.push_back(std::move(entry));
         }
         value = std::move(style);
 
-      } else if (pbCompoundValue.has_styleable()) {
-        const pb::Styleable& pbStyleable = pbCompoundValue.styleable();
+      } else if (pb_compound_value.has_styleable()) {
+        const pb::Styleable& pb_styleable = pb_compound_value.styleable();
         std::unique_ptr<Styleable> styleable = util::make_unique<Styleable>();
-        for (const pb::Styleable_Entry& pbEntry : pbStyleable.entries()) {
-          Reference attrRef;
-          deserializeItemCommon(pbEntry, &attrRef);
-          deserializeReferenceFromPb(pbEntry.attr(), &attrRef);
-          styleable->entries.push_back(std::move(attrRef));
+        for (const pb::Styleable_Entry& pb_entry : pb_styleable.entries()) {
+          Reference attr_ref;
+          DeserializeItemCommon(pb_entry, &attr_ref);
+          DeserializeReferenceFromPb(pb_entry.attr(), &attr_ref);
+          styleable->entries.push_back(std::move(attr_ref));
         }
         value = std::move(styleable);
 
-      } else if (pbCompoundValue.has_array()) {
-        const pb::Array& pbArray = pbCompoundValue.array();
+      } else if (pb_compound_value.has_array()) {
+        const pb::Array& pb_array = pb_compound_value.array();
         std::unique_ptr<Array> array = util::make_unique<Array>();
-        for (const pb::Array_Entry& pbEntry : pbArray.entries()) {
+        for (const pb::Array_Entry& pb_entry : pb_array.entries()) {
           std::unique_ptr<Item> item =
-              deserializeItemFromPb(pbEntry.item(), config, pool);
+              DeserializeItemFromPb(pb_entry.item(), config, pool);
           if (!item) {
             return {};
           }
 
-          deserializeItemCommon(pbEntry, item.get());
+          DeserializeItemCommon(pb_entry, item.get());
           array->items.push_back(std::move(item));
         }
         value = std::move(array);
 
-      } else if (pbCompoundValue.has_plural()) {
-        const pb::Plural& pbPlural = pbCompoundValue.plural();
+      } else if (pb_compound_value.has_plural()) {
+        const pb::Plural& pb_plural = pb_compound_value.plural();
         std::unique_ptr<Plural> plural = util::make_unique<Plural>();
-        for (const pb::Plural_Entry& pbEntry : pbPlural.entries()) {
-          size_t pluralIdx = deserializePluralEnumFromPb(pbEntry.arity());
+        for (const pb::Plural_Entry& pb_entry : pb_plural.entries()) {
+          size_t pluralIdx = DeserializePluralEnumFromPb(pb_entry.arity());
           plural->values[pluralIdx] =
-              deserializeItemFromPb(pbEntry.item(), config, pool);
+              DeserializeItemFromPb(pb_entry.item(), config, pool);
           if (!plural->values[pluralIdx]) {
             return {};
           }
 
-          deserializeItemCommon(pbEntry, plural->values[pluralIdx].get());
+          DeserializeItemCommon(pb_entry, plural->values[pluralIdx].get());
         }
         value = std::move(plural);
 
       } else {
-        mDiag->error(DiagMessage(mSource) << "unknown compound value");
+        diag_->Error(DiagMessage(source_) << "unknown compound value");
         return {};
       }
     } else {
-      mDiag->error(DiagMessage(mSource) << "unknown value");
+      diag_->Error(DiagMessage(source_) << "unknown value");
       return {};
     }
 
-    assert(value && "forgot to set value");
+    CHECK(value) << "forgot to set value";
 
-    value->setWeak(isWeak);
-    deserializeItemCommon(pbValue, value.get());
+    value->SetWeak(is_weak);
+    DeserializeItemCommon(pb_value, value.get());
     return value;
   }
 
-  bool deserializeReferenceFromPb(const pb::Reference& pbRef,
-                                  Reference* outRef) {
-    outRef->referenceType = deserializeReferenceTypeFromPb(pbRef.type());
-    outRef->privateReference = pbRef.private_();
+  bool DeserializeReferenceFromPb(const pb::Reference& pb_ref,
+                                  Reference* out_ref) {
+    out_ref->reference_type = DeserializeReferenceTypeFromPb(pb_ref.type());
+    out_ref->private_reference = pb_ref.private_();
 
-    if (!pbRef.has_id() && !pbRef.has_symbol_idx()) {
+    if (!pb_ref.has_id() && !pb_ref.has_symbol_idx()) {
       return false;
     }
 
-    if (pbRef.has_id()) {
-      outRef->id = ResourceId(pbRef.id());
+    if (pb_ref.has_id()) {
+      out_ref->id = ResourceId(pb_ref.id());
     }
 
-    if (pbRef.has_symbol_idx()) {
-      const std::string strSymbol =
-          util::getString(*mSymbolPool, pbRef.symbol_idx());
-      ResourceNameRef nameRef;
-      if (!ResourceUtils::parseResourceName(strSymbol, &nameRef, nullptr)) {
-        mDiag->error(DiagMessage(mSource) << "invalid reference name '"
-                                          << strSymbol << "'");
+    if (pb_ref.has_symbol_idx()) {
+      const std::string str_symbol =
+          util::GetString(*symbol_pool_, pb_ref.symbol_idx());
+      ResourceNameRef name_ref;
+      if (!ResourceUtils::ParseResourceName(str_symbol, &name_ref, nullptr)) {
+        diag_->Error(DiagMessage(source_) << "invalid reference name '"
+                                          << str_symbol << "'");
         return false;
       }
 
-      outRef->name = nameRef.toResourceName();
+      out_ref->name = name_ref.ToResourceName();
     }
     return true;
   }
 
   template <typename T>
-  void deserializeItemCommon(const T& pbItem, Value* outValue) {
-    if (pbItem.has_source()) {
+  void DeserializeItemCommon(const T& pb_item, Value* out_value) {
+    if (pb_item.has_source()) {
       Source source;
-      deserializeSourceFromPb(pbItem.source(), *mSourcePool, &source);
-      outValue->setSource(std::move(source));
+      DeserializeSourceFromPb(pb_item.source(), *source_pool_, &source);
+      out_value->SetSource(std::move(source));
     }
 
-    if (pbItem.has_comment()) {
-      outValue->setComment(pbItem.comment());
+    if (pb_item.has_comment()) {
+      out_value->SetComment(pb_item.comment());
     }
   }
 
  private:
-  const android::ResStringPool* mValuePool;
-  const android::ResStringPool* mSourcePool;
-  const android::ResStringPool* mSymbolPool;
-  const Source mSource;
-  IDiagnostics* mDiag;
+  const android::ResStringPool* value_pool_;
+  const android::ResStringPool* source_pool_;
+  const android::ResStringPool* symbol_pool_;
+  const Source source_;
+  IDiagnostics* diag_;
 };
 
 }  // namespace
 
-std::unique_ptr<ResourceTable> deserializeTableFromPb(
-    const pb::ResourceTable& pbTable, const Source& source,
+std::unique_ptr<ResourceTable> DeserializeTableFromPb(
+    const pb::ResourceTable& pb_table, const Source& source,
     IDiagnostics* diag) {
   // We import the android namespace because on Windows NO_ERROR is a macro, not
   // an enum, which
@@ -407,78 +409,79 @@ std::unique_ptr<ResourceTable> deserializeTableFromPb(
 
   std::unique_ptr<ResourceTable> table = util::make_unique<ResourceTable>();
 
-  if (!pbTable.has_string_pool()) {
-    diag->error(DiagMessage(source) << "no string pool found");
+  if (!pb_table.has_string_pool()) {
+    diag->Error(DiagMessage(source) << "no string pool found");
     return {};
   }
 
-  ResStringPool valuePool;
-  status_t result = valuePool.setTo(pbTable.string_pool().data().data(),
-                                    pbTable.string_pool().data().size());
+  ResStringPool value_pool;
+  status_t result = value_pool.setTo(pb_table.string_pool().data().data(),
+                                     pb_table.string_pool().data().size());
   if (result != NO_ERROR) {
-    diag->error(DiagMessage(source) << "invalid string pool");
+    diag->Error(DiagMessage(source) << "invalid string pool");
     return {};
   }
 
-  ResStringPool sourcePool;
-  if (pbTable.has_source_pool()) {
-    result = sourcePool.setTo(pbTable.source_pool().data().data(),
-                              pbTable.source_pool().data().size());
+  ResStringPool source_pool;
+  if (pb_table.has_source_pool()) {
+    result = source_pool.setTo(pb_table.source_pool().data().data(),
+                               pb_table.source_pool().data().size());
     if (result != NO_ERROR) {
-      diag->error(DiagMessage(source) << "invalid source pool");
+      diag->Error(DiagMessage(source) << "invalid source pool");
       return {};
     }
   }
 
-  ResStringPool symbolPool;
-  if (pbTable.has_symbol_pool()) {
-    result = symbolPool.setTo(pbTable.symbol_pool().data().data(),
-                              pbTable.symbol_pool().data().size());
+  ResStringPool symbol_pool;
+  if (pb_table.has_symbol_pool()) {
+    result = symbol_pool.setTo(pb_table.symbol_pool().data().data(),
+                               pb_table.symbol_pool().data().size());
     if (result != NO_ERROR) {
-      diag->error(DiagMessage(source) << "invalid symbol pool");
+      diag->Error(DiagMessage(source) << "invalid symbol pool");
       return {};
     }
   }
 
-  PackagePbDeserializer packagePbDeserializer(&valuePool, &sourcePool,
-                                              &symbolPool, source, diag);
-  for (const pb::Package& pbPackage : pbTable.packages()) {
-    if (!packagePbDeserializer.deserializeFromPb(pbPackage, table.get())) {
+  PackagePbDeserializer package_pb_deserializer(&value_pool, &source_pool,
+                                                &symbol_pool, source, diag);
+  for (const pb::Package& pb_package : pb_table.packages()) {
+    if (!package_pb_deserializer.DeserializeFromPb(pb_package, table.get())) {
       return {};
     }
   }
   return table;
 }
 
-std::unique_ptr<ResourceFile> deserializeCompiledFileFromPb(
-    const pb::CompiledFile& pbFile, const Source& source, IDiagnostics* diag) {
+std::unique_ptr<ResourceFile> DeserializeCompiledFileFromPb(
+    const pb::CompiledFile& pb_file, const Source& source, IDiagnostics* diag) {
   std::unique_ptr<ResourceFile> file = util::make_unique<ResourceFile>();
 
-  ResourceNameRef nameRef;
+  ResourceNameRef name_ref;
 
   // Need to create an lvalue here so that nameRef can point to something real.
-  if (!ResourceUtils::parseResourceName(pbFile.resource_name(), &nameRef)) {
-    diag->error(DiagMessage(source)
+  if (!ResourceUtils::ParseResourceName(pb_file.resource_name(), &name_ref)) {
+    diag->Error(DiagMessage(source)
                 << "invalid resource name in compiled file header: "
-                << pbFile.resource_name());
+                << pb_file.resource_name());
     return {};
   }
-  file->name = nameRef.toResourceName();
-  file->source.path = pbFile.source_path();
-  deserializeConfigDescriptionFromPb(pbFile.config(), &file->config);
+  file->name = name_ref.ToResourceName();
+  file->source.path = pb_file.source_path();
+  DeserializeConfigDescriptionFromPb(pb_file.config(), &file->config);
 
-  for (const pb::CompiledFile_Symbol& pbSymbol : pbFile.exported_symbols()) {
+  for (const pb::CompiledFile_Symbol& pb_symbol : pb_file.exported_symbols()) {
     // Need to create an lvalue here so that nameRef can point to something
     // real.
-    if (!ResourceUtils::parseResourceName(pbSymbol.resource_name(), &nameRef)) {
-      diag->error(DiagMessage(source)
+    if (!ResourceUtils::ParseResourceName(pb_symbol.resource_name(),
+                                          &name_ref)) {
+      diag->Error(DiagMessage(source)
                   << "invalid resource name for exported symbol in "
                      "compiled file header: "
-                  << pbFile.resource_name());
+                  << pb_file.resource_name());
       return {};
     }
-    file->exportedSymbols.push_back(
-        SourcedResourceName{nameRef.toResourceName(), pbSymbol.line_no()});
+    file->exported_symbols.push_back(
+        SourcedResourceName{name_ref.ToResourceName(), pb_symbol.line_no()});
   }
   return file;
 }
diff --git a/tools/aapt2/proto/TableProtoSerializer.cpp b/tools/aapt2/proto/TableProtoSerializer.cpp
index a5c2cbc0277bb..68db6b333bdc6 100644
--- a/tools/aapt2/proto/TableProtoSerializer.cpp
+++ b/tools/aapt2/proto/TableProtoSerializer.cpp
@@ -22,6 +22,8 @@
 #include "proto/ProtoSerialize.h"
 #include "util/BigBuffer.h"
 
+#include <android-base/logging.h>
+
 using google::protobuf::io::CodedOutputStream;
 using google::protobuf::io::CodedInputStream;
 using google::protobuf::io::ZeroCopyOutputStream;
@@ -31,179 +33,185 @@ namespace aapt {
 namespace {
 
 class PbSerializerVisitor : public RawValueVisitor {
-public:
-    using RawValueVisitor::visit;
+ public:
+  using RawValueVisitor::Visit;
 
-    /**
-     * Constructor to use when expecting to serialize any value.
-     */
-    PbSerializerVisitor(StringPool* sourcePool, StringPool* symbolPool, pb::Value* outPbValue) :
-            mSourcePool(sourcePool), mSymbolPool(symbolPool), mOutPbValue(outPbValue),
-            mOutPbItem(nullptr) {
+  /**
+   * Constructor to use when expecting to serialize any value.
+   */
+  PbSerializerVisitor(StringPool* source_pool, StringPool* symbol_pool,
+                      pb::Value* out_pb_value)
+      : source_pool_(source_pool),
+        symbol_pool_(symbol_pool),
+        out_pb_value_(out_pb_value),
+        out_pb_item_(nullptr) {}
+
+  /**
+   * Constructor to use when expecting to serialize an Item.
+   */
+  PbSerializerVisitor(StringPool* sourcePool, StringPool* symbolPool,
+                      pb::Item* outPbItem)
+      : source_pool_(sourcePool),
+        symbol_pool_(symbolPool),
+        out_pb_value_(nullptr),
+        out_pb_item_(outPbItem) {}
+
+  void Visit(Reference* ref) override {
+    SerializeReferenceToPb(*ref, pb_item()->mutable_ref());
+  }
+
+  void Visit(String* str) override {
+    pb_item()->mutable_str()->set_idx(str->value.index());
+  }
+
+  void Visit(StyledString* str) override {
+    pb_item()->mutable_str()->set_idx(str->value.index());
+  }
+
+  void Visit(FileReference* file) override {
+    pb_item()->mutable_file()->set_path_idx(file->path.index());
+  }
+
+  void Visit(Id* id) override { pb_item()->mutable_id(); }
+
+  void Visit(RawString* raw_str) override {
+    pb_item()->mutable_raw_str()->set_idx(raw_str->value.index());
+  }
+
+  void Visit(BinaryPrimitive* prim) override {
+    android::Res_value val = {};
+    prim->Flatten(&val);
+
+    pb::Primitive* pb_prim = pb_item()->mutable_prim();
+    pb_prim->set_type(val.dataType);
+    pb_prim->set_data(val.data);
+  }
+
+  void VisitItem(Item* item) override { LOG(FATAL) << "unimplemented item"; }
+
+  void Visit(Attribute* attr) override {
+    pb::Attribute* pb_attr = pb_compound_value()->mutable_attr();
+    pb_attr->set_format_flags(attr->type_mask);
+    pb_attr->set_min_int(attr->min_int);
+    pb_attr->set_max_int(attr->max_int);
+
+    for (auto& symbol : attr->symbols) {
+      pb::Attribute_Symbol* pb_symbol = pb_attr->add_symbols();
+      SerializeItemCommonToPb(symbol.symbol, pb_symbol);
+      SerializeReferenceToPb(symbol.symbol, pb_symbol->mutable_name());
+      pb_symbol->set_value(symbol.value);
+    }
+  }
+
+  void Visit(Style* style) override {
+    pb::Style* pb_style = pb_compound_value()->mutable_style();
+    if (style->parent) {
+      SerializeReferenceToPb(style->parent.value(), pb_style->mutable_parent());
+      SerializeSourceToPb(style->parent.value().GetSource(), source_pool_,
+                          pb_style->mutable_parent_source());
     }
 
-    /**
-     * Constructor to use when expecting to serialize an Item.
-     */
-    PbSerializerVisitor(StringPool* sourcePool, StringPool* symbolPool, pb::Item* outPbItem) :
-            mSourcePool(sourcePool), mSymbolPool(symbolPool), mOutPbValue(nullptr),
-            mOutPbItem(outPbItem) {
+    for (Style::Entry& entry : style->entries) {
+      pb::Style_Entry* pb_entry = pb_style->add_entries();
+      SerializeReferenceToPb(entry.key, pb_entry->mutable_key());
+
+      pb::Item* pb_item = pb_entry->mutable_item();
+      SerializeItemCommonToPb(entry.key, pb_entry);
+      PbSerializerVisitor sub_visitor(source_pool_, symbol_pool_, pb_item);
+      entry.value->Accept(&sub_visitor);
+    }
+  }
+
+  void Visit(Styleable* styleable) override {
+    pb::Styleable* pb_styleable = pb_compound_value()->mutable_styleable();
+    for (Reference& entry : styleable->entries) {
+      pb::Styleable_Entry* pb_entry = pb_styleable->add_entries();
+      SerializeItemCommonToPb(entry, pb_entry);
+      SerializeReferenceToPb(entry, pb_entry->mutable_attr());
+    }
+  }
+
+  void Visit(Array* array) override {
+    pb::Array* pb_array = pb_compound_value()->mutable_array();
+    for (auto& value : array->items) {
+      pb::Array_Entry* pb_entry = pb_array->add_entries();
+      SerializeItemCommonToPb(*value, pb_entry);
+      PbSerializerVisitor sub_visitor(source_pool_, symbol_pool_,
+                                      pb_entry->mutable_item());
+      value->Accept(&sub_visitor);
+    }
+  }
+
+  void Visit(Plural* plural) override {
+    pb::Plural* pb_plural = pb_compound_value()->mutable_plural();
+    const size_t count = plural->values.size();
+    for (size_t i = 0; i < count; i++) {
+      if (!plural->values[i]) {
+        // No plural value set here.
+        continue;
+      }
+
+      pb::Plural_Entry* pb_entry = pb_plural->add_entries();
+      pb_entry->set_arity(SerializePluralEnumToPb(i));
+      pb::Item* pb_element = pb_entry->mutable_item();
+      SerializeItemCommonToPb(*plural->values[i], pb_entry);
+      PbSerializerVisitor sub_visitor(source_pool_, symbol_pool_, pb_element);
+      plural->values[i]->Accept(&sub_visitor);
+    }
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(PbSerializerVisitor);
+
+  pb::Item* pb_item() {
+    if (out_pb_value_) {
+      return out_pb_value_->mutable_item();
+    }
+    return out_pb_item_;
+  }
+
+  pb::CompoundValue* pb_compound_value() {
+    CHECK(out_pb_value_ != nullptr);
+    return out_pb_value_->mutable_compound_value();
+  }
+
+  template <typename T>
+  void SerializeItemCommonToPb(const Item& item, T* pb_item) {
+    SerializeSourceToPb(item.GetSource(), source_pool_,
+                        pb_item->mutable_source());
+    if (!item.GetComment().empty()) {
+      pb_item->set_comment(item.GetComment());
+    }
+  }
+
+  void SerializeReferenceToPb(const Reference& ref, pb::Reference* pb_ref) {
+    if (ref.id) {
+      pb_ref->set_id(ref.id.value().id);
     }
 
-    void visit(Reference* ref) override {
-        serializeReferenceToPb(*ref, getPbItem()->mutable_ref());
+    if (ref.name) {
+      StringPool::Ref symbol_ref =
+          symbol_pool_->MakeRef(ref.name.value().ToString());
+      pb_ref->set_symbol_idx(static_cast<uint32_t>(symbol_ref.index()));
     }
 
-    void visit(String* str) override {
-        getPbItem()->mutable_str()->set_idx(str->value.getIndex());
-    }
+    pb_ref->set_private_(ref.private_reference);
+    pb_ref->set_type(SerializeReferenceTypeToPb(ref.reference_type));
+  }
 
-    void visit(StyledString* str) override {
-        getPbItem()->mutable_str()->set_idx(str->value.getIndex());
-    }
-
-    void visit(FileReference* file) override {
-        getPbItem()->mutable_file()->set_path_idx(file->path.getIndex());
-    }
-
-    void visit(Id* id) override {
-        getPbItem()->mutable_id();
-    }
-
-    void visit(RawString* rawStr) override {
-        getPbItem()->mutable_raw_str()->set_idx(rawStr->value.getIndex());
-    }
-
-    void visit(BinaryPrimitive* prim) override {
-        android::Res_value val = {};
-        prim->flatten(&val);
-
-        pb::Primitive* pbPrim = getPbItem()->mutable_prim();
-        pbPrim->set_type(val.dataType);
-        pbPrim->set_data(val.data);
-    }
-
-    void visitItem(Item* item) override {
-        assert(false && "unimplemented item");
-    }
-
-    void visit(Attribute* attr) override {
-        pb::Attribute* pbAttr = getPbCompoundValue()->mutable_attr();
-        pbAttr->set_format_flags(attr->typeMask);
-        pbAttr->set_min_int(attr->minInt);
-        pbAttr->set_max_int(attr->maxInt);
-
-        for (auto& symbol : attr->symbols) {
-            pb::Attribute_Symbol* pbSymbol = pbAttr->add_symbols();
-            serializeItemCommonToPb(symbol.symbol, pbSymbol);
-            serializeReferenceToPb(symbol.symbol, pbSymbol->mutable_name());
-            pbSymbol->set_value(symbol.value);
-        }
-    }
-
-    void visit(Style* style) override {
-        pb::Style* pbStyle = getPbCompoundValue()->mutable_style();
-        if (style->parent) {
-            serializeReferenceToPb(style->parent.value(), pbStyle->mutable_parent());
-            serializeSourceToPb(style->parent.value().getSource(),
-                                mSourcePool,
-                                pbStyle->mutable_parent_source());
-        }
-
-        for (Style::Entry& entry : style->entries) {
-            pb::Style_Entry* pbEntry = pbStyle->add_entries();
-            serializeReferenceToPb(entry.key, pbEntry->mutable_key());
-
-            pb::Item* pbItem = pbEntry->mutable_item();
-            serializeItemCommonToPb(entry.key, pbEntry);
-            PbSerializerVisitor subVisitor(mSourcePool, mSymbolPool, pbItem);
-            entry.value->accept(&subVisitor);
-        }
-    }
-
-    void visit(Styleable* styleable) override {
-        pb::Styleable* pbStyleable = getPbCompoundValue()->mutable_styleable();
-        for (Reference& entry : styleable->entries) {
-            pb::Styleable_Entry* pbEntry = pbStyleable->add_entries();
-            serializeItemCommonToPb(entry, pbEntry);
-            serializeReferenceToPb(entry, pbEntry->mutable_attr());
-        }
-    }
-
-    void visit(Array* array) override {
-        pb::Array* pbArray = getPbCompoundValue()->mutable_array();
-        for (auto& value : array->items) {
-            pb::Array_Entry* pbEntry = pbArray->add_entries();
-            serializeItemCommonToPb(*value, pbEntry);
-            PbSerializerVisitor subVisitor(mSourcePool, mSymbolPool, pbEntry->mutable_item());
-            value->accept(&subVisitor);
-        }
-    }
-
-    void visit(Plural* plural) override {
-        pb::Plural* pbPlural = getPbCompoundValue()->mutable_plural();
-        const size_t count = plural->values.size();
-        for (size_t i = 0; i < count; i++) {
-            if (!plural->values[i]) {
-                // No plural value set here.
-                continue;
-            }
-
-            pb::Plural_Entry* pbEntry = pbPlural->add_entries();
-            pbEntry->set_arity(serializePluralEnumToPb(i));
-            pb::Item* pbElement = pbEntry->mutable_item();
-            serializeItemCommonToPb(*plural->values[i], pbEntry);
-            PbSerializerVisitor subVisitor(mSourcePool, mSymbolPool, pbElement);
-            plural->values[i]->accept(&subVisitor);
-        }
-    }
-
-private:
-    pb::Item* getPbItem() {
-        if (mOutPbValue) {
-            return mOutPbValue->mutable_item();
-        }
-        return mOutPbItem;
-    }
-
-    pb::CompoundValue* getPbCompoundValue() {
-        assert(mOutPbValue);
-        return mOutPbValue->mutable_compound_value();
-    }
-
-    template <typename T>
-    void serializeItemCommonToPb(const Item& item, T* pbItem) {
-        serializeSourceToPb(item.getSource(), mSourcePool, pbItem->mutable_source());
-        if (!item.getComment().empty()) {
-            pbItem->set_comment(item.getComment());
-        }
-    }
-
-    void serializeReferenceToPb(const Reference& ref, pb::Reference* pbRef) {
-        if (ref.id) {
-            pbRef->set_id(ref.id.value().id);
-        }
-
-        if (ref.name) {
-            StringPool::Ref symbolRef = mSymbolPool->makeRef(ref.name.value().toString());
-            pbRef->set_symbol_idx(static_cast<uint32_t>(symbolRef.getIndex()));
-        }
-
-        pbRef->set_private_(ref.privateReference);
-        pbRef->set_type(serializeReferenceTypeToPb(ref.referenceType));
-    }
-
-    StringPool* mSourcePool;
-    StringPool* mSymbolPool;
-    pb::Value* mOutPbValue;
-    pb::Item* mOutPbItem;
+  StringPool* source_pool_;
+  StringPool* symbol_pool_;
+  pb::Value* out_pb_value_;
+  pb::Item* out_pb_item_;
 };
 
-} // namespace
+}  // namespace
 
-std::unique_ptr<pb::ResourceTable> serializeTableToPb(ResourceTable* table) {
-    // We must do this before writing the resources, since the string pool IDs may change.
-    table->stringPool.sort([](const StringPool::Entry& a, const StringPool::Entry& b) -> bool {
+std::unique_ptr<pb::ResourceTable> SerializeTableToPb(ResourceTable* table) {
+  // We must do this before writing the resources, since the string pool IDs may
+  // change.
+  table->string_pool.Sort(
+      [](const StringPool::Entry& a, const StringPool::Entry& b) -> bool {
         int diff = a.context.priority - b.context.priority;
         if (diff < 0) return true;
         if (diff > 0) return false;
@@ -211,192 +219,195 @@ std::unique_ptr<pb::ResourceTable> serializeTableToPb(ResourceTable* table) {
         if (diff < 0) return true;
         if (diff > 0) return false;
         return a.value < b.value;
-    });
-    table->stringPool.prune();
+      });
+  table->string_pool.Prune();
 
-    auto pbTable = util::make_unique<pb::ResourceTable>();
-    serializeStringPoolToPb(table->stringPool, pbTable->mutable_string_pool());
+  auto pb_table = util::make_unique<pb::ResourceTable>();
+  SerializeStringPoolToPb(table->string_pool, pb_table->mutable_string_pool());
 
-    StringPool sourcePool, symbolPool;
+  StringPool source_pool, symbol_pool;
 
-    for (auto& package : table->packages) {
-        pb::Package* pbPackage = pbTable->add_packages();
-        if (package->id) {
-            pbPackage->set_package_id(package->id.value());
+  for (auto& package : table->packages) {
+    pb::Package* pb_package = pb_table->add_packages();
+    if (package->id) {
+      pb_package->set_package_id(package->id.value());
+    }
+    pb_package->set_package_name(package->name);
+
+    for (auto& type : package->types) {
+      pb::Type* pb_type = pb_package->add_types();
+      if (type->id) {
+        pb_type->set_id(type->id.value());
+      }
+      pb_type->set_name(ToString(type->type).ToString());
+
+      for (auto& entry : type->entries) {
+        pb::Entry* pb_entry = pb_type->add_entries();
+        if (entry->id) {
+          pb_entry->set_id(entry->id.value());
         }
-        pbPackage->set_package_name(package->name);
+        pb_entry->set_name(entry->name);
 
-        for (auto& type : package->types) {
-            pb::Type* pbType = pbPackage->add_types();
-            if (type->id) {
-                pbType->set_id(type->id.value());
-            }
-            pbType->set_name(toString(type->type).toString());
+        // Write the SymbolStatus struct.
+        pb::SymbolStatus* pb_status = pb_entry->mutable_symbol_status();
+        pb_status->set_visibility(
+            SerializeVisibilityToPb(entry->symbol_status.state));
+        SerializeSourceToPb(entry->symbol_status.source, &source_pool,
+                            pb_status->mutable_source());
+        pb_status->set_comment(entry->symbol_status.comment);
 
-            for (auto& entry : type->entries) {
-                pb::Entry* pbEntry = pbType->add_entries();
-                if (entry->id) {
-                    pbEntry->set_id(entry->id.value());
-                }
-                pbEntry->set_name(entry->name);
+        for (auto& config_value : entry->values) {
+          pb::ConfigValue* pb_config_value = pb_entry->add_config_values();
+          SerializeConfig(config_value->config,
+                          pb_config_value->mutable_config());
+          if (!config_value->product.empty()) {
+            pb_config_value->mutable_config()->set_product(
+                config_value->product);
+          }
 
-                // Write the SymbolStatus struct.
-                pb::SymbolStatus* pbStatus = pbEntry->mutable_symbol_status();
-                pbStatus->set_visibility(serializeVisibilityToPb(entry->symbolStatus.state));
-                serializeSourceToPb(entry->symbolStatus.source, &sourcePool,
-                                    pbStatus->mutable_source());
-                pbStatus->set_comment(entry->symbolStatus.comment);
+          pb::Value* pb_value = pb_config_value->mutable_value();
+          SerializeSourceToPb(config_value->value->GetSource(), &source_pool,
+                              pb_value->mutable_source());
+          if (!config_value->value->GetComment().empty()) {
+            pb_value->set_comment(config_value->value->GetComment());
+          }
 
-                for (auto& configValue : entry->values) {
-                    pb::ConfigValue* pbConfigValue = pbEntry->add_config_values();
-                    serializeConfig(configValue->config, pbConfigValue->mutable_config());
-                    if (!configValue->product.empty()) {
-                        pbConfigValue->mutable_config()->set_product(configValue->product);
-                    }
+          if (config_value->value->IsWeak()) {
+            pb_value->set_weak(true);
+          }
 
-                    pb::Value* pbValue = pbConfigValue->mutable_value();
-                    serializeSourceToPb(configValue->value->getSource(), &sourcePool,
-                                        pbValue->mutable_source());
-                    if (!configValue->value->getComment().empty()) {
-                        pbValue->set_comment(configValue->value->getComment());
-                    }
-
-                    if (configValue->value->isWeak()) {
-                        pbValue->set_weak(true);
-                    }
-
-                    PbSerializerVisitor visitor(&sourcePool, &symbolPool, pbValue);
-                    configValue->value->accept(&visitor);
-                }
-            }
+          PbSerializerVisitor visitor(&source_pool, &symbol_pool, pb_value);
+          config_value->value->Accept(&visitor);
         }
+      }
     }
+  }
 
-    serializeStringPoolToPb(sourcePool, pbTable->mutable_source_pool());
-    serializeStringPoolToPb(symbolPool, pbTable->mutable_symbol_pool());
-    return pbTable;
+  SerializeStringPoolToPb(source_pool, pb_table->mutable_source_pool());
+  SerializeStringPoolToPb(symbol_pool, pb_table->mutable_symbol_pool());
+  return pb_table;
 }
 
-std::unique_ptr<pb::CompiledFile> serializeCompiledFileToPb(const ResourceFile& file) {
-    auto pbFile = util::make_unique<pb::CompiledFile>();
-    pbFile->set_resource_name(file.name.toString());
-    pbFile->set_source_path(file.source.path);
-    serializeConfig(file.config, pbFile->mutable_config());
+std::unique_ptr<pb::CompiledFile> SerializeCompiledFileToPb(
+    const ResourceFile& file) {
+  auto pb_file = util::make_unique<pb::CompiledFile>();
+  pb_file->set_resource_name(file.name.ToString());
+  pb_file->set_source_path(file.source.path);
+  SerializeConfig(file.config, pb_file->mutable_config());
 
-    for (const SourcedResourceName& exported : file.exportedSymbols) {
-        pb::CompiledFile_Symbol* pbSymbol = pbFile->add_exported_symbols();
-        pbSymbol->set_resource_name(exported.name.toString());
-        pbSymbol->set_line_no(exported.line);
-    }
-    return pbFile;
+  for (const SourcedResourceName& exported : file.exported_symbols) {
+    pb::CompiledFile_Symbol* pb_symbol = pb_file->add_exported_symbols();
+    pb_symbol->set_resource_name(exported.name.ToString());
+    pb_symbol->set_line_no(exported.line);
+  }
+  return pb_file;
 }
 
-CompiledFileOutputStream::CompiledFileOutputStream(ZeroCopyOutputStream* out) : mOut(out) {
-}
+CompiledFileOutputStream::CompiledFileOutputStream(ZeroCopyOutputStream* out)
+    : out_(out) {}
 
-void CompiledFileOutputStream::ensureAlignedWrite() {
-    const int padding = mOut.ByteCount() % 4;
-    if (padding > 0) {
-        uint32_t zero = 0u;
-        mOut.WriteRaw(&zero, padding);
-    }
+void CompiledFileOutputStream::EnsureAlignedWrite() {
+  const int padding = out_.ByteCount() % 4;
+  if (padding > 0) {
+    uint32_t zero = 0u;
+    out_.WriteRaw(&zero, padding);
+  }
 }
 
 void CompiledFileOutputStream::WriteLittleEndian32(uint32_t val) {
-    ensureAlignedWrite();
-    mOut.WriteLittleEndian32(val);
+  EnsureAlignedWrite();
+  out_.WriteLittleEndian32(val);
 }
 
-void CompiledFileOutputStream::WriteCompiledFile(const pb::CompiledFile* compiledFile) {
-    ensureAlignedWrite();
-    mOut.WriteLittleEndian64(static_cast<uint64_t>(compiledFile->ByteSize()));
-    compiledFile->SerializeWithCachedSizes(&mOut);
+void CompiledFileOutputStream::WriteCompiledFile(
+    const pb::CompiledFile* compiled_file) {
+  EnsureAlignedWrite();
+  out_.WriteLittleEndian64(static_cast<uint64_t>(compiled_file->ByteSize()));
+  compiled_file->SerializeWithCachedSizes(&out_);
 }
 
 void CompiledFileOutputStream::WriteData(const BigBuffer* buffer) {
-    ensureAlignedWrite();
-    mOut.WriteLittleEndian64(static_cast<uint64_t>(buffer->size()));
-    for (const BigBuffer::Block& block : *buffer) {
-        mOut.WriteRaw(block.buffer.get(), block.size);
-    }
+  EnsureAlignedWrite();
+  out_.WriteLittleEndian64(static_cast<uint64_t>(buffer->size()));
+  for (const BigBuffer::Block& block : *buffer) {
+    out_.WriteRaw(block.buffer.get(), block.size);
+  }
 }
 
 void CompiledFileOutputStream::WriteData(const void* data, size_t len) {
-    ensureAlignedWrite();
-    mOut.WriteLittleEndian64(static_cast<uint64_t>(len));
-    mOut.WriteRaw(data, len);
+  EnsureAlignedWrite();
+  out_.WriteLittleEndian64(static_cast<uint64_t>(len));
+  out_.WriteRaw(data, len);
 }
 
-bool CompiledFileOutputStream::HadError() {
-    return mOut.HadError();
+bool CompiledFileOutputStream::HadError() { return out_.HadError(); }
+
+CompiledFileInputStream::CompiledFileInputStream(const void* data, size_t size)
+    : in_(static_cast<const uint8_t*>(data), size) {}
+
+void CompiledFileInputStream::EnsureAlignedRead() {
+  const int padding = in_.CurrentPosition() % 4;
+  if (padding > 0) {
+    // Reads are always 4 byte aligned.
+    in_.Skip(padding);
+  }
 }
 
-CompiledFileInputStream::CompiledFileInputStream(const void* data, size_t size) :
-        mIn(static_cast<const uint8_t*>(data), size) {
+bool CompiledFileInputStream::ReadLittleEndian32(uint32_t* out_val) {
+  EnsureAlignedRead();
+  return in_.ReadLittleEndian32(out_val);
 }
 
-void CompiledFileInputStream::ensureAlignedRead() {
-    const int padding = mIn.CurrentPosition() % 4;
-    if (padding > 0) {
-        // Reads are always 4 byte aligned.
-        mIn.Skip(padding);
-    }
+bool CompiledFileInputStream::ReadCompiledFile(pb::CompiledFile* out_val) {
+  EnsureAlignedRead();
+
+  uint64_t pb_size = 0u;
+  if (!in_.ReadLittleEndian64(&pb_size)) {
+    return false;
+  }
+
+  CodedInputStream::Limit l = in_.PushLimit(static_cast<int>(pb_size));
+
+  // Check that we haven't tried to read past the end.
+  if (static_cast<uint64_t>(in_.BytesUntilLimit()) != pb_size) {
+    in_.PopLimit(l);
+    in_.PushLimit(0);
+    return false;
+  }
+
+  if (!out_val->ParsePartialFromCodedStream(&in_)) {
+    in_.PopLimit(l);
+    in_.PushLimit(0);
+    return false;
+  }
+
+  in_.PopLimit(l);
+  return true;
 }
 
-bool CompiledFileInputStream::ReadLittleEndian32(uint32_t* outVal) {
-    ensureAlignedRead();
-    return mIn.ReadLittleEndian32(outVal);
+bool CompiledFileInputStream::ReadDataMetaData(uint64_t* out_offset,
+                                               uint64_t* out_len) {
+  EnsureAlignedRead();
+
+  uint64_t pb_size = 0u;
+  if (!in_.ReadLittleEndian64(&pb_size)) {
+    return false;
+  }
+
+  // Check that we aren't trying to read past the end.
+  if (pb_size > static_cast<uint64_t>(in_.BytesUntilLimit())) {
+    in_.PushLimit(0);
+    return false;
+  }
+
+  uint64_t offset = static_cast<uint64_t>(in_.CurrentPosition());
+  if (!in_.Skip(pb_size)) {
+    return false;
+  }
+
+  *out_offset = offset;
+  *out_len = pb_size;
+  return true;
 }
 
-bool CompiledFileInputStream::ReadCompiledFile(pb::CompiledFile* outVal) {
-    ensureAlignedRead();
-
-    uint64_t pbSize = 0u;
-    if (!mIn.ReadLittleEndian64(&pbSize)) {
-        return false;
-    }
-
-    CodedInputStream::Limit l = mIn.PushLimit(static_cast<int>(pbSize));
-
-    // Check that we haven't tried to read past the end.
-    if (static_cast<uint64_t>(mIn.BytesUntilLimit()) != pbSize) {
-        mIn.PopLimit(l);
-        mIn.PushLimit(0);
-        return false;
-    }
-
-    if (!outVal->ParsePartialFromCodedStream(&mIn)) {
-        mIn.PopLimit(l);
-        mIn.PushLimit(0);
-        return false;
-    }
-
-    mIn.PopLimit(l);
-    return true;
-}
-
-bool CompiledFileInputStream::ReadDataMetaData(uint64_t* outOffset, uint64_t* outLen) {
-    ensureAlignedRead();
-
-    uint64_t pbSize = 0u;
-    if (!mIn.ReadLittleEndian64(&pbSize)) {
-        return false;
-    }
-
-    // Check that we aren't trying to read past the end.
-    if (pbSize > static_cast<uint64_t>(mIn.BytesUntilLimit())) {
-        mIn.PushLimit(0);
-        return false;
-    }
-
-    uint64_t offset = static_cast<uint64_t>(mIn.CurrentPosition());
-    if (!mIn.Skip(pbSize)) {
-        return false;
-    }
-
-    *outOffset = offset;
-    *outLen = pbSize;
-    return true;
-}
-
-} // namespace aapt
+}  // namespace aapt
diff --git a/tools/aapt2/proto/TableProtoSerializer_test.cpp b/tools/aapt2/proto/TableProtoSerializer_test.cpp
index 2bd976796f531..fdd5197167efd 100644
--- a/tools/aapt2/proto/TableProtoSerializer_test.cpp
+++ b/tools/aapt2/proto/TableProtoSerializer_test.cpp
@@ -14,200 +14,211 @@
  * limitations under the License.
  */
 
-#include "ResourceTable.h"
 #include "proto/ProtoSerialize.h"
+
+#include "ResourceTable.h"
 #include "test/Test.h"
 
-using namespace google::protobuf::io;
+using ::google::protobuf::io::StringOutputStream;
 
 namespace aapt {
 
 TEST(TableProtoSerializer, SerializeSinglePackage) {
-    std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
-    std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
-            .setPackageId("com.app.a", 0x7f)
-            .addFileReference("com.app.a:layout/main", ResourceId(0x7f020000),
-                              "res/layout/main.xml")
-            .addReference("com.app.a:layout/other", ResourceId(0x7f020001),
-                          "com.app.a:layout/main")
-            .addString("com.app.a:string/text", {}, "hi")
-            .addValue("com.app.a:id/foo", {}, util::make_unique<Id>())
-            .build();
+  std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
+  std::unique_ptr<ResourceTable> table =
+      test::ResourceTableBuilder()
+          .SetPackageId("com.app.a", 0x7f)
+          .AddFileReference("com.app.a:layout/main", ResourceId(0x7f020000),
+                            "res/layout/main.xml")
+          .AddReference("com.app.a:layout/other", ResourceId(0x7f020001),
+                        "com.app.a:layout/main")
+          .AddString("com.app.a:string/text", {}, "hi")
+          .AddValue("com.app.a:id/foo", {}, util::make_unique<Id>())
+          .Build();
 
-    Symbol publicSymbol;
-    publicSymbol.state = SymbolState::kPublic;
-    ASSERT_TRUE(table->setSymbolState(test::parseNameOrDie("com.app.a:layout/main"),
-                                      ResourceId(0x7f020000),
-                                      publicSymbol, context->getDiagnostics()));
+  Symbol public_symbol;
+  public_symbol.state = SymbolState::kPublic;
+  ASSERT_TRUE(table->SetSymbolState(
+      test::ParseNameOrDie("com.app.a:layout/main"), ResourceId(0x7f020000),
+      public_symbol, context->GetDiagnostics()));
 
-    Id* id = test::getValue<Id>(table.get(), "com.app.a:id/foo");
-    ASSERT_NE(nullptr, id);
+  Id* id = test::GetValue<Id>(table.get(), "com.app.a:id/foo");
+  ASSERT_NE(nullptr, id);
 
-    // Make a plural.
-    std::unique_ptr<Plural> plural = util::make_unique<Plural>();
-    plural->values[Plural::One] = util::make_unique<String>(table->stringPool.makeRef("one"));
-    ASSERT_TRUE(table->addResource(test::parseNameOrDie("com.app.a:plurals/hey"),
-                                   ConfigDescription{}, {}, std::move(plural),
-                                   context->getDiagnostics()));
+  // Make a plural.
+  std::unique_ptr<Plural> plural = util::make_unique<Plural>();
+  plural->values[Plural::One] =
+      util::make_unique<String>(table->string_pool.MakeRef("one"));
+  ASSERT_TRUE(table->AddResource(test::ParseNameOrDie("com.app.a:plurals/hey"),
+                                 ConfigDescription{}, {}, std::move(plural),
+                                 context->GetDiagnostics()));
 
-    // Make a resource with different products.
-    ASSERT_TRUE(table->addResource(test::parseNameOrDie("com.app.a:integer/one"),
-                                   test::parseConfigOrDie("land"), {},
-                                   test::buildPrimitive(android::Res_value::TYPE_INT_DEC, 123u),
-                                   context->getDiagnostics()));
-    ASSERT_TRUE(table->addResource(test::parseNameOrDie("com.app.a:integer/one"),
-                                       test::parseConfigOrDie("land"), "tablet",
-                                       test::buildPrimitive(android::Res_value::TYPE_INT_DEC, 321u),
-                                       context->getDiagnostics()));
+  // Make a resource with different products.
+  ASSERT_TRUE(table->AddResource(
+      test::ParseNameOrDie("com.app.a:integer/one"),
+      test::ParseConfigOrDie("land"), {},
+      test::BuildPrimitive(android::Res_value::TYPE_INT_DEC, 123u),
+      context->GetDiagnostics()));
+  ASSERT_TRUE(table->AddResource(
+      test::ParseNameOrDie("com.app.a:integer/one"),
+      test::ParseConfigOrDie("land"), "tablet",
+      test::BuildPrimitive(android::Res_value::TYPE_INT_DEC, 321u),
+      context->GetDiagnostics()));
 
-    // Make a reference with both resource name and resource ID.
-    // The reference should point to a resource outside of this table to test that both
-    // name and id get serialized.
-    Reference expectedRef;
-    expectedRef.name = test::parseNameOrDie("android:layout/main");
-    expectedRef.id = ResourceId(0x01020000);
-    ASSERT_TRUE(table->addResource(test::parseNameOrDie("com.app.a:layout/abc"),
-                                   ConfigDescription::defaultConfig(), {},
-                                   util::make_unique<Reference>(expectedRef),
-                                   context->getDiagnostics()));
+  // Make a reference with both resource name and resource ID.
+  // The reference should point to a resource outside of this table to test that
+  // both
+  // name and id get serialized.
+  Reference expected_ref;
+  expected_ref.name = test::ParseNameOrDie("android:layout/main");
+  expected_ref.id = ResourceId(0x01020000);
+  ASSERT_TRUE(table->AddResource(test::ParseNameOrDie("com.app.a:layout/abc"),
+                                 ConfigDescription::DefaultConfig(), {},
+                                 util::make_unique<Reference>(expected_ref),
+                                 context->GetDiagnostics()));
 
-    std::unique_ptr<pb::ResourceTable> pbTable = serializeTableToPb(table.get());
-    ASSERT_NE(nullptr, pbTable);
+  std::unique_ptr<pb::ResourceTable> pb_table = SerializeTableToPb(table.get());
+  ASSERT_NE(nullptr, pb_table);
 
-    std::unique_ptr<ResourceTable> newTable = deserializeTableFromPb(*pbTable,
-                                                                     Source{ "test" },
-                                                                     context->getDiagnostics());
-    ASSERT_NE(nullptr, newTable);
+  std::unique_ptr<ResourceTable> new_table = DeserializeTableFromPb(
+      *pb_table, Source{"test"}, context->GetDiagnostics());
+  ASSERT_NE(nullptr, new_table);
 
-    Id* newId = test::getValue<Id>(newTable.get(), "com.app.a:id/foo");
-    ASSERT_NE(nullptr, newId);
-    EXPECT_EQ(id->isWeak(), newId->isWeak());
+  Id* new_id = test::GetValue<Id>(new_table.get(), "com.app.a:id/foo");
+  ASSERT_NE(nullptr, new_id);
+  EXPECT_EQ(id->IsWeak(), new_id->IsWeak());
 
-    Maybe<ResourceTable::SearchResult> result = newTable->findResource(
-            test::parseNameOrDie("com.app.a:layout/main"));
-    AAPT_ASSERT_TRUE(result);
-    EXPECT_EQ(SymbolState::kPublic, result.value().type->symbolStatus.state);
-    EXPECT_EQ(SymbolState::kPublic, result.value().entry->symbolStatus.state);
+  Maybe<ResourceTable::SearchResult> result =
+      new_table->FindResource(test::ParseNameOrDie("com.app.a:layout/main"));
+  AAPT_ASSERT_TRUE(result);
+  EXPECT_EQ(SymbolState::kPublic, result.value().type->symbol_status.state);
+  EXPECT_EQ(SymbolState::kPublic, result.value().entry->symbol_status.state);
 
-    // Find the product-dependent values
-    BinaryPrimitive* prim = test::getValueForConfigAndProduct<BinaryPrimitive>(
-            newTable.get(), "com.app.a:integer/one", test::parseConfigOrDie("land"), "");
-    ASSERT_NE(nullptr, prim);
-    EXPECT_EQ(123u, prim->value.data);
+  // Find the product-dependent values
+  BinaryPrimitive* prim = test::GetValueForConfigAndProduct<BinaryPrimitive>(
+      new_table.get(), "com.app.a:integer/one", test::ParseConfigOrDie("land"),
+      "");
+  ASSERT_NE(nullptr, prim);
+  EXPECT_EQ(123u, prim->value.data);
 
-    prim = test::getValueForConfigAndProduct<BinaryPrimitive>(
-            newTable.get(), "com.app.a:integer/one", test::parseConfigOrDie("land"), "tablet");
-    ASSERT_NE(nullptr, prim);
-    EXPECT_EQ(321u, prim->value.data);
+  prim = test::GetValueForConfigAndProduct<BinaryPrimitive>(
+      new_table.get(), "com.app.a:integer/one", test::ParseConfigOrDie("land"),
+      "tablet");
+  ASSERT_NE(nullptr, prim);
+  EXPECT_EQ(321u, prim->value.data);
 
-    Reference* actualRef = test::getValue<Reference>(newTable.get(), "com.app.a:layout/abc");
-    ASSERT_NE(nullptr, actualRef);
-    AAPT_ASSERT_TRUE(actualRef->name);
-    AAPT_ASSERT_TRUE(actualRef->id);
-    EXPECT_EQ(expectedRef.name.value(), actualRef->name.value());
-    EXPECT_EQ(expectedRef.id.value(), actualRef->id.value());
+  Reference* actual_ref =
+      test::GetValue<Reference>(new_table.get(), "com.app.a:layout/abc");
+  ASSERT_NE(nullptr, actual_ref);
+  AAPT_ASSERT_TRUE(actual_ref->name);
+  AAPT_ASSERT_TRUE(actual_ref->id);
+  EXPECT_EQ(expected_ref.name.value(), actual_ref->name.value());
+  EXPECT_EQ(expected_ref.id.value(), actual_ref->id.value());
 }
 
 TEST(TableProtoSerializer, SerializeFileHeader) {
-    std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
+  std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
 
-    ResourceFile f;
-    f.config = test::parseConfigOrDie("hdpi-v9");
-    f.name = test::parseNameOrDie("com.app.a:layout/main");
-    f.source.path = "res/layout-hdpi-v9/main.xml";
-    f.exportedSymbols.push_back(SourcedResourceName{ test::parseNameOrDie("id/unchecked"), 23u });
+  ResourceFile f;
+  f.config = test::ParseConfigOrDie("hdpi-v9");
+  f.name = test::ParseNameOrDie("com.app.a:layout/main");
+  f.source.path = "res/layout-hdpi-v9/main.xml";
+  f.exported_symbols.push_back(
+      SourcedResourceName{test::ParseNameOrDie("id/unchecked"), 23u});
 
-    const std::string expectedData1 = "123";
-    const std::string expectedData2 = "1234";
+  const std::string expected_data1 = "123";
+  const std::string expected_data2 = "1234";
 
-    std::string outputStr;
-    {
-        std::unique_ptr<pb::CompiledFile> pbFile1 = serializeCompiledFileToPb(f);
+  std::string output_str;
+  {
+    std::unique_ptr<pb::CompiledFile> pb_file1 = SerializeCompiledFileToPb(f);
 
-        f.name.entry = "__" + f.name.entry + "$0";
-        std::unique_ptr<pb::CompiledFile> pbFile2 = serializeCompiledFileToPb(f);
+    f.name.entry = "__" + f.name.entry + "$0";
+    std::unique_ptr<pb::CompiledFile> pb_file2 = SerializeCompiledFileToPb(f);
 
-        StringOutputStream outStream(&outputStr);
-        CompiledFileOutputStream outFileStream(&outStream);
-        outFileStream.WriteLittleEndian32(2);
-        outFileStream.WriteCompiledFile(pbFile1.get());
-        outFileStream.WriteData(expectedData1.data(), expectedData1.size());
-        outFileStream.WriteCompiledFile(pbFile2.get());
-        outFileStream.WriteData(expectedData2.data(), expectedData2.size());
-        ASSERT_FALSE(outFileStream.HadError());
-    }
+    StringOutputStream out_stream(&output_str);
+    CompiledFileOutputStream out_file_stream(&out_stream);
+    out_file_stream.WriteLittleEndian32(2);
+    out_file_stream.WriteCompiledFile(pb_file1.get());
+    out_file_stream.WriteData(expected_data1.data(), expected_data1.size());
+    out_file_stream.WriteCompiledFile(pb_file2.get());
+    out_file_stream.WriteData(expected_data2.data(), expected_data2.size());
+    ASSERT_FALSE(out_file_stream.HadError());
+  }
 
-    CompiledFileInputStream inFileStream(outputStr.data(), outputStr.size());
-    uint32_t numFiles = 0;
-    ASSERT_TRUE(inFileStream.ReadLittleEndian32(&numFiles));
-    ASSERT_EQ(2u, numFiles);
+  CompiledFileInputStream in_file_stream(output_str.data(), output_str.size());
+  uint32_t num_files = 0;
+  ASSERT_TRUE(in_file_stream.ReadLittleEndian32(&num_files));
+  ASSERT_EQ(2u, num_files);
 
-    // Read the first compiled file.
+  // Read the first compiled file.
 
-    pb::CompiledFile newPbFile;
-    ASSERT_TRUE(inFileStream.ReadCompiledFile(&newPbFile));
+  pb::CompiledFile new_pb_file;
+  ASSERT_TRUE(in_file_stream.ReadCompiledFile(&new_pb_file));
 
-    std::unique_ptr<ResourceFile> file = deserializeCompiledFileFromPb(newPbFile, Source("test"),
-                                                                       context->getDiagnostics());
-    ASSERT_NE(nullptr, file);
+  std::unique_ptr<ResourceFile> file = DeserializeCompiledFileFromPb(
+      new_pb_file, Source("test"), context->GetDiagnostics());
+  ASSERT_NE(nullptr, file);
 
-    uint64_t offset, len;
-    ASSERT_TRUE(inFileStream.ReadDataMetaData(&offset, &len));
+  uint64_t offset, len;
+  ASSERT_TRUE(in_file_stream.ReadDataMetaData(&offset, &len));
 
-    std::string actualData(outputStr.data() + offset, len);
-    EXPECT_EQ(expectedData1, actualData);
+  std::string actual_data(output_str.data() + offset, len);
+  EXPECT_EQ(expected_data1, actual_data);
 
-    // Expect the data to be aligned.
-    EXPECT_EQ(0u, offset & 0x03);
+  // Expect the data to be aligned.
+  EXPECT_EQ(0u, offset & 0x03);
 
-    ASSERT_EQ(1u, file->exportedSymbols.size());
-    EXPECT_EQ(test::parseNameOrDie("id/unchecked"), file->exportedSymbols[0].name);
+  ASSERT_EQ(1u, file->exported_symbols.size());
+  EXPECT_EQ(test::ParseNameOrDie("id/unchecked"),
+            file->exported_symbols[0].name);
 
-    // Read the second compiled file.
+  // Read the second compiled file.
 
-    ASSERT_TRUE(inFileStream.ReadCompiledFile(&newPbFile));
+  ASSERT_TRUE(in_file_stream.ReadCompiledFile(&new_pb_file));
 
-    file = deserializeCompiledFileFromPb(newPbFile, Source("test"), context->getDiagnostics());
-    ASSERT_NE(nullptr, file);
+  file = DeserializeCompiledFileFromPb(new_pb_file, Source("test"),
+                                       context->GetDiagnostics());
+  ASSERT_NE(nullptr, file);
 
-    ASSERT_TRUE(inFileStream.ReadDataMetaData(&offset, &len));
+  ASSERT_TRUE(in_file_stream.ReadDataMetaData(&offset, &len));
 
-    actualData = std::string(outputStr.data() + offset, len);
-    EXPECT_EQ(expectedData2, actualData);
+  actual_data = std::string(output_str.data() + offset, len);
+  EXPECT_EQ(expected_data2, actual_data);
 
-    // Expect the data to be aligned.
-    EXPECT_EQ(0u, offset & 0x03);
+  // Expect the data to be aligned.
+  EXPECT_EQ(0u, offset & 0x03);
 }
 
 TEST(TableProtoSerializer, DeserializeCorruptHeaderSafely) {
-    ResourceFile f;
-    std::unique_ptr<pb::CompiledFile> pbFile = serializeCompiledFileToPb(f);
+  ResourceFile f;
+  std::unique_ptr<pb::CompiledFile> pb_file = SerializeCompiledFileToPb(f);
 
-    const std::string expectedData = "1234";
+  const std::string expected_data = "1234";
 
-    std::string outputStr;
-    {
-        StringOutputStream outStream(&outputStr);
-        CompiledFileOutputStream outFileStream(&outStream);
-        outFileStream.WriteLittleEndian32(1);
-        outFileStream.WriteCompiledFile(pbFile.get());
-        outFileStream.WriteData(expectedData.data(), expectedData.size());
-        ASSERT_FALSE(outFileStream.HadError());
-    }
+  std::string output_str;
+  {
+    StringOutputStream out_stream(&output_str);
+    CompiledFileOutputStream out_file_stream(&out_stream);
+    out_file_stream.WriteLittleEndian32(1);
+    out_file_stream.WriteCompiledFile(pb_file.get());
+    out_file_stream.WriteData(expected_data.data(), expected_data.size());
+    ASSERT_FALSE(out_file_stream.HadError());
+  }
 
-    outputStr[4] = 0xff;
+  output_str[4] = 0xff;
 
-    CompiledFileInputStream inFileStream(outputStr.data(), outputStr.size());
+  CompiledFileInputStream in_file_stream(output_str.data(), output_str.size());
 
-    uint32_t numFiles = 0;
-    EXPECT_TRUE(inFileStream.ReadLittleEndian32(&numFiles));
-    EXPECT_EQ(1u, numFiles);
+  uint32_t num_files = 0;
+  EXPECT_TRUE(in_file_stream.ReadLittleEndian32(&num_files));
+  EXPECT_EQ(1u, num_files);
 
-    pb::CompiledFile newPbFile;
-    EXPECT_FALSE(inFileStream.ReadCompiledFile(&newPbFile));
+  pb::CompiledFile new_pb_file;
+  EXPECT_FALSE(in_file_stream.ReadCompiledFile(&new_pb_file));
 
-    uint64_t offset, len;
-    EXPECT_FALSE(inFileStream.ReadDataMetaData(&offset, &len));
+  uint64_t offset, len;
+  EXPECT_FALSE(in_file_stream.ReadDataMetaData(&offset, &len));
 }
 
-} // namespace aapt
+}  // namespace aapt
diff --git a/tools/aapt2/split/TableSplitter.cpp b/tools/aapt2/split/TableSplitter.cpp
index 08b9ee9cbe1bd..7aad86fa72577 100644
--- a/tools/aapt2/split/TableSplitter.cpp
+++ b/tools/aapt2/split/TableSplitter.cpp
@@ -14,251 +14,278 @@
  * limitations under the License.
  */
 
-#include "ConfigDescription.h"
-#include "ResourceTable.h"
 #include "split/TableSplitter.h"
-#include "util/Util.h"
 
 #include <algorithm>
 #include <map>
 #include <set>
 #include <unordered_map>
 #include <vector>
+#include "android-base/logging.h"
+
+#include "ConfigDescription.h"
+#include "ResourceTable.h"
+#include "util/Util.h"
 
 namespace aapt {
 
 using ConfigClaimedMap = std::unordered_map<ResourceConfigValue*, bool>;
-using ConfigDensityGroups = std::map<ConfigDescription, std::vector<ResourceConfigValue*>>;
+using ConfigDensityGroups =
+    std::map<ConfigDescription, std::vector<ResourceConfigValue*>>;
 
-static ConfigDescription copyWithoutDensity(const ConfigDescription& config) {
-    ConfigDescription withoutDensity = config;
-    withoutDensity.density = 0;
-    return withoutDensity;
+static ConfigDescription CopyWithoutDensity(const ConfigDescription& config) {
+  ConfigDescription without_density = config;
+  without_density.density = 0;
+  return without_density;
 }
 
 /**
  * Selects values that match exactly the constraints given.
  */
 class SplitValueSelector {
-public:
-    explicit SplitValueSelector(const SplitConstraints& constraints) {
-        for (const ConfigDescription& config : constraints.configs) {
-            if (config.density == 0) {
-                mDensityIndependentConfigs.insert(config);
-            } else {
-                mDensityDependentConfigToDensityMap[copyWithoutDensity(config)] = config.density;
-            }
+ public:
+  explicit SplitValueSelector(const SplitConstraints& constraints) {
+    for (const ConfigDescription& config : constraints.configs) {
+      if (config.density == 0) {
+        density_independent_configs_.insert(config);
+      } else {
+        density_dependent_config_to_density_map_[CopyWithoutDensity(config)] =
+            config.density;
+      }
+    }
+  }
+
+  std::vector<ResourceConfigValue*> SelectValues(
+      const ConfigDensityGroups& density_groups,
+      ConfigClaimedMap* claimed_values) {
+    std::vector<ResourceConfigValue*> selected;
+
+    // Select the regular values.
+    for (auto& entry : *claimed_values) {
+      // Check if the entry has a density.
+      ResourceConfigValue* config_value = entry.first;
+      if (config_value->config.density == 0 && !entry.second) {
+        // This is still available.
+        if (density_independent_configs_.find(config_value->config) !=
+            density_independent_configs_.end()) {
+          selected.push_back(config_value);
+
+          // Mark the entry as taken.
+          entry.second = true;
         }
+      }
     }
 
-    std::vector<ResourceConfigValue*> selectValues(const ConfigDensityGroups& densityGroups,
-                                                   ConfigClaimedMap* claimedValues) {
-        std::vector<ResourceConfigValue*> selected;
+    // Now examine the densities
+    for (auto& entry : density_groups) {
+      // We do not care if the value is claimed, since density values can be
+      // in multiple splits.
+      const ConfigDescription& config = entry.first;
+      const std::vector<ResourceConfigValue*>& related_values = entry.second;
+      auto density_value_iter =
+          density_dependent_config_to_density_map_.find(config);
+      if (density_value_iter !=
+          density_dependent_config_to_density_map_.end()) {
+        // Select the best one!
+        ConfigDescription target_density = config;
+        target_density.density = density_value_iter->second;
 
-        // Select the regular values.
-        for (auto& entry : *claimedValues) {
-            // Check if the entry has a density.
-            ResourceConfigValue* configValue = entry.first;
-            if (configValue->config.density == 0 && !entry.second) {
-                // This is still available.
-                if (mDensityIndependentConfigs.find(configValue->config) !=
-                        mDensityIndependentConfigs.end()) {
-                    selected.push_back(configValue);
-
-                    // Mark the entry as taken.
-                    entry.second = true;
-                }
-            }
+        ResourceConfigValue* best_value = nullptr;
+        for (ResourceConfigValue* this_value : related_values) {
+          if (!best_value ||
+              this_value->config.isBetterThan(best_value->config,
+                                              &target_density)) {
+            best_value = this_value;
+          }
         }
+        CHECK(best_value != nullptr);
 
-        // Now examine the densities
-        for (auto& entry : densityGroups) {
-            // We do not care if the value is claimed, since density values can be
-            // in multiple splits.
-            const ConfigDescription& config = entry.first;
-            const std::vector<ResourceConfigValue*>& relatedValues = entry.second;
-            auto densityValueIter = mDensityDependentConfigToDensityMap.find(config);
-            if (densityValueIter != mDensityDependentConfigToDensityMap.end()) {
-                // Select the best one!
-                ConfigDescription targetDensity = config;
-                targetDensity.density = densityValueIter->second;
-
-                ResourceConfigValue* bestValue = nullptr;
-                for (ResourceConfigValue* thisValue : relatedValues) {
-                    if (!bestValue ||
-                            thisValue->config.isBetterThan(bestValue->config, &targetDensity)) {
-                        bestValue = thisValue;
-                    }
-                }
-                assert(bestValue);
-
-                // When we select one of these, they are all claimed such that the base
-                // doesn't include any anymore.
-                (*claimedValues)[bestValue] = true;
-                selected.push_back(bestValue);
-            }
-        }
-        return selected;
+        // When we select one of these, they are all claimed such that the base
+        // doesn't include any anymore.
+        (*claimed_values)[best_value] = true;
+        selected.push_back(best_value);
+      }
     }
+    return selected;
+  }
 
-private:
-    std::set<ConfigDescription> mDensityIndependentConfigs;
-    std::map<ConfigDescription, uint16_t> mDensityDependentConfigToDensityMap;
+ private:
+  DISALLOW_COPY_AND_ASSIGN(SplitValueSelector);
+
+  std::set<ConfigDescription> density_independent_configs_;
+  std::map<ConfigDescription, uint16_t>
+      density_dependent_config_to_density_map_;
 };
 
 /**
- * Marking non-preferred densities as claimed will make sure the base doesn't include them,
+ * Marking non-preferred densities as claimed will make sure the base doesn't
+ * include them,
  * leaving only the preferred density behind.
  */
-static void markNonPreferredDensitiesAsClaimed(uint16_t preferredDensity,
-                                               const ConfigDensityGroups& densityGroups,
-                                               ConfigClaimedMap* configClaimedMap) {
-    for (auto& entry : densityGroups) {
-        const ConfigDescription& config = entry.first;
-        const std::vector<ResourceConfigValue*>& relatedValues = entry.second;
+static void MarkNonPreferredDensitiesAsClaimed(
+    uint16_t preferred_density, const ConfigDensityGroups& density_groups,
+    ConfigClaimedMap* config_claimed_map) {
+  for (auto& entry : density_groups) {
+    const ConfigDescription& config = entry.first;
+    const std::vector<ResourceConfigValue*>& related_values = entry.second;
 
-        ConfigDescription targetDensity = config;
-        targetDensity.density = preferredDensity;
-        ResourceConfigValue* bestValue = nullptr;
-        for (ResourceConfigValue* thisValue : relatedValues) {
-            if (!bestValue) {
-                bestValue = thisValue;
-            } else if (thisValue->config.isBetterThan(bestValue->config, &targetDensity)) {
-                // Claim the previous value so that it is not included in the base.
-                (*configClaimedMap)[bestValue] = true;
-                bestValue = thisValue;
-            } else {
-                // Claim this value so that it is not included in the base.
-                (*configClaimedMap)[thisValue] = true;
-            }
-        }
-        assert(bestValue);
+    ConfigDescription target_density = config;
+    target_density.density = preferred_density;
+    ResourceConfigValue* best_value = nullptr;
+    for (ResourceConfigValue* this_value : related_values) {
+      if (!best_value) {
+        best_value = this_value;
+      } else if (this_value->config.isBetterThan(best_value->config,
+                                                 &target_density)) {
+        // Claim the previous value so that it is not included in the base.
+        (*config_claimed_map)[best_value] = true;
+        best_value = this_value;
+      } else {
+        // Claim this value so that it is not included in the base.
+        (*config_claimed_map)[this_value] = true;
+      }
     }
+    CHECK(best_value != nullptr);
+  }
 }
-bool TableSplitter::verifySplitConstraints(IAaptContext* context) {
-    bool error = false;
-    for (size_t i = 0; i < mSplitConstraints.size(); i++) {
-        for (size_t j = i + 1; j < mSplitConstraints.size(); j++) {
-            for (const ConfigDescription& config : mSplitConstraints[i].configs) {
-                if (mSplitConstraints[j].configs.find(config) !=
-                        mSplitConstraints[j].configs.end()) {
-                    context->getDiagnostics()->error(DiagMessage() << "config '" << config
-                                                     << "' appears in multiple splits, "
-                                                     << "target split ambiguous");
-                    error = true;
-                }
-            }
+bool TableSplitter::VerifySplitConstraints(IAaptContext* context) {
+  bool error = false;
+  for (size_t i = 0; i < split_constraints_.size(); i++) {
+    for (size_t j = i + 1; j < split_constraints_.size(); j++) {
+      for (const ConfigDescription& config : split_constraints_[i].configs) {
+        if (split_constraints_[j].configs.find(config) !=
+            split_constraints_[j].configs.end()) {
+          context->GetDiagnostics()->Error(DiagMessage()
+                                           << "config '" << config
+                                           << "' appears in multiple splits, "
+                                           << "target split ambiguous");
+          error = true;
         }
+      }
     }
-    return !error;
+  }
+  return !error;
 }
 
-void TableSplitter::splitTable(ResourceTable* originalTable) {
-    const size_t splitCount = mSplitConstraints.size();
-    for (auto& pkg : originalTable->packages) {
-        // Initialize all packages for splits.
-        for (size_t idx = 0; idx < splitCount; idx++) {
-            ResourceTable* splitTable = mSplits[idx].get();
-            splitTable->createPackage(pkg->name, pkg->id);
-        }
-
-        for (auto& type : pkg->types) {
-            if (type->type == ResourceType::kMipmap) {
-                // Always keep mipmaps.
-                continue;
-            }
-
-            for (auto& entry : type->entries) {
-                if (mConfigFilter) {
-                    // First eliminate any resource that we definitely don't want.
-                    for (std::unique_ptr<ResourceConfigValue>& configValue : entry->values) {
-                        if (!mConfigFilter->match(configValue->config)) {
-                            // null out the entry. We will clean up and remove nulls at the end
-                            // for performance reasons.
-                            configValue.reset();
-                        }
-                    }
-                }
-
-                // Organize the values into two separate buckets. Those that are density-dependent
-                // and those that are density-independent.
-                // One density technically matches all density, it's just that some densities
-                // match better. So we need to be aware of the full set of densities to make this
-                // decision.
-                ConfigDensityGroups densityGroups;
-                ConfigClaimedMap configClaimedMap;
-                for (const std::unique_ptr<ResourceConfigValue>& configValue : entry->values) {
-                    if (configValue) {
-                        configClaimedMap[configValue.get()] = false;
-
-                        if (configValue->config.density != 0) {
-                            // Create a bucket for this density-dependent config.
-                            densityGroups[copyWithoutDensity(configValue->config)]
-                                          .push_back(configValue.get());
-                        }
-                    }
-                }
-
-                // First we check all the splits. If it doesn't match one of the splits, we
-                // leave it in the base.
-                for (size_t idx = 0; idx < splitCount; idx++) {
-                    const SplitConstraints& splitConstraint = mSplitConstraints[idx];
-                    ResourceTable* splitTable = mSplits[idx].get();
-
-                    // Select the values we want from this entry for this split.
-                    SplitValueSelector selector(splitConstraint);
-                    std::vector<ResourceConfigValue*> selectedValues =
-                            selector.selectValues(densityGroups, &configClaimedMap);
-
-                    // No need to do any work if we selected nothing.
-                    if (!selectedValues.empty()) {
-                        // Create the same resource structure in the split. We do this lazily
-                        // because we might not have actual values for each type/entry.
-                        ResourceTablePackage* splitPkg = splitTable->findPackage(pkg->name);
-                        ResourceTableType* splitType = splitPkg->findOrCreateType(type->type);
-                        if (!splitType->id) {
-                            splitType->id = type->id;
-                            splitType->symbolStatus = type->symbolStatus;
-                        }
-
-                        ResourceEntry* splitEntry = splitType->findOrCreateEntry(entry->name);
-                        if (!splitEntry->id) {
-                            splitEntry->id = entry->id;
-                            splitEntry->symbolStatus = entry->symbolStatus;
-                        }
-
-                        // Copy the selected values into the new Split Entry.
-                        for (ResourceConfigValue* configValue : selectedValues) {
-                            ResourceConfigValue* newConfigValue = splitEntry->findOrCreateValue(
-                                    configValue->config, configValue->product);
-                            newConfigValue->value = std::unique_ptr<Value>(
-                                    configValue->value->clone(&splitTable->stringPool));
-                        }
-                    }
-                }
-
-                if (mPreferredDensity) {
-                    markNonPreferredDensitiesAsClaimed(mPreferredDensity.value(),
-                                                       densityGroups,
-                                                       &configClaimedMap);
-                }
-
-                // All splits are handled, now check to see what wasn't claimed and remove
-                // whatever exists in other splits.
-                for (std::unique_ptr<ResourceConfigValue>& configValue : entry->values) {
-                    if (configValue && configClaimedMap[configValue.get()]) {
-                        // Claimed, remove from base.
-                        configValue.reset();
-                    }
-                }
-
-                // Now erase all nullptrs.
-                entry->values.erase(
-                        std::remove(entry->values.begin(), entry->values.end(), nullptr),
-                        entry->values.end());
-            }
-        }
+void TableSplitter::SplitTable(ResourceTable* original_table) {
+  const size_t split_count = split_constraints_.size();
+  for (auto& pkg : original_table->packages) {
+    // Initialize all packages for splits.
+    for (size_t idx = 0; idx < split_count; idx++) {
+      ResourceTable* split_table = splits_[idx].get();
+      split_table->CreatePackage(pkg->name, pkg->id);
     }
+
+    for (auto& type : pkg->types) {
+      if (type->type == ResourceType::kMipmap) {
+        // Always keep mipmaps.
+        continue;
+      }
+
+      for (auto& entry : type->entries) {
+        if (options_.config_filter) {
+          // First eliminate any resource that we definitely don't want.
+          for (std::unique_ptr<ResourceConfigValue>& config_value :
+               entry->values) {
+            if (!options_.config_filter->Match(config_value->config)) {
+              // null out the entry. We will clean up and remove nulls at the
+              // end for performance reasons.
+              config_value.reset();
+            }
+          }
+        }
+
+        // Organize the values into two separate buckets. Those that are
+        // density-dependent
+        // and those that are density-independent.
+        // One density technically matches all density, it's just that some
+        // densities
+        // match better. So we need to be aware of the full set of densities to
+        // make this
+        // decision.
+        ConfigDensityGroups density_groups;
+        ConfigClaimedMap config_claimed_map;
+        for (const std::unique_ptr<ResourceConfigValue>& config_value :
+             entry->values) {
+          if (config_value) {
+            config_claimed_map[config_value.get()] = false;
+
+            if (config_value->config.density != 0) {
+              // Create a bucket for this density-dependent config.
+              density_groups[CopyWithoutDensity(config_value->config)]
+                  .push_back(config_value.get());
+            }
+          }
+        }
+
+        // First we check all the splits. If it doesn't match one of the splits,
+        // we
+        // leave it in the base.
+        for (size_t idx = 0; idx < split_count; idx++) {
+          const SplitConstraints& split_constraint = split_constraints_[idx];
+          ResourceTable* split_table = splits_[idx].get();
+
+          // Select the values we want from this entry for this split.
+          SplitValueSelector selector(split_constraint);
+          std::vector<ResourceConfigValue*> selected_values =
+              selector.SelectValues(density_groups, &config_claimed_map);
+
+          // No need to do any work if we selected nothing.
+          if (!selected_values.empty()) {
+            // Create the same resource structure in the split. We do this
+            // lazily because we might not have actual values for each
+            // type/entry.
+            ResourceTablePackage* split_pkg =
+                split_table->FindPackage(pkg->name);
+            ResourceTableType* split_type =
+                split_pkg->FindOrCreateType(type->type);
+            if (!split_type->id) {
+              split_type->id = type->id;
+              split_type->symbol_status = type->symbol_status;
+            }
+
+            ResourceEntry* split_entry =
+                split_type->FindOrCreateEntry(entry->name);
+            if (!split_entry->id) {
+              split_entry->id = entry->id;
+              split_entry->symbol_status = entry->symbol_status;
+            }
+
+            // Copy the selected values into the new Split Entry.
+            for (ResourceConfigValue* config_value : selected_values) {
+              ResourceConfigValue* new_config_value =
+                  split_entry->FindOrCreateValue(config_value->config,
+                                                 config_value->product);
+              new_config_value->value = std::unique_ptr<Value>(
+                  config_value->value->Clone(&split_table->string_pool));
+            }
+          }
+        }
+
+        if (options_.preferred_density) {
+          MarkNonPreferredDensitiesAsClaimed(options_.preferred_density.value(),
+                                             density_groups,
+                                             &config_claimed_map);
+        }
+
+        // All splits are handled, now check to see what wasn't claimed and
+        // remove
+        // whatever exists in other splits.
+        for (std::unique_ptr<ResourceConfigValue>& config_value :
+             entry->values) {
+          if (config_value && config_claimed_map[config_value.get()]) {
+            // Claimed, remove from base.
+            config_value.reset();
+          }
+        }
+
+        // Now erase all nullptrs.
+        entry->values.erase(
+            std::remove(entry->values.begin(), entry->values.end(), nullptr),
+            entry->values.end());
+      }
+    }
+  }
 }
 
-} // namespace aapt
+}  // namespace aapt
diff --git a/tools/aapt2/split/TableSplitter.h b/tools/aapt2/split/TableSplitter.h
index d7ecc8245ea89..1ae327120796d 100644
--- a/tools/aapt2/split/TableSplitter.h
+++ b/tools/aapt2/split/TableSplitter.h
@@ -17,15 +17,15 @@
 #ifndef AAPT_SPLIT_TABLESPLITTER_H
 #define AAPT_SPLIT_TABLESPLITTER_H
 
+#include <set>
+#include <vector>
+#include "android-base/macros.h"
+
 #include "ConfigDescription.h"
 #include "ResourceTable.h"
 #include "filter/ConfigFilter.h"
 #include "process/IResourceTableConsumer.h"
 
-#include <android-base/macros.h>
-#include <set>
-#include <vector>
-
 namespace aapt {
 
 struct SplitConstraints {
@@ -36,39 +36,36 @@ struct TableSplitterOptions {
   /**
    * The preferred density to keep in the table, stripping out all others.
    */
-  Maybe<uint16_t> preferredDensity;
+  Maybe<uint16_t> preferred_density;
 
   /**
    * Configuration filter that determines which resource configuration values
    * end up in
    * the final table.
    */
-  IConfigFilter* configFilter = nullptr;
+  IConfigFilter* config_filter = nullptr;
 };
 
 class TableSplitter {
  public:
   TableSplitter(const std::vector<SplitConstraints>& splits,
                 const TableSplitterOptions& options)
-      : mSplitConstraints(splits),
-        mPreferredDensity(options.preferredDensity),
-        mConfigFilter(options.configFilter) {
-    for (size_t i = 0; i < mSplitConstraints.size(); i++) {
-      mSplits.push_back(util::make_unique<ResourceTable>());
+      : split_constraints_(splits), options_(options) {
+    for (size_t i = 0; i < split_constraints_.size(); i++) {
+      splits_.push_back(util::make_unique<ResourceTable>());
     }
   }
 
-  bool verifySplitConstraints(IAaptContext* context);
+  bool VerifySplitConstraints(IAaptContext* context);
 
-  void splitTable(ResourceTable* originalTable);
+  void SplitTable(ResourceTable* original_table);
 
-  std::vector<std::unique_ptr<ResourceTable>>& getSplits() { return mSplits; }
+  std::vector<std::unique_ptr<ResourceTable>>& splits() { return splits_; }
 
  private:
-  std::vector<SplitConstraints> mSplitConstraints;
-  std::vector<std::unique_ptr<ResourceTable>> mSplits;
-  Maybe<uint16_t> mPreferredDensity;
-  IConfigFilter* mConfigFilter;
+  std::vector<SplitConstraints> split_constraints_;
+  std::vector<std::unique_ptr<ResourceTable>> splits_;
+  TableSplitterOptions options_;
 
   DISALLOW_COPY_AND_ASSIGN(TableSplitter);
 };
diff --git a/tools/aapt2/split/TableSplitter_test.cpp b/tools/aapt2/split/TableSplitter_test.cpp
index 5150e82b6d93b..088dac3744583 100644
--- a/tools/aapt2/split/TableSplitter_test.cpp
+++ b/tools/aapt2/split/TableSplitter_test.cpp
@@ -15,155 +15,192 @@
  */
 
 #include "split/TableSplitter.h"
+
 #include "test/Test.h"
 
 namespace aapt {
 
 TEST(TableSplitterTest, NoSplitPreferredDensity) {
-    std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
-            .addFileReference("android:drawable/icon", "res/drawable-mdpi/icon.png",
-                              test::parseConfigOrDie("mdpi"))
-            .addFileReference("android:drawable/icon", "res/drawable-hdpi/icon.png",
-                              test::parseConfigOrDie("hdpi"))
-            .addFileReference("android:drawable/icon", "res/drawable-xhdpi/icon.png",
-                              test::parseConfigOrDie("xhdpi"))
-            .addFileReference("android:drawable/icon", "res/drawable-xxhdpi/icon.png",
-                              test::parseConfigOrDie("xxhdpi"))
-            .addSimple("android:string/one")
-            .build();
+  std::unique_ptr<ResourceTable> table =
+      test::ResourceTableBuilder()
+          .AddFileReference("android:drawable/icon",
+                            "res/drawable-mdpi/icon.png",
+                            test::ParseConfigOrDie("mdpi"))
+          .AddFileReference("android:drawable/icon",
+                            "res/drawable-hdpi/icon.png",
+                            test::ParseConfigOrDie("hdpi"))
+          .AddFileReference("android:drawable/icon",
+                            "res/drawable-xhdpi/icon.png",
+                            test::ParseConfigOrDie("xhdpi"))
+          .AddFileReference("android:drawable/icon",
+                            "res/drawable-xxhdpi/icon.png",
+                            test::ParseConfigOrDie("xxhdpi"))
+          .AddSimple("android:string/one")
+          .Build();
 
-    TableSplitterOptions options;
-    options.preferredDensity = ConfigDescription::DENSITY_XHIGH;
-    TableSplitter splitter({}, options);
-    splitter.splitTable(table.get());
+  TableSplitterOptions options;
+  options.preferred_density = ConfigDescription::DENSITY_XHIGH;
+  TableSplitter splitter({}, options);
+  splitter.SplitTable(table.get());
 
-    EXPECT_EQ(nullptr, test::getValueForConfig<FileReference>(table.get(),
-                                                              "android:drawable/icon",
-                                                              test::parseConfigOrDie("mdpi")));
-    EXPECT_EQ(nullptr, test::getValueForConfig<FileReference>(table.get(),
-                                                              "android:drawable/icon",
-                                                              test::parseConfigOrDie("hdpi")));
-    EXPECT_NE(nullptr, test::getValueForConfig<FileReference>(table.get(),
-                                                              "android:drawable/icon",
-                                                              test::parseConfigOrDie("xhdpi")));
-    EXPECT_EQ(nullptr, test::getValueForConfig<FileReference>(table.get(),
-                                                              "android:drawable/icon",
-                                                              test::parseConfigOrDie("xxhdpi")));
-    EXPECT_NE(nullptr, test::getValue<Id>(table.get(), "android:string/one"));
+  EXPECT_EQ(nullptr, test::GetValueForConfig<FileReference>(
+                         table.get(), "android:drawable/icon",
+                         test::ParseConfigOrDie("mdpi")));
+  EXPECT_EQ(nullptr, test::GetValueForConfig<FileReference>(
+                         table.get(), "android:drawable/icon",
+                         test::ParseConfigOrDie("hdpi")));
+  EXPECT_NE(nullptr, test::GetValueForConfig<FileReference>(
+                         table.get(), "android:drawable/icon",
+                         test::ParseConfigOrDie("xhdpi")));
+  EXPECT_EQ(nullptr, test::GetValueForConfig<FileReference>(
+                         table.get(), "android:drawable/icon",
+                         test::ParseConfigOrDie("xxhdpi")));
+  EXPECT_NE(nullptr, test::GetValue<Id>(table.get(), "android:string/one"));
 }
 
 TEST(TableSplitterTest, SplitTableByDensity) {
-    std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
-            .addFileReference("android:drawable/foo", "res/drawable-mdpi/foo.png",
-                              test::parseConfigOrDie("mdpi"))
-            .addFileReference("android:drawable/foo", "res/drawable-hdpi/foo.png",
-                              test::parseConfigOrDie("hdpi"))
-            .addFileReference("android:drawable/foo", "res/drawable-xhdpi/foo.png",
-                              test::parseConfigOrDie("xhdpi"))
-            .addFileReference("android:drawable/foo", "res/drawable-xxhdpi/foo.png",
-                              test::parseConfigOrDie("xxhdpi"))
-            .build();
+  std::unique_ptr<ResourceTable> table =
+      test::ResourceTableBuilder()
+          .AddFileReference("android:drawable/foo", "res/drawable-mdpi/foo.png",
+                            test::ParseConfigOrDie("mdpi"))
+          .AddFileReference("android:drawable/foo", "res/drawable-hdpi/foo.png",
+                            test::ParseConfigOrDie("hdpi"))
+          .AddFileReference("android:drawable/foo",
+                            "res/drawable-xhdpi/foo.png",
+                            test::ParseConfigOrDie("xhdpi"))
+          .AddFileReference("android:drawable/foo",
+                            "res/drawable-xxhdpi/foo.png",
+                            test::ParseConfigOrDie("xxhdpi"))
+          .Build();
 
-    std::vector<SplitConstraints> constraints;
-    constraints.push_back(SplitConstraints{ { test::parseConfigOrDie("mdpi") } });
-    constraints.push_back(SplitConstraints{ { test::parseConfigOrDie("hdpi") } });
-    constraints.push_back(SplitConstraints{ { test::parseConfigOrDie("xhdpi") } });
+  std::vector<SplitConstraints> constraints;
+  constraints.push_back(SplitConstraints{{test::ParseConfigOrDie("mdpi")}});
+  constraints.push_back(SplitConstraints{{test::ParseConfigOrDie("hdpi")}});
+  constraints.push_back(SplitConstraints{{test::ParseConfigOrDie("xhdpi")}});
 
-    TableSplitter splitter(constraints, TableSplitterOptions{});
-    splitter.splitTable(table.get());
+  TableSplitter splitter(constraints, TableSplitterOptions{});
+  splitter.SplitTable(table.get());
 
-    ASSERT_EQ(3u, splitter.getSplits().size());
+  ASSERT_EQ(3u, splitter.splits().size());
 
-    ResourceTable* splitOne = splitter.getSplits()[0].get();
-    ResourceTable* splitTwo = splitter.getSplits()[1].get();
-    ResourceTable* splitThree = splitter.getSplits()[2].get();
+  ResourceTable* split_one = splitter.splits()[0].get();
+  ResourceTable* split_two = splitter.splits()[1].get();
+  ResourceTable* split_three = splitter.splits()[2].get();
 
-    // Just xxhdpi should be in the base.
-    EXPECT_EQ(nullptr, test::getValueForConfig<FileReference>(table.get(), "android:drawable/foo",
-                                                              test::parseConfigOrDie("mdpi")));
-    EXPECT_EQ(nullptr, test::getValueForConfig<FileReference>(table.get(), "android:drawable/foo",
-                                                              test::parseConfigOrDie("hdpi")));
-    EXPECT_EQ(nullptr, test::getValueForConfig<FileReference>(table.get(), "android:drawable/foo",
-                                                              test::parseConfigOrDie("xhdpi")));
-    EXPECT_NE(nullptr, test::getValueForConfig<FileReference>(table.get(), "android:drawable/foo",
-                                                              test::parseConfigOrDie("xxhdpi")));
+  // Just xxhdpi should be in the base.
+  EXPECT_EQ(nullptr, test::GetValueForConfig<FileReference>(
+                         table.get(), "android:drawable/foo",
+                         test::ParseConfigOrDie("mdpi")));
+  EXPECT_EQ(nullptr, test::GetValueForConfig<FileReference>(
+                         table.get(), "android:drawable/foo",
+                         test::ParseConfigOrDie("hdpi")));
+  EXPECT_EQ(nullptr, test::GetValueForConfig<FileReference>(
+                         table.get(), "android:drawable/foo",
+                         test::ParseConfigOrDie("xhdpi")));
+  EXPECT_NE(nullptr, test::GetValueForConfig<FileReference>(
+                         table.get(), "android:drawable/foo",
+                         test::ParseConfigOrDie("xxhdpi")));
 
-    // Each split should have one and only one drawable.
-    EXPECT_NE(nullptr, test::getValueForConfig<FileReference>(splitOne, "android:drawable/foo",
-                                                              test::parseConfigOrDie("mdpi")));
-    EXPECT_EQ(nullptr, test::getValueForConfig<FileReference>(splitOne, "android:drawable/foo",
-                                                              test::parseConfigOrDie("hdpi")));
-    EXPECT_EQ(nullptr, test::getValueForConfig<FileReference>(splitOne, "android:drawable/foo",
-                                                              test::parseConfigOrDie("xhdpi")));
-    EXPECT_EQ(nullptr, test::getValueForConfig<FileReference>(splitOne, "android:drawable/foo",
-                                                              test::parseConfigOrDie("xxhdpi")));
+  // Each split should have one and only one drawable.
+  EXPECT_NE(nullptr, test::GetValueForConfig<FileReference>(
+                         split_one, "android:drawable/foo",
+                         test::ParseConfigOrDie("mdpi")));
+  EXPECT_EQ(nullptr, test::GetValueForConfig<FileReference>(
+                         split_one, "android:drawable/foo",
+                         test::ParseConfigOrDie("hdpi")));
+  EXPECT_EQ(nullptr, test::GetValueForConfig<FileReference>(
+                         split_one, "android:drawable/foo",
+                         test::ParseConfigOrDie("xhdpi")));
+  EXPECT_EQ(nullptr, test::GetValueForConfig<FileReference>(
+                         split_one, "android:drawable/foo",
+                         test::ParseConfigOrDie("xxhdpi")));
 
-    EXPECT_EQ(nullptr, test::getValueForConfig<FileReference>(splitTwo, "android:drawable/foo",
-                                                              test::parseConfigOrDie("mdpi")));
-    EXPECT_NE(nullptr, test::getValueForConfig<FileReference>(splitTwo, "android:drawable/foo",
-                                                              test::parseConfigOrDie("hdpi")));
-    EXPECT_EQ(nullptr, test::getValueForConfig<FileReference>(splitTwo, "android:drawable/foo",
-                                                              test::parseConfigOrDie("xhdpi")));
-    EXPECT_EQ(nullptr, test::getValueForConfig<FileReference>(splitTwo, "android:drawable/foo",
-                                                              test::parseConfigOrDie("xxhdpi")));
+  EXPECT_EQ(nullptr, test::GetValueForConfig<FileReference>(
+                         split_two, "android:drawable/foo",
+                         test::ParseConfigOrDie("mdpi")));
+  EXPECT_NE(nullptr, test::GetValueForConfig<FileReference>(
+                         split_two, "android:drawable/foo",
+                         test::ParseConfigOrDie("hdpi")));
+  EXPECT_EQ(nullptr, test::GetValueForConfig<FileReference>(
+                         split_two, "android:drawable/foo",
+                         test::ParseConfigOrDie("xhdpi")));
+  EXPECT_EQ(nullptr, test::GetValueForConfig<FileReference>(
+                         split_two, "android:drawable/foo",
+                         test::ParseConfigOrDie("xxhdpi")));
 
-    EXPECT_EQ(nullptr, test::getValueForConfig<FileReference>(splitThree, "android:drawable/foo",
-                                                              test::parseConfigOrDie("mdpi")));
-    EXPECT_EQ(nullptr, test::getValueForConfig<FileReference>(splitThree, "android:drawable/foo",
-                                                              test::parseConfigOrDie("hdpi")));
-    EXPECT_NE(nullptr, test::getValueForConfig<FileReference>(splitThree, "android:drawable/foo",
-                                                              test::parseConfigOrDie("xhdpi")));
-    EXPECT_EQ(nullptr, test::getValueForConfig<FileReference>(splitThree, "android:drawable/foo",
-                                                              test::parseConfigOrDie("xxhdpi")));
+  EXPECT_EQ(nullptr, test::GetValueForConfig<FileReference>(
+                         split_three, "android:drawable/foo",
+                         test::ParseConfigOrDie("mdpi")));
+  EXPECT_EQ(nullptr, test::GetValueForConfig<FileReference>(
+                         split_three, "android:drawable/foo",
+                         test::ParseConfigOrDie("hdpi")));
+  EXPECT_NE(nullptr, test::GetValueForConfig<FileReference>(
+                         split_three, "android:drawable/foo",
+                         test::ParseConfigOrDie("xhdpi")));
+  EXPECT_EQ(nullptr, test::GetValueForConfig<FileReference>(
+                         split_three, "android:drawable/foo",
+                         test::ParseConfigOrDie("xxhdpi")));
 }
 
 TEST(TableSplitterTest, SplitTableByConfigAndDensity) {
-    ResourceTable table;
+  ResourceTable table;
 
-    const ResourceName foo = test::parseNameOrDie("android:string/foo");
-    ASSERT_TRUE(table.addResource(foo, test::parseConfigOrDie("land-hdpi"), {},
-                                  util::make_unique<Id>(),
-                                  test::getDiagnostics()));
-    ASSERT_TRUE(table.addResource(foo, test::parseConfigOrDie("land-xhdpi"), {},
-                                  util::make_unique<Id>(),
-                                  test::getDiagnostics()));
-    ASSERT_TRUE(table.addResource(foo, test::parseConfigOrDie("land-xxhdpi"), {},
-                                  util::make_unique<Id>(),
-                                  test::getDiagnostics()));
+  const ResourceName foo = test::ParseNameOrDie("android:string/foo");
+  ASSERT_TRUE(table.AddResource(foo, test::ParseConfigOrDie("land-hdpi"), {},
+                                util::make_unique<Id>(),
+                                test::GetDiagnostics()));
+  ASSERT_TRUE(table.AddResource(foo, test::ParseConfigOrDie("land-xhdpi"), {},
+                                util::make_unique<Id>(),
+                                test::GetDiagnostics()));
+  ASSERT_TRUE(table.AddResource(foo, test::ParseConfigOrDie("land-xxhdpi"), {},
+                                util::make_unique<Id>(),
+                                test::GetDiagnostics()));
 
-    std::vector<SplitConstraints> constraints;
-    constraints.push_back(SplitConstraints{ { test::parseConfigOrDie("land-mdpi") } });
-    constraints.push_back(SplitConstraints{ { test::parseConfigOrDie("land-xhdpi") } });
+  std::vector<SplitConstraints> constraints;
+  constraints.push_back(
+      SplitConstraints{{test::ParseConfigOrDie("land-mdpi")}});
+  constraints.push_back(
+      SplitConstraints{{test::ParseConfigOrDie("land-xhdpi")}});
 
-    TableSplitter splitter(constraints, TableSplitterOptions{});
-    splitter.splitTable(&table);
+  TableSplitter splitter(constraints, TableSplitterOptions{});
+  splitter.SplitTable(&table);
 
-    ASSERT_EQ(2u, splitter.getSplits().size());
+  ASSERT_EQ(2u, splitter.splits().size());
 
-    ResourceTable* splitOne = splitter.getSplits()[0].get();
-    ResourceTable* splitTwo = splitter.getSplits()[1].get();
+  ResourceTable* split_one = splitter.splits()[0].get();
+  ResourceTable* split_two = splitter.splits()[1].get();
 
-    // All but the xxhdpi resource should be gone, since there were closer matches in land-xhdpi.
-    EXPECT_EQ(nullptr, test::getValueForConfig<Id>(&table, "android:string/foo",
-                                                   test::parseConfigOrDie("land-hdpi")));
-    EXPECT_EQ(nullptr, test::getValueForConfig<Id>(&table, "android:string/foo",
-                                                   test::parseConfigOrDie("land-xhdpi")));
-    EXPECT_NE(nullptr, test::getValueForConfig<Id>(&table, "android:string/foo",
-                                                   test::parseConfigOrDie("land-xxhdpi")));
+  // All but the xxhdpi resource should be gone, since there were closer matches
+  // in land-xhdpi.
+  EXPECT_EQ(nullptr,
+            test::GetValueForConfig<Id>(&table, "android:string/foo",
+                                        test::ParseConfigOrDie("land-hdpi")));
+  EXPECT_EQ(nullptr,
+            test::GetValueForConfig<Id>(&table, "android:string/foo",
+                                        test::ParseConfigOrDie("land-xhdpi")));
+  EXPECT_NE(nullptr,
+            test::GetValueForConfig<Id>(&table, "android:string/foo",
+                                        test::ParseConfigOrDie("land-xxhdpi")));
 
-    EXPECT_NE(nullptr, test::getValueForConfig<Id>(splitOne, "android:string/foo",
-                                                   test::parseConfigOrDie("land-hdpi")));
-    EXPECT_EQ(nullptr, test::getValueForConfig<Id>(splitOne, "android:string/foo",
-                                                   test::parseConfigOrDie("land-xhdpi")));
-    EXPECT_EQ(nullptr, test::getValueForConfig<Id>(splitOne, "android:string/foo",
-                                                   test::parseConfigOrDie("land-xxhdpi")));
+  EXPECT_NE(nullptr,
+            test::GetValueForConfig<Id>(split_one, "android:string/foo",
+                                        test::ParseConfigOrDie("land-hdpi")));
+  EXPECT_EQ(nullptr,
+            test::GetValueForConfig<Id>(split_one, "android:string/foo",
+                                        test::ParseConfigOrDie("land-xhdpi")));
+  EXPECT_EQ(nullptr,
+            test::GetValueForConfig<Id>(split_one, "android:string/foo",
+                                        test::ParseConfigOrDie("land-xxhdpi")));
 
-    EXPECT_EQ(nullptr, test::getValueForConfig<Id>(splitTwo, "android:string/foo",
-                                                   test::parseConfigOrDie("land-hdpi")));
-    EXPECT_NE(nullptr, test::getValueForConfig<Id>(splitTwo, "android:string/foo",
-                                                   test::parseConfigOrDie("land-xhdpi")));
-    EXPECT_EQ(nullptr, test::getValueForConfig<Id>(splitTwo, "android:string/foo",
-                                                   test::parseConfigOrDie("land-xxhdpi")));
+  EXPECT_EQ(nullptr,
+            test::GetValueForConfig<Id>(split_two, "android:string/foo",
+                                        test::ParseConfigOrDie("land-hdpi")));
+  EXPECT_NE(nullptr,
+            test::GetValueForConfig<Id>(split_two, "android:string/foo",
+                                        test::ParseConfigOrDie("land-xhdpi")));
+  EXPECT_EQ(nullptr,
+            test::GetValueForConfig<Id>(split_two, "android:string/foo",
+                                        test::ParseConfigOrDie("land-xxhdpi")));
 }
 
-} // namespace aapt
+}  // namespace aapt
diff --git a/tools/aapt2/test/Builders.h b/tools/aapt2/test/Builders.h
index c64715945b7b0..9377306dc1b6e 100644
--- a/tools/aapt2/test/Builders.h
+++ b/tools/aapt2/test/Builders.h
@@ -17,139 +17,142 @@
 #ifndef AAPT_TEST_BUILDERS_H
 #define AAPT_TEST_BUILDERS_H
 
+#include <memory>
+
+#include "android-base/logging.h"
+#include "android-base/macros.h"
+
 #include "ResourceTable.h"
 #include "ResourceValues.h"
 #include "test/Common.h"
 #include "util/Util.h"
 #include "xml/XmlDom.h"
 
-#include <memory>
-
 namespace aapt {
 namespace test {
 
 class ResourceTableBuilder {
- private:
-  DummyDiagnosticsImpl mDiagnostics;
-  std::unique_ptr<ResourceTable> mTable = util::make_unique<ResourceTable>();
-
  public:
   ResourceTableBuilder() = default;
 
-  StringPool* getStringPool() { return &mTable->stringPool; }
+  StringPool* string_pool() { return &table_->string_pool; }
 
-  ResourceTableBuilder& setPackageId(const StringPiece& packageName,
+  ResourceTableBuilder& SetPackageId(const StringPiece& package_name,
                                      uint8_t id) {
-    ResourceTablePackage* package = mTable->createPackage(packageName, id);
-    assert(package);
+    ResourceTablePackage* package = table_->CreatePackage(package_name, id);
+    CHECK(package != nullptr);
     return *this;
   }
 
-  ResourceTableBuilder& addSimple(const StringPiece& name,
+  ResourceTableBuilder& AddSimple(const StringPiece& name,
                                   const ResourceId& id = {}) {
-    return addValue(name, id, util::make_unique<Id>());
+    return AddValue(name, id, util::make_unique<Id>());
   }
 
-  ResourceTableBuilder& addSimple(const StringPiece& name,
+  ResourceTableBuilder& AddSimple(const StringPiece& name,
                                   const ConfigDescription& config,
                                   const ResourceId& id = {}) {
-    return addValue(name, config, id, util::make_unique<Id>());
+    return AddValue(name, config, id, util::make_unique<Id>());
   }
 
-  ResourceTableBuilder& addReference(const StringPiece& name,
+  ResourceTableBuilder& AddReference(const StringPiece& name,
                                      const StringPiece& ref) {
-    return addReference(name, {}, ref);
+    return AddReference(name, {}, ref);
   }
 
-  ResourceTableBuilder& addReference(const StringPiece& name,
+  ResourceTableBuilder& AddReference(const StringPiece& name,
                                      const ResourceId& id,
                                      const StringPiece& ref) {
-    return addValue(name, id,
-                    util::make_unique<Reference>(parseNameOrDie(ref)));
+    return AddValue(name, id,
+                    util::make_unique<Reference>(ParseNameOrDie(ref)));
   }
 
-  ResourceTableBuilder& addString(const StringPiece& name,
+  ResourceTableBuilder& AddString(const StringPiece& name,
                                   const StringPiece& str) {
-    return addString(name, {}, str);
+    return AddString(name, {}, str);
   }
 
-  ResourceTableBuilder& addString(const StringPiece& name, const ResourceId& id,
+  ResourceTableBuilder& AddString(const StringPiece& name, const ResourceId& id,
                                   const StringPiece& str) {
-    return addValue(name, id,
-                    util::make_unique<String>(mTable->stringPool.makeRef(str)));
+    return AddValue(
+        name, id, util::make_unique<String>(table_->string_pool.MakeRef(str)));
   }
 
-  ResourceTableBuilder& addString(const StringPiece& name, const ResourceId& id,
+  ResourceTableBuilder& AddString(const StringPiece& name, const ResourceId& id,
                                   const ConfigDescription& config,
                                   const StringPiece& str) {
-    return addValue(name, config, id,
-                    util::make_unique<String>(mTable->stringPool.makeRef(str)));
+    return AddValue(name, config, id, util::make_unique<String>(
+                                          table_->string_pool.MakeRef(str)));
   }
 
-  ResourceTableBuilder& addFileReference(const StringPiece& name,
+  ResourceTableBuilder& AddFileReference(const StringPiece& name,
                                          const StringPiece& path) {
-    return addFileReference(name, {}, path);
+    return AddFileReference(name, {}, path);
   }
 
-  ResourceTableBuilder& addFileReference(const StringPiece& name,
+  ResourceTableBuilder& AddFileReference(const StringPiece& name,
                                          const ResourceId& id,
                                          const StringPiece& path) {
-    return addValue(name, id, util::make_unique<FileReference>(
-                                  mTable->stringPool.makeRef(path)));
+    return AddValue(name, id, util::make_unique<FileReference>(
+                                  table_->string_pool.MakeRef(path)));
   }
 
-  ResourceTableBuilder& addFileReference(const StringPiece& name,
+  ResourceTableBuilder& AddFileReference(const StringPiece& name,
                                          const StringPiece& path,
                                          const ConfigDescription& config) {
-    return addValue(name, config, {}, util::make_unique<FileReference>(
-                                          mTable->stringPool.makeRef(path)));
+    return AddValue(name, config, {}, util::make_unique<FileReference>(
+                                          table_->string_pool.MakeRef(path)));
   }
 
-  ResourceTableBuilder& addValue(const StringPiece& name,
+  ResourceTableBuilder& AddValue(const StringPiece& name,
                                  std::unique_ptr<Value> value) {
-    return addValue(name, {}, std::move(value));
+    return AddValue(name, {}, std::move(value));
   }
 
-  ResourceTableBuilder& addValue(const StringPiece& name, const ResourceId& id,
+  ResourceTableBuilder& AddValue(const StringPiece& name, const ResourceId& id,
                                  std::unique_ptr<Value> value) {
-    return addValue(name, {}, id, std::move(value));
+    return AddValue(name, {}, id, std::move(value));
   }
 
-  ResourceTableBuilder& addValue(const StringPiece& name,
+  ResourceTableBuilder& AddValue(const StringPiece& name,
                                  const ConfigDescription& config,
                                  const ResourceId& id,
                                  std::unique_ptr<Value> value) {
-    ResourceName resName = parseNameOrDie(name);
-    bool result = mTable->addResourceAllowMangled(
-        resName, id, config, {}, std::move(value), &mDiagnostics);
-    assert(result);
+    ResourceName res_name = ParseNameOrDie(name);
+    CHECK(table_->AddResourceAllowMangled(res_name, id, config, {},
+                                          std::move(value), &diagnostics_));
     return *this;
   }
 
-  ResourceTableBuilder& setSymbolState(const StringPiece& name,
+  ResourceTableBuilder& SetSymbolState(const StringPiece& name,
                                        const ResourceId& id,
                                        SymbolState state) {
-    ResourceName resName = parseNameOrDie(name);
+    ResourceName res_name = ParseNameOrDie(name);
     Symbol symbol;
     symbol.state = state;
-    bool result =
-        mTable->setSymbolStateAllowMangled(resName, id, symbol, &mDiagnostics);
-    assert(result);
+    CHECK(table_->SetSymbolStateAllowMangled(res_name, id, symbol,
+                                             &diagnostics_));
     return *this;
   }
 
-  std::unique_ptr<ResourceTable> build() { return std::move(mTable); }
+  std::unique_ptr<ResourceTable> Build() { return std::move(table_); }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ResourceTableBuilder);
+
+  DummyDiagnosticsImpl diagnostics_;
+  std::unique_ptr<ResourceTable> table_ = util::make_unique<ResourceTable>();
 };
 
-inline std::unique_ptr<Reference> buildReference(
+inline std::unique_ptr<Reference> BuildReference(
     const StringPiece& ref, const Maybe<ResourceId>& id = {}) {
   std::unique_ptr<Reference> reference =
-      util::make_unique<Reference>(parseNameOrDie(ref));
+      util::make_unique<Reference>(ParseNameOrDie(ref));
   reference->id = id;
   return reference;
 }
 
-inline std::unique_ptr<BinaryPrimitive> buildPrimitive(uint8_t type,
+inline std::unique_ptr<BinaryPrimitive> BuildPrimitive(uint8_t type,
                                                        uint32_t data) {
   android::Res_value value = {};
   value.size = sizeof(value);
@@ -160,107 +163,119 @@ inline std::unique_ptr<BinaryPrimitive> buildPrimitive(uint8_t type,
 
 template <typename T>
 class ValueBuilder {
- private:
-  std::unique_ptr<Value> mValue;
-
  public:
   template <typename... Args>
   explicit ValueBuilder(Args&&... args)
-      : mValue(new T{std::forward<Args>(args)...}) {}
+      : value_(new T{std::forward<Args>(args)...}) {}
 
   template <typename... Args>
-  ValueBuilder& setSource(Args&&... args) {
-    mValue->setSource(Source{std::forward<Args>(args)...});
+  ValueBuilder& SetSource(Args&&... args) {
+    value_->SetSource(Source{std::forward<Args>(args)...});
     return *this;
   }
 
-  ValueBuilder& setComment(const StringPiece& str) {
-    mValue->setComment(str);
+  ValueBuilder& SetComment(const StringPiece& str) {
+    value_->SetComment(str);
     return *this;
   }
 
-  std::unique_ptr<Value> build() { return std::move(mValue); }
+  std::unique_ptr<Value> Build() { return std::move(value_); }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ValueBuilder);
+
+  std::unique_ptr<Value> value_;
 };
 
 class AttributeBuilder {
- private:
-  std::unique_ptr<Attribute> mAttr;
-
  public:
   explicit AttributeBuilder(bool weak = false)
-      : mAttr(util::make_unique<Attribute>(weak)) {
-    mAttr->typeMask = android::ResTable_map::TYPE_ANY;
+      : attr_(util::make_unique<Attribute>(weak)) {
+    attr_->type_mask = android::ResTable_map::TYPE_ANY;
   }
 
-  AttributeBuilder& setTypeMask(uint32_t typeMask) {
-    mAttr->typeMask = typeMask;
+  AttributeBuilder& SetTypeMask(uint32_t typeMask) {
+    attr_->type_mask = typeMask;
     return *this;
   }
 
-  AttributeBuilder& addItem(const StringPiece& name, uint32_t value) {
-    mAttr->symbols.push_back(Attribute::Symbol{
+  AttributeBuilder& AddItem(const StringPiece& name, uint32_t value) {
+    attr_->symbols.push_back(Attribute::Symbol{
         Reference(ResourceName({}, ResourceType::kId, name)), value});
     return *this;
   }
 
-  std::unique_ptr<Attribute> build() { return std::move(mAttr); }
+  std::unique_ptr<Attribute> Build() { return std::move(attr_); }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(AttributeBuilder);
+
+  std::unique_ptr<Attribute> attr_;
 };
 
 class StyleBuilder {
- private:
-  std::unique_ptr<Style> mStyle = util::make_unique<Style>();
-
  public:
-  StyleBuilder& setParent(const StringPiece& str) {
-    mStyle->parent = Reference(parseNameOrDie(str));
+  StyleBuilder() = default;
+
+  StyleBuilder& SetParent(const StringPiece& str) {
+    style_->parent = Reference(ParseNameOrDie(str));
     return *this;
   }
 
-  StyleBuilder& addItem(const StringPiece& str, std::unique_ptr<Item> value) {
-    mStyle->entries.push_back(
-        Style::Entry{Reference(parseNameOrDie(str)), std::move(value)});
+  StyleBuilder& AddItem(const StringPiece& str, std::unique_ptr<Item> value) {
+    style_->entries.push_back(
+        Style::Entry{Reference(ParseNameOrDie(str)), std::move(value)});
     return *this;
   }
 
-  StyleBuilder& addItem(const StringPiece& str, const ResourceId& id,
+  StyleBuilder& AddItem(const StringPiece& str, const ResourceId& id,
                         std::unique_ptr<Item> value) {
-    addItem(str, std::move(value));
-    mStyle->entries.back().key.id = id;
+    AddItem(str, std::move(value));
+    style_->entries.back().key.id = id;
     return *this;
   }
 
-  std::unique_ptr<Style> build() { return std::move(mStyle); }
+  std::unique_ptr<Style> Build() { return std::move(style_); }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(StyleBuilder);
+
+  std::unique_ptr<Style> style_ = util::make_unique<Style>();
 };
 
 class StyleableBuilder {
- private:
-  std::unique_ptr<Styleable> mStyleable = util::make_unique<Styleable>();
-
  public:
-  StyleableBuilder& addItem(const StringPiece& str,
+  StyleableBuilder() = default;
+
+  StyleableBuilder& AddItem(const StringPiece& str,
                             const Maybe<ResourceId>& id = {}) {
-    mStyleable->entries.push_back(Reference(parseNameOrDie(str)));
-    mStyleable->entries.back().id = id;
+    styleable_->entries.push_back(Reference(ParseNameOrDie(str)));
+    styleable_->entries.back().id = id;
     return *this;
   }
 
-  std::unique_ptr<Styleable> build() { return std::move(mStyleable); }
+  std::unique_ptr<Styleable> Build() { return std::move(styleable_); }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(StyleableBuilder);
+
+  std::unique_ptr<Styleable> styleable_ = util::make_unique<Styleable>();
 };
 
-inline std::unique_ptr<xml::XmlResource> buildXmlDom(const StringPiece& str) {
+inline std::unique_ptr<xml::XmlResource> BuildXmlDom(const StringPiece& str) {
   std::stringstream in;
   in << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n" << str;
   StdErrDiagnostics diag;
   std::unique_ptr<xml::XmlResource> doc =
-      xml::inflate(&in, &diag, Source("test.xml"));
-  assert(doc);
+      xml::Inflate(&in, &diag, Source("test.xml"));
+  CHECK(doc != nullptr) << "failed to parse inline XML string";
   return doc;
 }
 
-inline std::unique_ptr<xml::XmlResource> buildXmlDomForPackageName(
+inline std::unique_ptr<xml::XmlResource> BuildXmlDomForPackageName(
     IAaptContext* context, const StringPiece& str) {
-  std::unique_ptr<xml::XmlResource> doc = buildXmlDom(str);
-  doc->file.name.package = context->getCompilationPackage();
+  std::unique_ptr<xml::XmlResource> doc = BuildXmlDom(str);
+  doc->file.name.package = context->GetCompilationPackage();
   return doc;
 }
 
diff --git a/tools/aapt2/test/Common.h b/tools/aapt2/test/Common.h
index 2d571e7624e5b..36892017f2d30 100644
--- a/tools/aapt2/test/Common.h
+++ b/tools/aapt2/test/Common.h
@@ -17,6 +17,12 @@
 #ifndef AAPT_TEST_COMMON_H
 #define AAPT_TEST_COMMON_H
 
+#include <iostream>
+
+#include "android-base/logging.h"
+#include "android-base/macros.h"
+#include "gtest/gtest.h"
+
 #include "ConfigDescription.h"
 #include "Debug.h"
 #include "ResourceTable.h"
@@ -26,9 +32,6 @@
 #include "process/IResourceTableConsumer.h"
 #include "util/StringPiece.h"
 
-#include <gtest/gtest.h>
-#include <iostream>
-
 //
 // GTEST 1.7 doesn't explicitly cast to bool, which causes explicit operators to
 // fail to compile.
@@ -42,80 +45,81 @@ namespace aapt {
 namespace test {
 
 struct DummyDiagnosticsImpl : public IDiagnostics {
-  void log(Level level, DiagMessageActual& actualMsg) override {
+  void Log(Level level, DiagMessageActual& actual_msg) override {
     switch (level) {
       case Level::Note:
         return;
 
       case Level::Warn:
-        std::cerr << actualMsg.source << ": warn: " << actualMsg.message << "."
-                  << std::endl;
+        std::cerr << actual_msg.source << ": warn: " << actual_msg.message
+                  << "." << std::endl;
         break;
 
       case Level::Error:
-        std::cerr << actualMsg.source << ": error: " << actualMsg.message << "."
-                  << std::endl;
+        std::cerr << actual_msg.source << ": error: " << actual_msg.message
+                  << "." << std::endl;
         break;
     }
   }
 };
 
-inline IDiagnostics* getDiagnostics() {
+inline IDiagnostics* GetDiagnostics() {
   static DummyDiagnosticsImpl diag;
   return &diag;
 }
 
-inline ResourceName parseNameOrDie(const StringPiece& str) {
+inline ResourceName ParseNameOrDie(const StringPiece& str) {
   ResourceNameRef ref;
-  bool result = ResourceUtils::parseResourceName(str, &ref);
-  assert(result && "invalid resource name");
-  return ref.toResourceName();
+  CHECK(ResourceUtils::ParseResourceName(str, &ref)) << "invalid resource name";
+  return ref.ToResourceName();
 }
 
-inline ConfigDescription parseConfigOrDie(const StringPiece& str) {
+inline ConfigDescription ParseConfigOrDie(const StringPiece& str) {
   ConfigDescription config;
-  bool result = ConfigDescription::parse(str, &config);
-  assert(result && "invalid configuration");
+  CHECK(ConfigDescription::Parse(str, &config)) << "invalid configuration";
   return config;
 }
 
 template <typename T>
-T* getValueForConfigAndProduct(ResourceTable* table, const StringPiece& resName,
+T* GetValueForConfigAndProduct(ResourceTable* table,
+                               const StringPiece& res_name,
                                const ConfigDescription& config,
                                const StringPiece& product) {
   Maybe<ResourceTable::SearchResult> result =
-      table->findResource(parseNameOrDie(resName));
+      table->FindResource(ParseNameOrDie(res_name));
   if (result) {
-    ResourceConfigValue* configValue =
-        result.value().entry->findValue(config, product);
-    if (configValue) {
-      return valueCast<T>(configValue->value.get());
+    ResourceConfigValue* config_value =
+        result.value().entry->FindValue(config, product);
+    if (config_value) {
+      return ValueCast<T>(config_value->value.get());
     }
   }
   return nullptr;
 }
 
 template <typename T>
-T* getValueForConfig(ResourceTable* table, const StringPiece& resName,
+T* GetValueForConfig(ResourceTable* table, const StringPiece& res_name,
                      const ConfigDescription& config) {
-  return getValueForConfigAndProduct<T>(table, resName, config, {});
+  return GetValueForConfigAndProduct<T>(table, res_name, config, {});
 }
 
 template <typename T>
-T* getValue(ResourceTable* table, const StringPiece& resName) {
-  return getValueForConfig<T>(table, resName, {});
+T* GetValue(ResourceTable* table, const StringPiece& res_name) {
+  return GetValueForConfig<T>(table, res_name, {});
 }
 
 class TestFile : public io::IFile {
- private:
-  Source mSource;
-
  public:
-  explicit TestFile(const StringPiece& path) : mSource(path) {}
+  explicit TestFile(const StringPiece& path) : source_(path) {}
 
-  std::unique_ptr<io::IData> openAsData() override { return {}; }
+  std::unique_ptr<io::IData> OpenAsData() override { return {}; }
 
-  const Source& getSource() const override { return mSource; }
+  const Source& GetSource() const override { return source_; }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TestFile);
+
+  Source source_;
 };
 
 }  // namespace test
diff --git a/tools/aapt2/test/Context.h b/tools/aapt2/test/Context.h
index 6c7f6f78a71d0..7986329ab6405 100644
--- a/tools/aapt2/test/Context.h
+++ b/tools/aapt2/test/Context.h
@@ -17,152 +17,158 @@
 #ifndef AAPT_TEST_CONTEXT_H
 #define AAPT_TEST_CONTEXT_H
 
+#include <list>
+
+#include "android-base/logging.h"
+#include "android-base/macros.h"
+
 #include "NameMangler.h"
 #include "process/IResourceTableConsumer.h"
 #include "process/SymbolTable.h"
 #include "test/Common.h"
 #include "util/Util.h"
 
-#include <cassert>
-#include <list>
-
 namespace aapt {
 namespace test {
 
 class Context : public IAaptContext {
  public:
-  SymbolTable* getExternalSymbols() override { return &mSymbols; }
+  Context() = default;
 
-  IDiagnostics* getDiagnostics() override { return &mDiagnostics; }
+  SymbolTable* GetExternalSymbols() override { return &symbols_; }
 
-  const std::string& getCompilationPackage() override {
-    assert(mCompilationPackage && "package name not set");
-    return mCompilationPackage.value();
+  IDiagnostics* GetDiagnostics() override { return &diagnostics_; }
+
+  const std::string& GetCompilationPackage() override {
+    CHECK(bool(compilation_package_)) << "package name not set";
+    return compilation_package_.value();
   }
 
-  uint8_t getPackageId() override {
-    assert(mPackageId && "package ID not set");
-    return mPackageId.value();
+  uint8_t GetPackageId() override {
+    CHECK(bool(package_id_)) << "package ID not set";
+    return package_id_.value();
   }
 
-  NameMangler* getNameMangler() override { return &mNameMangler; }
+  NameMangler* GetNameMangler() override { return &name_mangler_; }
 
-  bool verbose() override { return false; }
+  bool IsVerbose() override { return false; }
 
-  int getMinSdkVersion() override { return mMinSdkVersion; }
+  int GetMinSdkVersion() override { return min_sdk_version_; }
 
  private:
+  DISALLOW_COPY_AND_ASSIGN(Context);
+
   friend class ContextBuilder;
 
-  Maybe<std::string> mCompilationPackage;
-  Maybe<uint8_t> mPackageId;
-  StdErrDiagnostics mDiagnostics;
-  SymbolTable mSymbols;
-  NameMangler mNameMangler = NameMangler({});
-  int mMinSdkVersion = 0;
+  Maybe<std::string> compilation_package_;
+  Maybe<uint8_t> package_id_;
+  StdErrDiagnostics diagnostics_;
+  SymbolTable symbols_;
+  NameMangler name_mangler_ = NameMangler({});
+  int min_sdk_version_ = 0;
 };
 
 class ContextBuilder {
- private:
-  std::unique_ptr<Context> mContext = std::unique_ptr<Context>(new Context());
-
  public:
-  ContextBuilder& setCompilationPackage(const StringPiece& package) {
-    mContext->mCompilationPackage = package.toString();
+  ContextBuilder& SetCompilationPackage(const StringPiece& package) {
+    context_->compilation_package_ = package.ToString();
     return *this;
   }
 
-  ContextBuilder& setPackageId(uint8_t id) {
-    mContext->mPackageId = id;
+  ContextBuilder& SetPackageId(uint8_t id) {
+    context_->package_id_ = id;
     return *this;
   }
 
-  ContextBuilder& setNameManglerPolicy(const NameManglerPolicy& policy) {
-    mContext->mNameMangler = NameMangler(policy);
+  ContextBuilder& SetNameManglerPolicy(const NameManglerPolicy& policy) {
+    context_->name_mangler_ = NameMangler(policy);
     return *this;
   }
 
-  ContextBuilder& addSymbolSource(std::unique_ptr<ISymbolSource> src) {
-    mContext->getExternalSymbols()->appendSource(std::move(src));
+  ContextBuilder& AddSymbolSource(std::unique_ptr<ISymbolSource> src) {
+    context_->GetExternalSymbols()->AppendSource(std::move(src));
     return *this;
   }
 
-  ContextBuilder& setMinSdkVersion(int minSdk) {
-    mContext->mMinSdkVersion = minSdk;
+  ContextBuilder& SetMinSdkVersion(int min_sdk) {
+    context_->min_sdk_version_ = min_sdk;
     return *this;
   }
 
-  std::unique_ptr<Context> build() { return std::move(mContext); }
+  std::unique_ptr<Context> Build() { return std::move(context_); }
+
+ private:
+  std::unique_ptr<Context> context_ = std::unique_ptr<Context>(new Context());
 };
 
 class StaticSymbolSourceBuilder {
  public:
-  StaticSymbolSourceBuilder& addPublicSymbol(
+  StaticSymbolSourceBuilder& AddPublicSymbol(
       const StringPiece& name, ResourceId id,
       std::unique_ptr<Attribute> attr = {}) {
     std::unique_ptr<SymbolTable::Symbol> symbol =
         util::make_unique<SymbolTable::Symbol>(id, std::move(attr), true);
-    mSymbolSource->mNameMap[parseNameOrDie(name)] = symbol.get();
-    mSymbolSource->mIdMap[id] = symbol.get();
-    mSymbolSource->mSymbols.push_back(std::move(symbol));
+    symbol_source_->name_map_[ParseNameOrDie(name)] = symbol.get();
+    symbol_source_->id_map_[id] = symbol.get();
+    symbol_source_->symbols_.push_back(std::move(symbol));
     return *this;
   }
 
-  StaticSymbolSourceBuilder& addSymbol(const StringPiece& name, ResourceId id,
+  StaticSymbolSourceBuilder& AddSymbol(const StringPiece& name, ResourceId id,
                                        std::unique_ptr<Attribute> attr = {}) {
     std::unique_ptr<SymbolTable::Symbol> symbol =
         util::make_unique<SymbolTable::Symbol>(id, std::move(attr), false);
-    mSymbolSource->mNameMap[parseNameOrDie(name)] = symbol.get();
-    mSymbolSource->mIdMap[id] = symbol.get();
-    mSymbolSource->mSymbols.push_back(std::move(symbol));
+    symbol_source_->name_map_[ParseNameOrDie(name)] = symbol.get();
+    symbol_source_->id_map_[id] = symbol.get();
+    symbol_source_->symbols_.push_back(std::move(symbol));
     return *this;
   }
 
-  std::unique_ptr<ISymbolSource> build() { return std::move(mSymbolSource); }
+  std::unique_ptr<ISymbolSource> Build() { return std::move(symbol_source_); }
 
  private:
   class StaticSymbolSource : public ISymbolSource {
    public:
     StaticSymbolSource() = default;
 
-    std::unique_ptr<SymbolTable::Symbol> findByName(
+    std::unique_ptr<SymbolTable::Symbol> FindByName(
         const ResourceName& name) override {
-      auto iter = mNameMap.find(name);
-      if (iter != mNameMap.end()) {
-        return cloneSymbol(iter->second);
+      auto iter = name_map_.find(name);
+      if (iter != name_map_.end()) {
+        return CloneSymbol(iter->second);
       }
       return nullptr;
     }
 
-    std::unique_ptr<SymbolTable::Symbol> findById(ResourceId id) override {
-      auto iter = mIdMap.find(id);
-      if (iter != mIdMap.end()) {
-        return cloneSymbol(iter->second);
+    std::unique_ptr<SymbolTable::Symbol> FindById(ResourceId id) override {
+      auto iter = id_map_.find(id);
+      if (iter != id_map_.end()) {
+        return CloneSymbol(iter->second);
       }
       return nullptr;
     }
 
-    std::list<std::unique_ptr<SymbolTable::Symbol>> mSymbols;
-    std::map<ResourceName, SymbolTable::Symbol*> mNameMap;
-    std::map<ResourceId, SymbolTable::Symbol*> mIdMap;
+    std::list<std::unique_ptr<SymbolTable::Symbol>> symbols_;
+    std::map<ResourceName, SymbolTable::Symbol*> name_map_;
+    std::map<ResourceId, SymbolTable::Symbol*> id_map_;
 
    private:
-    std::unique_ptr<SymbolTable::Symbol> cloneSymbol(SymbolTable::Symbol* sym) {
+    std::unique_ptr<SymbolTable::Symbol> CloneSymbol(SymbolTable::Symbol* sym) {
       std::unique_ptr<SymbolTable::Symbol> clone =
           util::make_unique<SymbolTable::Symbol>();
       clone->id = sym->id;
       if (sym->attribute) {
         clone->attribute =
-            std::unique_ptr<Attribute>(sym->attribute->clone(nullptr));
+            std::unique_ptr<Attribute>(sym->attribute->Clone(nullptr));
       }
-      clone->isPublic = sym->isPublic;
+      clone->is_public = sym->is_public;
       return clone;
     }
 
     DISALLOW_COPY_AND_ASSIGN(StaticSymbolSource);
   };
 
-  std::unique_ptr<StaticSymbolSource> mSymbolSource =
+  std::unique_ptr<StaticSymbolSource> symbol_source_ =
       util::make_unique<StaticSymbolSource>();
 };
 
diff --git a/tools/aapt2/test/Test.h b/tools/aapt2/test/Test.h
index c9188bf84c683..ec07432fa51e8 100644
--- a/tools/aapt2/test/Test.h
+++ b/tools/aapt2/test/Test.h
@@ -17,14 +17,10 @@
 #ifndef AAPT_TEST_TEST_H
 #define AAPT_TEST_TEST_H
 
+#include "gtest/gtest.h"
+
 #include "test/Builders.h"
 #include "test/Common.h"
 #include "test/Context.h"
 
-#include <gtest/gtest.h>
-
-namespace aapt {
-namespace test {}  // namespace test
-}  // namespace aapt
-
 #endif  // AAPT_TEST_TEST_H
diff --git a/tools/aapt2/unflatten/BinaryResourceParser.cpp b/tools/aapt2/unflatten/BinaryResourceParser.cpp
index 546b6078ddb0e..aeabcff011edf 100644
--- a/tools/aapt2/unflatten/BinaryResourceParser.cpp
+++ b/tools/aapt2/unflatten/BinaryResourceParser.cpp
@@ -15,6 +15,16 @@
  */
 
 #include "unflatten/BinaryResourceParser.h"
+
+#include <algorithm>
+#include <map>
+#include <string>
+
+#include "android-base/logging.h"
+#include "android-base/macros.h"
+#include "androidfw/ResourceTypes.h"
+#include "androidfw/TypeWrappers.h"
+
 #include "ResourceTable.h"
 #include "ResourceUtils.h"
 #include "ResourceValues.h"
@@ -23,13 +33,6 @@
 #include "unflatten/ResChunkPullParser.h"
 #include "util/Util.h"
 
-#include <android-base/macros.h>
-#include <androidfw/ResourceTypes.h>
-#include <androidfw/TypeWrappers.h>
-#include <algorithm>
-#include <map>
-#include <string>
-
 namespace aapt {
 
 using namespace android;
@@ -41,29 +44,31 @@ namespace {
  * given a mapping from resource ID to resource name.
  */
 class ReferenceIdToNameVisitor : public ValueVisitor {
- private:
-  const std::map<ResourceId, ResourceName>* mMapping;
-
  public:
-  using ValueVisitor::visit;
+  using ValueVisitor::Visit;
 
   explicit ReferenceIdToNameVisitor(
       const std::map<ResourceId, ResourceName>* mapping)
-      : mMapping(mapping) {
-    assert(mMapping);
+      : mapping_(mapping) {
+    CHECK(mapping_ != nullptr);
   }
 
-  void visit(Reference* reference) override {
-    if (!reference->id || !reference->id.value().isValid()) {
+  void Visit(Reference* reference) override {
+    if (!reference->id || !reference->id.value().is_valid()) {
       return;
     }
 
     ResourceId id = reference->id.value();
-    auto cacheIter = mMapping->find(id);
-    if (cacheIter != mMapping->end()) {
-      reference->name = cacheIter->second;
+    auto cache_iter = mapping_->find(id);
+    if (cache_iter != mapping_->end()) {
+      reference->name = cache_iter->second;
     }
   }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ReferenceIdToNameVisitor);
+
+  const std::map<ResourceId, ResourceName>* mapping_;
 };
 
 }  // namespace
@@ -72,33 +77,32 @@ BinaryResourceParser::BinaryResourceParser(IAaptContext* context,
                                            ResourceTable* table,
                                            const Source& source,
                                            const void* data, size_t len)
-    : mContext(context),
-      mTable(table),
-      mSource(source),
-      mData(data),
-      mDataLen(len) {}
+    : context_(context),
+      table_(table),
+      source_(source),
+      data_(data),
+      data_len_(len) {}
 
-bool BinaryResourceParser::parse() {
-  ResChunkPullParser parser(mData, mDataLen);
+bool BinaryResourceParser::Parse() {
+  ResChunkPullParser parser(data_, data_len_);
 
   bool error = false;
-  while (ResChunkPullParser::isGoodEvent(parser.next())) {
-    if (parser.getChunk()->type != android::RES_TABLE_TYPE) {
-      mContext->getDiagnostics()->warn(DiagMessage(mSource)
+  while (ResChunkPullParser::IsGoodEvent(parser.Next())) {
+    if (parser.chunk()->type != android::RES_TABLE_TYPE) {
+      context_->GetDiagnostics()->Warn(DiagMessage(source_)
                                        << "unknown chunk of type '"
-                                       << (int)parser.getChunk()->type << "'");
+                                       << (int)parser.chunk()->type << "'");
       continue;
     }
 
-    if (!parseTable(parser.getChunk())) {
+    if (!ParseTable(parser.chunk())) {
       error = true;
     }
   }
 
-  if (parser.getEvent() == ResChunkPullParser::Event::BadDocument) {
-    mContext->getDiagnostics()->error(DiagMessage(mSource)
-                                      << "corrupt resource table: "
-                                      << parser.getLastError());
+  if (parser.event() == ResChunkPullParser::Event::kBadDocument) {
+    context_->GetDiagnostics()->Error(
+        DiagMessage(source_) << "corrupt resource table: " << parser.error());
     return false;
   }
   return !error;
@@ -108,212 +112,210 @@ bool BinaryResourceParser::parse() {
  * Parses the resource table, which contains all the packages, types, and
  * entries.
  */
-bool BinaryResourceParser::parseTable(const ResChunk_header* chunk) {
-  const ResTable_header* tableHeader = convertTo<ResTable_header>(chunk);
-  if (!tableHeader) {
-    mContext->getDiagnostics()->error(DiagMessage(mSource)
+bool BinaryResourceParser::ParseTable(const ResChunk_header* chunk) {
+  const ResTable_header* table_header = ConvertTo<ResTable_header>(chunk);
+  if (!table_header) {
+    context_->GetDiagnostics()->Error(DiagMessage(source_)
                                       << "corrupt ResTable_header chunk");
     return false;
   }
 
-  ResChunkPullParser parser(getChunkData(&tableHeader->header),
-                            getChunkDataLen(&tableHeader->header));
-  while (ResChunkPullParser::isGoodEvent(parser.next())) {
-    switch (util::deviceToHost16(parser.getChunk()->type)) {
+  ResChunkPullParser parser(GetChunkData(&table_header->header),
+                            GetChunkDataLen(&table_header->header));
+  while (ResChunkPullParser::IsGoodEvent(parser.Next())) {
+    switch (util::DeviceToHost16(parser.chunk()->type)) {
       case android::RES_STRING_POOL_TYPE:
-        if (mValuePool.getError() == NO_INIT) {
-          status_t err = mValuePool.setTo(
-              parser.getChunk(), util::deviceToHost32(parser.getChunk()->size));
+        if (value_pool_.getError() == NO_INIT) {
+          status_t err = value_pool_.setTo(
+              parser.chunk(), util::DeviceToHost32(parser.chunk()->size));
           if (err != NO_ERROR) {
-            mContext->getDiagnostics()->error(
-                DiagMessage(mSource) << "corrupt string pool in ResTable: "
-                                     << mValuePool.getError());
+            context_->GetDiagnostics()->Error(
+                DiagMessage(source_) << "corrupt string pool in ResTable: "
+                                     << value_pool_.getError());
             return false;
           }
 
           // Reserve some space for the strings we are going to add.
-          mTable->stringPool.hintWillAdd(mValuePool.size(),
-                                         mValuePool.styleCount());
+          table_->string_pool.HintWillAdd(value_pool_.size(),
+                                          value_pool_.styleCount());
         } else {
-          mContext->getDiagnostics()->warn(
-              DiagMessage(mSource) << "unexpected string pool in ResTable");
+          context_->GetDiagnostics()->Warn(
+              DiagMessage(source_) << "unexpected string pool in ResTable");
         }
         break;
 
       case android::RES_TABLE_PACKAGE_TYPE:
-        if (!parsePackage(parser.getChunk())) {
+        if (!ParsePackage(parser.chunk())) {
           return false;
         }
         break;
 
       default:
-        mContext->getDiagnostics()->warn(
-            DiagMessage(mSource)
+        context_->GetDiagnostics()->Warn(
+            DiagMessage(source_)
             << "unexpected chunk type "
-            << (int)util::deviceToHost16(parser.getChunk()->type));
+            << (int)util::DeviceToHost16(parser.chunk()->type));
         break;
     }
   }
 
-  if (parser.getEvent() == ResChunkPullParser::Event::BadDocument) {
-    mContext->getDiagnostics()->error(DiagMessage(mSource)
-                                      << "corrupt resource table: "
-                                      << parser.getLastError());
+  if (parser.event() == ResChunkPullParser::Event::kBadDocument) {
+    context_->GetDiagnostics()->Error(
+        DiagMessage(source_) << "corrupt resource table: " << parser.error());
     return false;
   }
   return true;
 }
 
-bool BinaryResourceParser::parsePackage(const ResChunk_header* chunk) {
-  const ResTable_package* packageHeader = convertTo<ResTable_package>(chunk);
-  if (!packageHeader) {
-    mContext->getDiagnostics()->error(DiagMessage(mSource)
+bool BinaryResourceParser::ParsePackage(const ResChunk_header* chunk) {
+  const ResTable_package* package_header = ConvertTo<ResTable_package>(chunk);
+  if (!package_header) {
+    context_->GetDiagnostics()->Error(DiagMessage(source_)
                                       << "corrupt ResTable_package chunk");
     return false;
   }
 
-  uint32_t packageId = util::deviceToHost32(packageHeader->id);
-  if (packageId > std::numeric_limits<uint8_t>::max()) {
-    mContext->getDiagnostics()->error(
-        DiagMessage(mSource) << "package ID is too big (" << packageId << ")");
+  uint32_t package_id = util::DeviceToHost32(package_header->id);
+  if (package_id > std::numeric_limits<uint8_t>::max()) {
+    context_->GetDiagnostics()->Error(
+        DiagMessage(source_) << "package ID is too big (" << package_id << ")");
     return false;
   }
 
   // Extract the package name.
-  size_t len = strnlen16((const char16_t*)packageHeader->name,
-                         arraysize(packageHeader->name));
-  std::u16string packageName;
-  packageName.resize(len);
+  size_t len = strnlen16((const char16_t*)package_header->name,
+                         arraysize(package_header->name));
+  std::u16string package_name;
+  package_name.resize(len);
   for (size_t i = 0; i < len; i++) {
-    packageName[i] = util::deviceToHost16(packageHeader->name[i]);
+    package_name[i] = util::DeviceToHost16(package_header->name[i]);
   }
 
-  ResourceTablePackage* package = mTable->createPackage(
-      util::utf16ToUtf8(packageName), static_cast<uint8_t>(packageId));
+  ResourceTablePackage* package = table_->CreatePackage(
+      util::Utf16ToUtf8(package_name), static_cast<uint8_t>(package_id));
   if (!package) {
-    mContext->getDiagnostics()->error(DiagMessage(mSource)
-                                      << "incompatible package '" << packageName
-                                      << "' with ID " << packageId);
+    context_->GetDiagnostics()->Error(
+        DiagMessage(source_) << "incompatible package '" << package_name
+                             << "' with ID " << package_id);
     return false;
   }
 
   // There can be multiple packages in a table, so
   // clear the type and key pool in case they were set from a previous package.
-  mTypePool.uninit();
-  mKeyPool.uninit();
+  type_pool_.uninit();
+  key_pool_.uninit();
 
-  ResChunkPullParser parser(getChunkData(&packageHeader->header),
-                            getChunkDataLen(&packageHeader->header));
-  while (ResChunkPullParser::isGoodEvent(parser.next())) {
-    switch (util::deviceToHost16(parser.getChunk()->type)) {
+  ResChunkPullParser parser(GetChunkData(&package_header->header),
+                            GetChunkDataLen(&package_header->header));
+  while (ResChunkPullParser::IsGoodEvent(parser.Next())) {
+    switch (util::DeviceToHost16(parser.chunk()->type)) {
       case android::RES_STRING_POOL_TYPE:
-        if (mTypePool.getError() == NO_INIT) {
-          status_t err = mTypePool.setTo(
-              parser.getChunk(), util::deviceToHost32(parser.getChunk()->size));
+        if (type_pool_.getError() == NO_INIT) {
+          status_t err = type_pool_.setTo(
+              parser.chunk(), util::DeviceToHost32(parser.chunk()->size));
           if (err != NO_ERROR) {
-            mContext->getDiagnostics()->error(DiagMessage(mSource)
+            context_->GetDiagnostics()->Error(DiagMessage(source_)
                                               << "corrupt type string pool in "
                                               << "ResTable_package: "
-                                              << mTypePool.getError());
+                                              << type_pool_.getError());
             return false;
           }
-        } else if (mKeyPool.getError() == NO_INIT) {
-          status_t err = mKeyPool.setTo(
-              parser.getChunk(), util::deviceToHost32(parser.getChunk()->size));
+        } else if (key_pool_.getError() == NO_INIT) {
+          status_t err = key_pool_.setTo(
+              parser.chunk(), util::DeviceToHost32(parser.chunk()->size));
           if (err != NO_ERROR) {
-            mContext->getDiagnostics()->error(DiagMessage(mSource)
+            context_->GetDiagnostics()->Error(DiagMessage(source_)
                                               << "corrupt key string pool in "
                                               << "ResTable_package: "
-                                              << mKeyPool.getError());
+                                              << key_pool_.getError());
             return false;
           }
         } else {
-          mContext->getDiagnostics()->warn(DiagMessage(mSource)
+          context_->GetDiagnostics()->Warn(DiagMessage(source_)
                                            << "unexpected string pool");
         }
         break;
 
       case android::RES_TABLE_TYPE_SPEC_TYPE:
-        if (!parseTypeSpec(parser.getChunk())) {
+        if (!ParseTypeSpec(parser.chunk())) {
           return false;
         }
         break;
 
       case android::RES_TABLE_TYPE_TYPE:
-        if (!parseType(package, parser.getChunk())) {
+        if (!ParseType(package, parser.chunk())) {
           return false;
         }
         break;
 
       default:
-        mContext->getDiagnostics()->warn(
-            DiagMessage(mSource)
+        context_->GetDiagnostics()->Warn(
+            DiagMessage(source_)
             << "unexpected chunk type "
-            << (int)util::deviceToHost16(parser.getChunk()->type));
+            << (int)util::DeviceToHost16(parser.chunk()->type));
         break;
     }
   }
 
-  if (parser.getEvent() == ResChunkPullParser::Event::BadDocument) {
-    mContext->getDiagnostics()->error(DiagMessage(mSource)
-                                      << "corrupt ResTable_package: "
-                                      << parser.getLastError());
+  if (parser.event() == ResChunkPullParser::Event::kBadDocument) {
+    context_->GetDiagnostics()->Error(
+        DiagMessage(source_) << "corrupt ResTable_package: " << parser.error());
     return false;
   }
 
   // Now go through the table and change local resource ID references to
   // symbolic references.
-  ReferenceIdToNameVisitor visitor(&mIdIndex);
-  visitAllValuesInTable(mTable, &visitor);
+  ReferenceIdToNameVisitor visitor(&id_index_);
+  VisitAllValuesInTable(table_, &visitor);
   return true;
 }
 
-bool BinaryResourceParser::parseTypeSpec(const ResChunk_header* chunk) {
-  if (mTypePool.getError() != NO_ERROR) {
-    mContext->getDiagnostics()->error(DiagMessage(mSource)
+bool BinaryResourceParser::ParseTypeSpec(const ResChunk_header* chunk) {
+  if (type_pool_.getError() != NO_ERROR) {
+    context_->GetDiagnostics()->Error(DiagMessage(source_)
                                       << "missing type string pool");
     return false;
   }
 
-  const ResTable_typeSpec* typeSpec = convertTo<ResTable_typeSpec>(chunk);
-  if (!typeSpec) {
-    mContext->getDiagnostics()->error(DiagMessage(mSource)
+  const ResTable_typeSpec* type_spec = ConvertTo<ResTable_typeSpec>(chunk);
+  if (!type_spec) {
+    context_->GetDiagnostics()->Error(DiagMessage(source_)
                                       << "corrupt ResTable_typeSpec chunk");
     return false;
   }
 
-  if (typeSpec->id == 0) {
-    mContext->getDiagnostics()->error(DiagMessage(mSource)
+  if (type_spec->id == 0) {
+    context_->GetDiagnostics()->Error(DiagMessage(source_)
                                       << "ResTable_typeSpec has invalid id: "
-                                      << typeSpec->id);
+                                      << type_spec->id);
     return false;
   }
   return true;
 }
 
-bool BinaryResourceParser::parseType(const ResourceTablePackage* package,
+bool BinaryResourceParser::ParseType(const ResourceTablePackage* package,
                                      const ResChunk_header* chunk) {
-  if (mTypePool.getError() != NO_ERROR) {
-    mContext->getDiagnostics()->error(DiagMessage(mSource)
+  if (type_pool_.getError() != NO_ERROR) {
+    context_->GetDiagnostics()->Error(DiagMessage(source_)
                                       << "missing type string pool");
     return false;
   }
 
-  if (mKeyPool.getError() != NO_ERROR) {
-    mContext->getDiagnostics()->error(DiagMessage(mSource)
+  if (key_pool_.getError() != NO_ERROR) {
+    context_->GetDiagnostics()->Error(DiagMessage(source_)
                                       << "missing key string pool");
     return false;
   }
 
-  const ResTable_type* type = convertTo<ResTable_type>(chunk);
+  const ResTable_type* type = ConvertTo<ResTable_type>(chunk);
   if (!type) {
-    mContext->getDiagnostics()->error(DiagMessage(mSource)
+    context_->GetDiagnostics()->Error(DiagMessage(source_)
                                       << "corrupt ResTable_type chunk");
     return false;
   }
 
   if (type->id == 0) {
-    mContext->getDiagnostics()->error(DiagMessage(mSource)
+    context_->GetDiagnostics()->Error(DiagMessage(source_)
                                       << "ResTable_type has invalid id: "
                                       << (int)type->id);
     return false;
@@ -322,12 +324,12 @@ bool BinaryResourceParser::parseType(const ResourceTablePackage* package,
   ConfigDescription config;
   config.copyFromDtoH(type->config);
 
-  const std::string typeStr = util::getString(mTypePool, type->id - 1);
+  const std::string type_str = util::GetString(type_pool_, type->id - 1);
 
-  const ResourceType* parsedType = parseResourceType(typeStr);
-  if (!parsedType) {
-    mContext->getDiagnostics()->error(
-        DiagMessage(mSource) << "invalid type name '" << typeStr
+  const ResourceType* parsed_type = ParseResourceType(type_str);
+  if (!parsed_type) {
+    context_->GetDiagnostics()->Error(
+        DiagMessage(source_) << "invalid type name '" << type_str
                              << "' for type with ID " << (int)type->id);
     return false;
   }
@@ -340,91 +342,90 @@ bool BinaryResourceParser::parseType(const ResourceTablePackage* package,
     }
 
     const ResourceName name(
-        package->name, *parsedType,
-        util::getString(mKeyPool, util::deviceToHost32(entry->key.index)));
+        package->name, *parsed_type,
+        util::GetString(key_pool_, util::DeviceToHost32(entry->key.index)));
 
-    const ResourceId resId(package->id.value(), type->id,
-                           static_cast<uint16_t>(it.index()));
+    const ResourceId res_id(package->id.value(), type->id,
+                            static_cast<uint16_t>(it.index()));
 
-    std::unique_ptr<Value> resourceValue;
+    std::unique_ptr<Value> resource_value;
     if (entry->flags & ResTable_entry::FLAG_COMPLEX) {
       const ResTable_map_entry* mapEntry =
           static_cast<const ResTable_map_entry*>(entry);
 
       // TODO(adamlesinski): Check that the entry count is valid.
-      resourceValue = parseMapEntry(name, config, mapEntry);
+      resource_value = ParseMapEntry(name, config, mapEntry);
     } else {
       const Res_value* value =
           (const Res_value*)((const uint8_t*)entry +
-                             util::deviceToHost32(entry->size));
-      resourceValue = parseValue(name, config, value, entry->flags);
+                             util::DeviceToHost32(entry->size));
+      resource_value = ParseValue(name, config, value, entry->flags);
     }
 
-    if (!resourceValue) {
-      mContext->getDiagnostics()->error(
-          DiagMessage(mSource) << "failed to parse value for resource " << name
-                               << " (" << resId << ") with configuration '"
+    if (!resource_value) {
+      context_->GetDiagnostics()->Error(
+          DiagMessage(source_) << "failed to parse value for resource " << name
+                               << " (" << res_id << ") with configuration '"
                                << config << "'");
       return false;
     }
 
-    if (!mTable->addResourceAllowMangled(name, config, {},
-                                         std::move(resourceValue),
-                                         mContext->getDiagnostics())) {
+    if (!table_->AddResourceAllowMangled(name, config, {},
+                                         std::move(resource_value),
+                                         context_->GetDiagnostics())) {
       return false;
     }
 
     if ((entry->flags & ResTable_entry::FLAG_PUBLIC) != 0) {
       Symbol symbol;
       symbol.state = SymbolState::kPublic;
-      symbol.source = mSource.withLine(0);
-      if (!mTable->setSymbolStateAllowMangled(name, resId, symbol,
-                                              mContext->getDiagnostics())) {
+      symbol.source = source_.WithLine(0);
+      if (!table_->SetSymbolStateAllowMangled(name, res_id, symbol,
+                                              context_->GetDiagnostics())) {
         return false;
       }
     }
 
     // Add this resource name->id mapping to the index so
     // that we can resolve all ID references to name references.
-    auto cacheIter = mIdIndex.find(resId);
-    if (cacheIter == mIdIndex.end()) {
-      mIdIndex.insert({resId, name});
+    auto cache_iter = id_index_.find(res_id);
+    if (cache_iter == id_index_.end()) {
+      id_index_.insert({res_id, name});
     }
   }
   return true;
 }
 
-std::unique_ptr<Item> BinaryResourceParser::parseValue(
+std::unique_ptr<Item> BinaryResourceParser::ParseValue(
     const ResourceNameRef& name, const ConfigDescription& config,
     const Res_value* value, uint16_t flags) {
   if (name.type == ResourceType::kId) {
     return util::make_unique<Id>();
   }
 
-  const uint32_t data = util::deviceToHost32(value->data);
+  const uint32_t data = util::DeviceToHost32(value->data);
 
   if (value->dataType == Res_value::TYPE_STRING) {
-    const std::string str = util::getString(mValuePool, data);
+    const std::string str = util::GetString(value_pool_, data);
 
-    const ResStringPool_span* spans = mValuePool.styleAt(data);
+    const ResStringPool_span* spans = value_pool_.styleAt(data);
 
     // Check if the string has a valid style associated with it.
     if (spans != nullptr && spans->name.index != ResStringPool_span::END) {
-      StyleString styleStr = {str};
+      StyleString style_str = {str};
       while (spans->name.index != ResStringPool_span::END) {
-        styleStr.spans.push_back(
-            Span{util::getString(mValuePool, spans->name.index),
+        style_str.spans.push_back(
+            Span{util::GetString(value_pool_, spans->name.index),
                  spans->firstChar, spans->lastChar});
         spans++;
       }
-      return util::make_unique<StyledString>(mTable->stringPool.makeRef(
-          styleStr,
+      return util::make_unique<StyledString>(table_->string_pool.MakeRef(
+          style_str,
           StringPool::Context(StringPool::Context::kStylePriority, config)));
     } else {
-      if (name.type != ResourceType::kString &&
-          util::stringStartsWith(str, "res/")) {
+      if (name.type != ResourceType::kString && util::StartsWith(str, "res/")) {
         // This must be a FileReference.
-        return util::make_unique<FileReference>(mTable->stringPool.makeRef(
+        return util::make_unique<FileReference>(table_->string_pool.MakeRef(
             str,
             StringPool::Context(StringPool::Context::kHighPriority, config)));
       }
@@ -432,7 +433,7 @@ std::unique_ptr<Item> BinaryResourceParser::parseValue(
       // There are no styles associated with this string, so treat it as
       // a simple string.
       return util::make_unique<String>(
-          mTable->stringPool.makeRef(str, StringPool::Context(config)));
+          table_->string_pool.MakeRef(str, StringPool::Context(config)));
     }
   }
 
@@ -444,9 +445,9 @@ std::unique_ptr<Item> BinaryResourceParser::parseValue(
 
     if (data == 0) {
       // A reference of 0, must be the magic @null reference.
-      Res_value nullType = {};
-      nullType.dataType = Res_value::TYPE_REFERENCE;
-      return util::make_unique<BinaryPrimitive>(nullType);
+      Res_value null_type = {};
+      null_type.dataType = Res_value::TYPE_REFERENCE;
+      return util::make_unique<BinaryPrimitive>(null_type);
     }
 
     // This is a normal reference.
@@ -457,87 +458,88 @@ std::unique_ptr<Item> BinaryResourceParser::parseValue(
   return util::make_unique<BinaryPrimitive>(*value);
 }
 
-std::unique_ptr<Value> BinaryResourceParser::parseMapEntry(
+std::unique_ptr<Value> BinaryResourceParser::ParseMapEntry(
     const ResourceNameRef& name, const ConfigDescription& config,
     const ResTable_map_entry* map) {
   switch (name.type) {
     case ResourceType::kStyle:
-      return parseStyle(name, config, map);
+      return ParseStyle(name, config, map);
     case ResourceType::kAttrPrivate:
     // fallthrough
     case ResourceType::kAttr:
-      return parseAttr(name, config, map);
+      return ParseAttr(name, config, map);
     case ResourceType::kArray:
-      return parseArray(name, config, map);
+      return ParseArray(name, config, map);
     case ResourceType::kPlurals:
-      return parsePlural(name, config, map);
+      return ParsePlural(name, config, map);
     default:
-      assert(false && "unknown map type");
+      LOG(FATAL) << "unknown map type";
       break;
   }
   return {};
 }
 
-std::unique_ptr<Style> BinaryResourceParser::parseStyle(
+std::unique_ptr<Style> BinaryResourceParser::ParseStyle(
     const ResourceNameRef& name, const ConfigDescription& config,
     const ResTable_map_entry* map) {
   std::unique_ptr<Style> style = util::make_unique<Style>();
-  if (util::deviceToHost32(map->parent.ident) != 0) {
+  if (util::DeviceToHost32(map->parent.ident) != 0) {
     // The parent is a regular reference to a resource.
-    style->parent = Reference(util::deviceToHost32(map->parent.ident));
+    style->parent = Reference(util::DeviceToHost32(map->parent.ident));
   }
 
-  for (const ResTable_map& mapEntry : map) {
-    if (Res_INTERNALID(util::deviceToHost32(mapEntry.name.ident))) {
+  for (const ResTable_map& map_entry : map) {
+    if (Res_INTERNALID(util::DeviceToHost32(map_entry.name.ident))) {
       continue;
     }
 
-    Style::Entry styleEntry;
-    styleEntry.key = Reference(util::deviceToHost32(mapEntry.name.ident));
-    styleEntry.value = parseValue(name, config, &mapEntry.value, 0);
-    if (!styleEntry.value) {
+    Style::Entry style_entry;
+    style_entry.key = Reference(util::DeviceToHost32(map_entry.name.ident));
+    style_entry.value = ParseValue(name, config, &map_entry.value, 0);
+    if (!style_entry.value) {
       return {};
     }
-    style->entries.push_back(std::move(styleEntry));
+    style->entries.push_back(std::move(style_entry));
   }
   return style;
 }
 
-std::unique_ptr<Attribute> BinaryResourceParser::parseAttr(
+std::unique_ptr<Attribute> BinaryResourceParser::ParseAttr(
     const ResourceNameRef& name, const ConfigDescription& config,
     const ResTable_map_entry* map) {
-  const bool isWeak =
-      (util::deviceToHost16(map->flags) & ResTable_entry::FLAG_WEAK) != 0;
-  std::unique_ptr<Attribute> attr = util::make_unique<Attribute>(isWeak);
+  const bool is_weak =
+      (util::DeviceToHost16(map->flags) & ResTable_entry::FLAG_WEAK) != 0;
+  std::unique_ptr<Attribute> attr = util::make_unique<Attribute>(is_weak);
 
   // First we must discover what type of attribute this is. Find the type mask.
-  auto typeMaskIter =
+  auto type_mask_iter =
       std::find_if(begin(map), end(map), [](const ResTable_map& entry) -> bool {
-        return util::deviceToHost32(entry.name.ident) ==
+        return util::DeviceToHost32(entry.name.ident) ==
                ResTable_map::ATTR_TYPE;
       });
 
-  if (typeMaskIter != end(map)) {
-    attr->typeMask = util::deviceToHost32(typeMaskIter->value.data);
+  if (type_mask_iter != end(map)) {
+    attr->type_mask = util::DeviceToHost32(type_mask_iter->value.data);
   }
 
-  for (const ResTable_map& mapEntry : map) {
-    if (Res_INTERNALID(util::deviceToHost32(mapEntry.name.ident))) {
-      switch (util::deviceToHost32(mapEntry.name.ident)) {
+  for (const ResTable_map& map_entry : map) {
+    if (Res_INTERNALID(util::DeviceToHost32(map_entry.name.ident))) {
+      switch (util::DeviceToHost32(map_entry.name.ident)) {
         case ResTable_map::ATTR_MIN:
-          attr->minInt = static_cast<int32_t>(mapEntry.value.data);
+          attr->min_int = static_cast<int32_t>(map_entry.value.data);
           break;
         case ResTable_map::ATTR_MAX:
-          attr->maxInt = static_cast<int32_t>(mapEntry.value.data);
+          attr->max_int = static_cast<int32_t>(map_entry.value.data);
           break;
       }
       continue;
     }
 
-    if (attr->typeMask & (ResTable_map::TYPE_ENUM | ResTable_map::TYPE_FLAGS)) {
+    if (attr->type_mask &
+        (ResTable_map::TYPE_ENUM | ResTable_map::TYPE_FLAGS)) {
       Attribute::Symbol symbol;
-      symbol.value = util::deviceToHost32(mapEntry.value.data);
-      symbol.symbol = Reference(util::deviceToHost32(mapEntry.name.ident));
+      symbol.value = util::DeviceToHost32(map_entry.value.data);
+      symbol.symbol = Reference(util::DeviceToHost32(map_entry.name.ident));
       attr->symbols.push_back(std::move(symbol));
     }
   }
@@ -546,27 +548,27 @@ std::unique_ptr<Attribute> BinaryResourceParser::parseAttr(
   return attr;
 }
 
-std::unique_ptr<Array> BinaryResourceParser::parseArray(
+std::unique_ptr<Array> BinaryResourceParser::ParseArray(
     const ResourceNameRef& name, const ConfigDescription& config,
     const ResTable_map_entry* map) {
   std::unique_ptr<Array> array = util::make_unique<Array>();
-  for (const ResTable_map& mapEntry : map) {
-    array->items.push_back(parseValue(name, config, &mapEntry.value, 0));
+  for (const ResTable_map& map_entry : map) {
+    array->items.push_back(ParseValue(name, config, &map_entry.value, 0));
   }
   return array;
 }
 
-std::unique_ptr<Plural> BinaryResourceParser::parsePlural(
+std::unique_ptr<Plural> BinaryResourceParser::ParsePlural(
     const ResourceNameRef& name, const ConfigDescription& config,
     const ResTable_map_entry* map) {
   std::unique_ptr<Plural> plural = util::make_unique<Plural>();
-  for (const ResTable_map& mapEntry : map) {
-    std::unique_ptr<Item> item = parseValue(name, config, &mapEntry.value, 0);
+  for (const ResTable_map& map_entry : map) {
+    std::unique_ptr<Item> item = ParseValue(name, config, &map_entry.value, 0);
     if (!item) {
       return {};
     }
 
-    switch (util::deviceToHost32(mapEntry.name.ident)) {
+    switch (util::DeviceToHost32(map_entry.name.ident)) {
       case ResTable_map::ATTR_ZERO:
         plural->values[Plural::Zero] = std::move(item);
         break;
diff --git a/tools/aapt2/unflatten/BinaryResourceParser.h b/tools/aapt2/unflatten/BinaryResourceParser.h
index 99f2bd4e7e311..dc668fdab7b68 100644
--- a/tools/aapt2/unflatten/BinaryResourceParser.h
+++ b/tools/aapt2/unflatten/BinaryResourceParser.h
@@ -17,16 +17,17 @@
 #ifndef AAPT_BINARY_RESOURCE_PARSER_H
 #define AAPT_BINARY_RESOURCE_PARSER_H
 
+#include <string>
+
+#include "android-base/macros.h"
+#include "androidfw/ResourceTypes.h"
+
 #include "ResourceTable.h"
 #include "ResourceValues.h"
 #include "Source.h"
-
 #include "process/IResourceTableConsumer.h"
 #include "util/Util.h"
 
-#include <androidfw/ResourceTypes.h>
-#include <string>
-
 namespace aapt {
 
 struct SymbolTable_entry;
@@ -45,44 +46,44 @@ class BinaryResourceParser {
    * add any resources parsed to `table`. `source` is for logging purposes.
    */
   BinaryResourceParser(IAaptContext* context, ResourceTable* table,
-                       const Source& source, const void* data, size_t dataLen);
-
-  BinaryResourceParser(const BinaryResourceParser&) = delete;  // No copy.
+                       const Source& source, const void* data, size_t data_len);
 
   /*
    * Parses the binary resource table and returns true if successful.
    */
-  bool parse();
+  bool Parse();
 
  private:
-  bool parseTable(const android::ResChunk_header* chunk);
-  bool parsePackage(const android::ResChunk_header* chunk);
-  bool parseTypeSpec(const android::ResChunk_header* chunk);
-  bool parseType(const ResourceTablePackage* package,
+  DISALLOW_COPY_AND_ASSIGN(BinaryResourceParser);
+
+  bool ParseTable(const android::ResChunk_header* chunk);
+  bool ParsePackage(const android::ResChunk_header* chunk);
+  bool ParseTypeSpec(const android::ResChunk_header* chunk);
+  bool ParseType(const ResourceTablePackage* package,
                  const android::ResChunk_header* chunk);
 
-  std::unique_ptr<Item> parseValue(const ResourceNameRef& name,
+  std::unique_ptr<Item> ParseValue(const ResourceNameRef& name,
                                    const ConfigDescription& config,
                                    const android::Res_value* value,
                                    uint16_t flags);
 
-  std::unique_ptr<Value> parseMapEntry(const ResourceNameRef& name,
+  std::unique_ptr<Value> ParseMapEntry(const ResourceNameRef& name,
                                        const ConfigDescription& config,
                                        const android::ResTable_map_entry* map);
 
-  std::unique_ptr<Style> parseStyle(const ResourceNameRef& name,
+  std::unique_ptr<Style> ParseStyle(const ResourceNameRef& name,
                                     const ConfigDescription& config,
                                     const android::ResTable_map_entry* map);
 
-  std::unique_ptr<Attribute> parseAttr(const ResourceNameRef& name,
+  std::unique_ptr<Attribute> ParseAttr(const ResourceNameRef& name,
                                        const ConfigDescription& config,
                                        const android::ResTable_map_entry* map);
 
-  std::unique_ptr<Array> parseArray(const ResourceNameRef& name,
+  std::unique_ptr<Array> ParseArray(const ResourceNameRef& name,
                                     const ConfigDescription& config,
                                     const android::ResTable_map_entry* map);
 
-  std::unique_ptr<Plural> parsePlural(const ResourceNameRef& name,
+  std::unique_ptr<Plural> ParsePlural(const ResourceNameRef& name,
                                       const ConfigDescription& config,
                                       const android::ResTable_map_entry* map);
 
@@ -92,30 +93,30 @@ class BinaryResourceParser {
    * read and added to the Value.
    * Returns true if the mapEntry was meta data.
    */
-  bool collectMetaData(const android::ResTable_map& mapEntry, Value* value);
+  bool CollectMetaData(const android::ResTable_map& map_entry, Value* value);
 
-  IAaptContext* mContext;
-  ResourceTable* mTable;
+  IAaptContext* context_;
+  ResourceTable* table_;
 
-  const Source mSource;
+  const Source source_;
 
-  const void* mData;
-  const size_t mDataLen;
+  const void* data_;
+  const size_t data_len_;
 
   // The standard value string pool for resource values.
-  android::ResStringPool mValuePool;
+  android::ResStringPool value_pool_;
 
   // The string pool that holds the names of the types defined
   // in this table.
-  android::ResStringPool mTypePool;
+  android::ResStringPool type_pool_;
 
   // The string pool that holds the names of the entries defined
   // in this table.
-  android::ResStringPool mKeyPool;
+  android::ResStringPool key_pool_;
 
   // A mapping of resource ID to resource name. When we finish parsing
   // we use this to convert all resource IDs to symbolic references.
-  std::map<ResourceId, ResourceName> mIdIndex;
+  std::map<ResourceId, ResourceName> id_index_;
 };
 
 }  // namespace aapt
@@ -128,11 +129,11 @@ namespace android {
 
 inline const ResTable_map* begin(const ResTable_map_entry* map) {
   return (const ResTable_map*)((const uint8_t*)map +
-                               aapt::util::deviceToHost32(map->size));
+                               aapt::util::DeviceToHost32(map->size));
 }
 
 inline const ResTable_map* end(const ResTable_map_entry* map) {
-  return begin(map) + aapt::util::deviceToHost32(map->count);
+  return begin(map) + aapt::util::DeviceToHost32(map->count);
 }
 
 }  // namespace android
diff --git a/tools/aapt2/unflatten/ResChunkPullParser.cpp b/tools/aapt2/unflatten/ResChunkPullParser.cpp
index 6f8bb1b29b626..5d71ff315874f 100644
--- a/tools/aapt2/unflatten/ResChunkPullParser.cpp
+++ b/tools/aapt2/unflatten/ResChunkPullParser.cpp
@@ -15,55 +15,60 @@
  */
 
 #include "unflatten/ResChunkPullParser.h"
-#include "util/Util.h"
 
-#include <androidfw/ResourceTypes.h>
 #include <cstddef>
 
+#include "android-base/logging.h"
+#include "androidfw/ResourceTypes.h"
+
+#include "util/Util.h"
+
 namespace aapt {
 
 using android::ResChunk_header;
 
-ResChunkPullParser::Event ResChunkPullParser::next() {
-    if (!isGoodEvent(mEvent)) {
-        return mEvent;
-    }
+ResChunkPullParser::Event ResChunkPullParser::Next() {
+  if (!IsGoodEvent(event_)) {
+    return event_;
+  }
 
-    if (mEvent == Event::StartDocument) {
-        mCurrentChunk = mData;
-    } else {
-        mCurrentChunk = (const ResChunk_header*)
-                (((const char*) mCurrentChunk) + util::deviceToHost32(mCurrentChunk->size));
-    }
+  if (event_ == Event::kStartDocument) {
+    current_chunk_ = data_;
+  } else {
+    current_chunk_ =
+        (const ResChunk_header*)(((const char*)current_chunk_) +
+                                 util::DeviceToHost32(current_chunk_->size));
+  }
 
-    const std::ptrdiff_t diff = (const char*) mCurrentChunk - (const char*) mData;
-    assert(diff >= 0 && "diff is negative");
-    const size_t offset = static_cast<const size_t>(diff);
+  const std::ptrdiff_t diff = (const char*)current_chunk_ - (const char*)data_;
+  CHECK(diff >= 0) << "diff is negative";
+  const size_t offset = static_cast<const size_t>(diff);
 
-    if (offset == mLen) {
-        mCurrentChunk = nullptr;
-        return (mEvent = Event::EndDocument);
-    } else if (offset + sizeof(ResChunk_header) > mLen) {
-        mLastError = "chunk is past the end of the document";
-        mCurrentChunk = nullptr;
-        return (mEvent = Event::BadDocument);
-    }
+  if (offset == len_) {
+    current_chunk_ = nullptr;
+    return (event_ = Event::kEndDocument);
+  } else if (offset + sizeof(ResChunk_header) > len_) {
+    error_ = "chunk is past the end of the document";
+    current_chunk_ = nullptr;
+    return (event_ = Event::kBadDocument);
+  }
 
-    if (util::deviceToHost16(mCurrentChunk->headerSize) < sizeof(ResChunk_header)) {
-        mLastError = "chunk has too small header";
-        mCurrentChunk = nullptr;
-        return (mEvent = Event::BadDocument);
-    } else if (util::deviceToHost32(mCurrentChunk->size) <
-            util::deviceToHost16(mCurrentChunk->headerSize)) {
-        mLastError = "chunk's total size is smaller than header";
-        mCurrentChunk = nullptr;
-        return (mEvent = Event::BadDocument);
-    } else if (offset + util::deviceToHost32(mCurrentChunk->size) > mLen) {
-        mLastError = "chunk's data extends past the end of the document";
-        mCurrentChunk = nullptr;
-        return (mEvent = Event::BadDocument);
-    }
-    return (mEvent = Event::Chunk);
+  if (util::DeviceToHost16(current_chunk_->headerSize) <
+      sizeof(ResChunk_header)) {
+    error_ = "chunk has too small header";
+    current_chunk_ = nullptr;
+    return (event_ = Event::kBadDocument);
+  } else if (util::DeviceToHost32(current_chunk_->size) <
+             util::DeviceToHost16(current_chunk_->headerSize)) {
+    error_ = "chunk's total size is smaller than header";
+    current_chunk_ = nullptr;
+    return (event_ = Event::kBadDocument);
+  } else if (offset + util::DeviceToHost32(current_chunk_->size) > len_) {
+    error_ = "chunk's data extends past the end of the document";
+    current_chunk_ = nullptr;
+    return (event_ = Event::kBadDocument);
+  }
+  return (event_ = Event::kChunk);
 }
 
-} // namespace aapt
+}  // namespace aapt
diff --git a/tools/aapt2/unflatten/ResChunkPullParser.h b/tools/aapt2/unflatten/ResChunkPullParser.h
index 24fa63d6e5b4d..437fc5c8a9b6a 100644
--- a/tools/aapt2/unflatten/ResChunkPullParser.h
+++ b/tools/aapt2/unflatten/ResChunkPullParser.h
@@ -17,11 +17,13 @@
 #ifndef AAPT_RES_CHUNK_PULL_PARSER_H
 #define AAPT_RES_CHUNK_PULL_PARSER_H
 
-#include "util/Util.h"
-
-#include <androidfw/ResourceTypes.h>
 #include <string>
 
+#include "android-base/macros.h"
+#include "androidfw/ResourceTypes.h"
+
+#include "util/Util.h"
+
 namespace aapt {
 
 /**
@@ -39,17 +41,17 @@ namespace aapt {
 class ResChunkPullParser {
  public:
   enum class Event {
-    StartDocument,
-    EndDocument,
-    BadDocument,
+    kStartDocument,
+    kEndDocument,
+    kBadDocument,
 
-    Chunk,
+    kChunk,
   };
 
   /**
    * Returns false if the event is EndDocument or BadDocument.
    */
-  static bool isGoodEvent(Event event);
+  static bool IsGoodEvent(Event event);
 
   /**
    * Create a ResChunkPullParser to read android::ResChunk_headers
@@ -57,68 +59,66 @@ class ResChunkPullParser {
    */
   ResChunkPullParser(const void* data, size_t len);
 
-  ResChunkPullParser(const ResChunkPullParser&) = delete;
-
-  Event getEvent() const;
-  const std::string& getLastError() const;
-  const android::ResChunk_header* getChunk() const;
+  Event event() const;
+  const std::string& error() const;
+  const android::ResChunk_header* chunk() const;
 
   /**
    * Move to the next android::ResChunk_header.
    */
-  Event next();
+  Event Next();
 
  private:
-  Event mEvent;
-  const android::ResChunk_header* mData;
-  size_t mLen;
-  const android::ResChunk_header* mCurrentChunk;
-  std::string mLastError;
+  DISALLOW_COPY_AND_ASSIGN(ResChunkPullParser);
+
+  Event event_;
+  const android::ResChunk_header* data_;
+  size_t len_;
+  const android::ResChunk_header* current_chunk_;
+  std::string error_;
 };
 
 template <typename T>
-inline static const T* convertTo(const android::ResChunk_header* chunk) {
-  if (util::deviceToHost16(chunk->headerSize) < sizeof(T)) {
+inline static const T* ConvertTo(const android::ResChunk_header* chunk) {
+  if (util::DeviceToHost16(chunk->headerSize) < sizeof(T)) {
     return nullptr;
   }
   return reinterpret_cast<const T*>(chunk);
 }
 
-inline static const uint8_t* getChunkData(
+inline static const uint8_t* GetChunkData(
     const android::ResChunk_header* chunk) {
   return reinterpret_cast<const uint8_t*>(chunk) +
-         util::deviceToHost16(chunk->headerSize);
+         util::DeviceToHost16(chunk->headerSize);
 }
 
-inline static uint32_t getChunkDataLen(const android::ResChunk_header* chunk) {
-  return util::deviceToHost32(chunk->size) -
-         util::deviceToHost16(chunk->headerSize);
+inline static uint32_t GetChunkDataLen(const android::ResChunk_header* chunk) {
+  return util::DeviceToHost32(chunk->size) -
+         util::DeviceToHost16(chunk->headerSize);
 }
 
 //
 // Implementation
 //
 
-inline bool ResChunkPullParser::isGoodEvent(ResChunkPullParser::Event event) {
-  return event != Event::EndDocument && event != Event::BadDocument;
+inline bool ResChunkPullParser::IsGoodEvent(ResChunkPullParser::Event event) {
+  return event != Event::kEndDocument && event != Event::kBadDocument;
 }
 
 inline ResChunkPullParser::ResChunkPullParser(const void* data, size_t len)
-    : mEvent(Event::StartDocument),
-      mData(reinterpret_cast<const android::ResChunk_header*>(data)),
-      mLen(len),
-      mCurrentChunk(nullptr) {}
+    : event_(Event::kStartDocument),
+      data_(reinterpret_cast<const android::ResChunk_header*>(data)),
+      len_(len),
+      current_chunk_(nullptr) {}
 
-inline ResChunkPullParser::Event ResChunkPullParser::getEvent() const {
-  return mEvent;
+inline ResChunkPullParser::Event ResChunkPullParser::event() const {
+  return event_;
 }
 
-inline const std::string& ResChunkPullParser::getLastError() const {
-  return mLastError;
-}
+inline const std::string& ResChunkPullParser::error() const { return error_; }
 
-inline const android::ResChunk_header* ResChunkPullParser::getChunk() const {
-  return mCurrentChunk;
+inline const android::ResChunk_header* ResChunkPullParser::chunk() const {
+  return current_chunk_;
 }
 
 }  // namespace aapt
diff --git a/tools/aapt2/util/BigBuffer.cpp b/tools/aapt2/util/BigBuffer.cpp
index de4ecd21ec2d3..ef99dca286a49 100644
--- a/tools/aapt2/util/BigBuffer.cpp
+++ b/tools/aapt2/util/BigBuffer.cpp
@@ -20,58 +20,60 @@
 #include <memory>
 #include <vector>
 
+#include "android-base/logging.h"
+
 namespace aapt {
 
-void* BigBuffer::nextBlockImpl(size_t size) {
-    if (!mBlocks.empty()) {
-        Block& block = mBlocks.back();
-        if (block.mBlockSize - block.size >= size) {
-            void* outBuffer = block.buffer.get() + block.size;
-            block.size += size;
-            mSize += size;
-            return outBuffer;
-        }
+void* BigBuffer::NextBlockImpl(size_t size) {
+  if (!blocks_.empty()) {
+    Block& block = blocks_.back();
+    if (block.block_size_ - block.size >= size) {
+      void* out_buffer = block.buffer.get() + block.size;
+      block.size += size;
+      size_ += size;
+      return out_buffer;
     }
+  }
 
-    const size_t actualSize = std::max(mBlockSize, size);
+  const size_t actual_size = std::max(block_size_, size);
 
-    Block block = {};
+  Block block = {};
 
-    // Zero-allocate the block's buffer.
-    block.buffer = std::unique_ptr<uint8_t[]>(new uint8_t[actualSize]());
-    assert(block.buffer);
+  // Zero-allocate the block's buffer.
+  block.buffer = std::unique_ptr<uint8_t[]>(new uint8_t[actual_size]());
+  CHECK(block.buffer);
 
-    block.size = size;
-    block.mBlockSize = actualSize;
+  block.size = size;
+  block.block_size_ = actual_size;
 
-    mBlocks.push_back(std::move(block));
-    mSize += size;
-    return mBlocks.back().buffer.get();
+  blocks_.push_back(std::move(block));
+  size_ += size;
+  return blocks_.back().buffer.get();
 }
 
-void* BigBuffer::nextBlock(size_t* outSize) {
-    if (!mBlocks.empty()) {
-        Block& block = mBlocks.back();
-        if (block.size != block.mBlockSize) {
-            void* outBuffer = block.buffer.get() + block.size;
-            size_t size = block.mBlockSize - block.size;
-            block.size = block.mBlockSize;
-            mSize += size;
-            *outSize = size;
-            return outBuffer;
-        }
+void* BigBuffer::NextBlock(size_t* out_size) {
+  if (!blocks_.empty()) {
+    Block& block = blocks_.back();
+    if (block.size != block.block_size_) {
+      void* out_buffer = block.buffer.get() + block.size;
+      size_t size = block.block_size_ - block.size;
+      block.size = block.block_size_;
+      size_ += size;
+      *out_size = size;
+      return out_buffer;
     }
+  }
 
-    // Zero-allocate the block's buffer.
-    Block block = {};
-    block.buffer = std::unique_ptr<uint8_t[]>(new uint8_t[mBlockSize]());
-    assert(block.buffer);
-    block.size = mBlockSize;
-    block.mBlockSize = mBlockSize;
-    mBlocks.push_back(std::move(block));
-    mSize += mBlockSize;
-    *outSize = mBlockSize;
-    return mBlocks.back().buffer.get();
+  // Zero-allocate the block's buffer.
+  Block block = {};
+  block.buffer = std::unique_ptr<uint8_t[]>(new uint8_t[block_size_]());
+  CHECK(block.buffer);
+  block.size = block_size_;
+  block.block_size_ = block_size_;
+  blocks_.push_back(std::move(block));
+  size_ += block_size_;
+  *out_size = block_size_;
+  return blocks_.back().buffer.get();
 }
 
-} // namespace aapt
+}  // namespace aapt
diff --git a/tools/aapt2/util/BigBuffer.h b/tools/aapt2/util/BigBuffer.h
index b273733f6489f..d23c41d4d6f0f 100644
--- a/tools/aapt2/util/BigBuffer.h
+++ b/tools/aapt2/util/BigBuffer.h
@@ -17,12 +17,14 @@
 #ifndef AAPT_BIG_BUFFER_H
 #define AAPT_BIG_BUFFER_H
 
-#include <cassert>
 #include <cstring>
 #include <memory>
 #include <type_traits>
 #include <vector>
 
+#include "android-base/logging.h"
+#include "android-base/macros.h"
+
 namespace aapt {
 
 /**
@@ -54,18 +56,16 @@ class BigBuffer {
     /**
      * The size of the memory block allocation.
      */
-    size_t mBlockSize;
+    size_t block_size_;
   };
 
   typedef std::vector<Block>::const_iterator const_iterator;
 
   /**
    * Create a BigBuffer with block allocation sizes
-   * of blockSize.
+   * of block_size.
    */
-  explicit BigBuffer(size_t blockSize);
-
-  BigBuffer(const BigBuffer&) = delete;  // No copying.
+  explicit BigBuffer(size_t block_size);
 
   BigBuffer(BigBuffer&& rhs);
 
@@ -79,104 +79,106 @@ class BigBuffer {
    * a POD type. The elements are zero-initialized.
    */
   template <typename T>
-  T* nextBlock(size_t count = 1);
+  T* NextBlock(size_t count = 1);
 
   /**
-   * Returns the next block available and puts the size in outCount.
+   * Returns the next block available and puts the size in out_count.
    * This is useful for grabbing blocks where the size doesn't matter.
-   * Use backUp() to give back any bytes that were not used.
+   * Use BackUp() to give back any bytes that were not used.
    */
-  void* nextBlock(size_t* outCount);
+  void* NextBlock(size_t* out_count);
 
   /**
-   * Backs up count bytes. This must only be called after nextBlock()
-   * and can not be larger than sizeof(T) * count of the last nextBlock()
+   * Backs up count bytes. This must only be called after NextBlock()
+   * and can not be larger than sizeof(T) * count of the last NextBlock()
    * call.
    */
-  void backUp(size_t count);
+  void BackUp(size_t count);
 
   /**
    * Moves the specified BigBuffer into this one. When this method
    * returns, buffer is empty.
    */
-  void appendBuffer(BigBuffer&& buffer);
+  void AppendBuffer(BigBuffer&& buffer);
 
   /**
    * Pads the block with 'bytes' bytes of zero values.
    */
-  void pad(size_t bytes);
+  void Pad(size_t bytes);
 
   /**
    * Pads the block so that it aligns on a 4 byte boundary.
    */
-  void align4();
+  void Align4();
 
-  size_t getBlockSize() const;
+  size_t block_size() const;
 
   const_iterator begin() const;
   const_iterator end() const;
 
  private:
+  DISALLOW_COPY_AND_ASSIGN(BigBuffer);
+
   /**
    * Returns a pointer to a buffer of the requested size.
    * The buffer is zero-initialized.
    */
-  void* nextBlockImpl(size_t size);
+  void* NextBlockImpl(size_t size);
 
-  size_t mBlockSize;
-  size_t mSize;
-  std::vector<Block> mBlocks;
+  size_t block_size_;
+  size_t size_;
+  std::vector<Block> blocks_;
 };
 
-inline BigBuffer::BigBuffer(size_t blockSize)
-    : mBlockSize(blockSize), mSize(0) {}
+inline BigBuffer::BigBuffer(size_t block_size)
+    : block_size_(block_size), size_(0) {}
 
 inline BigBuffer::BigBuffer(BigBuffer&& rhs)
-    : mBlockSize(rhs.mBlockSize),
-      mSize(rhs.mSize),
-      mBlocks(std::move(rhs.mBlocks)) {}
+    : block_size_(rhs.block_size_),
+      size_(rhs.size_),
+      blocks_(std::move(rhs.blocks_)) {}
 
-inline size_t BigBuffer::size() const { return mSize; }
+inline size_t BigBuffer::size() const { return size_; }
 
-inline size_t BigBuffer::getBlockSize() const { return mBlockSize; }
+inline size_t BigBuffer::block_size() const { return block_size_; }
 
 template <typename T>
-inline T* BigBuffer::nextBlock(size_t count) {
+inline T* BigBuffer::NextBlock(size_t count) {
   static_assert(std::is_standard_layout<T>::value,
                 "T must be standard_layout type");
-  assert(count != 0);
-  return reinterpret_cast<T*>(nextBlockImpl(sizeof(T) * count));
+  CHECK(count != 0);
+  return reinterpret_cast<T*>(NextBlockImpl(sizeof(T) * count));
 }
 
-inline void BigBuffer::backUp(size_t count) {
-  Block& block = mBlocks.back();
+inline void BigBuffer::BackUp(size_t count) {
+  Block& block = blocks_.back();
   block.size -= count;
-  mSize -= count;
+  size_ -= count;
 }
 
-inline void BigBuffer::appendBuffer(BigBuffer&& buffer) {
-  std::move(buffer.mBlocks.begin(), buffer.mBlocks.end(),
-            std::back_inserter(mBlocks));
-  mSize += buffer.mSize;
-  buffer.mBlocks.clear();
-  buffer.mSize = 0;
+inline void BigBuffer::AppendBuffer(BigBuffer&& buffer) {
+  std::move(buffer.blocks_.begin(), buffer.blocks_.end(),
+            std::back_inserter(blocks_));
+  size_ += buffer.size_;
+  buffer.blocks_.clear();
+  buffer.size_ = 0;
 }
 
-inline void BigBuffer::pad(size_t bytes) { nextBlock<char>(bytes); }
+inline void BigBuffer::Pad(size_t bytes) { NextBlock<char>(bytes); }
 
-inline void BigBuffer::align4() {
-  const size_t unaligned = mSize % 4;
+inline void BigBuffer::Align4() {
+  const size_t unaligned = size_ % 4;
   if (unaligned != 0) {
-    pad(4 - unaligned);
+    Pad(4 - unaligned);
   }
 }
 
 inline BigBuffer::const_iterator BigBuffer::begin() const {
-  return mBlocks.begin();
+  return blocks_.begin();
 }
 
 inline BigBuffer::const_iterator BigBuffer::end() const {
-  return mBlocks.end();
+  return blocks_.end();
 }
 
 }  // namespace aapt
diff --git a/tools/aapt2/util/BigBuffer_test.cpp b/tools/aapt2/util/BigBuffer_test.cpp
index 2a24f123e18eb..12c0b3ee3214c 100644
--- a/tools/aapt2/util/BigBuffer_test.cpp
+++ b/tools/aapt2/util/BigBuffer_test.cpp
@@ -16,83 +16,83 @@
 
 #include "util/BigBuffer.h"
 
-#include <gtest/gtest.h>
+#include "test/Test.h"
 
 namespace aapt {
 
 TEST(BigBufferTest, AllocateSingleBlock) {
-    BigBuffer buffer(4);
+  BigBuffer buffer(4);
 
-    EXPECT_NE(nullptr, buffer.nextBlock<char>(2));
-    EXPECT_EQ(2u, buffer.size());
+  EXPECT_NE(nullptr, buffer.NextBlock<char>(2));
+  EXPECT_EQ(2u, buffer.size());
 }
 
 TEST(BigBufferTest, ReturnSameBlockIfNextAllocationFits) {
-    BigBuffer buffer(16);
+  BigBuffer buffer(16);
 
-    char* b1 = buffer.nextBlock<char>(8);
-    EXPECT_NE(nullptr, b1);
+  char* b1 = buffer.NextBlock<char>(8);
+  EXPECT_NE(nullptr, b1);
 
-    char* b2 = buffer.nextBlock<char>(4);
-    EXPECT_NE(nullptr, b2);
+  char* b2 = buffer.NextBlock<char>(4);
+  EXPECT_NE(nullptr, b2);
 
-    EXPECT_EQ(b1 + 8, b2);
+  EXPECT_EQ(b1 + 8, b2);
 }
 
 TEST(BigBufferTest, AllocateExactSizeBlockIfLargerThanBlockSize) {
-    BigBuffer buffer(16);
+  BigBuffer buffer(16);
 
-    EXPECT_NE(nullptr, buffer.nextBlock<char>(32));
-    EXPECT_EQ(32u, buffer.size());
+  EXPECT_NE(nullptr, buffer.NextBlock<char>(32));
+  EXPECT_EQ(32u, buffer.size());
 }
 
 TEST(BigBufferTest, AppendAndMoveBlock) {
-    BigBuffer buffer(16);
+  BigBuffer buffer(16);
 
-    uint32_t* b1 = buffer.nextBlock<uint32_t>();
+  uint32_t* b1 = buffer.NextBlock<uint32_t>();
+  ASSERT_NE(nullptr, b1);
+  *b1 = 33;
+
+  {
+    BigBuffer buffer2(16);
+    b1 = buffer2.NextBlock<uint32_t>();
     ASSERT_NE(nullptr, b1);
-    *b1 = 33;
+    *b1 = 44;
 
-    {
-        BigBuffer buffer2(16);
-        b1 = buffer2.nextBlock<uint32_t>();
-        ASSERT_NE(nullptr, b1);
-        *b1 = 44;
+    buffer.AppendBuffer(std::move(buffer2));
+    EXPECT_EQ(0u, buffer2.size());
+    EXPECT_EQ(buffer2.begin(), buffer2.end());
+  }
 
-        buffer.appendBuffer(std::move(buffer2));
-        EXPECT_EQ(0u, buffer2.size());
-        EXPECT_EQ(buffer2.begin(), buffer2.end());
-    }
+  EXPECT_EQ(2 * sizeof(uint32_t), buffer.size());
 
-    EXPECT_EQ(2 * sizeof(uint32_t), buffer.size());
+  auto b = buffer.begin();
+  ASSERT_NE(b, buffer.end());
+  ASSERT_EQ(sizeof(uint32_t), b->size);
+  ASSERT_EQ(33u, *reinterpret_cast<uint32_t*>(b->buffer.get()));
+  ++b;
 
-    auto b = buffer.begin();
-    ASSERT_NE(b, buffer.end());
-    ASSERT_EQ(sizeof(uint32_t), b->size);
-    ASSERT_EQ(33u, *reinterpret_cast<uint32_t*>(b->buffer.get()));
-    ++b;
+  ASSERT_NE(b, buffer.end());
+  ASSERT_EQ(sizeof(uint32_t), b->size);
+  ASSERT_EQ(44u, *reinterpret_cast<uint32_t*>(b->buffer.get()));
+  ++b;
 
-    ASSERT_NE(b, buffer.end());
-    ASSERT_EQ(sizeof(uint32_t), b->size);
-    ASSERT_EQ(44u, *reinterpret_cast<uint32_t*>(b->buffer.get()));
-    ++b;
-
-    ASSERT_EQ(b, buffer.end());
+  ASSERT_EQ(b, buffer.end());
 }
 
 TEST(BigBufferTest, PadAndAlignProperly) {
-    BigBuffer buffer(16);
+  BigBuffer buffer(16);
 
-    ASSERT_NE(buffer.nextBlock<char>(2), nullptr);
-    ASSERT_EQ(2u, buffer.size());
-    buffer.pad(2);
-    ASSERT_EQ(4u, buffer.size());
-    buffer.align4();
-    ASSERT_EQ(4u, buffer.size());
-    buffer.pad(2);
-    ASSERT_EQ(6u, buffer.size());
-    buffer.align4();
-    ASSERT_EQ(8u, buffer.size());
+  ASSERT_NE(buffer.NextBlock<char>(2), nullptr);
+  ASSERT_EQ(2u, buffer.size());
+  buffer.Pad(2);
+  ASSERT_EQ(4u, buffer.size());
+  buffer.Align4();
+  ASSERT_EQ(4u, buffer.size());
+  buffer.Pad(2);
+  ASSERT_EQ(6u, buffer.size());
+  buffer.Align4();
+  ASSERT_EQ(8u, buffer.size());
 }
 
-} // namespace aapt
+}  // namespace aapt
diff --git a/tools/aapt2/util/Files.cpp b/tools/aapt2/util/Files.cpp
index 4cba921eb79f9..f034607ea8f57 100644
--- a/tools/aapt2/util/Files.cpp
+++ b/tools/aapt2/util/Files.cpp
@@ -15,15 +15,20 @@
  */
 
 #include "util/Files.h"
-#include "util/Util.h"
+
+#include <dirent.h>
+#include <sys/stat.h>
 
 #include <algorithm>
-#include <android-base/file.h>
 #include <cerrno>
 #include <cstdio>
-#include <dirent.h>
 #include <string>
-#include <sys/stat.h>
+
+#include "android-base/errors.h"
+#include "android-base/file.h"
+#include "android-base/logging.h"
+
+#include "util/Util.h"
 
 #ifdef _WIN32
 // Windows includes.
@@ -33,244 +38,230 @@
 namespace aapt {
 namespace file {
 
-FileType getFileType(const StringPiece& path) {
-    struct stat sb;
-    if (stat(path.data(), &sb) < 0) {
-        if (errno == ENOENT || errno == ENOTDIR) {
-            return FileType::kNonexistant;
-        }
-        return FileType::kUnknown;
+FileType GetFileType(const StringPiece& path) {
+  struct stat sb;
+  if (stat(path.data(), &sb) < 0) {
+    if (errno == ENOENT || errno == ENOTDIR) {
+      return FileType::kNonexistant;
     }
+    return FileType::kUnknown;
+  }
 
-    if (S_ISREG(sb.st_mode)) {
-        return FileType::kRegular;
-    } else if (S_ISDIR(sb.st_mode)) {
-        return FileType::kDirectory;
-    } else if (S_ISCHR(sb.st_mode)) {
-        return FileType::kCharDev;
-    } else if (S_ISBLK(sb.st_mode)) {
-        return FileType::kBlockDev;
-    } else if (S_ISFIFO(sb.st_mode)) {
-        return FileType::kFifo;
+  if (S_ISREG(sb.st_mode)) {
+    return FileType::kRegular;
+  } else if (S_ISDIR(sb.st_mode)) {
+    return FileType::kDirectory;
+  } else if (S_ISCHR(sb.st_mode)) {
+    return FileType::kCharDev;
+  } else if (S_ISBLK(sb.st_mode)) {
+    return FileType::kBlockDev;
+  } else if (S_ISFIFO(sb.st_mode)) {
+    return FileType::kFifo;
 #if defined(S_ISLNK)
-    } else if (S_ISLNK(sb.st_mode)) {
-        return FileType::kSymlink;
+  } else if (S_ISLNK(sb.st_mode)) {
+    return FileType::kSymlink;
 #endif
 #if defined(S_ISSOCK)
-    } else if (S_ISSOCK(sb.st_mode)) {
-        return FileType::kSocket;
+  } else if (S_ISSOCK(sb.st_mode)) {
+    return FileType::kSocket;
 #endif
-    } else {
-        return FileType::kUnknown;
-    }
+  } else {
+    return FileType::kUnknown;
+  }
 }
 
-std::vector<std::string> listFiles(const StringPiece& root, std::string* outError) {
-    DIR* dir = opendir(root.data());
-    if (dir == nullptr) {
-        if (outError) {
-            std::stringstream errorStr;
-            errorStr << "unable to open file: " << strerror(errno);
-            *outError = errorStr.str();
-        }
-        return {};
-    }
-
-    std::vector<std::string> files;
-    dirent* entry;
-    while ((entry = readdir(dir))) {
-        files.emplace_back(entry->d_name);
-    }
-
-    closedir(dir);
-    return files;
-}
-
-inline static int mkdirImpl(const StringPiece& path) {
+inline static int MkdirImpl(const StringPiece& path) {
 #ifdef _WIN32
-    return _mkdir(path.toString().c_str());
+  return _mkdir(path.ToString().c_str());
 #else
-    return mkdir(path.toString().c_str(), S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IXGRP);
+  return mkdir(path.ToString().c_str(),
+               S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP);
 #endif
 }
 
 bool mkdirs(const StringPiece& path) {
-    const char* start = path.begin();
-    const char* end = path.end();
-    for (const char* current = start; current != end; ++current) {
-        if (*current == sDirSep && current != start) {
-            StringPiece parentPath(start, current - start);
-            int result = mkdirImpl(parentPath);
-            if (result < 0 && errno != EEXIST) {
-                return false;
-            }
-        }
-    }
-    return mkdirImpl(path) == 0 || errno == EEXIST;
-}
-
-StringPiece getStem(const StringPiece& path) {
-    const char* start = path.begin();
-    const char* end = path.end();
-    for (const char* current = end - 1; current != start - 1; --current) {
-        if (*current == sDirSep) {
-            return StringPiece(start, current - start);
-        }
-    }
-    return {};
-}
-
-StringPiece getFilename(const StringPiece& path) {
-    const char* end = path.end();
-    const char* lastDirSep = path.begin();
-    for (const char* c = path.begin(); c != end; ++c) {
-        if (*c == sDirSep) {
-            lastDirSep = c + 1;
-        }
-    }
-    return StringPiece(lastDirSep, end - lastDirSep);
-}
-
-StringPiece getExtension(const StringPiece& path) {
-    StringPiece filename = getFilename(path);
-    const char* const end = filename.end();
-    const char* c = std::find(filename.begin(), end, '.');
-    if (c != end) {
-        return StringPiece(c, end - c);
-    }
-    return {};
-}
-
-void appendPath(std::string* base, StringPiece part) {
-    assert(base);
-    const bool baseHasTrailingSep = (!base->empty() && *(base->end() - 1) == sDirSep);
-    const bool partHasLeadingSep = (!part.empty() && *(part.begin()) == sDirSep);
-    if (baseHasTrailingSep && partHasLeadingSep) {
-        // Remove the part's leading sep
-        part = part.substr(1, part.size() - 1);
-    } else if (!baseHasTrailingSep && !partHasLeadingSep) {
-        // None of the pieces has a separator.
-        *base += sDirSep;
-    }
-    base->append(part.data(), part.size());
-}
-
-std::string packageToPath(const StringPiece& package) {
-    std::string outPath;
-    for (StringPiece part : util::tokenize(package, '.')) {
-        appendPath(&outPath, part);
-    }
-    return outPath;
-}
-
-Maybe<android::FileMap> mmapPath(const StringPiece& path, std::string* outError) {
-    std::unique_ptr<FILE, decltype(fclose)*> f = { fopen(path.data(), "rb"), fclose };
-    if (!f) {
-        if (outError) *outError = strerror(errno);
-        return {};
-    }
-
-    int fd = fileno(f.get());
-
-    struct stat fileStats = {};
-    if (fstat(fd, &fileStats) != 0) {
-        if (outError) *outError = strerror(errno);
-        return {};
-    }
-
-    android::FileMap fileMap;
-    if (fileStats.st_size == 0) {
-        // mmap doesn't like a length of 0. Instead we return an empty FileMap.
-        return std::move(fileMap);
-    }
-
-    if (!fileMap.create(path.data(), fd, 0, fileStats.st_size, true)) {
-        if (outError) *outError = strerror(errno);
-        return {};
-    }
-    return std::move(fileMap);
-}
-
-bool appendArgsFromFile(const StringPiece& path, std::vector<std::string>* outArgList,
-                        std::string* outError) {
-    std::string contents;
-    if (!android::base::ReadFileToString(path.toString(), &contents)) {
-        if (outError) *outError = "failed to read argument-list file";
+  const char* start = path.begin();
+  const char* end = path.end();
+  for (const char* current = start; current != end; ++current) {
+    if (*current == sDirSep && current != start) {
+      StringPiece parent_path(start, current - start);
+      int result = MkdirImpl(parent_path);
+      if (result < 0 && errno != EEXIST) {
         return false;
+      }
     }
-
-    for (StringPiece line : util::tokenize(contents, ' ')) {
-        line = util::trimWhitespace(line);
-        if (!line.empty()) {
-            outArgList->push_back(line.toString());
-        }
-    }
-    return true;
+  }
+  return MkdirImpl(path) == 0 || errno == EEXIST;
 }
 
-bool FileFilter::setPattern(const StringPiece& pattern) {
-    mPatternTokens = util::splitAndLowercase(pattern, ':');
-    return true;
+StringPiece GetStem(const StringPiece& path) {
+  const char* start = path.begin();
+  const char* end = path.end();
+  for (const char* current = end - 1; current != start - 1; --current) {
+    if (*current == sDirSep) {
+      return StringPiece(start, current - start);
+    }
+  }
+  return {};
+}
+
+StringPiece GetFilename(const StringPiece& path) {
+  const char* end = path.end();
+  const char* last_dir_sep = path.begin();
+  for (const char* c = path.begin(); c != end; ++c) {
+    if (*c == sDirSep) {
+      last_dir_sep = c + 1;
+    }
+  }
+  return StringPiece(last_dir_sep, end - last_dir_sep);
+}
+
+StringPiece GetExtension(const StringPiece& path) {
+  StringPiece filename = GetFilename(path);
+  const char* const end = filename.end();
+  const char* c = std::find(filename.begin(), end, '.');
+  if (c != end) {
+    return StringPiece(c, end - c);
+  }
+  return {};
+}
+
+void AppendPath(std::string* base, StringPiece part) {
+  CHECK(base != nullptr);
+  const bool base_has_trailing_sep =
+      (!base->empty() && *(base->end() - 1) == sDirSep);
+  const bool part_has_leading_sep =
+      (!part.empty() && *(part.begin()) == sDirSep);
+  if (base_has_trailing_sep && part_has_leading_sep) {
+    // Remove the part's leading sep
+    part = part.substr(1, part.size() - 1);
+  } else if (!base_has_trailing_sep && !part_has_leading_sep) {
+    // None of the pieces has a separator.
+    *base += sDirSep;
+  }
+  base->append(part.data(), part.size());
+}
+
+std::string PackageToPath(const StringPiece& package) {
+  std::string out_path;
+  for (StringPiece part : util::Tokenize(package, '.')) {
+    AppendPath(&out_path, part);
+  }
+  return out_path;
+}
+
+Maybe<android::FileMap> MmapPath(const StringPiece& path,
+                                 std::string* out_error) {
+  std::unique_ptr<FILE, decltype(fclose)*> f = {fopen(path.data(), "rb"),
+                                                fclose};
+  if (!f) {
+    if (out_error) *out_error = android::base::SystemErrorCodeToString(errno);
+    return {};
+  }
+
+  int fd = fileno(f.get());
+
+  struct stat filestats = {};
+  if (fstat(fd, &filestats) != 0) {
+    if (out_error) *out_error = android::base::SystemErrorCodeToString(errno);
+    return {};
+  }
+
+  android::FileMap filemap;
+  if (filestats.st_size == 0) {
+    // mmap doesn't like a length of 0. Instead we return an empty FileMap.
+    return std::move(filemap);
+  }
+
+  if (!filemap.create(path.data(), fd, 0, filestats.st_size, true)) {
+    if (out_error) *out_error = android::base::SystemErrorCodeToString(errno);
+    return {};
+  }
+  return std::move(filemap);
+}
+
+bool AppendArgsFromFile(const StringPiece& path,
+                        std::vector<std::string>* out_arglist,
+                        std::string* out_error) {
+  std::string contents;
+  if (!android::base::ReadFileToString(path.ToString(), &contents)) {
+    if (out_error) *out_error = "failed to read argument-list file";
+    return false;
+  }
+
+  for (StringPiece line : util::Tokenize(contents, ' ')) {
+    line = util::TrimWhitespace(line);
+    if (!line.empty()) {
+      out_arglist->push_back(line.ToString());
+    }
+  }
+  return true;
+}
+
+bool FileFilter::SetPattern(const StringPiece& pattern) {
+  pattern_tokens_ = util::SplitAndLowercase(pattern, ':');
+  return true;
 }
 
 bool FileFilter::operator()(const std::string& filename, FileType type) const {
-    if (filename == "." || filename == "..") {
-        return false;
+  if (filename == "." || filename == "..") {
+    return false;
+  }
+
+  const char kDir[] = "dir";
+  const char kFile[] = "file";
+  const size_t filename_len = filename.length();
+  bool chatty = true;
+  for (const std::string& token : pattern_tokens_) {
+    const char* token_str = token.c_str();
+    if (*token_str == '!') {
+      chatty = false;
+      token_str++;
     }
 
-    const char kDir[] = "dir";
-    const char kFile[] = "file";
-    const size_t filenameLen = filename.length();
-    bool chatty = true;
-    for (const std::string& token : mPatternTokens) {
-        const char* tokenStr = token.c_str();
-        if (*tokenStr == '!') {
-            chatty = false;
-            tokenStr++;
-        }
-
-        if (strncasecmp(tokenStr, kDir, sizeof(kDir)) == 0) {
-            if (type != FileType::kDirectory) {
-                continue;
-            }
-            tokenStr += sizeof(kDir);
-        }
-
-        if (strncasecmp(tokenStr, kFile, sizeof(kFile)) == 0) {
-            if (type != FileType::kRegular) {
-                continue;
-            }
-            tokenStr += sizeof(kFile);
-        }
-
-        bool ignore = false;
-        size_t n = strlen(tokenStr);
-        if (*tokenStr == '*') {
-            // Math suffix.
-            tokenStr++;
-            n--;
-            if (n <= filenameLen) {
-                ignore = strncasecmp(tokenStr, filename.c_str() + filenameLen - n, n) == 0;
-            }
-        } else if (n > 1 && tokenStr[n - 1] == '*') {
-            // Match prefix.
-            ignore = strncasecmp(tokenStr, filename.c_str(), n - 1) == 0;
-        } else {
-            ignore = strcasecmp(tokenStr, filename.c_str()) == 0;
-        }
-
-        if (ignore) {
-            if (chatty) {
-                mDiag->warn(DiagMessage() << "skipping "
-                            << (type == FileType::kDirectory ? "dir '" : "file '")
-                            << filename << "' due to ignore pattern '"
-                            << token << "'");
-            }
-            return false;
-        }
+    if (strncasecmp(token_str, kDir, sizeof(kDir)) == 0) {
+      if (type != FileType::kDirectory) {
+        continue;
+      }
+      token_str += sizeof(kDir);
     }
-    return true;
+
+    if (strncasecmp(token_str, kFile, sizeof(kFile)) == 0) {
+      if (type != FileType::kRegular) {
+        continue;
+      }
+      token_str += sizeof(kFile);
+    }
+
+    bool ignore = false;
+    size_t n = strlen(token_str);
+    if (*token_str == '*') {
+      // Math suffix.
+      token_str++;
+      n--;
+      if (n <= filename_len) {
+        ignore =
+            strncasecmp(token_str, filename.c_str() + filename_len - n, n) == 0;
+      }
+    } else if (n > 1 && token_str[n - 1] == '*') {
+      // Match prefix.
+      ignore = strncasecmp(token_str, filename.c_str(), n - 1) == 0;
+    } else {
+      ignore = strcasecmp(token_str, filename.c_str()) == 0;
+    }
+
+    if (ignore) {
+      if (chatty) {
+        diag_->Warn(DiagMessage()
+                    << "skipping "
+                    << (type == FileType::kDirectory ? "dir '" : "file '")
+                    << filename << "' due to ignore pattern '" << token << "'");
+      }
+      return false;
+    }
+  }
+  return true;
 }
 
-} // namespace file
-} // namespace aapt
+}  // namespace file
+}  // namespace aapt
diff --git a/tools/aapt2/util/Files.h b/tools/aapt2/util/Files.h
index d90c6b692a7ce..a157dbd808932 100644
--- a/tools/aapt2/util/Files.h
+++ b/tools/aapt2/util/Files.h
@@ -17,18 +17,18 @@
 #ifndef AAPT_FILES_H
 #define AAPT_FILES_H
 
-#include "Diagnostics.h"
-#include "Maybe.h"
-#include "Source.h"
-
-#include "util/StringPiece.h"
-
-#include <utils/FileMap.h>
-#include <cassert>
 #include <memory>
 #include <string>
 #include <vector>
 
+#include "android-base/macros.h"
+#include "utils/FileMap.h"
+
+#include "Diagnostics.h"
+#include "Maybe.h"
+#include "Source.h"
+#include "util/StringPiece.h"
+
 namespace aapt {
 namespace file {
 
@@ -50,18 +50,12 @@ enum class FileType {
   kSocket,
 };
 
-FileType getFileType(const StringPiece& path);
-
-/*
- * Lists files under the directory `root`. Files are listed
- * with just their leaf (filename) names.
- */
-std::vector<std::string> listFiles(const StringPiece& root);
+FileType GetFileType(const StringPiece& path);
 
 /*
  * Appends a path to `base`, separated by the directory separator.
  */
-void appendPath(std::string* base, StringPiece part);
+void AppendPath(std::string* base, StringPiece part);
 
 /*
  * Makes all the directories in `path`. The last element in the path
@@ -72,46 +66,45 @@ bool mkdirs(const StringPiece& path);
 /**
  * Returns all but the last part of the path.
  */
-StringPiece getStem(const StringPiece& path);
+StringPiece GetStem(const StringPiece& path);
 
 /**
  * Returns the last part of the path with extension.
  */
-StringPiece getFilename(const StringPiece& path);
+StringPiece GetFilename(const StringPiece& path);
 
 /**
  * Returns the extension of the path. This is the entire string after
  * the first '.' of the last part of the path.
  */
-StringPiece getExtension(const StringPiece& path);
+StringPiece GetExtension(const StringPiece& path);
 
 /**
  * Converts a package name (com.android.app) to a path: com/android/app
  */
-std::string packageToPath(const StringPiece& package);
+std::string PackageToPath(const StringPiece& package);
 
 /**
  * Creates a FileMap for the file at path.
  */
-Maybe<android::FileMap> mmapPath(const StringPiece& path,
-                                 std::string* outError);
+Maybe<android::FileMap> MmapPath(const StringPiece& path,
+                                 std::string* out_error);
 
 /**
  * Reads the file at path and appends each line to the outArgList vector.
  */
-bool appendArgsFromFile(const StringPiece& path,
-                        std::vector<std::string>* outArgList,
-                        std::string* outError);
+bool AppendArgsFromFile(const StringPiece& path,
+                        std::vector<std::string>* out_arglist,
+                        std::string* out_error);
 
 /*
  * Filter that determines which resource files/directories are
  * processed by AAPT. Takes a pattern string supplied by the user.
- * Pattern format is specified in the
- * FileFilter::setPattern(const std::string&) method.
+ * Pattern format is specified in the FileFilter::SetPattern() method.
  */
 class FileFilter {
  public:
-  explicit FileFilter(IDiagnostics* diag) : mDiag(diag) {}
+  explicit FileFilter(IDiagnostics* diag) : diag_(diag) {}
 
   /*
    * Patterns syntax:
@@ -127,7 +120,7 @@ class FileFilter {
    * - Otherwise the full string is matched.
    * - match is not case-sensitive.
    */
-  bool setPattern(const StringPiece& pattern);
+  bool SetPattern(const StringPiece& pattern);
 
   /**
    * Applies the filter, returning true for pass, false for fail.
@@ -135,8 +128,10 @@ class FileFilter {
   bool operator()(const std::string& filename, FileType type) const;
 
  private:
-  IDiagnostics* mDiag;
-  std::vector<std::string> mPatternTokens;
+  DISALLOW_COPY_AND_ASSIGN(FileFilter);
+
+  IDiagnostics* diag_;
+  std::vector<std::string> pattern_tokens_;
 };
 
 }  // namespace file
diff --git a/tools/aapt2/util/Files_test.cpp b/tools/aapt2/util/Files_test.cpp
index efb04593ff821..219c183973589 100644
--- a/tools/aapt2/util/Files_test.cpp
+++ b/tools/aapt2/util/Files_test.cpp
@@ -14,45 +14,46 @@
  * limitations under the License.
  */
 
-#include "test/Test.h"
 #include "util/Files.h"
 
 #include <sstream>
 
+#include "test/Test.h"
+
 namespace aapt {
 namespace file {
 
 class FilesTest : public ::testing::Test {
-public:
-    void SetUp() override {
-        std::stringstream builder;
-        builder << "hello" << sDirSep << "there";
-        mExpectedPath = builder.str();
-    }
+ public:
+  void SetUp() override {
+    std::stringstream builder;
+    builder << "hello" << sDirSep << "there";
+    expected_path_ = builder.str();
+  }
 
-protected:
-    std::string mExpectedPath;
+ protected:
+  std::string expected_path_;
 };
 
-TEST_F(FilesTest, appendPath) {
-    std::string base = "hello";
-    appendPath(&base, "there");
-    EXPECT_EQ(mExpectedPath, base);
+TEST_F(FilesTest, AppendPath) {
+  std::string base = "hello";
+  AppendPath(&base, "there");
+  EXPECT_EQ(expected_path_, base);
 }
 
-TEST_F(FilesTest, appendPathWithLeadingOrTrailingSeparators) {
-    std::string base = "hello/";
-    appendPath(&base, "there");
-    EXPECT_EQ(mExpectedPath, base);
+TEST_F(FilesTest, AppendPathWithLeadingOrTrailingSeparators) {
+  std::string base = "hello/";
+  AppendPath(&base, "there");
+  EXPECT_EQ(expected_path_, base);
 
-    base = "hello";
-    appendPath(&base, "/there");
-    EXPECT_EQ(mExpectedPath, base);
+  base = "hello";
+  AppendPath(&base, "/there");
+  EXPECT_EQ(expected_path_, base);
 
-    base = "hello/";
-    appendPath(&base, "/there");
-    EXPECT_EQ(mExpectedPath, base);
+  base = "hello/";
+  AppendPath(&base, "/there");
+  EXPECT_EQ(expected_path_, base);
 }
 
-} // namespace files
-} // namespace aapt
+}  // namespace files
+}  // namespace aapt
diff --git a/tools/aapt2/util/ImmutableMap.h b/tools/aapt2/util/ImmutableMap.h
index 6f48764d6bd48..59858e492c4c5 100644
--- a/tools/aapt2/util/ImmutableMap.h
+++ b/tools/aapt2/util/ImmutableMap.h
@@ -17,39 +17,31 @@
 #ifndef AAPT_UTIL_IMMUTABLEMAP_H
 #define AAPT_UTIL_IMMUTABLEMAP_H
 
-#include "util/TypeTraits.h"
-
 #include <utility>
 #include <vector>
 
+#include "util/TypeTraits.h"
+
 namespace aapt {
 
 template <typename TKey, typename TValue>
 class ImmutableMap {
   static_assert(is_comparable<TKey, TKey>::value, "key is not comparable");
 
- private:
-  std::vector<std::pair<TKey, TValue>> mData;
-
-  explicit ImmutableMap(std::vector<std::pair<TKey, TValue>> data)
-      : mData(std::move(data)) {}
-
  public:
-  using const_iterator = typename decltype(mData)::const_iterator;
+  using const_iterator =
+      typename std::vector<std::pair<TKey, TValue>>::const_iterator;
 
   ImmutableMap(ImmutableMap&&) = default;
   ImmutableMap& operator=(ImmutableMap&&) = default;
 
-  ImmutableMap(const ImmutableMap&) = delete;
-  ImmutableMap& operator=(const ImmutableMap&) = delete;
-
-  static ImmutableMap<TKey, TValue> createPreSorted(
+  static ImmutableMap<TKey, TValue> CreatePreSorted(
       std::initializer_list<std::pair<TKey, TValue>> list) {
     return ImmutableMap(
         std::vector<std::pair<TKey, TValue>>(list.begin(), list.end()));
   }
 
-  static ImmutableMap<TKey, TValue> createAndSort(
+  static ImmutableMap<TKey, TValue> CreateAndSort(
       std::initializer_list<std::pair<TKey, TValue>> list) {
     std::vector<std::pair<TKey, TValue>> data(list.begin(), list.end());
     std::sort(data.begin(), data.end());
@@ -64,17 +56,25 @@ class ImmutableMap {
       return candidate.first < target;
     };
 
-    const_iterator endIter = end();
-    auto iter = std::lower_bound(mData.begin(), endIter, key, cmp);
-    if (iter == endIter || iter->first == key) {
+    const_iterator end_iter = end();
+    auto iter = std::lower_bound(data_.begin(), end_iter, key, cmp);
+    if (iter == end_iter || iter->first == key) {
       return iter;
     }
-    return endIter;
+    return end_iter;
   }
 
-  const_iterator begin() const { return mData.begin(); }
+  const_iterator begin() const { return data_.begin(); }
 
-  const_iterator end() const { return mData.end(); }
+  const_iterator end() const { return data_.end(); }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ImmutableMap);
+
+  explicit ImmutableMap(std::vector<std::pair<TKey, TValue>> data)
+      : data_(std::move(data)) {}
+
+  std::vector<std::pair<TKey, TValue>> data_;
 };
 
 }  // namespace aapt
diff --git a/tools/aapt2/util/Maybe.h b/tools/aapt2/util/Maybe.h
index 90a0198b4e42d..b43f8e87fd684 100644
--- a/tools/aapt2/util/Maybe.h
+++ b/tools/aapt2/util/Maybe.h
@@ -17,12 +17,13 @@
 #ifndef AAPT_MAYBE_H
 #define AAPT_MAYBE_H
 
-#include "util/TypeTraits.h"
-
-#include <cassert>
 #include <type_traits>
 #include <utility>
 
+#include "android-base/logging.h"
+
+#include "util/TypeTraits.h"
+
 namespace aapt {
 
 /**
@@ -88,7 +89,7 @@ class Maybe {
    */
   const T& value() const;
 
-  T valueOrDefault(const T& def) const;
+  T value_or_default(const T& def) const;
 
  private:
   template <typename U>
@@ -102,55 +103,55 @@ class Maybe {
 
   void destroy();
 
-  bool mNothing;
+  bool nothing_;
 
-  typename std::aligned_storage<sizeof(T), alignof(T)>::type mStorage;
+  typename std::aligned_storage<sizeof(T), alignof(T)>::type storage_;
 };
 
 template <typename T>
-Maybe<T>::Maybe() : mNothing(true) {}
+Maybe<T>::Maybe() : nothing_(true) {}
 
 template <typename T>
 Maybe<T>::~Maybe() {
-  if (!mNothing) {
+  if (!nothing_) {
     destroy();
   }
 }
 
 template <typename T>
-Maybe<T>::Maybe(const Maybe& rhs) : mNothing(rhs.mNothing) {
-  if (!rhs.mNothing) {
-    new (&mStorage) T(reinterpret_cast<const T&>(rhs.mStorage));
+Maybe<T>::Maybe(const Maybe& rhs) : nothing_(rhs.nothing_) {
+  if (!rhs.nothing_) {
+    new (&storage_) T(reinterpret_cast<const T&>(rhs.storage_));
   }
 }
 
 template <typename T>
 template <typename U>
-Maybe<T>::Maybe(const Maybe<U>& rhs) : mNothing(rhs.mNothing) {
-  if (!rhs.mNothing) {
-    new (&mStorage) T(reinterpret_cast<const U&>(rhs.mStorage));
+Maybe<T>::Maybe(const Maybe<U>& rhs) : nothing_(rhs.nothing_) {
+  if (!rhs.nothing_) {
+    new (&storage_) T(reinterpret_cast<const U&>(rhs.storage_));
   }
 }
 
 template <typename T>
-Maybe<T>::Maybe(Maybe&& rhs) : mNothing(rhs.mNothing) {
-  if (!rhs.mNothing) {
-    rhs.mNothing = true;
+Maybe<T>::Maybe(Maybe&& rhs) : nothing_(rhs.nothing_) {
+  if (!rhs.nothing_) {
+    rhs.nothing_ = true;
 
     // Move the value from rhs.
-    new (&mStorage) T(std::move(reinterpret_cast<T&>(rhs.mStorage)));
+    new (&storage_) T(std::move(reinterpret_cast<T&>(rhs.storage_)));
     rhs.destroy();
   }
 }
 
 template <typename T>
 template <typename U>
-Maybe<T>::Maybe(Maybe<U>&& rhs) : mNothing(rhs.mNothing) {
-  if (!rhs.mNothing) {
-    rhs.mNothing = true;
+Maybe<T>::Maybe(Maybe<U>&& rhs) : nothing_(rhs.nothing_) {
+  if (!rhs.nothing_) {
+    rhs.nothing_ = true;
 
     // Move the value from rhs.
-    new (&mStorage) T(std::move(reinterpret_cast<U&>(rhs.mStorage)));
+    new (&storage_) T(std::move(reinterpret_cast<U&>(rhs.storage_)));
     rhs.destroy();
   }
 }
@@ -170,21 +171,21 @@ inline Maybe<T>& Maybe<T>::operator=(const Maybe<U>& rhs) {
 template <typename T>
 template <typename U>
 Maybe<T>& Maybe<T>::copy(const Maybe<U>& rhs) {
-  if (mNothing && rhs.mNothing) {
+  if (nothing_ && rhs.nothing_) {
     // Both are nothing, nothing to do.
     return *this;
-  } else if (!mNothing && !rhs.mNothing) {
+  } else if (!nothing_ && !rhs.nothing_) {
     // We both are something, so assign rhs to us.
-    reinterpret_cast<T&>(mStorage) = reinterpret_cast<const U&>(rhs.mStorage);
-  } else if (mNothing) {
+    reinterpret_cast<T&>(storage_) = reinterpret_cast<const U&>(rhs.storage_);
+  } else if (nothing_) {
     // We are nothing but rhs is something.
-    mNothing = rhs.mNothing;
+    nothing_ = rhs.nothing_;
 
     // Copy the value from rhs.
-    new (&mStorage) T(reinterpret_cast<const U&>(rhs.mStorage));
+    new (&storage_) T(reinterpret_cast<const U&>(rhs.storage_));
   } else {
     // We are something but rhs is nothing, so destroy our value.
-    mNothing = rhs.mNothing;
+    nothing_ = rhs.nothing_;
     destroy();
   }
   return *this;
@@ -205,69 +206,69 @@ inline Maybe<T>& Maybe<T>::operator=(Maybe<U>&& rhs) {
 template <typename T>
 template <typename U>
 Maybe<T>& Maybe<T>::move(Maybe<U>&& rhs) {
-  if (mNothing && rhs.mNothing) {
+  if (nothing_ && rhs.nothing_) {
     // Both are nothing, nothing to do.
     return *this;
-  } else if (!mNothing && !rhs.mNothing) {
+  } else if (!nothing_ && !rhs.nothing_) {
     // We both are something, so move assign rhs to us.
-    rhs.mNothing = true;
-    reinterpret_cast<T&>(mStorage) =
-        std::move(reinterpret_cast<U&>(rhs.mStorage));
+    rhs.nothing_ = true;
+    reinterpret_cast<T&>(storage_) =
+        std::move(reinterpret_cast<U&>(rhs.storage_));
     rhs.destroy();
-  } else if (mNothing) {
+  } else if (nothing_) {
     // We are nothing but rhs is something.
-    mNothing = false;
-    rhs.mNothing = true;
+    nothing_ = false;
+    rhs.nothing_ = true;
 
     // Move the value from rhs.
-    new (&mStorage) T(std::move(reinterpret_cast<U&>(rhs.mStorage)));
+    new (&storage_) T(std::move(reinterpret_cast<U&>(rhs.storage_)));
     rhs.destroy();
   } else {
     // We are something but rhs is nothing, so destroy our value.
-    mNothing = true;
+    nothing_ = true;
     destroy();
   }
   return *this;
 }
 
 template <typename T>
-Maybe<T>::Maybe(const T& value) : mNothing(false) {
-  new (&mStorage) T(value);
+Maybe<T>::Maybe(const T& value) : nothing_(false) {
+  new (&storage_) T(value);
 }
 
 template <typename T>
-Maybe<T>::Maybe(T&& value) : mNothing(false) {
-  new (&mStorage) T(std::forward<T>(value));
+Maybe<T>::Maybe(T&& value) : nothing_(false) {
+  new (&storage_) T(std::forward<T>(value));
 }
 
 template <typename T>
 Maybe<T>::operator bool() const {
-  return !mNothing;
+  return !nothing_;
 }
 
 template <typename T>
 T& Maybe<T>::value() {
-  assert(!mNothing && "Maybe<T>::value() called on Nothing");
-  return reinterpret_cast<T&>(mStorage);
+  CHECK(!nothing_) << "Maybe<T>::value() called on Nothing";
+  return reinterpret_cast<T&>(storage_);
 }
 
 template <typename T>
 const T& Maybe<T>::value() const {
-  assert(!mNothing && "Maybe<T>::value() called on Nothing");
-  return reinterpret_cast<const T&>(mStorage);
+  CHECK(!nothing_) << "Maybe<T>::value() called on Nothing";
+  return reinterpret_cast<const T&>(storage_);
 }
 
 template <typename T>
-T Maybe<T>::valueOrDefault(const T& def) const {
-  if (mNothing) {
+T Maybe<T>::value_or_default(const T& def) const {
+  if (nothing_) {
     return def;
   }
-  return reinterpret_cast<const T&>(mStorage);
+  return reinterpret_cast<const T&>(storage_);
 }
 
 template <typename T>
 void Maybe<T>::destroy() {
-  reinterpret_cast<T&>(mStorage).~T();
+  reinterpret_cast<T&>(storage_).~T();
 }
 
 template <typename T>
diff --git a/tools/aapt2/util/Maybe_test.cpp b/tools/aapt2/util/Maybe_test.cpp
index 5d42dc3ac3ab2..ca14793dd5c32 100644
--- a/tools/aapt2/util/Maybe_test.cpp
+++ b/tools/aapt2/util/Maybe_test.cpp
@@ -14,122 +14,116 @@
  * limitations under the License.
  */
 
-#include "test/Common.h"
 #include "util/Maybe.h"
 
-#include <gtest/gtest.h>
 #include <string>
 
+#include "test/Test.h"
+
 namespace aapt {
 
 struct Dummy {
-    Dummy() {
-        data = new int;
-        *data = 1;
-        std::cerr << "Construct Dummy{0x" << (void *) this
-                  << "} with data=0x" << (void*) data
-                  << std::endl;
+  Dummy() {
+    data = new int;
+    *data = 1;
+    std::cerr << "Construct Dummy{0x" << (void*)this << "} with data=0x"
+              << (void*)data << std::endl;
+  }
+
+  Dummy(const Dummy& rhs) {
+    data = nullptr;
+    if (rhs.data) {
+      data = new int;
+      *data = *rhs.data;
     }
+    std::cerr << "CopyConstruct Dummy{0x" << (void*)this << "} from Dummy{0x"
+              << (const void*)&rhs << "}" << std::endl;
+  }
 
-    Dummy(const Dummy& rhs) {
-        data = nullptr;
-        if (rhs.data) {
-            data = new int;
-            *data = *rhs.data;
-        }
-        std::cerr << "CopyConstruct Dummy{0x" << (void *) this
-                  << "} from Dummy{0x" << (const void*) &rhs
-                  << "}" << std::endl;
+  Dummy(Dummy&& rhs) {
+    data = rhs.data;
+    rhs.data = nullptr;
+    std::cerr << "MoveConstruct Dummy{0x" << (void*)this << "} from Dummy{0x"
+              << (const void*)&rhs << "}" << std::endl;
+  }
+
+  Dummy& operator=(const Dummy& rhs) {
+    delete data;
+    data = nullptr;
+
+    if (rhs.data) {
+      data = new int;
+      *data = *rhs.data;
     }
+    std::cerr << "CopyAssign Dummy{0x" << (void*)this << "} from Dummy{0x"
+              << (const void*)&rhs << "}" << std::endl;
+    return *this;
+  }
 
-    Dummy(Dummy&& rhs) {
-        data = rhs.data;
-        rhs.data = nullptr;
-        std::cerr << "MoveConstruct Dummy{0x" << (void *) this
-                  << "} from Dummy{0x" << (const void*) &rhs
-                  << "}" << std::endl;
-    }
+  Dummy& operator=(Dummy&& rhs) {
+    delete data;
+    data = rhs.data;
+    rhs.data = nullptr;
+    std::cerr << "MoveAssign Dummy{0x" << (void*)this << "} from Dummy{0x"
+              << (const void*)&rhs << "}" << std::endl;
+    return *this;
+  }
 
-    Dummy& operator=(const Dummy& rhs) {
-        delete data;
-        data = nullptr;
+  ~Dummy() {
+    std::cerr << "Destruct Dummy{0x" << (void*)this << "} with data=0x"
+              << (void*)data << std::endl;
+    delete data;
+  }
 
-        if (rhs.data) {
-            data = new int;
-            *data = *rhs.data;
-        }
-        std::cerr << "CopyAssign Dummy{0x" << (void *) this
-                  << "} from Dummy{0x" << (const void*) &rhs
-                  << "}" << std::endl;
-        return *this;
-    }
-
-    Dummy& operator=(Dummy&& rhs) {
-        delete data;
-        data = rhs.data;
-        rhs.data = nullptr;
-        std::cerr << "MoveAssign Dummy{0x" << (void *) this
-                  << "} from Dummy{0x" << (const void*) &rhs
-                  << "}" << std::endl;
-        return *this;
-    }
-
-    ~Dummy() {
-        std::cerr << "Destruct Dummy{0x" << (void *) this
-                  << "} with data=0x" << (void*) data
-                  << std::endl;
-        delete data;
-    }
-
-    int* data;
+  int* data;
 };
 
 TEST(MaybeTest, MakeNothing) {
-    Maybe<int> val = make_nothing<int>();
-    AAPT_EXPECT_FALSE(val);
+  Maybe<int> val = make_nothing<int>();
+  AAPT_EXPECT_FALSE(val);
 
-    Maybe<std::string> val2 = make_nothing<std::string>();
-    AAPT_EXPECT_FALSE(val2);
+  Maybe<std::string> val2 = make_nothing<std::string>();
+  AAPT_EXPECT_FALSE(val2);
 
-    val2 = make_nothing<std::string>();
-    AAPT_EXPECT_FALSE(val2);
+  val2 = make_nothing<std::string>();
+  AAPT_EXPECT_FALSE(val2);
 }
 
 TEST(MaybeTest, MakeSomething) {
-    Maybe<int> val = make_value(23);
-    AAPT_ASSERT_TRUE(val);
-    EXPECT_EQ(23, val.value());
+  Maybe<int> val = make_value(23);
+  AAPT_ASSERT_TRUE(val);
+  EXPECT_EQ(23, val.value());
 
-    Maybe<std::string> val2 = make_value(std::string("hey"));
-    AAPT_ASSERT_TRUE(val2);
-    EXPECT_EQ(std::string("hey"), val2.value());
+  Maybe<std::string> val2 = make_value(std::string("hey"));
+  AAPT_ASSERT_TRUE(val2);
+  EXPECT_EQ(std::string("hey"), val2.value());
 }
 
 TEST(MaybeTest, Lifecycle) {
-    Maybe<Dummy> val = make_nothing<Dummy>();
+  Maybe<Dummy> val = make_nothing<Dummy>();
 
-    Maybe<Dummy> val2 = make_value(Dummy());
+  Maybe<Dummy> val2 = make_value(Dummy());
 }
 
 TEST(MaybeTest, MoveAssign) {
-    Maybe<Dummy> val;
-    {
-        Maybe<Dummy> val2 = Dummy();
-        val = std::move(val2);
-    }
+  Maybe<Dummy> val;
+  {
+    Maybe<Dummy> val2 = Dummy();
+    val = std::move(val2);
+  }
 }
 
 TEST(MaybeTest, Equality) {
-    Maybe<int> a = 1;
-    Maybe<int> b = 1;
-    Maybe<int> c;
+  Maybe<int> a = 1;
+  Maybe<int> b = 1;
+  Maybe<int> c;
 
-    Maybe<int> emptyA, emptyB;
+  Maybe<int> emptyA, emptyB;
 
-    EXPECT_EQ(a, b);
-    EXPECT_EQ(b, a);
-    EXPECT_NE(a, c);
-    EXPECT_EQ(emptyA, emptyB);
+  EXPECT_EQ(a, b);
+  EXPECT_EQ(b, a);
+  EXPECT_NE(a, c);
+  EXPECT_EQ(emptyA, emptyB);
 }
 
-} // namespace aapt
+}  // namespace aapt
diff --git a/tools/aapt2/util/StringPiece.h b/tools/aapt2/util/StringPiece.h
index de938228b30db..5144b1f1fd6a4 100644
--- a/tools/aapt2/util/StringPiece.h
+++ b/tools/aapt2/util/StringPiece.h
@@ -17,12 +17,13 @@
 #ifndef AAPT_STRING_PIECE_H
 #define AAPT_STRING_PIECE_H
 
-#include <utils/JenkinsHash.h>
-#include <utils/String8.h>
-#include <utils/Unicode.h>
 #include <ostream>
 #include <string>
 
+#include "utils/JenkinsHash.h"
+#include "utils/String8.h"
+#include "utils/Unicode.h"
+
 namespace aapt {
 
 /**
@@ -60,7 +61,7 @@ class BasicStringPiece {
   size_t length() const;
   size_t size() const;
   bool empty() const;
-  std::basic_string<TChar> toString() const;
+  std::basic_string<TChar> ToString() const;
 
   bool contains(const BasicStringPiece<TChar>& rhs) const;
   int compare(const BasicStringPiece<TChar>& rhs) const;
@@ -73,8 +74,8 @@ class BasicStringPiece {
   const_iterator end() const;
 
  private:
-  const TChar* mData;
-  size_t mLength;
+  const TChar* data_;
+  size_t length_;
 };
 
 using StringPiece = BasicStringPiece<char>;
@@ -89,43 +90,43 @@ constexpr const size_t BasicStringPiece<TChar>::npos;
 
 template <typename TChar>
 inline BasicStringPiece<TChar>::BasicStringPiece()
-    : mData(nullptr), mLength(0) {}
+    : data_(nullptr), length_(0) {}
 
 template <typename TChar>
 inline BasicStringPiece<TChar>::BasicStringPiece(
     const BasicStringPiece<TChar>& str)
-    : mData(str.mData), mLength(str.mLength) {}
+    : data_(str.data_), length_(str.length_) {}
 
 template <typename TChar>
 inline BasicStringPiece<TChar>::BasicStringPiece(
     const std::basic_string<TChar>& str)
-    : mData(str.data()), mLength(str.length()) {}
+    : data_(str.data()), length_(str.length()) {}
 
 template <>
 inline BasicStringPiece<char>::BasicStringPiece(const char* str)
-    : mData(str), mLength(str != nullptr ? strlen(str) : 0) {}
+    : data_(str), length_(str != nullptr ? strlen(str) : 0) {}
 
 template <>
 inline BasicStringPiece<char16_t>::BasicStringPiece(const char16_t* str)
-    : mData(str), mLength(str != nullptr ? strlen16(str) : 0) {}
+    : data_(str), length_(str != nullptr ? strlen16(str) : 0) {}
 
 template <typename TChar>
 inline BasicStringPiece<TChar>::BasicStringPiece(const TChar* str, size_t len)
-    : mData(str), mLength(len) {}
+    : data_(str), length_(len) {}
 
 template <typename TChar>
 inline BasicStringPiece<TChar>& BasicStringPiece<TChar>::operator=(
     const BasicStringPiece<TChar>& rhs) {
-  mData = rhs.mData;
-  mLength = rhs.mLength;
+  data_ = rhs.data_;
+  length_ = rhs.length_;
   return *this;
 }
 
 template <typename TChar>
 inline BasicStringPiece<TChar>& BasicStringPiece<TChar>::assign(
     const TChar* str, size_t len) {
-  mData = str;
-  mLength = len;
+  data_ = str;
+  length_ = len;
   return *this;
 }
 
@@ -133,13 +134,13 @@ template <typename TChar>
 inline BasicStringPiece<TChar> BasicStringPiece<TChar>::substr(
     size_t start, size_t len) const {
   if (len == npos) {
-    len = mLength - start;
+    len = length_ - start;
   }
 
-  if (start > mLength || start + len > mLength) {
+  if (start > length_ || start + len > length_) {
     return BasicStringPiece<TChar>();
   }
-  return BasicStringPiece<TChar>(mData + start, len);
+  return BasicStringPiece<TChar>(data_ + start, len);
 }
 
 template <typename TChar>
@@ -151,49 +152,49 @@ inline BasicStringPiece<TChar> BasicStringPiece<TChar>::substr(
 
 template <typename TChar>
 inline const TChar* BasicStringPiece<TChar>::data() const {
-  return mData;
+  return data_;
 }
 
 template <typename TChar>
 inline size_t BasicStringPiece<TChar>::length() const {
-  return mLength;
+  return length_;
 }
 
 template <typename TChar>
 inline size_t BasicStringPiece<TChar>::size() const {
-  return mLength;
+  return length_;
 }
 
 template <typename TChar>
 inline bool BasicStringPiece<TChar>::empty() const {
-  return mLength == 0;
+  return length_ == 0;
 }
 
 template <typename TChar>
-inline std::basic_string<TChar> BasicStringPiece<TChar>::toString() const {
-  return std::basic_string<TChar>(mData, mLength);
+inline std::basic_string<TChar> BasicStringPiece<TChar>::ToString() const {
+  return std::basic_string<TChar>(data_, length_);
 }
 
 template <>
 inline bool BasicStringPiece<char>::contains(
     const BasicStringPiece<char>& rhs) const {
-  if (!mData || !rhs.mData) {
+  if (!data_ || !rhs.data_) {
     return false;
   }
-  if (rhs.mLength > mLength) {
+  if (rhs.length_ > length_) {
     return false;
   }
-  return strstr(mData, rhs.mData) != nullptr;
+  return strstr(data_, rhs.data_) != nullptr;
 }
 
 template <>
 inline int BasicStringPiece<char>::compare(
     const BasicStringPiece<char>& rhs) const {
   const char nullStr = '\0';
-  const char* b1 = mData != nullptr ? mData : &nullStr;
-  const char* e1 = b1 + mLength;
-  const char* b2 = rhs.mData != nullptr ? rhs.mData : &nullStr;
-  const char* e2 = b2 + rhs.mLength;
+  const char* b1 = data_ != nullptr ? data_ : &nullStr;
+  const char* e1 = b1 + length_;
+  const char* b2 = rhs.data_ != nullptr ? rhs.data_ : &nullStr;
+  const char* e2 = b2 + rhs.length_;
 
   while (b1 < e1 && b2 < e2) {
     const int d = static_cast<int>(*b1++) - static_cast<int>(*b2++);
@@ -201,7 +202,7 @@ inline int BasicStringPiece<char>::compare(
       return d;
     }
   }
-  return static_cast<int>(mLength - rhs.mLength);
+  return static_cast<int>(length_ - rhs.length_);
 }
 
 inline ::std::ostream& operator<<(::std::ostream& out,
@@ -213,22 +214,22 @@ inline ::std::ostream& operator<<(::std::ostream& out,
 template <>
 inline bool BasicStringPiece<char16_t>::contains(
     const BasicStringPiece<char16_t>& rhs) const {
-  if (!mData || !rhs.mData) {
+  if (!data_ || !rhs.data_) {
     return false;
   }
-  if (rhs.mLength > mLength) {
+  if (rhs.length_ > length_) {
     return false;
   }
-  return strstr16(mData, rhs.mData) != nullptr;
+  return strstr16(data_, rhs.data_) != nullptr;
 }
 
 template <>
 inline int BasicStringPiece<char16_t>::compare(
     const BasicStringPiece<char16_t>& rhs) const {
   const char16_t nullStr = u'\0';
-  const char16_t* b1 = mData != nullptr ? mData : &nullStr;
-  const char16_t* b2 = rhs.mData != nullptr ? rhs.mData : &nullStr;
-  return strzcmp16(b1, mLength, b2, rhs.mLength);
+  const char16_t* b1 = data_ != nullptr ? data_ : &nullStr;
+  const char16_t* b2 = rhs.data_ != nullptr ? rhs.data_ : &nullStr;
+  return strzcmp16(b1, length_, b2, rhs.length_);
 }
 
 template <typename TChar>
@@ -258,13 +259,13 @@ inline bool BasicStringPiece<TChar>::operator!=(
 template <typename TChar>
 inline typename BasicStringPiece<TChar>::const_iterator
 BasicStringPiece<TChar>::begin() const {
-  return mData;
+  return data_;
 }
 
 template <typename TChar>
 inline typename BasicStringPiece<TChar>::const_iterator
 BasicStringPiece<TChar>::end() const {
-  return mData + mLength;
+  return data_ + length_;
 }
 
 inline ::std::ostream& operator<<(::std::ostream& out,
diff --git a/tools/aapt2/util/StringPiece_test.cpp b/tools/aapt2/util/StringPiece_test.cpp
index a87065acd3a02..048961d495841 100644
--- a/tools/aapt2/util/StringPiece_test.cpp
+++ b/tools/aapt2/util/StringPiece_test.cpp
@@ -14,81 +14,82 @@
  * limitations under the License.
  */
 
+#include "util/StringPiece.h"
+
 #include <algorithm>
-#include <gtest/gtest.h>
 #include <string>
 #include <vector>
 
-#include "util/StringPiece.h"
+#include "test/Test.h"
 
 namespace aapt {
 
 TEST(StringPieceTest, CompareNonNullTerminatedPiece) {
-    StringPiece a("hello world", 5);
-    StringPiece b("hello moon", 5);
-    EXPECT_EQ(a, b);
+  StringPiece a("hello world", 5);
+  StringPiece b("hello moon", 5);
+  EXPECT_EQ(a, b);
 
-    StringPiece16 a16(u"hello world", 5);
-    StringPiece16 b16(u"hello moon", 5);
-    EXPECT_EQ(a16, b16);
+  StringPiece16 a16(u"hello world", 5);
+  StringPiece16 b16(u"hello moon", 5);
+  EXPECT_EQ(a16, b16);
 }
 
 TEST(StringPieceTest, PiecesHaveCorrectSortOrder) {
-    std::string testing("testing");
-    std::string banana("banana");
-    std::string car("car");
+  std::string testing("testing");
+  std::string banana("banana");
+  std::string car("car");
 
-    EXPECT_TRUE(StringPiece(testing) > banana);
-    EXPECT_TRUE(StringPiece(testing) > car);
-    EXPECT_TRUE(StringPiece(banana) < testing);
-    EXPECT_TRUE(StringPiece(banana) < car);
-    EXPECT_TRUE(StringPiece(car) < testing);
-    EXPECT_TRUE(StringPiece(car) > banana);
+  EXPECT_TRUE(StringPiece(testing) > banana);
+  EXPECT_TRUE(StringPiece(testing) > car);
+  EXPECT_TRUE(StringPiece(banana) < testing);
+  EXPECT_TRUE(StringPiece(banana) < car);
+  EXPECT_TRUE(StringPiece(car) < testing);
+  EXPECT_TRUE(StringPiece(car) > banana);
 }
 
 TEST(StringPieceTest, PiecesHaveCorrectSortOrderUtf8) {
-    std::string testing("testing");
-    std::string banana("banana");
-    std::string car("car");
+  std::string testing("testing");
+  std::string banana("banana");
+  std::string car("car");
 
-    EXPECT_TRUE(StringPiece(testing) > banana);
-    EXPECT_TRUE(StringPiece(testing) > car);
-    EXPECT_TRUE(StringPiece(banana) < testing);
-    EXPECT_TRUE(StringPiece(banana) < car);
-    EXPECT_TRUE(StringPiece(car) < testing);
-    EXPECT_TRUE(StringPiece(car) > banana);
+  EXPECT_TRUE(StringPiece(testing) > banana);
+  EXPECT_TRUE(StringPiece(testing) > car);
+  EXPECT_TRUE(StringPiece(banana) < testing);
+  EXPECT_TRUE(StringPiece(banana) < car);
+  EXPECT_TRUE(StringPiece(car) < testing);
+  EXPECT_TRUE(StringPiece(car) > banana);
 }
 
 TEST(StringPieceTest, ContainsOtherStringPiece) {
-    StringPiece text("I am a leaf on the wind.");
-    StringPiece startNeedle("I am");
-    StringPiece endNeedle("wind.");
-    StringPiece middleNeedle("leaf");
-    StringPiece emptyNeedle("");
-    StringPiece missingNeedle("soar");
-    StringPiece longNeedle("This string is longer than the text.");
+  StringPiece text("I am a leaf on the wind.");
+  StringPiece start_needle("I am");
+  StringPiece end_needle("wind.");
+  StringPiece middle_needle("leaf");
+  StringPiece empty_needle("");
+  StringPiece missing_needle("soar");
+  StringPiece long_needle("This string is longer than the text.");
 
-    EXPECT_TRUE(text.contains(startNeedle));
-    EXPECT_TRUE(text.contains(endNeedle));
-    EXPECT_TRUE(text.contains(middleNeedle));
-    EXPECT_TRUE(text.contains(emptyNeedle));
-    EXPECT_FALSE(text.contains(missingNeedle));
-    EXPECT_FALSE(text.contains(longNeedle));
+  EXPECT_TRUE(text.contains(start_needle));
+  EXPECT_TRUE(text.contains(end_needle));
+  EXPECT_TRUE(text.contains(middle_needle));
+  EXPECT_TRUE(text.contains(empty_needle));
+  EXPECT_FALSE(text.contains(missing_needle));
+  EXPECT_FALSE(text.contains(long_needle));
 
-    StringPiece16 text16(u"I am a leaf on the wind.");
-    StringPiece16 startNeedle16(u"I am");
-    StringPiece16 endNeedle16(u"wind.");
-    StringPiece16 middleNeedle16(u"leaf");
-    StringPiece16 emptyNeedle16(u"");
-    StringPiece16 missingNeedle16(u"soar");
-    StringPiece16 longNeedle16(u"This string is longer than the text.");
+  StringPiece16 text16(u"I am a leaf on the wind.");
+  StringPiece16 start_needle16(u"I am");
+  StringPiece16 end_needle16(u"wind.");
+  StringPiece16 middle_needle16(u"leaf");
+  StringPiece16 empty_needle16(u"");
+  StringPiece16 missing_needle16(u"soar");
+  StringPiece16 long_needle16(u"This string is longer than the text.");
 
-    EXPECT_TRUE(text16.contains(startNeedle16));
-    EXPECT_TRUE(text16.contains(endNeedle16));
-    EXPECT_TRUE(text16.contains(middleNeedle16));
-    EXPECT_TRUE(text16.contains(emptyNeedle16));
-    EXPECT_FALSE(text16.contains(missingNeedle16));
-    EXPECT_FALSE(text16.contains(longNeedle16));
+  EXPECT_TRUE(text16.contains(start_needle16));
+  EXPECT_TRUE(text16.contains(end_needle16));
+  EXPECT_TRUE(text16.contains(middle_needle16));
+  EXPECT_TRUE(text16.contains(empty_needle16));
+  EXPECT_FALSE(text16.contains(missing_needle16));
+  EXPECT_FALSE(text16.contains(long_needle16));
 }
 
-} // namespace aapt
+}  // namespace aapt
diff --git a/tools/aapt2/util/Util.cpp b/tools/aapt2/util/Util.cpp
index b0bec624cc9cd..d5c0c8a7a5fe4 100644
--- a/tools/aapt2/util/Util.cpp
+++ b/tools/aapt2/util/Util.cpp
@@ -14,559 +14,558 @@
  * limitations under the License.
  */
 
+#include "util/Util.h"
 #include "util/BigBuffer.h"
 #include "util/Maybe.h"
 #include "util/StringPiece.h"
-#include "util/Util.h"
 
+#include <utils/Unicode.h>
 #include <algorithm>
 #include <ostream>
 #include <string>
-#include <utils/Unicode.h>
 #include <vector>
 
 namespace aapt {
 namespace util {
 
-static std::vector<std::string> splitAndTransform(const StringPiece& str, char sep,
-        const std::function<char(char)>& f) {
-    std::vector<std::string> parts;
-    const StringPiece::const_iterator end = std::end(str);
-    StringPiece::const_iterator start = std::begin(str);
-    StringPiece::const_iterator current;
-    do {
-        current = std::find(start, end, sep);
-        parts.emplace_back(str.substr(start, current).toString());
-        if (f) {
-            std::string& part = parts.back();
-            std::transform(part.begin(), part.end(), part.begin(), f);
-        }
-        start = current + 1;
-    } while (current != end);
-    return parts;
+static std::vector<std::string> SplitAndTransform(
+    const StringPiece& str, char sep, const std::function<char(char)>& f) {
+  std::vector<std::string> parts;
+  const StringPiece::const_iterator end = std::end(str);
+  StringPiece::const_iterator start = std::begin(str);
+  StringPiece::const_iterator current;
+  do {
+    current = std::find(start, end, sep);
+    parts.emplace_back(str.substr(start, current).ToString());
+    if (f) {
+      std::string& part = parts.back();
+      std::transform(part.begin(), part.end(), part.begin(), f);
+    }
+    start = current + 1;
+  } while (current != end);
+  return parts;
 }
 
-std::vector<std::string> split(const StringPiece& str, char sep) {
-    return splitAndTransform(str, sep, nullptr);
+std::vector<std::string> Split(const StringPiece& str, char sep) {
+  return SplitAndTransform(str, sep, nullptr);
 }
 
-std::vector<std::string> splitAndLowercase(const StringPiece& str, char sep) {
-    return splitAndTransform(str, sep, ::tolower);
+std::vector<std::string> SplitAndLowercase(const StringPiece& str, char sep) {
+  return SplitAndTransform(str, sep, ::tolower);
 }
 
-bool stringStartsWith(const StringPiece& str, const StringPiece& prefix) {
-    if (str.size() < prefix.size()) {
-        return false;
-    }
-    return str.substr(0, prefix.size()) == prefix;
+bool StartsWith(const StringPiece& str, const StringPiece& prefix) {
+  if (str.size() < prefix.size()) {
+    return false;
+  }
+  return str.substr(0, prefix.size()) == prefix;
 }
 
-bool stringEndsWith(const StringPiece& str, const StringPiece& suffix) {
-    if (str.size() < suffix.size()) {
-        return false;
-    }
-    return str.substr(str.size() - suffix.size(), suffix.size()) == suffix;
+bool EndsWith(const StringPiece& str, const StringPiece& suffix) {
+  if (str.size() < suffix.size()) {
+    return false;
+  }
+  return str.substr(str.size() - suffix.size(), suffix.size()) == suffix;
 }
 
-StringPiece trimWhitespace(const StringPiece& str) {
-    if (str.size() == 0 || str.data() == nullptr) {
-        return str;
-    }
+StringPiece TrimWhitespace(const StringPiece& str) {
+  if (str.size() == 0 || str.data() == nullptr) {
+    return str;
+  }
 
-    const char* start = str.data();
-    const char* end = str.data() + str.length();
+  const char* start = str.data();
+  const char* end = str.data() + str.length();
 
-    while (start != end && isspace(*start)) {
-        start++;
-    }
+  while (start != end && isspace(*start)) {
+    start++;
+  }
 
-    while (end != start && isspace(*(end - 1))) {
-        end--;
-    }
+  while (end != start && isspace(*(end - 1))) {
+    end--;
+  }
 
-    return StringPiece(start, end - start);
+  return StringPiece(start, end - start);
 }
 
-StringPiece::const_iterator findNonAlphaNumericAndNotInSet(const StringPiece& str,
-                                                           const StringPiece& allowedChars) {
-    const auto endIter = str.end();
-    for (auto iter = str.begin(); iter != endIter; ++iter) {
-        char c = *iter;
-        if ((c >= u'a' && c <= u'z') ||
-                (c >= u'A' && c <= u'Z') ||
-                (c >= u'0' && c <= u'9')) {
-            continue;
-        }
-
-        bool match = false;
-        for (char i : allowedChars) {
-            if (c == i) {
-                match = true;
-                break;
-            }
-        }
-
-        if (!match) {
-            return iter;
-        }
+StringPiece::const_iterator FindNonAlphaNumericAndNotInSet(
+    const StringPiece& str, const StringPiece& allowed_chars) {
+  const auto end_iter = str.end();
+  for (auto iter = str.begin(); iter != end_iter; ++iter) {
+    char c = *iter;
+    if ((c >= u'a' && c <= u'z') || (c >= u'A' && c <= u'Z') ||
+        (c >= u'0' && c <= u'9')) {
+      continue;
     }
-    return endIter;
+
+    bool match = false;
+    for (char i : allowed_chars) {
+      if (c == i) {
+        match = true;
+        break;
+      }
+    }
+
+    if (!match) {
+      return iter;
+    }
+  }
+  return end_iter;
 }
 
-bool isJavaClassName(const StringPiece& str) {
-    size_t pieces = 0;
-    for (const StringPiece& piece : tokenize(str, '.')) {
-        pieces++;
-        if (piece.empty()) {
-            return false;
-        }
-
-        // Can't have starting or trailing $ character.
-        if (piece.data()[0] == '$' || piece.data()[piece.size() - 1] == '$') {
-            return false;
-        }
-
-        if (findNonAlphaNumericAndNotInSet(piece, "$_") != piece.end()) {
-            return false;
-        }
+bool IsJavaClassName(const StringPiece& str) {
+  size_t pieces = 0;
+  for (const StringPiece& piece : Tokenize(str, '.')) {
+    pieces++;
+    if (piece.empty()) {
+      return false;
     }
-    return pieces >= 2;
+
+    // Can't have starting or trailing $ character.
+    if (piece.data()[0] == '$' || piece.data()[piece.size() - 1] == '$') {
+      return false;
+    }
+
+    if (FindNonAlphaNumericAndNotInSet(piece, "$_") != piece.end()) {
+      return false;
+    }
+  }
+  return pieces >= 2;
 }
 
-bool isJavaPackageName(const StringPiece& str) {
-    if (str.empty()) {
-        return false;
+bool IsJavaPackageName(const StringPiece& str) {
+  if (str.empty()) {
+    return false;
+  }
+
+  size_t pieces = 0;
+  for (const StringPiece& piece : Tokenize(str, '.')) {
+    pieces++;
+    if (piece.empty()) {
+      return false;
     }
 
-    size_t pieces = 0;
-    for (const StringPiece& piece : tokenize(str, '.')) {
-        pieces++;
-        if (piece.empty()) {
-            return false;
-        }
-
-        if (piece.data()[0] == '_' || piece.data()[piece.size() - 1] == '_') {
-            return false;
-        }
-
-        if (findNonAlphaNumericAndNotInSet(piece, "_") != piece.end()) {
-            return false;
-        }
+    if (piece.data()[0] == '_' || piece.data()[piece.size() - 1] == '_') {
+      return false;
     }
-    return pieces >= 1;
+
+    if (FindNonAlphaNumericAndNotInSet(piece, "_") != piece.end()) {
+      return false;
+    }
+  }
+  return pieces >= 1;
 }
 
-Maybe<std::string> getFullyQualifiedClassName(const StringPiece& package,
-                                              const StringPiece& className) {
-    if (className.empty()) {
-        return {};
-    }
+Maybe<std::string> GetFullyQualifiedClassName(const StringPiece& package,
+                                              const StringPiece& classname) {
+  if (classname.empty()) {
+    return {};
+  }
 
-    if (util::isJavaClassName(className)) {
-        return className.toString();
-    }
+  if (util::IsJavaClassName(classname)) {
+    return classname.ToString();
+  }
 
-    if (package.empty()) {
-        return {};
-    }
+  if (package.empty()) {
+    return {};
+  }
 
-    std::string result(package.data(), package.size());
-    if (className.data()[0] != '.') {
-        result += '.';
-    }
+  std::string result(package.data(), package.size());
+  if (classname.data()[0] != '.') {
+    result += '.';
+  }
 
-    result.append(className.data(), className.size());
-    if (!isJavaClassName(result)) {
-        return {};
-    }
-    return result;
+  result.append(classname.data(), classname.size());
+  if (!IsJavaClassName(result)) {
+    return {};
+  }
+  return result;
 }
 
-static size_t consumeDigits(const char* start, const char* end) {
-    const char* c = start;
-    for (; c != end && *c >= '0' && *c <= '9'; c++) {}
-    return static_cast<size_t>(c - start);
+static size_t ConsumeDigits(const char* start, const char* end) {
+  const char* c = start;
+  for (; c != end && *c >= '0' && *c <= '9'; c++) {
+  }
+  return static_cast<size_t>(c - start);
 }
 
-bool verifyJavaStringFormat(const StringPiece& str) {
-    const char* c = str.begin();
-    const char* const end = str.end();
+bool VerifyJavaStringFormat(const StringPiece& str) {
+  const char* c = str.begin();
+  const char* const end = str.end();
 
-    size_t argCount = 0;
-    bool nonpositional = false;
-    while (c != end) {
-        if (*c == '%' && c + 1 < end) {
-            c++;
+  size_t arg_count = 0;
+  bool nonpositional = false;
+  while (c != end) {
+    if (*c == '%' && c + 1 < end) {
+      c++;
 
-            if (*c == '%') {
-                c++;
-                continue;
-            }
+      if (*c == '%') {
+        c++;
+        continue;
+      }
 
-            argCount++;
+      arg_count++;
 
-            size_t numDigits = consumeDigits(c, end);
-            if (numDigits > 0) {
-                c += numDigits;
-                if (c != end && *c != '$') {
-                    // The digits were a size, but not a positional argument.
-                    nonpositional = true;
-                }
-            } else if (*c == '<') {
-                // Reusing last argument, bad idea since positions can be moved around
-                // during translation.
-                nonpositional = true;
-
-                c++;
-
-                // Optionally we can have a $ after
-                if (c != end && *c == '$') {
-                    c++;
-                }
-            } else {
-                nonpositional = true;
-            }
-
-            // Ignore size, width, flags, etc.
-            while (c != end && (*c == '-' ||
-                    *c == '#' ||
-                    *c == '+' ||
-                    *c == ' ' ||
-                    *c == ',' ||
-                    *c == '(' ||
-                    (*c >= '0' && *c <= '9'))) {
-                c++;
-            }
-
-            /*
-             * This is a shortcut to detect strings that are going to Time.format()
-             * instead of String.format()
-             *
-             * Comparison of String.format() and Time.format() args:
-             *
-             * String: ABC E GH  ST X abcdefgh  nost x
-             *   Time:    DEFGHKMS W Za  d   hkm  s w yz
-             *
-             * Therefore we know it's definitely Time if we have:
-             *     DFKMWZkmwyz
-             */
-            if (c != end) {
-                switch (*c) {
-                case 'D':
-                case 'F':
-                case 'K':
-                case 'M':
-                case 'W':
-                case 'Z':
-                case 'k':
-                case 'm':
-                case 'w':
-                case 'y':
-                case 'z':
-                    return true;
-                }
-            }
+      size_t num_digits = ConsumeDigits(c, end);
+      if (num_digits > 0) {
+        c += num_digits;
+        if (c != end && *c != '$') {
+          // The digits were a size, but not a positional argument.
+          nonpositional = true;
         }
+      } else if (*c == '<') {
+        // Reusing last argument, bad idea since positions can be moved around
+        // during translation.
+        nonpositional = true;
 
-        if (c != end) {
-            c++;
+        c++;
+
+        // Optionally we can have a $ after
+        if (c != end && *c == '$') {
+          c++;
         }
+      } else {
+        nonpositional = true;
+      }
+
+      // Ignore size, width, flags, etc.
+      while (c != end && (*c == '-' || *c == '#' || *c == '+' || *c == ' ' ||
+                          *c == ',' || *c == '(' || (*c >= '0' && *c <= '9'))) {
+        c++;
+      }
+
+      /*
+       * This is a shortcut to detect strings that are going to Time.format()
+       * instead of String.format()
+       *
+       * Comparison of String.format() and Time.format() args:
+       *
+       * String: ABC E GH  ST X abcdefgh  nost x
+       *   Time:    DEFGHKMS W Za  d   hkm  s w yz
+       *
+       * Therefore we know it's definitely Time if we have:
+       *     DFKMWZkmwyz
+       */
+      if (c != end) {
+        switch (*c) {
+          case 'D':
+          case 'F':
+          case 'K':
+          case 'M':
+          case 'W':
+          case 'Z':
+          case 'k':
+          case 'm':
+          case 'w':
+          case 'y':
+          case 'z':
+            return true;
+        }
+      }
     }
 
-    if (argCount > 1 && nonpositional) {
-        // Multiple arguments were specified, but some or all were non positional. Translated
-        // strings may rearrange the order of the arguments, which will break the string.
-        return false;
+    if (c != end) {
+      c++;
     }
-    return true;
+  }
+
+  if (arg_count > 1 && nonpositional) {
+    // Multiple arguments were specified, but some or all were non positional.
+    // Translated
+    // strings may rearrange the order of the arguments, which will break the
+    // string.
+    return false;
+  }
+  return true;
 }
 
-static Maybe<std::string> parseUnicodeCodepoint(const char** start, const char* end) {
-    char32_t code = 0;
-    for (size_t i = 0; i < 4 && *start != end; i++, (*start)++) {
-        char c = **start;
-        char32_t a;
-        if (c >= '0' && c <= '9') {
-            a = c - '0';
-        } else if (c >= 'a' && c <= 'f') {
-            a = c - 'a' + 10;
-        } else if (c >= 'A' && c <= 'F') {
-            a = c - 'A' + 10;
-        } else {
-            return {};
-        }
-        code = (code << 4) | a;
+static Maybe<std::string> ParseUnicodeCodepoint(const char** start,
+                                                const char* end) {
+  char32_t code = 0;
+  for (size_t i = 0; i < 4 && *start != end; i++, (*start)++) {
+    char c = **start;
+    char32_t a;
+    if (c >= '0' && c <= '9') {
+      a = c - '0';
+    } else if (c >= 'a' && c <= 'f') {
+      a = c - 'a' + 10;
+    } else if (c >= 'A' && c <= 'F') {
+      a = c - 'A' + 10;
+    } else {
+      return {};
     }
+    code = (code << 4) | a;
+  }
 
-    ssize_t len = utf32_to_utf8_length(&code, 1);
-    if (len < 0) {
-        return {};
-    }
+  ssize_t len = utf32_to_utf8_length(&code, 1);
+  if (len < 0) {
+    return {};
+  }
 
-    std::string resultUtf8;
-    resultUtf8.resize(len);
-    utf32_to_utf8(&code, 1, &*resultUtf8.begin(), len + 1);
-    return resultUtf8;
+  std::string result_utf8;
+  result_utf8.resize(len);
+  utf32_to_utf8(&code, 1, &*result_utf8.begin(), len + 1);
+  return result_utf8;
 }
 
-StringBuilder& StringBuilder::append(const StringPiece& str) {
-    if (!mError.empty()) {
-        return *this;
-    }
-
-    // Where the new data will be appended to.
-    size_t newDataIndex = mStr.size();
-
-    const char* const end = str.end();
-    const char* start = str.begin();
-    const char* current = start;
-    while (current != end) {
-        if (mLastCharWasEscape) {
-            switch (*current) {
-                case 't':
-                    mStr += '\t';
-                    break;
-                case 'n':
-                    mStr += '\n';
-                    break;
-                case '#':
-                    mStr += '#';
-                    break;
-                case '@':
-                    mStr += '@';
-                    break;
-                case '?':
-                    mStr += '?';
-                    break;
-                case '"':
-                    mStr += '"';
-                    break;
-                case '\'':
-                    mStr += '\'';
-                    break;
-                case '\\':
-                    mStr += '\\';
-                    break;
-                case 'u': {
-                    current++;
-                    Maybe<std::string> c = parseUnicodeCodepoint(&current, end);
-                    if (!c) {
-                        mError = "invalid unicode escape sequence";
-                        return *this;
-                    }
-                    mStr += c.value();
-                    current -= 1;
-                    break;
-                }
-
-                default:
-                    // Ignore.
-                    break;
-            }
-            mLastCharWasEscape = false;
-            start = current + 1;
-        } else if (*current == '"') {
-            if (!mQuote && mTrailingSpace) {
-                // We found an opening quote, and we have
-                // trailing space, so we should append that
-                // space now.
-                if (mTrailingSpace) {
-                    // We had trailing whitespace, so
-                    // replace with a single space.
-                    if (!mStr.empty()) {
-                        mStr += ' ';
-                    }
-                    mTrailingSpace = false;
-                }
-            }
-            mQuote = !mQuote;
-            mStr.append(start, current - start);
-            start = current + 1;
-        } else if (*current == '\'' && !mQuote) {
-            // This should be escaped.
-            mError = "unescaped apostrophe";
-            return *this;
-        } else if (*current == '\\') {
-            // This is an escape sequence, convert to the real value.
-            if (!mQuote && mTrailingSpace) {
-                // We had trailing whitespace, so
-                // replace with a single space.
-                if (!mStr.empty()) {
-                    mStr += ' ';
-                }
-                mTrailingSpace = false;
-            }
-            mStr.append(start, current - start);
-            start = current + 1;
-            mLastCharWasEscape = true;
-        } else if (!mQuote) {
-            // This is not quoted text, so look for whitespace.
-            if (isspace(*current)) {
-                // We found whitespace, see if we have seen some
-                // before.
-                if (!mTrailingSpace) {
-                    // We didn't see a previous adjacent space,
-                    // so mark that we did.
-                    mTrailingSpace = true;
-                    mStr.append(start, current - start);
-                }
-
-                // Keep skipping whitespace.
-                start = current + 1;
-            } else if (mTrailingSpace) {
-                // We saw trailing space before, so replace all
-                // that trailing space with one space.
-                if (!mStr.empty()) {
-                    mStr += ' ';
-                }
-                mTrailingSpace = false;
-            }
-        }
-        current++;
-    }
-    mStr.append(start, end - start);
-
-    // Accumulate the added string's UTF-16 length.
-    ssize_t len = utf8_to_utf16_length(
-            reinterpret_cast<const uint8_t*>(mStr.data()) + newDataIndex,
-            mStr.size() - newDataIndex);
-    if (len < 0) {
-        mError = "invalid unicode code point";
-        return *this;
-    }
-    mUtf16Len += len;
+StringBuilder& StringBuilder::Append(const StringPiece& str) {
+  if (!error_.empty()) {
     return *this;
-}
+  }
 
-std::u16string utf8ToUtf16(const StringPiece& utf8) {
-    ssize_t utf16Length = utf8_to_utf16_length(reinterpret_cast<const uint8_t*>(utf8.data()),
-            utf8.length());
-    if (utf16Length <= 0) {
-        return {};
-    }
+  // Where the new data will be appended to.
+  size_t new_data_index = str_.size();
 
-    std::u16string utf16;
-    utf16.resize(utf16Length);
-    utf8_to_utf16(reinterpret_cast<const uint8_t*>(utf8.data()), utf8.length(),
-                  &*utf16.begin(), utf16Length + 1);
-    return utf16;
-}
-
-std::string utf16ToUtf8(const StringPiece16& utf16) {
-    ssize_t utf8Length = utf16_to_utf8_length(utf16.data(), utf16.length());
-    if (utf8Length <= 0) {
-        return {};
-    }
-
-    std::string utf8;
-    utf8.resize(utf8Length);
-    utf16_to_utf8(utf16.data(), utf16.length(), &*utf8.begin(), utf8Length + 1);
-    return utf8;
-}
-
-bool writeAll(std::ostream& out, const BigBuffer& buffer) {
-    for (const auto& b : buffer) {
-        if (!out.write(reinterpret_cast<const char*>(b.buffer.get()), b.size)) {
-            return false;
+  const char* const end = str.end();
+  const char* start = str.begin();
+  const char* current = start;
+  while (current != end) {
+    if (last_char_was_escape_) {
+      switch (*current) {
+        case 't':
+          str_ += '\t';
+          break;
+        case 'n':
+          str_ += '\n';
+          break;
+        case '#':
+          str_ += '#';
+          break;
+        case '@':
+          str_ += '@';
+          break;
+        case '?':
+          str_ += '?';
+          break;
+        case '"':
+          str_ += '"';
+          break;
+        case '\'':
+          str_ += '\'';
+          break;
+        case '\\':
+          str_ += '\\';
+          break;
+        case 'u': {
+          current++;
+          Maybe<std::string> c = ParseUnicodeCodepoint(&current, end);
+          if (!c) {
+            error_ = "invalid unicode escape sequence";
+            return *this;
+          }
+          str_ += c.value();
+          current -= 1;
+          break;
         }
+
+        default:
+          // Ignore.
+          break;
+      }
+      last_char_was_escape_ = false;
+      start = current + 1;
+    } else if (*current == '"') {
+      if (!quote_ && trailing_space_) {
+        // We found an opening quote, and we have
+        // trailing space, so we should append that
+        // space now.
+        if (trailing_space_) {
+          // We had trailing whitespace, so
+          // replace with a single space.
+          if (!str_.empty()) {
+            str_ += ' ';
+          }
+          trailing_space_ = false;
+        }
+      }
+      quote_ = !quote_;
+      str_.append(start, current - start);
+      start = current + 1;
+    } else if (*current == '\'' && !quote_) {
+      // This should be escaped.
+      error_ = "unescaped apostrophe";
+      return *this;
+    } else if (*current == '\\') {
+      // This is an escape sequence, convert to the real value.
+      if (!quote_ && trailing_space_) {
+        // We had trailing whitespace, so
+        // replace with a single space.
+        if (!str_.empty()) {
+          str_ += ' ';
+        }
+        trailing_space_ = false;
+      }
+      str_.append(start, current - start);
+      start = current + 1;
+      last_char_was_escape_ = true;
+    } else if (!quote_) {
+      // This is not quoted text, so look for whitespace.
+      if (isspace(*current)) {
+        // We found whitespace, see if we have seen some
+        // before.
+        if (!trailing_space_) {
+          // We didn't see a previous adjacent space,
+          // so mark that we did.
+          trailing_space_ = true;
+          str_.append(start, current - start);
+        }
+
+        // Keep skipping whitespace.
+        start = current + 1;
+      } else if (trailing_space_) {
+        // We saw trailing space before, so replace all
+        // that trailing space with one space.
+        if (!str_.empty()) {
+          str_ += ' ';
+        }
+        trailing_space_ = false;
+      }
     }
-    return true;
+    current++;
+  }
+  str_.append(start, end - start);
+
+  // Accumulate the added string's UTF-16 length.
+  ssize_t len = utf8_to_utf16_length(
+      reinterpret_cast<const uint8_t*>(str_.data()) + new_data_index,
+      str_.size() - new_data_index);
+  if (len < 0) {
+    error_ = "invalid unicode code point";
+    return *this;
+  }
+  utf16_len_ += len;
+  return *this;
 }
 
-std::unique_ptr<uint8_t[]> copy(const BigBuffer& buffer) {
-    std::unique_ptr<uint8_t[]> data = std::unique_ptr<uint8_t[]>(new uint8_t[buffer.size()]);
-    uint8_t* p = data.get();
-    for (const auto& block : buffer) {
-        memcpy(p, block.buffer.get(), block.size);
-        p += block.size;
+std::u16string Utf8ToUtf16(const StringPiece& utf8) {
+  ssize_t utf16_length = utf8_to_utf16_length(
+      reinterpret_cast<const uint8_t*>(utf8.data()), utf8.length());
+  if (utf16_length <= 0) {
+    return {};
+  }
+
+  std::u16string utf16;
+  utf16.resize(utf16_length);
+  utf8_to_utf16(reinterpret_cast<const uint8_t*>(utf8.data()), utf8.length(),
+                &*utf16.begin(), utf16_length + 1);
+  return utf16;
+}
+
+std::string Utf16ToUtf8(const StringPiece16& utf16) {
+  ssize_t utf8_length = utf16_to_utf8_length(utf16.data(), utf16.length());
+  if (utf8_length <= 0) {
+    return {};
+  }
+
+  std::string utf8;
+  utf8.resize(utf8_length);
+  utf16_to_utf8(utf16.data(), utf16.length(), &*utf8.begin(), utf8_length + 1);
+  return utf8;
+}
+
+bool WriteAll(std::ostream& out, const BigBuffer& buffer) {
+  for (const auto& b : buffer) {
+    if (!out.write(reinterpret_cast<const char*>(b.buffer.get()), b.size)) {
+      return false;
     }
-    return data;
+  }
+  return true;
+}
+
+std::unique_ptr<uint8_t[]> Copy(const BigBuffer& buffer) {
+  std::unique_ptr<uint8_t[]> data =
+      std::unique_ptr<uint8_t[]>(new uint8_t[buffer.size()]);
+  uint8_t* p = data.get();
+  for (const auto& block : buffer) {
+    memcpy(p, block.buffer.get(), block.size);
+    p += block.size;
+  }
+  return data;
 }
 
 typename Tokenizer::iterator& Tokenizer::iterator::operator++() {
-    const char* start = mToken.end();
-    const char* end = mStr.end();
-    if (start == end) {
-        mEnd = true;
-        mToken.assign(mToken.end(), 0);
-        return *this;
-    }
-
-    start += 1;
-    const char* current = start;
-    while (current != end) {
-        if (*current == mSeparator) {
-            mToken.assign(start, current - start);
-            return *this;
-        }
-        ++current;
-    }
-    mToken.assign(start, end - start);
+  const char* start = token_.end();
+  const char* end = str_.end();
+  if (start == end) {
+    end_ = true;
+    token_.assign(token_.end(), 0);
     return *this;
+  }
+
+  start += 1;
+  const char* current = start;
+  while (current != end) {
+    if (*current == separator_) {
+      token_.assign(start, current - start);
+      return *this;
+    }
+    ++current;
+  }
+  token_.assign(start, end - start);
+  return *this;
 }
 
 bool Tokenizer::iterator::operator==(const iterator& rhs) const {
-    // We check equality here a bit differently.
-    // We need to know that the addresses are the same.
-    return mToken.begin() == rhs.mToken.begin() && mToken.end() == rhs.mToken.end() &&
-            mEnd == rhs.mEnd;
+  // We check equality here a bit differently.
+  // We need to know that the addresses are the same.
+  return token_.begin() == rhs.token_.begin() &&
+         token_.end() == rhs.token_.end() && end_ == rhs.end_;
 }
 
 bool Tokenizer::iterator::operator!=(const iterator& rhs) const {
-    return !(*this == rhs);
+  return !(*this == rhs);
 }
 
-Tokenizer::iterator::iterator(StringPiece s, char sep, StringPiece tok, bool end) :
-        mStr(s), mSeparator(sep), mToken(tok), mEnd(end) {
-}
+Tokenizer::iterator::iterator(StringPiece s, char sep, StringPiece tok,
+                              bool end)
+    : str_(s), separator_(sep), token_(tok), end_(end) {}
 
-Tokenizer::Tokenizer(StringPiece str, char sep) :
-        mBegin(++iterator(str, sep, StringPiece(str.begin() - 1, 0), false)),
-        mEnd(str, sep, StringPiece(str.end(), 0), true) {
-}
+Tokenizer::Tokenizer(StringPiece str, char sep)
+    : begin_(++iterator(str, sep, StringPiece(str.begin() - 1, 0), false)),
+      end_(str, sep, StringPiece(str.end(), 0), true) {}
 
-bool extractResFilePathParts(const StringPiece& path, StringPiece* outPrefix,
-                             StringPiece* outEntry, StringPiece* outSuffix) {
-    const StringPiece resPrefix("res/");
-    if (!stringStartsWith(path, resPrefix)) {
-        return false;
+bool ExtractResFilePathParts(const StringPiece& path, StringPiece* out_prefix,
+                             StringPiece* out_entry, StringPiece* out_suffix) {
+  const StringPiece res_prefix("res/");
+  if (!StartsWith(path, res_prefix)) {
+    return false;
+  }
+
+  StringPiece::const_iterator last_occurence = path.end();
+  for (auto iter = path.begin() + res_prefix.size(); iter != path.end();
+       ++iter) {
+    if (*iter == '/') {
+      last_occurence = iter;
     }
+  }
 
-    StringPiece::const_iterator lastOccurence = path.end();
-    for (auto iter = path.begin() + resPrefix.size(); iter != path.end(); ++iter) {
-        if (*iter == '/') {
-            lastOccurence = iter;
-        }
-    }
+  if (last_occurence == path.end()) {
+    return false;
+  }
 
-    if (lastOccurence == path.end()) {
-        return false;
-    }
-
-    auto iter = std::find(lastOccurence, path.end(), '.');
-    *outSuffix = StringPiece(iter, path.end() - iter);
-    *outEntry = StringPiece(lastOccurence + 1, iter - lastOccurence - 1);
-    *outPrefix = StringPiece(path.begin(), lastOccurence - path.begin() + 1);
-    return true;
+  auto iter = std::find(last_occurence, path.end(), '.');
+  *out_suffix = StringPiece(iter, path.end() - iter);
+  *out_entry = StringPiece(last_occurence + 1, iter - last_occurence - 1);
+  *out_prefix = StringPiece(path.begin(), last_occurence - path.begin() + 1);
+  return true;
 }
 
-StringPiece16 getString16(const android::ResStringPool& pool, size_t idx) {
-    size_t len;
-    const char16_t* str = pool.stringAt(idx, &len);
-    if (str != nullptr) {
-        return StringPiece16(str, len);
-    }
-    return StringPiece16();
+StringPiece16 GetString16(const android::ResStringPool& pool, size_t idx) {
+  size_t len;
+  const char16_t* str = pool.stringAt(idx, &len);
+  if (str != nullptr) {
+    return StringPiece16(str, len);
+  }
+  return StringPiece16();
 }
 
-std::string getString(const android::ResStringPool& pool, size_t idx) {
-    size_t len;
-    const char* str = pool.string8At(idx, &len);
-    if (str != nullptr) {
-        return std::string(str, len);
-    }
-    return utf16ToUtf8(getString16(pool, idx));
+std::string GetString(const android::ResStringPool& pool, size_t idx) {
+  size_t len;
+  const char* str = pool.string8At(idx, &len);
+  if (str != nullptr) {
+    return std::string(str, len);
+  }
+  return Utf16ToUtf8(GetString16(pool, idx));
 }
 
-} // namespace util
-} // namespace aapt
+}  // namespace util
+}  // namespace aapt
diff --git a/tools/aapt2/util/Util.h b/tools/aapt2/util/Util.h
index 077e193e091e2..05e9cc5d28ca2 100644
--- a/tools/aapt2/util/Util.h
+++ b/tools/aapt2/util/Util.h
@@ -17,40 +17,53 @@
 #ifndef AAPT_UTIL_H
 #define AAPT_UTIL_H
 
-#include "util/BigBuffer.h"
-#include "util/Maybe.h"
-#include "util/StringPiece.h"
-
-#include <androidfw/ResourceTypes.h>
 #include <functional>
 #include <memory>
 #include <ostream>
 #include <string>
 #include <vector>
 
+#include "androidfw/ResourceTypes.h"
+#include "utils/ByteOrder.h"
+
+#include "util/BigBuffer.h"
+#include "util/Maybe.h"
+#include "util/StringPiece.h"
+
+#ifdef _WIN32
+// TODO(adamlesinski): remove once http://b/32447322 is resolved.
+// utils/ByteOrder.h includes winsock2.h on WIN32,
+// which will pull in the ERROR definition. This conflicts
+// with android-base/logging.h, which takes care of undefining
+// ERROR, but it gets included too early (before winsock2.h).
+#ifdef ERROR
+#undef ERROR
+#endif
+#endif
+
 namespace aapt {
 namespace util {
 
-std::vector<std::string> split(const StringPiece& str, char sep);
-std::vector<std::string> splitAndLowercase(const StringPiece& str, char sep);
+std::vector<std::string> Split(const StringPiece& str, char sep);
+std::vector<std::string> SplitAndLowercase(const StringPiece& str, char sep);
 
 /**
  * Returns true if the string starts with prefix.
  */
-bool stringStartsWith(const StringPiece& str, const StringPiece& prefix);
+bool StartsWith(const StringPiece& str, const StringPiece& prefix);
 
 /**
  * Returns true if the string ends with suffix.
  */
-bool stringEndsWith(const StringPiece& str, const StringPiece& suffix);
+bool EndsWith(const StringPiece& str, const StringPiece& suffix);
 
 /**
  * Creates a new StringPiece16 that points to a substring
  * of the original string without leading or trailing whitespace.
  */
-StringPiece trimWhitespace(const StringPiece& str);
+StringPiece TrimWhitespace(const StringPiece& str);
 
-StringPiece trimWhitespace(const StringPiece& str);
+StringPiece TrimWhitespace(const StringPiece& str);
 
 /**
  * UTF-16 isspace(). It basically checks for lower range characters that are
@@ -62,18 +75,18 @@ inline bool isspace16(char16_t c) { return c < 0x0080 && isspace(c); }
  * Returns an iterator to the first character that is not alpha-numeric and that
  * is not in the allowedChars set.
  */
-StringPiece::const_iterator findNonAlphaNumericAndNotInSet(
-    const StringPiece& str, const StringPiece& allowedChars);
+StringPiece::const_iterator FindNonAlphaNumericAndNotInSet(
+    const StringPiece& str, const StringPiece& allowed_chars);
 
 /**
  * Tests that the string is a valid Java class name.
  */
-bool isJavaClassName(const StringPiece& str);
+bool IsJavaClassName(const StringPiece& str);
 
 /**
  * Tests that the string is a valid Java package name.
  */
-bool isJavaPackageName(const StringPiece& str);
+bool IsJavaPackageName(const StringPiece& str);
 
 /**
  * Converts the class name to a fully qualified class name from the given
@@ -84,8 +97,8 @@ bool isJavaPackageName(const StringPiece& str);
  * .a.b         --> package.a.b
  * asdf.adsf    --> asdf.adsf
  */
-Maybe<std::string> getFullyQualifiedClassName(const StringPiece& package,
-                                              const StringPiece& className);
+Maybe<std::string> GetFullyQualifiedClassName(const StringPiece& package,
+                                              const StringPiece& class_name);
 
 /**
  * Makes a std::unique_ptr<> with the template parameter inferred by the
@@ -103,15 +116,15 @@ std::unique_ptr<T> make_unique(Args&&... args) {
  * separator.
  */
 template <typename Container>
-::std::function<::std::ostream&(::std::ostream&)> joiner(
+::std::function<::std::ostream&(::std::ostream&)> Joiner(
     const Container& container, const char* sep) {
   using std::begin;
   using std::end;
-  const auto beginIter = begin(container);
-  const auto endIter = end(container);
-  return [beginIter, endIter, sep](::std::ostream& out) -> ::std::ostream& {
-    for (auto iter = beginIter; iter != endIter; ++iter) {
-      if (iter != beginIter) {
+  const auto begin_iter = begin(container);
+  const auto end_iter = end(container);
+  return [begin_iter, end_iter, sep](::std::ostream& out) -> ::std::ostream& {
+    for (auto iter = begin_iter; iter != end_iter; ++iter) {
+      if (iter != begin_iter) {
         out << sep;
       }
       out << *iter;
@@ -120,31 +133,12 @@ template <typename Container>
   };
 }
 
-inline ::std::function<::std::ostream&(::std::ostream&)> formatSize(
-    size_t size) {
-  return [size](::std::ostream& out) -> ::std::ostream& {
-    constexpr size_t K = 1024u;
-    constexpr size_t M = K * K;
-    constexpr size_t G = M * K;
-    if (size < K) {
-      out << size << "B";
-    } else if (size < M) {
-      out << (double(size) / K) << " KiB";
-    } else if (size < G) {
-      out << (double(size) / M) << " MiB";
-    } else {
-      out << (double(size) / G) << " GiB";
-    }
-    return out;
-  };
-}
-
 /**
  * Helper method to extract a UTF-16 string from a StringPool. If the string is
  * stored as UTF-8,
  * the conversion to UTF-16 happens within ResStringPool.
  */
-StringPiece16 getString16(const android::ResStringPool& pool, size_t idx);
+StringPiece16 GetString16(const android::ResStringPool& pool, size_t idx);
 
 /**
  * Helper method to extract a UTF-8 string from a StringPool. If the string is
@@ -154,7 +148,7 @@ StringPiece16 getString16(const android::ResStringPool& pool, size_t idx);
  * which maintains no state or cache. This means we must return an std::string
  * copy.
  */
-std::string getString(const android::ResStringPool& pool, size_t idx);
+std::string GetString(const android::ResStringPool& pool, size_t idx);
 
 /**
  * Checks that the Java string format contains no non-positional arguments
@@ -165,53 +159,53 @@ std::string getString(const android::ResStringPool& pool, size_t idx);
  * which will
  * break the string interpolation.
  */
-bool verifyJavaStringFormat(const StringPiece& str);
+bool VerifyJavaStringFormat(const StringPiece& str);
 
 class StringBuilder {
  public:
-  StringBuilder& append(const StringPiece& str);
-  const std::string& str() const;
-  const std::string& error() const;
+  StringBuilder& Append(const StringPiece& str);
+  const std::string& ToString() const;
+  const std::string& Error() const;
 
   // When building StyledStrings, we need UTF-16 indices into the string,
   // which is what the Java layer expects when dealing with java
   // String.charAt().
-  size_t utf16Len() const;
+  size_t Utf16Len() const;
 
-  operator bool() const;
+  explicit operator bool() const;
 
  private:
-  std::string mStr;
-  size_t mUtf16Len = 0;
-  bool mQuote = false;
-  bool mTrailingSpace = false;
-  bool mLastCharWasEscape = false;
-  std::string mError;
+  std::string str_;
+  size_t utf16_len_ = 0;
+  bool quote_ = false;
+  bool trailing_space_ = false;
+  bool last_char_was_escape_ = false;
+  std::string error_;
 };
 
-inline const std::string& StringBuilder::str() const { return mStr; }
+inline const std::string& StringBuilder::ToString() const { return str_; }
 
-inline const std::string& StringBuilder::error() const { return mError; }
+inline const std::string& StringBuilder::Error() const { return error_; }
 
-inline size_t StringBuilder::utf16Len() const { return mUtf16Len; }
+inline size_t StringBuilder::Utf16Len() const { return utf16_len_; }
 
-inline StringBuilder::operator bool() const { return mError.empty(); }
+inline StringBuilder::operator bool() const { return error_.empty(); }
 
 /**
  * Converts a UTF8 string to a UTF16 string.
  */
-std::u16string utf8ToUtf16(const StringPiece& utf8);
-std::string utf16ToUtf8(const StringPiece16& utf16);
+std::u16string Utf8ToUtf16(const StringPiece& utf8);
+std::string Utf16ToUtf8(const StringPiece16& utf16);
 
 /**
  * Writes the entire BigBuffer to the output stream.
  */
-bool writeAll(std::ostream& out, const BigBuffer& buffer);
+bool WriteAll(std::ostream& out, const BigBuffer& buffer);
 
 /*
  * Copies the entire BigBuffer into a single buffer.
  */
-std::unique_ptr<uint8_t[]> copy(const BigBuffer& buffer);
+std::unique_ptr<uint8_t[]> Copy(const BigBuffer& buffer);
 
 /**
  * A Tokenizer implemented as an iterable collection. It does not allocate
@@ -226,7 +220,7 @@ class Tokenizer {
 
     iterator& operator++();
 
-    StringPiece operator*() { return mToken; }
+    StringPiece operator*() { return token_; }
     bool operator==(const iterator& rhs) const;
     bool operator!=(const iterator& rhs) const;
 
@@ -235,34 +229,34 @@ class Tokenizer {
 
     iterator(StringPiece s, char sep, StringPiece tok, bool end);
 
-    StringPiece mStr;
-    char mSeparator;
-    StringPiece mToken;
-    bool mEnd;
+    StringPiece str_;
+    char separator_;
+    StringPiece token_;
+    bool end_;
   };
 
   Tokenizer(StringPiece str, char sep);
 
-  iterator begin() { return mBegin; }
+  iterator begin() { return begin_; }
 
-  iterator end() { return mEnd; }
+  iterator end() { return end_; }
 
  private:
-  const iterator mBegin;
-  const iterator mEnd;
+  const iterator begin_;
+  const iterator end_;
 };
 
-inline Tokenizer tokenize(const StringPiece& str, char sep) {
+inline Tokenizer Tokenize(const StringPiece& str, char sep) {
   return Tokenizer(str, sep);
 }
 
-inline uint16_t hostToDevice16(uint16_t value) { return htods(value); }
+inline uint16_t HostToDevice16(uint16_t value) { return htods(value); }
 
-inline uint32_t hostToDevice32(uint32_t value) { return htodl(value); }
+inline uint32_t HostToDevice32(uint32_t value) { return htodl(value); }
 
-inline uint16_t deviceToHost16(uint16_t value) { return dtohs(value); }
+inline uint16_t DeviceToHost16(uint16_t value) { return dtohs(value); }
 
-inline uint32_t deviceToHost32(uint32_t value) { return dtohl(value); }
+inline uint32_t DeviceToHost32(uint32_t value) { return dtohl(value); }
 
 /**
  * Given a path like: res/xml-sw600dp/foo.xml
@@ -273,8 +267,8 @@ inline uint32_t deviceToHost32(uint32_t value) { return dtohl(value); }
  *
  * Returns true if successful.
  */
-bool extractResFilePathParts(const StringPiece& path, StringPiece* outPrefix,
-                             StringPiece* outEntry, StringPiece* outSuffix);
+bool ExtractResFilePathParts(const StringPiece& path, StringPiece* out_prefix,
+                             StringPiece* out_entry, StringPiece* out_suffix);
 
 }  // namespace util
 
diff --git a/tools/aapt2/util/Util_test.cpp b/tools/aapt2/util/Util_test.cpp
index 0e27213a8d8a4..cac3de4696ab9 100644
--- a/tools/aapt2/util/Util_test.cpp
+++ b/tools/aapt2/util/Util_test.cpp
@@ -14,191 +14,196 @@
  * limitations under the License.
  */
 
-#include "test/Test.h"
-#include "util/StringPiece.h"
 #include "util/Util.h"
 
 #include <string>
 
+#include "test/Test.h"
+
 namespace aapt {
 
 TEST(UtilTest, TrimOnlyWhitespace) {
-    const std::string full = "\n        ";
+  const std::string full = "\n        ";
 
-    StringPiece trimmed = util::trimWhitespace(full);
-    EXPECT_TRUE(trimmed.empty());
-    EXPECT_EQ(0u, trimmed.size());
+  StringPiece trimmed = util::TrimWhitespace(full);
+  EXPECT_TRUE(trimmed.empty());
+  EXPECT_EQ(0u, trimmed.size());
 }
 
 TEST(UtilTest, StringEndsWith) {
-    EXPECT_TRUE(util::stringEndsWith("hello.xml", ".xml"));
+  EXPECT_TRUE(util::EndsWith("hello.xml", ".xml"));
 }
 
 TEST(UtilTest, StringStartsWith) {
-    EXPECT_TRUE(util::stringStartsWith("hello.xml", "he"));
+  EXPECT_TRUE(util::StartsWith("hello.xml", "he"));
 }
 
 TEST(UtilTest, StringBuilderSplitEscapeSequence) {
-    EXPECT_EQ(StringPiece("this is a new\nline."),
-              util::StringBuilder().append("this is a new\\")
-                                   .append("nline.")
-                                   .str());
+  EXPECT_EQ(StringPiece("this is a new\nline."), util::StringBuilder()
+                                                     .Append("this is a new\\")
+                                                     .Append("nline.")
+                                                     .ToString());
 }
 
 TEST(UtilTest, StringBuilderWhitespaceRemoval) {
-    EXPECT_EQ(StringPiece("hey guys this is so cool"),
-              util::StringBuilder().append("    hey guys ")
-                                   .append(" this is so cool ")
-                                   .str());
+  EXPECT_EQ(StringPiece("hey guys this is so cool"),
+            util::StringBuilder()
+                .Append("    hey guys ")
+                .Append(" this is so cool ")
+                .ToString());
 
-    EXPECT_EQ(StringPiece(" wow,  so many \t spaces. what?"),
-              util::StringBuilder().append(" \" wow,  so many \t ")
-                                   .append("spaces. \"what? ")
-                                   .str());
+  EXPECT_EQ(StringPiece(" wow,  so many \t spaces. what?"),
+            util::StringBuilder()
+                .Append(" \" wow,  so many \t ")
+                .Append("spaces. \"what? ")
+                .ToString());
 
-    EXPECT_EQ(StringPiece("where is the pie?"),
-              util::StringBuilder().append("  where \t ")
-                                   .append(" \nis the "" pie?")
-                                   .str());
+  EXPECT_EQ(StringPiece("where is the pie?"), util::StringBuilder()
+                                                  .Append("  where \t ")
+                                                  .Append(" \nis the "
+                                                          " pie?")
+                                                  .ToString());
 }
 
 TEST(UtilTest, StringBuilderEscaping) {
-    EXPECT_EQ(StringPiece("hey guys\n this \t is so\\ cool"),
-              util::StringBuilder().append("    hey guys\\n ")
-                                   .append(" this \\t is so\\\\ cool ")
-                                   .str());
+  EXPECT_EQ(StringPiece("hey guys\n this \t is so\\ cool"),
+            util::StringBuilder()
+                .Append("    hey guys\\n ")
+                .Append(" this \\t is so\\\\ cool ")
+                .ToString());
 
-    EXPECT_EQ(StringPiece("@?#\\\'"),
-              util::StringBuilder().append("\\@\\?\\#\\\\\\'")
-                                   .str());
+  EXPECT_EQ(StringPiece("@?#\\\'"),
+            util::StringBuilder().Append("\\@\\?\\#\\\\\\'").ToString());
 }
 
 TEST(UtilTest, StringBuilderMisplacedQuote) {
-    util::StringBuilder builder{};
-    EXPECT_FALSE(builder.append("they're coming!"));
+  util::StringBuilder builder{};
+  EXPECT_FALSE(builder.Append("they're coming!"));
 }
 
 TEST(UtilTest, StringBuilderUnicodeCodes) {
-    EXPECT_EQ(std::string("\u00AF\u0AF0 woah"),
-              util::StringBuilder().append("\\u00AF\\u0AF0 woah")
-                                   .str());
+  EXPECT_EQ(std::string("\u00AF\u0AF0 woah"),
+            util::StringBuilder().Append("\\u00AF\\u0AF0 woah").ToString());
 
-    EXPECT_FALSE(util::StringBuilder().append("\\u00 yo"));
+  EXPECT_FALSE(util::StringBuilder().Append("\\u00 yo"));
 }
 
 TEST(UtilTest, TokenizeInput) {
-    auto tokenizer = util::tokenize(StringPiece("this| is|the|end"), '|');
-    auto iter = tokenizer.begin();
-    ASSERT_EQ(*iter, StringPiece("this"));
-    ++iter;
-    ASSERT_EQ(*iter, StringPiece(" is"));
-    ++iter;
-    ASSERT_EQ(*iter, StringPiece("the"));
-    ++iter;
-    ASSERT_EQ(*iter, StringPiece("end"));
-    ++iter;
-    ASSERT_EQ(tokenizer.end(), iter);
+  auto tokenizer = util::Tokenize(StringPiece("this| is|the|end"), '|');
+  auto iter = tokenizer.begin();
+  ASSERT_EQ(*iter, StringPiece("this"));
+  ++iter;
+  ASSERT_EQ(*iter, StringPiece(" is"));
+  ++iter;
+  ASSERT_EQ(*iter, StringPiece("the"));
+  ++iter;
+  ASSERT_EQ(*iter, StringPiece("end"));
+  ++iter;
+  ASSERT_EQ(tokenizer.end(), iter);
 }
 
 TEST(UtilTest, TokenizeEmptyString) {
-    auto tokenizer = util::tokenize(StringPiece(""), '|');
-    auto iter = tokenizer.begin();
-    ASSERT_NE(tokenizer.end(), iter);
-    ASSERT_EQ(StringPiece(), *iter);
-    ++iter;
-    ASSERT_EQ(tokenizer.end(), iter);
+  auto tokenizer = util::Tokenize(StringPiece(""), '|');
+  auto iter = tokenizer.begin();
+  ASSERT_NE(tokenizer.end(), iter);
+  ASSERT_EQ(StringPiece(), *iter);
+  ++iter;
+  ASSERT_EQ(tokenizer.end(), iter);
 }
 
 TEST(UtilTest, TokenizeAtEnd) {
-    auto tokenizer = util::tokenize(StringPiece("one."), '.');
-    auto iter = tokenizer.begin();
-    ASSERT_EQ(*iter, StringPiece("one"));
-    ++iter;
-    ASSERT_NE(iter, tokenizer.end());
-    ASSERT_EQ(*iter, StringPiece());
+  auto tokenizer = util::Tokenize(StringPiece("one."), '.');
+  auto iter = tokenizer.begin();
+  ASSERT_EQ(*iter, StringPiece("one"));
+  ++iter;
+  ASSERT_NE(iter, tokenizer.end());
+  ASSERT_EQ(*iter, StringPiece());
 }
 
 TEST(UtilTest, IsJavaClassName) {
-    EXPECT_TRUE(util::isJavaClassName("android.test.Class"));
-    EXPECT_TRUE(util::isJavaClassName("android.test.Class$Inner"));
-    EXPECT_TRUE(util::isJavaClassName("android_test.test.Class"));
-    EXPECT_TRUE(util::isJavaClassName("_android_.test._Class_"));
-    EXPECT_FALSE(util::isJavaClassName("android.test.$Inner"));
-    EXPECT_FALSE(util::isJavaClassName("android.test.Inner$"));
-    EXPECT_FALSE(util::isJavaClassName(".test.Class"));
-    EXPECT_FALSE(util::isJavaClassName("android"));
+  EXPECT_TRUE(util::IsJavaClassName("android.test.Class"));
+  EXPECT_TRUE(util::IsJavaClassName("android.test.Class$Inner"));
+  EXPECT_TRUE(util::IsJavaClassName("android_test.test.Class"));
+  EXPECT_TRUE(util::IsJavaClassName("_android_.test._Class_"));
+  EXPECT_FALSE(util::IsJavaClassName("android.test.$Inner"));
+  EXPECT_FALSE(util::IsJavaClassName("android.test.Inner$"));
+  EXPECT_FALSE(util::IsJavaClassName(".test.Class"));
+  EXPECT_FALSE(util::IsJavaClassName("android"));
 }
 
 TEST(UtilTest, IsJavaPackageName) {
-    EXPECT_TRUE(util::isJavaPackageName("android"));
-    EXPECT_TRUE(util::isJavaPackageName("android.test"));
-    EXPECT_TRUE(util::isJavaPackageName("android.test_thing"));
-    EXPECT_FALSE(util::isJavaPackageName("_android"));
-    EXPECT_FALSE(util::isJavaPackageName("android_"));
-    EXPECT_FALSE(util::isJavaPackageName("android."));
-    EXPECT_FALSE(util::isJavaPackageName(".android"));
-    EXPECT_FALSE(util::isJavaPackageName("android._test"));
-    EXPECT_FALSE(util::isJavaPackageName(".."));
+  EXPECT_TRUE(util::IsJavaPackageName("android"));
+  EXPECT_TRUE(util::IsJavaPackageName("android.test"));
+  EXPECT_TRUE(util::IsJavaPackageName("android.test_thing"));
+  EXPECT_FALSE(util::IsJavaPackageName("_android"));
+  EXPECT_FALSE(util::IsJavaPackageName("android_"));
+  EXPECT_FALSE(util::IsJavaPackageName("android."));
+  EXPECT_FALSE(util::IsJavaPackageName(".android"));
+  EXPECT_FALSE(util::IsJavaPackageName("android._test"));
+  EXPECT_FALSE(util::IsJavaPackageName(".."));
 }
 
 TEST(UtilTest, FullyQualifiedClassName) {
-    Maybe<std::string> res = util::getFullyQualifiedClassName("android", ".asdf");
-    AAPT_ASSERT_TRUE(res);
-    EXPECT_EQ(res.value(), "android.asdf");
+  Maybe<std::string> res = util::GetFullyQualifiedClassName("android", ".asdf");
+  AAPT_ASSERT_TRUE(res);
+  EXPECT_EQ(res.value(), "android.asdf");
 
-    res = util::getFullyQualifiedClassName("android", ".a.b");
-    AAPT_ASSERT_TRUE(res);
-    EXPECT_EQ(res.value(), "android.a.b");
+  res = util::GetFullyQualifiedClassName("android", ".a.b");
+  AAPT_ASSERT_TRUE(res);
+  EXPECT_EQ(res.value(), "android.a.b");
 
-    res = util::getFullyQualifiedClassName("android", "a.b");
-    AAPT_ASSERT_TRUE(res);
-    EXPECT_EQ(res.value(), "a.b");
+  res = util::GetFullyQualifiedClassName("android", "a.b");
+  AAPT_ASSERT_TRUE(res);
+  EXPECT_EQ(res.value(), "a.b");
 
-    res = util::getFullyQualifiedClassName("", "a.b");
-    AAPT_ASSERT_TRUE(res);
-    EXPECT_EQ(res.value(), "a.b");
+  res = util::GetFullyQualifiedClassName("", "a.b");
+  AAPT_ASSERT_TRUE(res);
+  EXPECT_EQ(res.value(), "a.b");
 
-    res = util::getFullyQualifiedClassName("android", "Class");
-    AAPT_ASSERT_TRUE(res);
-    EXPECT_EQ(res.value(), "android.Class");
+  res = util::GetFullyQualifiedClassName("android", "Class");
+  AAPT_ASSERT_TRUE(res);
+  EXPECT_EQ(res.value(), "android.Class");
 
-    res = util::getFullyQualifiedClassName("", "");
-    AAPT_ASSERT_FALSE(res);
+  res = util::GetFullyQualifiedClassName("", "");
+  AAPT_ASSERT_FALSE(res);
 
-    res = util::getFullyQualifiedClassName("android", "./Apple");
-    AAPT_ASSERT_FALSE(res);
+  res = util::GetFullyQualifiedClassName("android", "./Apple");
+  AAPT_ASSERT_FALSE(res);
 }
 
 TEST(UtilTest, ExtractResourcePathComponents) {
-    StringPiece prefix, entry, suffix;
-    ASSERT_TRUE(util::extractResFilePathParts("res/xml-sw600dp/entry.xml", &prefix, &entry,
-                                              &suffix));
-    EXPECT_EQ(prefix, "res/xml-sw600dp/");
-    EXPECT_EQ(entry, "entry");
-    EXPECT_EQ(suffix, ".xml");
+  StringPiece prefix, entry, suffix;
+  ASSERT_TRUE(util::ExtractResFilePathParts("res/xml-sw600dp/entry.xml",
+                                            &prefix, &entry, &suffix));
+  EXPECT_EQ(prefix, "res/xml-sw600dp/");
+  EXPECT_EQ(entry, "entry");
+  EXPECT_EQ(suffix, ".xml");
 
-    ASSERT_TRUE(util::extractResFilePathParts("res/xml-sw600dp/entry.9.png", &prefix, &entry,
-                                              &suffix));
+  ASSERT_TRUE(util::ExtractResFilePathParts("res/xml-sw600dp/entry.9.png",
+                                            &prefix, &entry, &suffix));
 
-    EXPECT_EQ(prefix, "res/xml-sw600dp/");
-    EXPECT_EQ(entry, "entry");
-    EXPECT_EQ(suffix, ".9.png");
+  EXPECT_EQ(prefix, "res/xml-sw600dp/");
+  EXPECT_EQ(entry, "entry");
+  EXPECT_EQ(suffix, ".9.png");
 
-    EXPECT_FALSE(util::extractResFilePathParts("AndroidManifest.xml", &prefix, &entry, &suffix));
-    EXPECT_FALSE(util::extractResFilePathParts("res/.xml", &prefix, &entry, &suffix));
+  EXPECT_FALSE(util::ExtractResFilePathParts("AndroidManifest.xml", &prefix,
+                                             &entry, &suffix));
+  EXPECT_FALSE(
+      util::ExtractResFilePathParts("res/.xml", &prefix, &entry, &suffix));
 
-    ASSERT_TRUE(util::extractResFilePathParts("res//.", &prefix, &entry, &suffix));
-    EXPECT_EQ(prefix, "res//");
-    EXPECT_EQ(entry, "");
-    EXPECT_EQ(suffix, ".");
+  ASSERT_TRUE(
+      util::ExtractResFilePathParts("res//.", &prefix, &entry, &suffix));
+  EXPECT_EQ(prefix, "res//");
+  EXPECT_EQ(entry, "");
+  EXPECT_EQ(suffix, ".");
 }
 
 TEST(UtilTest, VerifyJavaStringFormat) {
-    ASSERT_TRUE(util::verifyJavaStringFormat("%09.34f"));
-    ASSERT_TRUE(util::verifyJavaStringFormat("%9$.34f %8$"));
-    ASSERT_TRUE(util::verifyJavaStringFormat("%% %%"));
-    ASSERT_FALSE(util::verifyJavaStringFormat("%09$f %f"));
-    ASSERT_FALSE(util::verifyJavaStringFormat("%09f %08s"));
+  ASSERT_TRUE(util::VerifyJavaStringFormat("%09.34f"));
+  ASSERT_TRUE(util::VerifyJavaStringFormat("%9$.34f %8$"));
+  ASSERT_TRUE(util::VerifyJavaStringFormat("%% %%"));
+  ASSERT_FALSE(util::VerifyJavaStringFormat("%09$f %f"));
+  ASSERT_FALSE(util::VerifyJavaStringFormat("%09f %08s"));
 }
 
-} // namespace aapt
+}  // namespace aapt
diff --git a/tools/aapt2/xml/XmlActionExecutor.cpp b/tools/aapt2/xml/XmlActionExecutor.cpp
index 745079c43c7c1..7580b469a98ed 100644
--- a/tools/aapt2/xml/XmlActionExecutor.cpp
+++ b/tools/aapt2/xml/XmlActionExecutor.cpp
@@ -19,93 +19,94 @@
 namespace aapt {
 namespace xml {
 
-static bool wrapperOne(XmlNodeAction::ActionFunc& f, Element* el, SourcePathDiagnostics*) {
-    return f(el);
+static bool wrapper_one(XmlNodeAction::ActionFunc& f, Element* el,
+                        SourcePathDiagnostics*) {
+  return f(el);
 }
 
-static bool wrapperTwo(XmlNodeAction::ActionFuncWithDiag& f, Element* el,
-                       SourcePathDiagnostics* diag) {
-    return f(el, diag);
+static bool wrapper_two(XmlNodeAction::ActionFuncWithDiag& f, Element* el,
+                        SourcePathDiagnostics* diag) {
+  return f(el, diag);
 }
 
-void XmlNodeAction::action(XmlNodeAction::ActionFunc f) {
-    mActions.emplace_back(std::bind(wrapperOne, std::move(f),
-                                    std::placeholders::_1,
-                                    std::placeholders::_2));
+void XmlNodeAction::Action(XmlNodeAction::ActionFunc f) {
+  actions_.emplace_back(std::bind(
+      wrapper_one, std::move(f), std::placeholders::_1, std::placeholders::_2));
 }
 
-void XmlNodeAction::action(XmlNodeAction::ActionFuncWithDiag f) {
-    mActions.emplace_back(std::bind(wrapperTwo, std::move(f),
-                                    std::placeholders::_1,
-                                    std::placeholders::_2));
+void XmlNodeAction::Action(XmlNodeAction::ActionFuncWithDiag f) {
+  actions_.emplace_back(std::bind(
+      wrapper_two, std::move(f), std::placeholders::_1, std::placeholders::_2));
 }
 
-static void printElementToDiagMessage(const Element* el, DiagMessage* msg) {
-    *msg << "<";
-    if (!el->namespaceUri.empty()) {
-        *msg << el->namespaceUri << ":";
-    }
-    *msg << el->name << ">";
+static void PrintElementToDiagMessage(const Element* el, DiagMessage* msg) {
+  *msg << "<";
+  if (!el->namespace_uri.empty()) {
+    *msg << el->namespace_uri << ":";
+  }
+  *msg << el->name << ">";
 }
 
-bool XmlNodeAction::execute(XmlActionExecutorPolicy policy, SourcePathDiagnostics* diag,
-                            Element* el) const {
-    bool error = false;
-    for (const ActionFuncWithDiag& action : mActions) {
-        error |= !action(el, diag);
+bool XmlNodeAction::Execute(XmlActionExecutorPolicy policy,
+                            SourcePathDiagnostics* diag, Element* el) const {
+  bool error = false;
+  for (const ActionFuncWithDiag& action : actions_) {
+    error |= !action(el, diag);
+  }
+
+  for (Element* child_el : el->GetChildElements()) {
+    if (child_el->namespace_uri.empty()) {
+      std::map<std::string, XmlNodeAction>::const_iterator iter =
+          map_.find(child_el->name);
+      if (iter != map_.end()) {
+        error |= !iter->second.Execute(policy, diag, child_el);
+        continue;
+      }
     }
 
-    for (Element* childEl : el->getChildElements()) {
-        if (childEl->namespaceUri.empty()) {
-            std::map<std::string, XmlNodeAction>::const_iterator iter = mMap.find(childEl->name);
-            if (iter != mMap.end()) {
-                error |= !iter->second.execute(policy, diag, childEl);
-                continue;
-            }
-        }
-
-        if (policy == XmlActionExecutorPolicy::Whitelist) {
-            DiagMessage errorMsg(childEl->lineNumber);
-            errorMsg << "unknown element ";
-            printElementToDiagMessage(childEl, &errorMsg);
-            errorMsg << " found";
-            diag->error(errorMsg);
-            error = true;
-        }
+    if (policy == XmlActionExecutorPolicy::kWhitelist) {
+      DiagMessage error_msg(child_el->line_number);
+      error_msg << "unknown element ";
+      PrintElementToDiagMessage(child_el, &error_msg);
+      error_msg << " found";
+      diag->Error(error_msg);
+      error = true;
     }
-    return !error;
+  }
+  return !error;
 }
 
-bool XmlActionExecutor::execute(XmlActionExecutorPolicy policy, IDiagnostics* diag,
-                                XmlResource* doc) const {
-    SourcePathDiagnostics sourceDiag(doc->file.source, diag);
+bool XmlActionExecutor::Execute(XmlActionExecutorPolicy policy,
+                                IDiagnostics* diag, XmlResource* doc) const {
+  SourcePathDiagnostics source_diag(doc->file.source, diag);
 
-    Element* el = findRootElement(doc);
-    if (!el) {
-        if (policy == XmlActionExecutorPolicy::Whitelist) {
-            sourceDiag.error(DiagMessage() << "no root XML tag found");
-            return false;
-        }
-        return true;
-    }
-
-    if (el->namespaceUri.empty()) {
-        std::map<std::string, XmlNodeAction>::const_iterator iter = mMap.find(el->name);
-        if (iter != mMap.end()) {
-            return iter->second.execute(policy, &sourceDiag, el);
-        }
-    }
-
-    if (policy == XmlActionExecutorPolicy::Whitelist) {
-        DiagMessage errorMsg(el->lineNumber);
-        errorMsg << "unknown element ";
-        printElementToDiagMessage(el, &errorMsg);
-        errorMsg << " found";
-        sourceDiag.error(errorMsg);
-        return false;
+  Element* el = FindRootElement(doc);
+  if (!el) {
+    if (policy == XmlActionExecutorPolicy::kWhitelist) {
+      source_diag.Error(DiagMessage() << "no root XML tag found");
+      return false;
     }
     return true;
+  }
+
+  if (el->namespace_uri.empty()) {
+    std::map<std::string, XmlNodeAction>::const_iterator iter =
+        map_.find(el->name);
+    if (iter != map_.end()) {
+      return iter->second.Execute(policy, &source_diag, el);
+    }
+  }
+
+  if (policy == XmlActionExecutorPolicy::kWhitelist) {
+    DiagMessage error_msg(el->line_number);
+    error_msg << "unknown element ";
+    PrintElementToDiagMessage(el, &error_msg);
+    error_msg << " found";
+    source_diag.Error(error_msg);
+    return false;
+  }
+  return true;
 }
 
-} // namespace xml
-} // namespace aapt
+}  // namespace xml
+}  // namespace aapt
diff --git a/tools/aapt2/xml/XmlActionExecutor.h b/tools/aapt2/xml/XmlActionExecutor.h
index ca21b087f9548..68e35631988e2 100644
--- a/tools/aapt2/xml/XmlActionExecutor.h
+++ b/tools/aapt2/xml/XmlActionExecutor.h
@@ -17,15 +17,16 @@
 #ifndef AAPT_XML_XMLPATTERN_H
 #define AAPT_XML_XMLPATTERN_H
 
-#include "Diagnostics.h"
-#include "xml/XmlDom.h"
-
-#include <android-base/macros.h>
 #include <functional>
 #include <map>
 #include <string>
 #include <vector>
 
+#include "android-base/macros.h"
+
+#include "Diagnostics.h"
+#include "xml/XmlDom.h"
+
 namespace aapt {
 namespace xml {
 
@@ -34,14 +35,14 @@ enum class XmlActionExecutorPolicy {
    * Actions on run if elements are matched, errors occur only when actions
    * return false.
    */
-  None,
+  kNone,
 
   /**
    * The actions defined must match and run. If an element is found that does
    * not match
    * an action, an error occurs.
    */
-  Whitelist,
+  kWhitelist,
 };
 
 /**
@@ -60,22 +61,22 @@ class XmlNodeAction {
    * element
    * with the name `name`.
    */
-  XmlNodeAction& operator[](const std::string& name) { return mMap[name]; }
+  XmlNodeAction& operator[](const std::string& name) { return map_[name]; }
 
   /**
    * Add an action to be performed at this XmlNodeAction.
    */
-  void action(ActionFunc f);
-  void action(ActionFuncWithDiag);
+  void Action(ActionFunc f);
+  void Action(ActionFuncWithDiag);
 
  private:
   friend class XmlActionExecutor;
 
-  bool execute(XmlActionExecutorPolicy policy, SourcePathDiagnostics* diag,
+  bool Execute(XmlActionExecutorPolicy policy, SourcePathDiagnostics* diag,
                Element* el) const;
 
-  std::map<std::string, XmlNodeAction> mMap;
-  std::vector<ActionFuncWithDiag> mActions;
+  std::map<std::string, XmlNodeAction> map_;
+  std::vector<ActionFuncWithDiag> actions_;
 };
 
 /**
@@ -89,20 +90,19 @@ class XmlActionExecutor {
 
   /**
    * Find or create a root XmlNodeAction that will be performed for the root XML
-   * element
-   * with the name `name`.
+   * element with the name `name`.
    */
-  XmlNodeAction& operator[](const std::string& name) { return mMap[name]; }
+  XmlNodeAction& operator[](const std::string& name) { return map_[name]; }
 
   /**
    * Execute the defined actions for this XmlResource.
    * Returns true if all actions return true, otherwise returns false.
    */
-  bool execute(XmlActionExecutorPolicy policy, IDiagnostics* diag,
+  bool Execute(XmlActionExecutorPolicy policy, IDiagnostics* diag,
                XmlResource* doc) const;
 
  private:
-  std::map<std::string, XmlNodeAction> mMap;
+  std::map<std::string, XmlNodeAction> map_;
 
   DISALLOW_COPY_AND_ASSIGN(XmlActionExecutor);
 };
diff --git a/tools/aapt2/xml/XmlActionExecutor_test.cpp b/tools/aapt2/xml/XmlActionExecutor_test.cpp
index 106e85601f6e5..7110c90fa3a94 100644
--- a/tools/aapt2/xml/XmlActionExecutor_test.cpp
+++ b/tools/aapt2/xml/XmlActionExecutor_test.cpp
@@ -14,49 +14,53 @@
  * limitations under the License.
  */
 
-#include "test/Test.h"
 #include "xml/XmlActionExecutor.h"
 
+#include "test/Test.h"
+
 namespace aapt {
 namespace xml {
 
 TEST(XmlActionExecutorTest, BuildsAccessibleNestedPattern) {
-    XmlActionExecutor executor;
-    XmlNodeAction& manifestAction = executor["manifest"];
-    XmlNodeAction& applicationAction = manifestAction["application"];
+  XmlActionExecutor executor;
+  XmlNodeAction& manifest_action = executor["manifest"];
+  XmlNodeAction& application_action = manifest_action["application"];
 
-    Element* manifestEl = nullptr;
-    manifestAction.action([&](Element* manifest) -> bool {
-        manifestEl = manifest;
-        return true;
-    });
+  Element* manifest_el = nullptr;
+  manifest_action.Action([&](Element* manifest) -> bool {
+    manifest_el = manifest;
+    return true;
+  });
 
-    Element* applicationEl = nullptr;
-    applicationAction.action([&](Element* application) -> bool {
-        applicationEl = application;
-        return true;
-    });
+  Element* application_el = nullptr;
+  application_action.Action([&](Element* application) -> bool {
+    application_el = application;
+    return true;
+  });
 
-    std::unique_ptr<XmlResource> doc = test::buildXmlDom("<manifest><application /></manifest>");
+  std::unique_ptr<XmlResource> doc =
+      test::BuildXmlDom("<manifest><application /></manifest>");
 
-    StdErrDiagnostics diag;
-    ASSERT_TRUE(executor.execute(XmlActionExecutorPolicy::None, &diag, doc.get()));
-    ASSERT_NE(nullptr, manifestEl);
-    EXPECT_EQ(std::string("manifest"), manifestEl->name);
+  StdErrDiagnostics diag;
+  ASSERT_TRUE(
+      executor.Execute(XmlActionExecutorPolicy::kNone, &diag, doc.get()));
+  ASSERT_NE(nullptr, manifest_el);
+  EXPECT_EQ(std::string("manifest"), manifest_el->name);
 
-    ASSERT_NE(nullptr, applicationEl);
-    EXPECT_EQ(std::string("application"), applicationEl->name);
+  ASSERT_NE(nullptr, application_el);
+  EXPECT_EQ(std::string("application"), application_el->name);
 }
 
 TEST(XmlActionExecutorTest, FailsWhenUndefinedHierarchyExists) {
-    XmlActionExecutor executor;
-    executor["manifest"]["application"];
+  XmlActionExecutor executor;
+  executor["manifest"]["application"];
 
-    std::unique_ptr<XmlResource> doc = test::buildXmlDom(
-            "<manifest><application /><activity /></manifest>");
-    StdErrDiagnostics diag;
-    ASSERT_FALSE(executor.execute(XmlActionExecutorPolicy::Whitelist, &diag, doc.get()));
+  std::unique_ptr<XmlResource> doc =
+      test::BuildXmlDom("<manifest><application /><activity /></manifest>");
+  StdErrDiagnostics diag;
+  ASSERT_FALSE(
+      executor.Execute(XmlActionExecutorPolicy::kWhitelist, &diag, doc.get()));
 }
 
-} // namespace xml
-} // namespace aapt
+}  // namespace xml
+}  // namespace aapt
diff --git a/tools/aapt2/xml/XmlDom.cpp b/tools/aapt2/xml/XmlDom.cpp
index 28de78a400f92..567418edf56ba 100644
--- a/tools/aapt2/xml/XmlDom.cpp
+++ b/tools/aapt2/xml/XmlDom.cpp
@@ -15,475 +15,496 @@
  */
 
 #include "XmlDom.h"
-#include "XmlPullParser.h"
-#include "util/Util.h"
+
+#include <expat.h>
 
 #include <cassert>
-#include <expat.h>
 #include <memory>
 #include <stack>
 #include <string>
 #include <tuple>
 
+#include "android-base/logging.h"
+
+#include "XmlPullParser.h"
+#include "util/Util.h"
+
 namespace aapt {
 namespace xml {
 
 constexpr char kXmlNamespaceSep = 1;
 
 struct Stack {
-    std::unique_ptr<xml::Node> root;
-    std::stack<xml::Node*> nodeStack;
-    std::string pendingComment;
+  std::unique_ptr<xml::Node> root;
+  std::stack<xml::Node*> node_stack;
+  std::string pending_comment;
 };
 
 /**
  * Extracts the namespace and name of an expanded element or attribute name.
  */
-static void splitName(const char* name, std::string* outNs, std::string* outName) {
-    const char* p = name;
-    while (*p != 0 && *p != kXmlNamespaceSep) {
-        p++;
-    }
+static void SplitName(const char* name, std::string* out_ns,
+                      std::string* out_name) {
+  const char* p = name;
+  while (*p != 0 && *p != kXmlNamespaceSep) {
+    p++;
+  }
 
-    if (*p == 0) {
-        outNs->clear();
-        *outName = StringPiece(name).toString();
-    } else {
-        *outNs = StringPiece(name, (p - name)).toString();
-        *outName = StringPiece(p + 1).toString();
-    }
+  if (*p == 0) {
+    out_ns->clear();
+    *out_name = StringPiece(name).ToString();
+  } else {
+    *out_ns = StringPiece(name, (p - name)).ToString();
+    *out_name = StringPiece(p + 1).ToString();
+  }
 }
 
-static void addToStack(Stack* stack, XML_Parser parser, std::unique_ptr<Node> node) {
-    node->lineNumber = XML_GetCurrentLineNumber(parser);
-    node->columnNumber = XML_GetCurrentColumnNumber(parser);
+static void AddToStack(Stack* stack, XML_Parser parser,
+                       std::unique_ptr<Node> node) {
+  node->line_number = XML_GetCurrentLineNumber(parser);
+  node->column_number = XML_GetCurrentColumnNumber(parser);
 
-    Node* thisNode = node.get();
-    if (!stack->nodeStack.empty()) {
-        stack->nodeStack.top()->addChild(std::move(node));
-    } else {
-        stack->root = std::move(node);
-    }
+  Node* this_node = node.get();
+  if (!stack->node_stack.empty()) {
+    stack->node_stack.top()->AddChild(std::move(node));
+  } else {
+    stack->root = std::move(node);
+  }
 
-    if (!nodeCast<Text>(thisNode)) {
-        stack->nodeStack.push(thisNode);
-    }
+  if (!NodeCast<Text>(this_node)) {
+    stack->node_stack.push(this_node);
+  }
 }
 
-static void XMLCALL startNamespaceHandler(void* userData, const char* prefix, const char* uri) {
-    XML_Parser parser = reinterpret_cast<XML_Parser>(userData);
-    Stack* stack = reinterpret_cast<Stack*>(XML_GetUserData(parser));
+static void XMLCALL StartNamespaceHandler(void* user_data, const char* prefix,
+                                          const char* uri) {
+  XML_Parser parser = reinterpret_cast<XML_Parser>(user_data);
+  Stack* stack = reinterpret_cast<Stack*>(XML_GetUserData(parser));
 
-    std::unique_ptr<Namespace> ns = util::make_unique<Namespace>();
-    if (prefix) {
-        ns->namespacePrefix = StringPiece(prefix).toString();
-    }
+  std::unique_ptr<Namespace> ns = util::make_unique<Namespace>();
+  if (prefix) {
+    ns->namespace_prefix = StringPiece(prefix).ToString();
+  }
 
-    if (uri) {
-        ns->namespaceUri = StringPiece(uri).toString();
-    }
+  if (uri) {
+    ns->namespace_uri = StringPiece(uri).ToString();
+  }
 
-    addToStack(stack, parser, std::move(ns));
+  AddToStack(stack, parser, std::move(ns));
 }
 
-static void XMLCALL endNamespaceHandler(void* userData, const char* prefix) {
-    XML_Parser parser = reinterpret_cast<XML_Parser>(userData);
-    Stack* stack = reinterpret_cast<Stack*>(XML_GetUserData(parser));
+static void XMLCALL EndNamespaceHandler(void* user_data, const char* prefix) {
+  XML_Parser parser = reinterpret_cast<XML_Parser>(user_data);
+  Stack* stack = reinterpret_cast<Stack*>(XML_GetUserData(parser));
 
-    assert(!stack->nodeStack.empty());
-    stack->nodeStack.pop();
+  CHECK(!stack->node_stack.empty());
+  stack->node_stack.pop();
 }
 
-static bool lessAttribute(const Attribute& lhs, const Attribute& rhs) {
-    return std::tie(lhs.namespaceUri, lhs.name, lhs.value) <
-            std::tie(rhs.namespaceUri, rhs.name, rhs.value);
+static bool less_attribute(const Attribute& lhs, const Attribute& rhs) {
+  return std::tie(lhs.namespace_uri, lhs.name, lhs.value) <
+         std::tie(rhs.namespace_uri, rhs.name, rhs.value);
 }
 
-static void XMLCALL startElementHandler(void* userData, const char* name, const char** attrs) {
-    XML_Parser parser = reinterpret_cast<XML_Parser>(userData);
-    Stack* stack = reinterpret_cast<Stack*>(XML_GetUserData(parser));
+static void XMLCALL StartElementHandler(void* user_data, const char* name,
+                                        const char** attrs) {
+  XML_Parser parser = reinterpret_cast<XML_Parser>(user_data);
+  Stack* stack = reinterpret_cast<Stack*>(XML_GetUserData(parser));
 
-    std::unique_ptr<Element> el = util::make_unique<Element>();
-    splitName(name, &el->namespaceUri, &el->name);
+  std::unique_ptr<Element> el = util::make_unique<Element>();
+  SplitName(name, &el->namespace_uri, &el->name);
 
-    while (*attrs) {
-        Attribute attribute;
-        splitName(*attrs++, &attribute.namespaceUri, &attribute.name);
-        attribute.value = StringPiece(*attrs++).toString();
+  while (*attrs) {
+    Attribute attribute;
+    SplitName(*attrs++, &attribute.namespace_uri, &attribute.name);
+    attribute.value = StringPiece(*attrs++).ToString();
 
-        // Insert in sorted order.
-        auto iter = std::lower_bound(el->attributes.begin(), el->attributes.end(), attribute,
-                                     lessAttribute);
-        el->attributes.insert(iter, std::move(attribute));
-    }
+    // Insert in sorted order.
+    auto iter = std::lower_bound(el->attributes.begin(), el->attributes.end(),
+                                 attribute, less_attribute);
+    el->attributes.insert(iter, std::move(attribute));
+  }
 
-    el->comment = std::move(stack->pendingComment);
-    addToStack(stack, parser, std::move(el));
+  el->comment = std::move(stack->pending_comment);
+  AddToStack(stack, parser, std::move(el));
 }
 
-static void XMLCALL endElementHandler(void* userData, const char* name) {
-    XML_Parser parser = reinterpret_cast<XML_Parser>(userData);
-    Stack* stack = reinterpret_cast<Stack*>(XML_GetUserData(parser));
+static void XMLCALL EndElementHandler(void* user_data, const char* name) {
+  XML_Parser parser = reinterpret_cast<XML_Parser>(user_data);
+  Stack* stack = reinterpret_cast<Stack*>(XML_GetUserData(parser));
 
-    assert(!stack->nodeStack.empty());
-    //stack->nodeStack.top()->comment = std::move(stack->pendingComment);
-    stack->nodeStack.pop();
+  CHECK(!stack->node_stack.empty());
+  // stack->nodeStack.top()->comment = std::move(stack->pendingComment);
+  stack->node_stack.pop();
 }
 
-static void XMLCALL characterDataHandler(void* userData, const char* s, int len) {
-    XML_Parser parser = reinterpret_cast<XML_Parser>(userData);
-    Stack* stack = reinterpret_cast<Stack*>(XML_GetUserData(parser));
+static void XMLCALL CharacterDataHandler(void* user_data, const char* s,
+                                         int len) {
+  XML_Parser parser = reinterpret_cast<XML_Parser>(user_data);
+  Stack* stack = reinterpret_cast<Stack*>(XML_GetUserData(parser));
 
-    if (!s || len <= 0) {
+  if (!s || len <= 0) {
+    return;
+  }
+
+  // See if we can just append the text to a previous text node.
+  if (!stack->node_stack.empty()) {
+    Node* currentParent = stack->node_stack.top();
+    if (!currentParent->children.empty()) {
+      Node* last_child = currentParent->children.back().get();
+      if (Text* text = NodeCast<Text>(last_child)) {
+        text->text += StringPiece(s, len).ToString();
         return;
+      }
     }
+  }
 
-    // See if we can just append the text to a previous text node.
-    if (!stack->nodeStack.empty()) {
-        Node* currentParent = stack->nodeStack.top();
-        if (!currentParent->children.empty()) {
-            Node* lastChild = currentParent->children.back().get();
-            if (Text* text = nodeCast<Text>(lastChild)) {
-                text->text += StringPiece(s, len).toString();
-                return;
-            }
-        }
-    }
-
-    std::unique_ptr<Text> text = util::make_unique<Text>();
-    text->text = StringPiece(s, len).toString();
-    addToStack(stack, parser, std::move(text));
+  std::unique_ptr<Text> text = util::make_unique<Text>();
+  text->text = StringPiece(s, len).ToString();
+  AddToStack(stack, parser, std::move(text));
 }
 
-static void XMLCALL commentDataHandler(void* userData, const char* comment) {
-    XML_Parser parser = reinterpret_cast<XML_Parser>(userData);
-    Stack* stack = reinterpret_cast<Stack*>(XML_GetUserData(parser));
+static void XMLCALL CommentDataHandler(void* user_data, const char* comment) {
+  XML_Parser parser = reinterpret_cast<XML_Parser>(user_data);
+  Stack* stack = reinterpret_cast<Stack*>(XML_GetUserData(parser));
 
-    if (!stack->pendingComment.empty()) {
-        stack->pendingComment += '\n';
-    }
-    stack->pendingComment += comment;
+  if (!stack->pending_comment.empty()) {
+    stack->pending_comment += '\n';
+  }
+  stack->pending_comment += comment;
 }
 
-std::unique_ptr<XmlResource> inflate(std::istream* in, IDiagnostics* diag, const Source& source) {
-    Stack stack;
-
-    XML_Parser parser = XML_ParserCreateNS(nullptr, kXmlNamespaceSep);
-    XML_SetUserData(parser, &stack);
-    XML_UseParserAsHandlerArg(parser);
-    XML_SetElementHandler(parser, startElementHandler, endElementHandler);
-    XML_SetNamespaceDeclHandler(parser, startNamespaceHandler, endNamespaceHandler);
-    XML_SetCharacterDataHandler(parser, characterDataHandler);
-    XML_SetCommentHandler(parser, commentDataHandler);
-
-    char buffer[1024];
-    while (!in->eof()) {
-        in->read(buffer, sizeof(buffer) / sizeof(buffer[0]));
-        if (in->bad() && !in->eof()) {
-            stack.root = {};
-            diag->error(DiagMessage(source) << strerror(errno));
-            break;
-        }
-
-        if (XML_Parse(parser, buffer, in->gcount(), in->eof()) == XML_STATUS_ERROR) {
-            stack.root = {};
-            diag->error(DiagMessage(source.withLine(XML_GetCurrentLineNumber(parser)))
-                        << XML_ErrorString(XML_GetErrorCode(parser)));
-            break;
-        }
-    }
-
-    XML_ParserFree(parser);
-    if (stack.root) {
-        return util::make_unique<XmlResource>(ResourceFile{ {}, {}, source }, std::move(stack.root));
-    }
-    return {};
-}
-
-static void copyAttributes(Element* el, android::ResXMLParser* parser) {
-    const size_t attrCount = parser->getAttributeCount();
-    if (attrCount > 0) {
-        el->attributes.reserve(attrCount);
-        for (size_t i = 0; i < attrCount; i++) {
-            Attribute attr;
-            size_t len;
-            const char16_t* str16 = parser->getAttributeNamespace(i, &len);
-            if (str16) {
-                attr.namespaceUri = util::utf16ToUtf8(StringPiece16(str16, len));
-            }
-
-            str16 = parser->getAttributeName(i, &len);
-            if (str16) {
-                attr.name = util::utf16ToUtf8(StringPiece16(str16, len));
-            }
-
-            str16 = parser->getAttributeStringValue(i, &len);
-            if (str16) {
-                attr.value = util::utf16ToUtf8(StringPiece16(str16, len));
-            }
-            el->attributes.push_back(std::move(attr));
-        }
-    }
-}
-
-std::unique_ptr<XmlResource> inflate(const void* data, size_t dataLen, IDiagnostics* diag,
+std::unique_ptr<XmlResource> Inflate(std::istream* in, IDiagnostics* diag,
                                      const Source& source) {
-    // We import the android namespace because on Windows NO_ERROR is a macro, not an enum, which
-    // causes errors when qualifying it with android::
-    using namespace android;
+  Stack stack;
 
-    std::unique_ptr<Node> root;
-    std::stack<Node*> nodeStack;
+  XML_Parser parser = XML_ParserCreateNS(nullptr, kXmlNamespaceSep);
+  XML_SetUserData(parser, &stack);
+  XML_UseParserAsHandlerArg(parser);
+  XML_SetElementHandler(parser, StartElementHandler, EndElementHandler);
+  XML_SetNamespaceDeclHandler(parser, StartNamespaceHandler,
+                              EndNamespaceHandler);
+  XML_SetCharacterDataHandler(parser, CharacterDataHandler);
+  XML_SetCommentHandler(parser, CommentDataHandler);
 
-    ResXMLTree tree;
-    if (tree.setTo(data, dataLen) != NO_ERROR) {
-        return {};
+  char buffer[1024];
+  while (!in->eof()) {
+    in->read(buffer, sizeof(buffer) / sizeof(buffer[0]));
+    if (in->bad() && !in->eof()) {
+      stack.root = {};
+      diag->Error(DiagMessage(source) << strerror(errno));
+      break;
     }
 
-    ResXMLParser::event_code_t code;
-    while ((code = tree.next()) != ResXMLParser::BAD_DOCUMENT &&
-            code != ResXMLParser::END_DOCUMENT) {
-        std::unique_ptr<Node> newNode;
-        switch (code) {
-            case ResXMLParser::START_NAMESPACE: {
-                std::unique_ptr<Namespace> node = util::make_unique<Namespace>();
-                size_t len;
-                const char16_t* str16 = tree.getNamespacePrefix(&len);
-                if (str16) {
-                    node->namespacePrefix = util::utf16ToUtf8(StringPiece16(str16, len));
-                }
+    if (XML_Parse(parser, buffer, in->gcount(), in->eof()) ==
+        XML_STATUS_ERROR) {
+      stack.root = {};
+      diag->Error(DiagMessage(source.WithLine(XML_GetCurrentLineNumber(parser)))
+                  << XML_ErrorString(XML_GetErrorCode(parser)));
+      break;
+    }
+  }
 
-                str16 = tree.getNamespaceUri(&len);
-                if (str16) {
-                    node->namespaceUri = util::utf16ToUtf8(StringPiece16(str16, len));
-                }
-                newNode = std::move(node);
-                break;
-            }
+  XML_ParserFree(parser);
+  if (stack.root) {
+    return util::make_unique<XmlResource>(ResourceFile{{}, {}, source},
+                                          std::move(stack.root));
+  }
+  return {};
+}
 
-            case ResXMLParser::START_TAG: {
-                std::unique_ptr<Element> node = util::make_unique<Element>();
-                size_t len;
-                const char16_t* str16 = tree.getElementNamespace(&len);
-                if (str16) {
-                    node->namespaceUri = util::utf16ToUtf8(StringPiece16(str16, len));
-                }
+static void CopyAttributes(Element* el, android::ResXMLParser* parser) {
+  const size_t attr_count = parser->getAttributeCount();
+  if (attr_count > 0) {
+    el->attributes.reserve(attr_count);
+    for (size_t i = 0; i < attr_count; i++) {
+      Attribute attr;
+      size_t len;
+      const char16_t* str16 = parser->getAttributeNamespace(i, &len);
+      if (str16) {
+        attr.namespace_uri = util::Utf16ToUtf8(StringPiece16(str16, len));
+      }
 
-                str16 = tree.getElementName(&len);
-                if (str16) {
-                    node->name = util::utf16ToUtf8(StringPiece16(str16, len));
-                }
+      str16 = parser->getAttributeName(i, &len);
+      if (str16) {
+        attr.name = util::Utf16ToUtf8(StringPiece16(str16, len));
+      }
 
-                copyAttributes(node.get(), &tree);
+      str16 = parser->getAttributeStringValue(i, &len);
+      if (str16) {
+        attr.value = util::Utf16ToUtf8(StringPiece16(str16, len));
+      }
+      el->attributes.push_back(std::move(attr));
+    }
+  }
+}
 
-                newNode = std::move(node);
-                break;
-            }
+std::unique_ptr<XmlResource> Inflate(const void* data, size_t data_len,
+                                     IDiagnostics* diag, const Source& source) {
+  // We import the android namespace because on Windows NO_ERROR is a macro, not
+  // an enum, which
+  // causes errors when qualifying it with android::
+  using namespace android;
 
-            case ResXMLParser::TEXT: {
-                std::unique_ptr<Text> node = util::make_unique<Text>();
-                size_t len;
-                const char16_t* str16 = tree.getText(&len);
-                if (str16) {
-                    node->text = util::utf16ToUtf8(StringPiece16(str16, len));
-                }
-                newNode = std::move(node);
-                break;
-            }
+  std::unique_ptr<Node> root;
+  std::stack<Node*> node_stack;
 
-            case ResXMLParser::END_NAMESPACE:
-            case ResXMLParser::END_TAG:
-                assert(!nodeStack.empty());
-                nodeStack.pop();
-                break;
+  ResXMLTree tree;
+  if (tree.setTo(data, data_len) != NO_ERROR) {
+    return {};
+  }
 
-            default:
-                assert(false);
-                break;
+  ResXMLParser::event_code_t code;
+  while ((code = tree.next()) != ResXMLParser::BAD_DOCUMENT &&
+         code != ResXMLParser::END_DOCUMENT) {
+    std::unique_ptr<Node> new_node;
+    switch (code) {
+      case ResXMLParser::START_NAMESPACE: {
+        std::unique_ptr<Namespace> node = util::make_unique<Namespace>();
+        size_t len;
+        const char16_t* str16 = tree.getNamespacePrefix(&len);
+        if (str16) {
+          node->namespace_prefix = util::Utf16ToUtf8(StringPiece16(str16, len));
         }
 
-        if (newNode) {
-            newNode->lineNumber = tree.getLineNumber();
-
-            Node* thisNode = newNode.get();
-            if (!root) {
-                assert(nodeStack.empty());
-                root = std::move(newNode);
-            } else {
-                assert(!nodeStack.empty());
-                nodeStack.top()->addChild(std::move(newNode));
-            }
-
-            if (!nodeCast<Text>(thisNode)) {
-                nodeStack.push(thisNode);
-            }
+        str16 = tree.getNamespaceUri(&len);
+        if (str16) {
+          node->namespace_uri = util::Utf16ToUtf8(StringPiece16(str16, len));
         }
-    }
-    return util::make_unique<XmlResource>(ResourceFile{}, std::move(root));
-}
+        new_node = std::move(node);
+        break;
+      }
 
-std::unique_ptr<Node> Namespace::clone() {
-    auto ns = util::make_unique<Namespace>();
-    ns->comment = comment;
-    ns->lineNumber = lineNumber;
-    ns->columnNumber = columnNumber;
-    ns->namespacePrefix = namespacePrefix;
-    ns->namespaceUri = namespaceUri;
-
-    ns->children.reserve(children.size());
-    for (const std::unique_ptr<xml::Node>& child : children) {
-        ns->addChild(child->clone());
-    }
-    return std::move(ns);
-}
-
-Element* findRootElement(XmlResource* doc) {
-    return findRootElement(doc->root.get());
-}
-
-Element* findRootElement(Node* node) {
-    if (!node) {
-        return nullptr;
-    }
-
-    Element* el = nullptr;
-    while ((el = nodeCast<Element>(node)) == nullptr) {
-        if (node->children.empty()) {
-            return nullptr;
+      case ResXMLParser::START_TAG: {
+        std::unique_ptr<Element> node = util::make_unique<Element>();
+        size_t len;
+        const char16_t* str16 = tree.getElementNamespace(&len);
+        if (str16) {
+          node->namespace_uri = util::Utf16ToUtf8(StringPiece16(str16, len));
         }
-        // We are looking for the first element, and namespaces can only have one child.
-        node = node->children.front().get();
-    }
-    return el;
-}
 
-void Node::addChild(std::unique_ptr<Node> child) {
-    child->parent = this;
-    children.push_back(std::move(child));
-}
-
-Attribute* Element::findAttribute(const StringPiece& ns, const StringPiece& name) {
-    for (auto& attr : attributes) {
-        if (ns == attr.namespaceUri && name == attr.name) {
-            return &attr;
+        str16 = tree.getElementName(&len);
+        if (str16) {
+          node->name = util::Utf16ToUtf8(StringPiece16(str16, len));
         }
+
+        CopyAttributes(node.get(), &tree);
+
+        new_node = std::move(node);
+        break;
+      }
+
+      case ResXMLParser::TEXT: {
+        std::unique_ptr<Text> node = util::make_unique<Text>();
+        size_t len;
+        const char16_t* str16 = tree.getText(&len);
+        if (str16) {
+          node->text = util::Utf16ToUtf8(StringPiece16(str16, len));
+        }
+        new_node = std::move(node);
+        break;
+      }
+
+      case ResXMLParser::END_NAMESPACE:
+      case ResXMLParser::END_TAG:
+        CHECK(!node_stack.empty());
+        node_stack.pop();
+        break;
+
+      default:
+        LOG(FATAL) << "unhandled XML chunk type";
+        break;
     }
+
+    if (new_node) {
+      new_node->line_number = tree.getLineNumber();
+
+      Node* this_node = new_node.get();
+      if (!root) {
+        CHECK(node_stack.empty()) << "node stack should be empty";
+        root = std::move(new_node);
+      } else {
+        CHECK(!node_stack.empty()) << "node stack should not be empty";
+        node_stack.top()->AddChild(std::move(new_node));
+      }
+
+      if (!NodeCast<Text>(this_node)) {
+        node_stack.push(this_node);
+      }
+    }
+  }
+  return util::make_unique<XmlResource>(ResourceFile{}, std::move(root));
+}
+
+std::unique_ptr<Node> Namespace::Clone() {
+  auto ns = util::make_unique<Namespace>();
+  ns->comment = comment;
+  ns->line_number = line_number;
+  ns->column_number = column_number;
+  ns->namespace_prefix = namespace_prefix;
+  ns->namespace_uri = namespace_uri;
+
+  ns->children.reserve(children.size());
+  for (const std::unique_ptr<xml::Node>& child : children) {
+    ns->AddChild(child->Clone());
+  }
+  return std::move(ns);
+}
+
+Element* FindRootElement(XmlResource* doc) {
+  return FindRootElement(doc->root.get());
+}
+
+Element* FindRootElement(Node* node) {
+  if (!node) {
     return nullptr;
-}
+  }
 
-Element* Element::findChild(const StringPiece& ns, const StringPiece& name) {
-    return findChildWithAttribute(ns, name, {}, {}, {});
-}
-
-Element* Element::findChildWithAttribute(const StringPiece& ns, const StringPiece& name,
-                                         const StringPiece& attrNs, const StringPiece& attrName,
-                                         const StringPiece& attrValue) {
-    for (auto& childNode : children) {
-        Node* child = childNode.get();
-        while (nodeCast<Namespace>(child)) {
-            if (child->children.empty()) {
-                break;
-            }
-            child = child->children[0].get();
-        }
-
-        if (Element* el = nodeCast<Element>(child)) {
-            if (ns == el->namespaceUri && name == el->name) {
-                if (attrNs.empty() && attrName.empty()) {
-                    return el;
-                }
-
-                Attribute* attr = el->findAttribute(attrNs, attrName);
-                if (attr && attrValue == attr->value) {
-                    return el;
-                }
-            }
-        }
+  Element* el = nullptr;
+  while ((el = NodeCast<Element>(node)) == nullptr) {
+    if (node->children.empty()) {
+      return nullptr;
     }
-    return nullptr;
+    // We are looking for the first element, and namespaces can only have one
+    // child.
+    node = node->children.front().get();
+  }
+  return el;
 }
 
-std::vector<Element*> Element::getChildElements() {
-    std::vector<Element*> elements;
-    for (auto& childNode : children) {
-        Node* child = childNode.get();
-        while (nodeCast<Namespace>(child)) {
-            if (child->children.empty()) {
-                break;
-            }
-            child = child->children[0].get();
-        }
+void Node::AddChild(std::unique_ptr<Node> child) {
+  child->parent = this;
+  children.push_back(std::move(child));
+}
 
-        if (Element* el = nodeCast<Element>(child)) {
-            elements.push_back(el);
-        }
+Attribute* Element::FindAttribute(const StringPiece& ns,
+                                  const StringPiece& name) {
+  for (auto& attr : attributes) {
+    if (ns == attr.namespace_uri && name == attr.name) {
+      return &attr;
     }
-    return elements;
+  }
+  return nullptr;
 }
 
-std::unique_ptr<Node> Element::clone() {
-    auto el = util::make_unique<Element>();
-    el->comment = comment;
-    el->lineNumber = lineNumber;
-    el->columnNumber = columnNumber;
-    el->name = name;
-    el->namespaceUri = namespaceUri;
+Element* Element::FindChild(const StringPiece& ns, const StringPiece& name) {
+  return FindChildWithAttribute(ns, name, {}, {}, {});
+}
 
-    el->attributes.reserve(attributes.size());
-    for (xml::Attribute& attr : attributes) {
-        // Don't copy compiled values or attributes.
-        el->attributes.push_back(xml::Attribute{ attr.namespaceUri, attr.name, attr.value });
+Element* Element::FindChildWithAttribute(const StringPiece& ns,
+                                         const StringPiece& name,
+                                         const StringPiece& attr_ns,
+                                         const StringPiece& attr_name,
+                                         const StringPiece& attr_value) {
+  for (auto& child_node : children) {
+    Node* child = child_node.get();
+    while (NodeCast<Namespace>(child)) {
+      if (child->children.empty()) {
+        break;
+      }
+      child = child->children[0].get();
     }
 
-    el->children.reserve(children.size());
-    for (const std::unique_ptr<xml::Node>& child : children) {
-        el->addChild(child->clone());
+    if (Element* el = NodeCast<Element>(child)) {
+      if (ns == el->namespace_uri && name == el->name) {
+        if (attr_ns.empty() && attr_name.empty()) {
+          return el;
+        }
+
+        Attribute* attr = el->FindAttribute(attr_ns, attr_name);
+        if (attr && attr_value == attr->value) {
+          return el;
+        }
+      }
     }
-    return std::move(el);
+  }
+  return nullptr;
 }
 
-std::unique_ptr<Node> Text::clone() {
-    auto t = util::make_unique<Text>();
-    t->comment = comment;
-    t->lineNumber = lineNumber;
-    t->columnNumber = columnNumber;
-    t->text = text;
-    return std::move(t);
+std::vector<Element*> Element::GetChildElements() {
+  std::vector<Element*> elements;
+  for (auto& child_node : children) {
+    Node* child = child_node.get();
+    while (NodeCast<Namespace>(child)) {
+      if (child->children.empty()) {
+        break;
+      }
+      child = child->children[0].get();
+    }
+
+    if (Element* el = NodeCast<Element>(child)) {
+      elements.push_back(el);
+    }
+  }
+  return elements;
 }
 
-void PackageAwareVisitor::visit(Namespace* ns) {
-   bool added = false;
-   if (Maybe<ExtractedPackage> maybePackage = extractPackageFromNamespace(ns->namespaceUri)) {
-       ExtractedPackage& package = maybePackage.value();
-       mPackageDecls.push_back(PackageDecl{ ns->namespacePrefix, std::move(package) });
-       added = true;
-   }
+std::unique_ptr<Node> Element::Clone() {
+  auto el = util::make_unique<Element>();
+  el->comment = comment;
+  el->line_number = line_number;
+  el->column_number = column_number;
+  el->name = name;
+  el->namespace_uri = namespace_uri;
 
-   Visitor::visit(ns);
+  el->attributes.reserve(attributes.size());
+  for (xml::Attribute& attr : attributes) {
+    // Don't copy compiled values or attributes.
+    el->attributes.push_back(
+        xml::Attribute{attr.namespace_uri, attr.name, attr.value});
+  }
 
-   if (added) {
-       mPackageDecls.pop_back();
-   }
+  el->children.reserve(children.size());
+  for (const std::unique_ptr<xml::Node>& child : children) {
+    el->AddChild(child->Clone());
+  }
+  return std::move(el);
 }
 
-Maybe<ExtractedPackage> PackageAwareVisitor::transformPackageAlias(
-       const StringPiece& alias, const StringPiece& localPackage) const {
-   if (alias.empty()) {
-       return ExtractedPackage{ localPackage.toString(), false /* private */ };
-   }
-
-   const auto rend = mPackageDecls.rend();
-   for (auto iter = mPackageDecls.rbegin(); iter != rend; ++iter) {
-       if (alias == iter->prefix) {
-           if (iter->package.package.empty()) {
-               return ExtractedPackage{ localPackage.toString(),
-                                              iter->package.privateNamespace };
-           }
-           return iter->package;
-       }
-   }
-   return {};
+std::unique_ptr<Node> Text::Clone() {
+  auto t = util::make_unique<Text>();
+  t->comment = comment;
+  t->line_number = line_number;
+  t->column_number = column_number;
+  t->text = text;
+  return std::move(t);
 }
 
-} // namespace xml
-} // namespace aapt
+void PackageAwareVisitor::Visit(Namespace* ns) {
+  bool added = false;
+  if (Maybe<ExtractedPackage> maybe_package =
+          ExtractPackageFromNamespace(ns->namespace_uri)) {
+    ExtractedPackage& package = maybe_package.value();
+    package_decls_.push_back(
+        PackageDecl{ns->namespace_prefix, std::move(package)});
+    added = true;
+  }
+
+  Visitor::Visit(ns);
+
+  if (added) {
+    package_decls_.pop_back();
+  }
+}
+
+Maybe<ExtractedPackage> PackageAwareVisitor::TransformPackageAlias(
+    const StringPiece& alias, const StringPiece& local_package) const {
+  if (alias.empty()) {
+    return ExtractedPackage{local_package.ToString(), false /* private */};
+  }
+
+  const auto rend = package_decls_.rend();
+  for (auto iter = package_decls_.rbegin(); iter != rend; ++iter) {
+    if (alias == iter->prefix) {
+      if (iter->package.package.empty()) {
+        return ExtractedPackage{local_package.ToString(),
+                                iter->package.private_namespace};
+      }
+      return iter->package;
+    }
+  }
+  return {};
+}
+
+}  // namespace xml
+}  // namespace aapt
diff --git a/tools/aapt2/xml/XmlDom.h b/tools/aapt2/xml/XmlDom.h
index 932303edf41a8..e771d8735ac04 100644
--- a/tools/aapt2/xml/XmlDom.h
+++ b/tools/aapt2/xml/XmlDom.h
@@ -17,6 +17,11 @@
 #ifndef AAPT_XML_DOM_H
 #define AAPT_XML_DOM_H
 
+#include <istream>
+#include <memory>
+#include <string>
+#include <vector>
+
 #include "Diagnostics.h"
 #include "Resource.h"
 #include "ResourceValues.h"
@@ -24,11 +29,6 @@
 #include "util/Util.h"
 #include "xml/XmlUtil.h"
 
-#include <istream>
-#include <memory>
-#include <string>
-#include <vector>
-
 namespace aapt {
 namespace xml {
 
@@ -40,16 +40,16 @@ class RawVisitor;
 class Node {
  public:
   Node* parent = nullptr;
-  size_t lineNumber = 0;
-  size_t columnNumber = 0;
+  size_t line_number = 0;
+  size_t column_number = 0;
   std::string comment;
   std::vector<std::unique_ptr<Node>> children;
 
   virtual ~Node() = default;
 
-  void addChild(std::unique_ptr<Node> child);
-  virtual void accept(RawVisitor* visitor) = 0;
-  virtual std::unique_ptr<Node> clone() = 0;
+  void AddChild(std::unique_ptr<Node> child);
+  virtual void Accept(RawVisitor* visitor) = 0;
+  virtual std::unique_ptr<Node> Clone() = 0;
 };
 
 /**
@@ -59,7 +59,7 @@ class Node {
 template <typename Derived>
 class BaseNode : public Node {
  public:
-  virtual void accept(RawVisitor* visitor) override;
+  virtual void Accept(RawVisitor* visitor) override;
 };
 
 /**
@@ -67,10 +67,10 @@ class BaseNode : public Node {
  */
 class Namespace : public BaseNode<Namespace> {
  public:
-  std::string namespacePrefix;
-  std::string namespaceUri;
+  std::string namespace_prefix;
+  std::string namespace_uri;
 
-  std::unique_ptr<Node> clone() override;
+  std::unique_ptr<Node> Clone() override;
 };
 
 struct AaptAttribute {
@@ -82,12 +82,12 @@ struct AaptAttribute {
  * An XML attribute.
  */
 struct Attribute {
-  std::string namespaceUri;
+  std::string namespace_uri;
   std::string name;
   std::string value;
 
-  Maybe<AaptAttribute> compiledAttribute;
-  std::unique_ptr<Item> compiledValue;
+  Maybe<AaptAttribute> compiled_attribute;
+  std::unique_ptr<Item> compiled_value;
 };
 
 /**
@@ -95,19 +95,19 @@ struct Attribute {
  */
 class Element : public BaseNode<Element> {
  public:
-  std::string namespaceUri;
+  std::string namespace_uri;
   std::string name;
   std::vector<Attribute> attributes;
 
-  Attribute* findAttribute(const StringPiece& ns, const StringPiece& name);
-  xml::Element* findChild(const StringPiece& ns, const StringPiece& name);
-  xml::Element* findChildWithAttribute(const StringPiece& ns,
+  Attribute* FindAttribute(const StringPiece& ns, const StringPiece& name);
+  xml::Element* FindChild(const StringPiece& ns, const StringPiece& name);
+  xml::Element* FindChildWithAttribute(const StringPiece& ns,
                                        const StringPiece& name,
-                                       const StringPiece& attrNs,
-                                       const StringPiece& attrName,
-                                       const StringPiece& attrValue);
-  std::vector<xml::Element*> getChildElements();
-  std::unique_ptr<Node> clone() override;
+                                       const StringPiece& attr_ns,
+                                       const StringPiece& attr_name,
+                                       const StringPiece& attr_value);
+  std::vector<xml::Element*> GetChildElements();
+  std::unique_ptr<Node> Clone() override;
 };
 
 /**
@@ -117,7 +117,7 @@ class Text : public BaseNode<Text> {
  public:
   std::string text;
 
-  std::unique_ptr<Node> clone() override;
+  std::unique_ptr<Node> Clone() override;
 };
 
 /**
@@ -133,18 +133,18 @@ class XmlResource {
  * Inflates an XML DOM from a text stream, logging errors to the logger.
  * Returns the root node on success, or nullptr on failure.
  */
-std::unique_ptr<XmlResource> inflate(std::istream* in, IDiagnostics* diag,
+std::unique_ptr<XmlResource> Inflate(std::istream* in, IDiagnostics* diag,
                                      const Source& source);
 
 /**
  * Inflates an XML DOM from a binary ResXMLTree, logging errors to the logger.
  * Returns the root node on success, or nullptr on failure.
  */
-std::unique_ptr<XmlResource> inflate(const void* data, size_t dataLen,
+std::unique_ptr<XmlResource> Inflate(const void* data, size_t data_len,
                                      IDiagnostics* diag, const Source& source);
 
-Element* findRootElement(XmlResource* doc);
-Element* findRootElement(Node* node);
+Element* FindRootElement(XmlResource* doc);
+Element* FindRootElement(Node* node);
 
 /**
  * A visitor interface for the different XML Node subtypes. This will not
@@ -155,9 +155,9 @@ class RawVisitor {
  public:
   virtual ~RawVisitor() = default;
 
-  virtual void visit(Namespace* node) {}
-  virtual void visit(Element* node) {}
-  virtual void visit(Text* text) {}
+  virtual void Visit(Namespace* node) {}
+  virtual void Visit(Element* node) {}
+  virtual void Visit(Text* text) {}
 };
 
 /**
@@ -165,17 +165,17 @@ class RawVisitor {
  */
 class Visitor : public RawVisitor {
  public:
-  using RawVisitor::visit;
+  using RawVisitor::Visit;
 
-  void visit(Namespace* node) override { visitChildren(node); }
+  void Visit(Namespace* node) override { VisitChildren(node); }
 
-  void visit(Element* node) override { visitChildren(node); }
+  void Visit(Element* node) override { VisitChildren(node); }
 
-  void visit(Text* text) override { visitChildren(text); }
+  void Visit(Text* text) override { VisitChildren(text); }
 
-  void visitChildren(Node* node) {
+  void VisitChildren(Node* node) {
     for (auto& child : node->children) {
-      child->accept(this);
+      child->Accept(this);
     }
   }
 };
@@ -185,11 +185,12 @@ class Visitor : public RawVisitor {
  */
 class PackageAwareVisitor : public Visitor, public IPackageDeclStack {
  public:
-  using Visitor::visit;
+  using Visitor::Visit;
 
-  void visit(Namespace* ns) override;
-  Maybe<ExtractedPackage> transformPackageAlias(
-      const StringPiece& alias, const StringPiece& localPackage) const override;
+  void Visit(Namespace* ns) override;
+  Maybe<ExtractedPackage> TransformPackageAlias(
+      const StringPiece& alias,
+      const StringPiece& local_package) const override;
 
  private:
   struct PackageDecl {
@@ -197,30 +198,30 @@ class PackageAwareVisitor : public Visitor, public IPackageDeclStack {
     ExtractedPackage package;
   };
 
-  std::vector<PackageDecl> mPackageDecls;
+  std::vector<PackageDecl> package_decls_;
 };
 
 // Implementations
 
 template <typename Derived>
-void BaseNode<Derived>::accept(RawVisitor* visitor) {
-  visitor->visit(static_cast<Derived*>(this));
+void BaseNode<Derived>::Accept(RawVisitor* visitor) {
+  visitor->Visit(static_cast<Derived*>(this));
 }
 
 template <typename T>
 class NodeCastImpl : public RawVisitor {
  public:
-  using RawVisitor::visit;
+  using RawVisitor::Visit;
 
   T* value = nullptr;
 
-  void visit(T* v) override { value = v; }
+  void Visit(T* v) override { value = v; }
 };
 
 template <typename T>
-T* nodeCast(Node* node) {
+T* NodeCast(Node* node) {
   NodeCastImpl<T> visitor;
-  node->accept(&visitor);
+  node->Accept(&visitor);
   return visitor.value;
 }
 
diff --git a/tools/aapt2/xml/XmlDom_test.cpp b/tools/aapt2/xml/XmlDom_test.cpp
index 1909f75ad0c32..a414afe92fc03 100644
--- a/tools/aapt2/xml/XmlDom_test.cpp
+++ b/tools/aapt2/xml/XmlDom_test.cpp
@@ -16,17 +16,19 @@
 
 #include "xml/XmlDom.h"
 
-#include <gtest/gtest.h>
 #include <sstream>
 #include <string>
 
+#include "test/Test.h"
+
 namespace aapt {
 
-constexpr const char* kXmlPreamble = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n";
+constexpr const char* kXmlPreamble =
+    "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n";
 
 TEST(XmlDomTest, Inflate) {
-    std::stringstream in(kXmlPreamble);
-    in << R"EOF(
+  std::stringstream in(kXmlPreamble);
+  in << R"EOF(
         <Layout xmlns:android="http://schemas.android.com/apk/res/android"
                 android:layout_width="match_parent"
                 android:layout_height="wrap_content">
@@ -36,15 +38,15 @@ TEST(XmlDomTest, Inflate) {
         </Layout>
     )EOF";
 
-    const Source source = { "test.xml" };
-    StdErrDiagnostics diag;
-    std::unique_ptr<xml::XmlResource> doc = xml::inflate(&in, &diag, source);
-    ASSERT_NE(doc, nullptr);
+  const Source source = {"test.xml"};
+  StdErrDiagnostics diag;
+  std::unique_ptr<xml::XmlResource> doc = xml::Inflate(&in, &diag, source);
+  ASSERT_NE(doc, nullptr);
 
-    xml::Namespace* ns = xml::nodeCast<xml::Namespace>(doc->root.get());
-    ASSERT_NE(ns, nullptr);
-    EXPECT_EQ(ns->namespaceUri, xml::kSchemaAndroid);
-    EXPECT_EQ(ns->namespacePrefix, "android");
+  xml::Namespace* ns = xml::NodeCast<xml::Namespace>(doc->root.get());
+  ASSERT_NE(ns, nullptr);
+  EXPECT_EQ(ns->namespace_uri, xml::kSchemaAndroid);
+  EXPECT_EQ(ns->namespace_prefix, "android");
 }
 
-} // namespace aapt
+}  // namespace aapt
diff --git a/tools/aapt2/xml/XmlPullParser.cpp b/tools/aapt2/xml/XmlPullParser.cpp
index 4a944f1b1e480..e59fa86788cd0 100644
--- a/tools/aapt2/xml/XmlPullParser.cpp
+++ b/tools/aapt2/xml/XmlPullParser.cpp
@@ -14,295 +14,295 @@
  * limitations under the License.
  */
 
+#include <iostream>
+#include <string>
+
 #include "util/Maybe.h"
 #include "util/Util.h"
 #include "xml/XmlPullParser.h"
 #include "xml/XmlUtil.h"
 
-#include <iostream>
-#include <string>
-
 namespace aapt {
 namespace xml {
 
 constexpr char kXmlNamespaceSep = 1;
 
-XmlPullParser::XmlPullParser(std::istream& in) : mIn(in), mEmpty(), mDepth(0) {
-    mParser = XML_ParserCreateNS(nullptr, kXmlNamespaceSep);
-    XML_SetUserData(mParser, this);
-    XML_SetElementHandler(mParser, startElementHandler, endElementHandler);
-    XML_SetNamespaceDeclHandler(mParser, startNamespaceHandler, endNamespaceHandler);
-    XML_SetCharacterDataHandler(mParser, characterDataHandler);
-    XML_SetCommentHandler(mParser, commentDataHandler);
-    mEventQueue.push(EventData{ Event::kStartDocument, 0, mDepth++ });
+XmlPullParser::XmlPullParser(std::istream& in) : in_(in), empty_(), depth_(0) {
+  parser_ = XML_ParserCreateNS(nullptr, kXmlNamespaceSep);
+  XML_SetUserData(parser_, this);
+  XML_SetElementHandler(parser_, StartElementHandler, EndElementHandler);
+  XML_SetNamespaceDeclHandler(parser_, StartNamespaceHandler,
+                              EndNamespaceHandler);
+  XML_SetCharacterDataHandler(parser_, CharacterDataHandler);
+  XML_SetCommentHandler(parser_, CommentDataHandler);
+  event_queue_.push(EventData{Event::kStartDocument, 0, depth_++});
 }
 
-XmlPullParser::~XmlPullParser() {
-    XML_ParserFree(mParser);
-}
+XmlPullParser::~XmlPullParser() { XML_ParserFree(parser_); }
 
-XmlPullParser::Event XmlPullParser::next() {
-    const Event currentEvent = getEvent();
-    if (currentEvent == Event::kBadDocument || currentEvent == Event::kEndDocument) {
-        return currentEvent;
+XmlPullParser::Event XmlPullParser::Next() {
+  const Event currentEvent = event();
+  if (currentEvent == Event::kBadDocument ||
+      currentEvent == Event::kEndDocument) {
+    return currentEvent;
+  }
+
+  event_queue_.pop();
+  while (event_queue_.empty()) {
+    in_.read(buffer_, sizeof(buffer_) / sizeof(*buffer_));
+
+    const bool done = in_.eof();
+    if (in_.bad() && !done) {
+      error_ = strerror(errno);
+      event_queue_.push(EventData{Event::kBadDocument});
+      continue;
     }
 
-    mEventQueue.pop();
-    while (mEventQueue.empty()) {
-        mIn.read(mBuffer, sizeof(mBuffer) / sizeof(*mBuffer));
-
-        const bool done = mIn.eof();
-        if (mIn.bad() && !done) {
-            mLastError = strerror(errno);
-            mEventQueue.push(EventData{ Event::kBadDocument });
-            continue;
-        }
-
-        if (XML_Parse(mParser, mBuffer, mIn.gcount(), done) == XML_STATUS_ERROR) {
-            mLastError = XML_ErrorString(XML_GetErrorCode(mParser));
-            mEventQueue.push(EventData{ Event::kBadDocument });
-            continue;
-        }
-
-        if (done) {
-            mEventQueue.push(EventData{ Event::kEndDocument, 0, 0 });
-        }
+    if (XML_Parse(parser_, buffer_, in_.gcount(), done) == XML_STATUS_ERROR) {
+      error_ = XML_ErrorString(XML_GetErrorCode(parser_));
+      event_queue_.push(EventData{Event::kBadDocument});
+      continue;
     }
 
-    Event event = getEvent();
-
-    // Record namespace prefixes and package names so that we can do our own
-    // handling of references that use namespace aliases.
-    if (event == Event::kStartNamespace || event == Event::kEndNamespace) {
-        Maybe<ExtractedPackage> result = extractPackageFromNamespace(getNamespaceUri());
-        if (event == Event::kStartNamespace) {
-            if (result) {
-                mPackageAliases.emplace_back(
-                        PackageDecl{ getNamespacePrefix(), std::move(result.value()) });
-            }
-        } else {
-            if (result) {
-                mPackageAliases.pop_back();
-            }
-        }
+    if (done) {
+      event_queue_.push(EventData{Event::kEndDocument, 0, 0});
     }
+  }
 
-    return event;
-}
+  Event next_event = event();
 
-XmlPullParser::Event XmlPullParser::getEvent() const {
-    return mEventQueue.front().event;
-}
-
-const std::string& XmlPullParser::getLastError() const {
-    return mLastError;
-}
-
-const std::string& XmlPullParser::getComment() const {
-    return mEventQueue.front().data1;
-}
-
-size_t XmlPullParser::getLineNumber() const {
-    return mEventQueue.front().lineNumber;
-}
-
-size_t XmlPullParser::getDepth() const {
-    return mEventQueue.front().depth;
-}
-
-const std::string& XmlPullParser::getText() const {
-    if (getEvent() != Event::kText) {
-        return mEmpty;
+  // Record namespace prefixes and package names so that we can do our own
+  // handling of references that use namespace aliases.
+  if (next_event == Event::kStartNamespace ||
+      next_event == Event::kEndNamespace) {
+    Maybe<ExtractedPackage> result =
+        ExtractPackageFromNamespace(namespace_uri());
+    if (next_event == Event::kStartNamespace) {
+      if (result) {
+        package_aliases_.emplace_back(
+            PackageDecl{namespace_prefix(), std::move(result.value())});
+      }
+    } else {
+      if (result) {
+        package_aliases_.pop_back();
+      }
     }
-    return mEventQueue.front().data1;
+  }
+
+  return next_event;
 }
 
-const std::string& XmlPullParser::getNamespacePrefix() const {
-    const Event currentEvent = getEvent();
-    if (currentEvent != Event::kStartNamespace && currentEvent != Event::kEndNamespace) {
-        return mEmpty;
+XmlPullParser::Event XmlPullParser::event() const {
+  return event_queue_.front().event;
+}
+
+const std::string& XmlPullParser::error() const { return error_; }
+
+const std::string& XmlPullParser::comment() const {
+  return event_queue_.front().data1;
+}
+
+size_t XmlPullParser::line_number() const {
+  return event_queue_.front().line_number;
+}
+
+size_t XmlPullParser::depth() const { return event_queue_.front().depth; }
+
+const std::string& XmlPullParser::text() const {
+  if (event() != Event::kText) {
+    return empty_;
+  }
+  return event_queue_.front().data1;
+}
+
+const std::string& XmlPullParser::namespace_prefix() const {
+  const Event current_event = event();
+  if (current_event != Event::kStartNamespace &&
+      current_event != Event::kEndNamespace) {
+    return empty_;
+  }
+  return event_queue_.front().data1;
+}
+
+const std::string& XmlPullParser::namespace_uri() const {
+  const Event current_event = event();
+  if (current_event != Event::kStartNamespace &&
+      current_event != Event::kEndNamespace) {
+    return empty_;
+  }
+  return event_queue_.front().data2;
+}
+
+Maybe<ExtractedPackage> XmlPullParser::TransformPackageAlias(
+    const StringPiece& alias, const StringPiece& local_package) const {
+  if (alias.empty()) {
+    return ExtractedPackage{local_package.ToString(), false /* private */};
+  }
+
+  const auto end_iter = package_aliases_.rend();
+  for (auto iter = package_aliases_.rbegin(); iter != end_iter; ++iter) {
+    if (alias == iter->prefix) {
+      if (iter->package.package.empty()) {
+        return ExtractedPackage{local_package.ToString(),
+                                iter->package.private_namespace};
+      }
+      return iter->package;
     }
-    return mEventQueue.front().data1;
+  }
+  return {};
 }
 
-const std::string& XmlPullParser::getNamespaceUri() const {
-    const Event currentEvent = getEvent();
-    if (currentEvent != Event::kStartNamespace && currentEvent != Event::kEndNamespace) {
-        return mEmpty;
-    }
-    return mEventQueue.front().data2;
+const std::string& XmlPullParser::element_namespace() const {
+  const Event current_event = event();
+  if (current_event != Event::kStartElement &&
+      current_event != Event::kEndElement) {
+    return empty_;
+  }
+  return event_queue_.front().data1;
 }
 
-Maybe<ExtractedPackage> XmlPullParser::transformPackageAlias(
-        const StringPiece& alias, const StringPiece& localPackage) const {
-    if (alias.empty()) {
-        return ExtractedPackage{ localPackage.toString(), false /* private */ };
-    }
-
-    const auto endIter = mPackageAliases.rend();
-    for (auto iter = mPackageAliases.rbegin(); iter != endIter; ++iter) {
-        if (alias == iter->prefix) {
-            if (iter->package.package.empty()) {
-                return ExtractedPackage{ localPackage.toString(),
-                                         iter->package.privateNamespace };
-            }
-            return iter->package;
-        }
-    }
-    return {};
+const std::string& XmlPullParser::element_name() const {
+  const Event current_event = event();
+  if (current_event != Event::kStartElement &&
+      current_event != Event::kEndElement) {
+    return empty_;
+  }
+  return event_queue_.front().data2;
 }
 
-const std::string& XmlPullParser::getElementNamespace() const {
-    const Event currentEvent = getEvent();
-    if (currentEvent != Event::kStartElement && currentEvent != Event::kEndElement) {
-        return mEmpty;
-    }
-    return mEventQueue.front().data1;
+XmlPullParser::const_iterator XmlPullParser::begin_attributes() const {
+  return event_queue_.front().attributes.begin();
 }
 
-const std::string& XmlPullParser::getElementName() const {
-    const Event currentEvent = getEvent();
-    if (currentEvent != Event::kStartElement && currentEvent != Event::kEndElement) {
-        return mEmpty;
-    }
-    return mEventQueue.front().data2;
+XmlPullParser::const_iterator XmlPullParser::end_attributes() const {
+  return event_queue_.front().attributes.end();
 }
 
-XmlPullParser::const_iterator XmlPullParser::beginAttributes() const {
-    return mEventQueue.front().attributes.begin();
-}
-
-XmlPullParser::const_iterator XmlPullParser::endAttributes() const {
-    return mEventQueue.front().attributes.end();
-}
-
-size_t XmlPullParser::getAttributeCount() const {
-    if (getEvent() != Event::kStartElement) {
-        return 0;
-    }
-    return mEventQueue.front().attributes.size();
+size_t XmlPullParser::attribute_count() const {
+  if (event() != Event::kStartElement) {
+    return 0;
+  }
+  return event_queue_.front().attributes.size();
 }
 
 /**
  * Extracts the namespace and name of an expanded element or attribute name.
  */
-static void splitName(const char* name, std::string& outNs, std::string& outName) {
-    const char* p = name;
-    while (*p != 0 && *p != kXmlNamespaceSep) {
-        p++;
-    }
-
-    if (*p == 0) {
-        outNs = std::string();
-        outName = name;
-    } else {
-        outNs = StringPiece(name, (p - name)).toString();
-        outName = p + 1;
+static void SplitName(const char* name, std::string& out_ns,
+                      std::string& out_name) {
+  const char* p = name;
+  while (*p != 0 && *p != kXmlNamespaceSep) {
+    p++;
+  }
+
+  if (*p == 0) {
+    out_ns = std::string();
+    out_name = name;
+  } else {
+    out_ns = StringPiece(name, (p - name)).ToString();
+    out_name = p + 1;
+  }
+}
+
+void XMLCALL XmlPullParser::StartNamespaceHandler(void* user_data,
+                                                  const char* prefix,
+                                                  const char* uri) {
+  XmlPullParser* parser = reinterpret_cast<XmlPullParser*>(user_data);
+  std::string namespace_uri = uri != nullptr ? uri : std::string();
+  parser->namespace_uris_.push(namespace_uri);
+  parser->event_queue_.push(
+      EventData{Event::kStartNamespace,
+                XML_GetCurrentLineNumber(parser->parser_), parser->depth_++,
+                prefix != nullptr ? prefix : std::string(), namespace_uri});
+}
+
+void XMLCALL XmlPullParser::StartElementHandler(void* user_data,
+                                                const char* name,
+                                                const char** attrs) {
+  XmlPullParser* parser = reinterpret_cast<XmlPullParser*>(user_data);
+
+  EventData data = {Event::kStartElement,
+                    XML_GetCurrentLineNumber(parser->parser_),
+                    parser->depth_++};
+  SplitName(name, data.data1, data.data2);
+
+  while (*attrs) {
+    Attribute attribute;
+    SplitName(*attrs++, attribute.namespace_uri, attribute.name);
+    attribute.value = *attrs++;
+
+    // Insert in sorted order.
+    auto iter = std::lower_bound(data.attributes.begin(), data.attributes.end(),
+                                 attribute);
+    data.attributes.insert(iter, std::move(attribute));
+  }
+
+  // Move the structure into the queue (no copy).
+  parser->event_queue_.push(std::move(data));
+}
+
+void XMLCALL XmlPullParser::CharacterDataHandler(void* user_data, const char* s,
+                                                 int len) {
+  XmlPullParser* parser = reinterpret_cast<XmlPullParser*>(user_data);
+
+  parser->event_queue_.push(
+      EventData{Event::kText, XML_GetCurrentLineNumber(parser->parser_),
+                parser->depth_, StringPiece(s, len).ToString()});
+}
+
+void XMLCALL XmlPullParser::EndElementHandler(void* user_data,
+                                              const char* name) {
+  XmlPullParser* parser = reinterpret_cast<XmlPullParser*>(user_data);
+
+  EventData data = {Event::kEndElement,
+                    XML_GetCurrentLineNumber(parser->parser_),
+                    --(parser->depth_)};
+  SplitName(name, data.data1, data.data2);
+
+  // Move the data into the queue (no copy).
+  parser->event_queue_.push(std::move(data));
+}
+
+void XMLCALL XmlPullParser::EndNamespaceHandler(void* user_data,
+                                                const char* prefix) {
+  XmlPullParser* parser = reinterpret_cast<XmlPullParser*>(user_data);
+
+  parser->event_queue_.push(
+      EventData{Event::kEndNamespace, XML_GetCurrentLineNumber(parser->parser_),
+                --(parser->depth_), prefix != nullptr ? prefix : std::string(),
+                parser->namespace_uris_.top()});
+  parser->namespace_uris_.pop();
+}
+
+void XMLCALL XmlPullParser::CommentDataHandler(void* user_data,
+                                               const char* comment) {
+  XmlPullParser* parser = reinterpret_cast<XmlPullParser*>(user_data);
+
+  parser->event_queue_.push(EventData{Event::kComment,
+                                      XML_GetCurrentLineNumber(parser->parser_),
+                                      parser->depth_, comment});
+}
+
+Maybe<StringPiece> FindAttribute(const XmlPullParser* parser,
+                                 const StringPiece& name) {
+  auto iter = parser->FindAttribute("", name);
+  if (iter != parser->end_attributes()) {
+    return StringPiece(util::TrimWhitespace(iter->value));
+  }
+  return {};
+}
+
+Maybe<StringPiece> FindNonEmptyAttribute(const XmlPullParser* parser,
+                                         const StringPiece& name) {
+  auto iter = parser->FindAttribute("", name);
+  if (iter != parser->end_attributes()) {
+    StringPiece trimmed = util::TrimWhitespace(iter->value);
+    if (!trimmed.empty()) {
+      return trimmed;
     }
+  }
+  return {};
 }
 
-void XMLCALL XmlPullParser::startNamespaceHandler(void* userData, const char* prefix,
-        const char* uri) {
-    XmlPullParser* parser = reinterpret_cast<XmlPullParser*>(userData);
-    std::string namespaceUri = uri != nullptr ? uri : std::string();
-    parser->mNamespaceUris.push(namespaceUri);
-    parser->mEventQueue.push(EventData{
-            Event::kStartNamespace,
-            XML_GetCurrentLineNumber(parser->mParser),
-            parser->mDepth++,
-            prefix != nullptr ? prefix : std::string(),
-            namespaceUri
-    });
-}
-
-void XMLCALL XmlPullParser::startElementHandler(void* userData, const char* name,
-        const char** attrs) {
-    XmlPullParser* parser = reinterpret_cast<XmlPullParser*>(userData);
-
-    EventData data = {
-            Event::kStartElement, XML_GetCurrentLineNumber(parser->mParser), parser->mDepth++
-    };
-    splitName(name, data.data1, data.data2);
-
-    while (*attrs) {
-        Attribute attribute;
-        splitName(*attrs++, attribute.namespaceUri, attribute.name);
-        attribute.value = *attrs++;
-
-        // Insert in sorted order.
-        auto iter = std::lower_bound(data.attributes.begin(), data.attributes.end(), attribute);
-        data.attributes.insert(iter, std::move(attribute));
-    }
-
-    // Move the structure into the queue (no copy).
-    parser->mEventQueue.push(std::move(data));
-}
-
-void XMLCALL XmlPullParser::characterDataHandler(void* userData, const char* s, int len) {
-    XmlPullParser* parser = reinterpret_cast<XmlPullParser*>(userData);
-
-    parser->mEventQueue.push(EventData{
-            Event::kText,
-            XML_GetCurrentLineNumber(parser->mParser),
-            parser->mDepth,
-            StringPiece(s, len).toString()
-    });
-}
-
-void XMLCALL XmlPullParser::endElementHandler(void* userData, const char* name) {
-    XmlPullParser* parser = reinterpret_cast<XmlPullParser*>(userData);
-
-    EventData data = {
-            Event::kEndElement, XML_GetCurrentLineNumber(parser->mParser), --(parser->mDepth)
-    };
-    splitName(name, data.data1, data.data2);
-
-    // Move the data into the queue (no copy).
-    parser->mEventQueue.push(std::move(data));
-}
-
-void XMLCALL XmlPullParser::endNamespaceHandler(void* userData, const char* prefix) {
-    XmlPullParser* parser = reinterpret_cast<XmlPullParser*>(userData);
-
-    parser->mEventQueue.push(EventData{
-            Event::kEndNamespace,
-            XML_GetCurrentLineNumber(parser->mParser),
-            --(parser->mDepth),
-            prefix != nullptr ? prefix : std::string(),
-            parser->mNamespaceUris.top()
-    });
-    parser->mNamespaceUris.pop();
-}
-
-void XMLCALL XmlPullParser::commentDataHandler(void* userData, const char* comment) {
-    XmlPullParser* parser = reinterpret_cast<XmlPullParser*>(userData);
-
-    parser->mEventQueue.push(EventData{
-            Event::kComment,
-            XML_GetCurrentLineNumber(parser->mParser),
-            parser->mDepth,
-            comment
-    });
-}
-
-Maybe<StringPiece> findAttribute(const XmlPullParser* parser, const StringPiece& name) {
-    auto iter = parser->findAttribute("", name);
-    if (iter != parser->endAttributes()) {
-        return StringPiece(util::trimWhitespace(iter->value));
-    }
-    return {};
-}
-
-Maybe<StringPiece> findNonEmptyAttribute(const XmlPullParser* parser, const StringPiece& name) {
-    auto iter = parser->findAttribute("", name);
-    if (iter != parser->endAttributes()) {
-        StringPiece trimmed = util::trimWhitespace(iter->value);
-        if (!trimmed.empty()) {
-            return trimmed;
-        }
-    }
-    return {};
-}
-
-} // namespace xml
-} // namespace aapt
+}  // namespace xml
+}  // namespace aapt
diff --git a/tools/aapt2/xml/XmlPullParser.h b/tools/aapt2/xml/XmlPullParser.h
index ce69df669b0c4..ff58d604e35ef 100644
--- a/tools/aapt2/xml/XmlPullParser.h
+++ b/tools/aapt2/xml/XmlPullParser.h
@@ -17,13 +17,8 @@
 #ifndef AAPT_XML_PULL_PARSER_H
 #define AAPT_XML_PULL_PARSER_H
 
-#include "Resource.h"
-#include "process/IResourceTableConsumer.h"
-#include "util/Maybe.h"
-#include "util/StringPiece.h"
-#include "xml/XmlUtil.h"
-
 #include <expat.h>
+
 #include <algorithm>
 #include <istream>
 #include <ostream>
@@ -32,6 +27,14 @@
 #include <string>
 #include <vector>
 
+#include "android-base/macros.h"
+
+#include "Resource.h"
+#include "process/IResourceTableConsumer.h"
+#include "util/Maybe.h"
+#include "util/StringPiece.h"
+#include "xml/XmlUtil.h"
+
 namespace aapt {
 namespace xml {
 
@@ -51,15 +54,15 @@ class XmlPullParser : public IPackageDeclStack {
   };
 
   /**
-   * Skips to the next direct descendant node of the given startDepth,
+   * Skips to the next direct descendant node of the given start_depth,
    * skipping namespace nodes.
    *
-   * When nextChildNode returns true, you can expect Comments, Text, and
+   * When NextChildNode() returns true, you can expect Comments, Text, and
    * StartElement events.
    */
-  static bool nextChildNode(XmlPullParser* parser, size_t startDepth);
-  static bool skipCurrentElement(XmlPullParser* parser);
-  static bool isGoodEvent(Event event);
+  static bool NextChildNode(XmlPullParser* parser, size_t start_depth);
+  static bool SkipCurrentElement(XmlPullParser* parser);
+  static bool IsGoodEvent(Event event);
 
   explicit XmlPullParser(std::istream& in);
   ~XmlPullParser();
@@ -67,42 +70,42 @@ class XmlPullParser : public IPackageDeclStack {
   /**
    * Returns the current event that is being processed.
    */
-  Event getEvent() const;
+  Event event() const;
 
-  const std::string& getLastError() const;
+  const std::string& error() const;
 
   /**
    * Note, unlike XmlPullParser, the first call to next() will return
    * StartElement of the first element.
    */
-  Event next();
+  Event Next();
 
   //
   // These are available for all nodes.
   //
 
-  const std::string& getComment() const;
-  size_t getLineNumber() const;
-  size_t getDepth() const;
+  const std::string& comment() const;
+  size_t line_number() const;
+  size_t depth() const;
 
   /**
    * Returns the character data for a Text event.
    */
-  const std::string& getText() const;
+  const std::string& text() const;
 
   //
   // Namespace prefix and URI are available for StartNamespace and EndNamespace.
   //
 
-  const std::string& getNamespacePrefix() const;
-  const std::string& getNamespaceUri() const;
+  const std::string& namespace_prefix() const;
+  const std::string& namespace_uri() const;
 
   //
   // These are available for StartElement and EndElement.
   //
 
-  const std::string& getElementNamespace() const;
-  const std::string& getElementName() const;
+  const std::string& element_namespace() const;
+  const std::string& element_name() const;
 
   /*
    * Uses the current stack of namespaces to resolve the package. Eg:
@@ -115,8 +118,9 @@ class XmlPullParser : public IPackageDeclStack {
    * If xmlns:app="http://schemas.android.com/apk/res-auto", then
    * 'package' will be set to 'defaultPackage'.
    */
-  Maybe<ExtractedPackage> transformPackageAlias(
-      const StringPiece& alias, const StringPiece& localPackage) const override;
+  Maybe<ExtractedPackage> TransformPackageAlias(
+      const StringPiece& alias,
+      const StringPiece& local_package) const override;
 
   //
   // Remaining methods are for retrieving information about attributes
@@ -127,7 +131,7 @@ class XmlPullParser : public IPackageDeclStack {
   //
 
   struct Attribute {
-    std::string namespaceUri;
+    std::string namespace_uri;
     std::string name;
     std::string value;
 
@@ -139,52 +143,54 @@ class XmlPullParser : public IPackageDeclStack {
 
   using const_iterator = std::vector<Attribute>::const_iterator;
 
-  const_iterator beginAttributes() const;
-  const_iterator endAttributes() const;
-  size_t getAttributeCount() const;
-  const_iterator findAttribute(StringPiece namespaceUri,
+  const_iterator begin_attributes() const;
+  const_iterator end_attributes() const;
+  size_t attribute_count() const;
+  const_iterator FindAttribute(StringPiece namespace_uri,
                                StringPiece name) const;
 
  private:
-  static void XMLCALL startNamespaceHandler(void* userData, const char* prefix,
+  DISALLOW_COPY_AND_ASSIGN(XmlPullParser);
+
+  static void XMLCALL StartNamespaceHandler(void* user_data, const char* prefix,
                                             const char* uri);
-  static void XMLCALL startElementHandler(void* userData, const char* name,
+  static void XMLCALL StartElementHandler(void* user_data, const char* name,
                                           const char** attrs);
-  static void XMLCALL characterDataHandler(void* userData, const char* s,
+  static void XMLCALL CharacterDataHandler(void* user_data, const char* s,
                                            int len);
-  static void XMLCALL endElementHandler(void* userData, const char* name);
-  static void XMLCALL endNamespaceHandler(void* userData, const char* prefix);
-  static void XMLCALL commentDataHandler(void* userData, const char* comment);
+  static void XMLCALL EndElementHandler(void* user_data, const char* name);
+  static void XMLCALL EndNamespaceHandler(void* user_data, const char* prefix);
+  static void XMLCALL CommentDataHandler(void* user_data, const char* comment);
 
   struct EventData {
     Event event;
-    size_t lineNumber;
+    size_t line_number;
     size_t depth;
     std::string data1;
     std::string data2;
     std::vector<Attribute> attributes;
   };
 
-  std::istream& mIn;
-  XML_Parser mParser;
-  char mBuffer[16384];
-  std::queue<EventData> mEventQueue;
-  std::string mLastError;
-  const std::string mEmpty;
-  size_t mDepth;
-  std::stack<std::string> mNamespaceUris;
+  std::istream& in_;
+  XML_Parser parser_;
+  char buffer_[16384];
+  std::queue<EventData> event_queue_;
+  std::string error_;
+  const std::string empty_;
+  size_t depth_;
+  std::stack<std::string> namespace_uris_;
 
   struct PackageDecl {
     std::string prefix;
     ExtractedPackage package;
   };
-  std::vector<PackageDecl> mPackageAliases;
+  std::vector<PackageDecl> package_aliases_;
 };
 
 /**
  * Finds the attribute in the current element within the global namespace.
  */
-Maybe<StringPiece> findAttribute(const XmlPullParser* parser,
+Maybe<StringPiece> FindAttribute(const XmlPullParser* parser,
                                  const StringPiece& name);
 
 /**
@@ -192,7 +198,7 @@ Maybe<StringPiece> findAttribute(const XmlPullParser* parser,
  * attribute's value
  * must not be the empty string.
  */
-Maybe<StringPiece> findNonEmptyAttribute(const XmlPullParser* parser,
+Maybe<StringPiece> FindNonEmptyAttribute(const XmlPullParser* parser,
                                          const StringPiece& name);
 
 //
@@ -224,18 +230,18 @@ inline ::std::ostream& operator<<(::std::ostream& out,
   return out;
 }
 
-inline bool XmlPullParser::nextChildNode(XmlPullParser* parser,
-                                         size_t startDepth) {
+inline bool XmlPullParser::NextChildNode(XmlPullParser* parser,
+                                         size_t start_depth) {
   Event event;
 
   // First get back to the start depth.
-  while (isGoodEvent(event = parser->next()) &&
-         parser->getDepth() > startDepth + 1) {
+  while (IsGoodEvent(event = parser->Next()) &&
+         parser->depth() > start_depth + 1) {
   }
 
   // Now look for the first good node.
-  while ((event != Event::kEndElement || parser->getDepth() > startDepth) &&
-         isGoodEvent(event)) {
+  while ((event != Event::kEndElement || parser->depth() > start_depth) &&
+         IsGoodEvent(event)) {
     switch (event) {
       case Event::kText:
       case Event::kComment:
@@ -244,15 +250,15 @@ inline bool XmlPullParser::nextChildNode(XmlPullParser* parser,
       default:
         break;
     }
-    event = parser->next();
+    event = parser->Next();
   }
   return false;
 }
 
-inline bool XmlPullParser::skipCurrentElement(XmlPullParser* parser) {
+inline bool XmlPullParser::SkipCurrentElement(XmlPullParser* parser) {
   int depth = 1;
   while (depth > 0) {
-    switch (parser->next()) {
+    switch (parser->Next()) {
       case Event::kEndDocument:
         return true;
       case Event::kBadDocument:
@@ -270,12 +276,12 @@ inline bool XmlPullParser::skipCurrentElement(XmlPullParser* parser) {
   return true;
 }
 
-inline bool XmlPullParser::isGoodEvent(XmlPullParser::Event event) {
+inline bool XmlPullParser::IsGoodEvent(XmlPullParser::Event event) {
   return event != Event::kBadDocument && event != Event::kEndDocument;
 }
 
 inline int XmlPullParser::Attribute::compare(const Attribute& rhs) const {
-  int cmp = namespaceUri.compare(rhs.namespaceUri);
+  int cmp = namespace_uri.compare(rhs.namespace_uri);
   if (cmp != 0) return cmp;
   return name.compare(rhs.name);
 }
@@ -292,16 +298,16 @@ inline bool XmlPullParser::Attribute::operator!=(const Attribute& rhs) const {
   return compare(rhs) != 0;
 }
 
-inline XmlPullParser::const_iterator XmlPullParser::findAttribute(
-    StringPiece namespaceUri, StringPiece name) const {
-  const auto endIter = endAttributes();
+inline XmlPullParser::const_iterator XmlPullParser::FindAttribute(
+    StringPiece namespace_uri, StringPiece name) const {
+  const auto end_iter = end_attributes();
   const auto iter = std::lower_bound(
-      beginAttributes(), endIter,
-      std::pair<StringPiece, StringPiece>(namespaceUri, name),
+      begin_attributes(), end_iter,
+      std::pair<StringPiece, StringPiece>(namespace_uri, name),
       [](const Attribute& attr,
          const std::pair<StringPiece, StringPiece>& rhs) -> bool {
-        int cmp = attr.namespaceUri.compare(0, attr.namespaceUri.size(),
-                                            rhs.first.data(), rhs.first.size());
+        int cmp = attr.namespace_uri.compare(
+            0, attr.namespace_uri.size(), rhs.first.data(), rhs.first.size());
         if (cmp < 0) return true;
         if (cmp > 0) return false;
         cmp = attr.name.compare(0, attr.name.size(), rhs.second.data(),
@@ -310,11 +316,11 @@ inline XmlPullParser::const_iterator XmlPullParser::findAttribute(
         return false;
       });
 
-  if (iter != endIter && namespaceUri == iter->namespaceUri &&
+  if (iter != end_iter && namespace_uri == iter->namespace_uri &&
       name == iter->name) {
     return iter;
   }
-  return endIter;
+  return end_iter;
 }
 
 }  // namespace xml
diff --git a/tools/aapt2/xml/XmlPullParser_test.cpp b/tools/aapt2/xml/XmlPullParser_test.cpp
index 2c1fdc76e9ad7..4f18cd218cd97 100644
--- a/tools/aapt2/xml/XmlPullParser_test.cpp
+++ b/tools/aapt2/xml/XmlPullParser_test.cpp
@@ -14,42 +14,43 @@
  * limitations under the License.
  */
 
-#include "test/Test.h"
-#include "util/StringPiece.h"
 #include "xml/XmlPullParser.h"
 
 #include <sstream>
 
+#include "test/Test.h"
+#include "util/StringPiece.h"
+
 namespace aapt {
 
 TEST(XmlPullParserTest, NextChildNodeTraversesCorrectly) {
-    std::stringstream str;
-    str << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
-            "<a><b><c xmlns:a=\"http://schema.org\"><d/></c><e/></b></a>";
-    xml::XmlPullParser parser(str);
+  std::stringstream str;
+  str << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
+         "<a><b><c xmlns:a=\"http://schema.org\"><d/></c><e/></b></a>";
+  xml::XmlPullParser parser(str);
 
-    const size_t depthOuter = parser.getDepth();
-    ASSERT_TRUE(xml::XmlPullParser::nextChildNode(&parser, depthOuter));
+  const size_t depth_outer = parser.depth();
+  ASSERT_TRUE(xml::XmlPullParser::NextChildNode(&parser, depth_outer));
 
-    EXPECT_EQ(xml::XmlPullParser::Event::kStartElement, parser.getEvent());
-    EXPECT_EQ(StringPiece("a"), StringPiece(parser.getElementName()));
+  EXPECT_EQ(xml::XmlPullParser::Event::kStartElement, parser.event());
+  EXPECT_EQ(StringPiece("a"), StringPiece(parser.element_name()));
 
-    const size_t depthA = parser.getDepth();
-    ASSERT_TRUE(xml::XmlPullParser::nextChildNode(&parser, depthA));
-    EXPECT_EQ(xml::XmlPullParser::Event::kStartElement, parser.getEvent());
-    EXPECT_EQ(StringPiece("b"), StringPiece(parser.getElementName()));
+  const size_t depth_a = parser.depth();
+  ASSERT_TRUE(xml::XmlPullParser::NextChildNode(&parser, depth_a));
+  EXPECT_EQ(xml::XmlPullParser::Event::kStartElement, parser.event());
+  EXPECT_EQ(StringPiece("b"), StringPiece(parser.element_name()));
 
-    const size_t depthB = parser.getDepth();
-    ASSERT_TRUE(xml::XmlPullParser::nextChildNode(&parser, depthB));
-    EXPECT_EQ(xml::XmlPullParser::Event::kStartElement, parser.getEvent());
-    EXPECT_EQ(StringPiece("c"), StringPiece(parser.getElementName()));
+  const size_t depth_b = parser.depth();
+  ASSERT_TRUE(xml::XmlPullParser::NextChildNode(&parser, depth_b));
+  EXPECT_EQ(xml::XmlPullParser::Event::kStartElement, parser.event());
+  EXPECT_EQ(StringPiece("c"), StringPiece(parser.element_name()));
 
-    ASSERT_TRUE(xml::XmlPullParser::nextChildNode(&parser, depthB));
-    EXPECT_EQ(xml::XmlPullParser::Event::kStartElement, parser.getEvent());
-    EXPECT_EQ(StringPiece("e"), StringPiece(parser.getElementName()));
+  ASSERT_TRUE(xml::XmlPullParser::NextChildNode(&parser, depth_b));
+  EXPECT_EQ(xml::XmlPullParser::Event::kStartElement, parser.event());
+  EXPECT_EQ(StringPiece("e"), StringPiece(parser.element_name()));
 
-    ASSERT_FALSE(xml::XmlPullParser::nextChildNode(&parser, depthOuter));
-    EXPECT_EQ(xml::XmlPullParser::Event::kEndDocument, parser.getEvent());
+  ASSERT_FALSE(xml::XmlPullParser::NextChildNode(&parser, depth_outer));
+  EXPECT_EQ(xml::XmlPullParser::Event::kEndDocument, parser.event());
 }
 
-} // namespace aapt
+}  // namespace aapt
diff --git a/tools/aapt2/xml/XmlUtil.cpp b/tools/aapt2/xml/XmlUtil.cpp
index b570fd75b44e4..d00f7f2fe0aa4 100644
--- a/tools/aapt2/xml/XmlUtil.cpp
+++ b/tools/aapt2/xml/XmlUtil.cpp
@@ -14,60 +14,69 @@
  * limitations under the License.
  */
 
-#include "util/Maybe.h"
-#include "util/Util.h"
 #include "xml/XmlUtil.h"
 
 #include <string>
 
+#include "util/Maybe.h"
+#include "util/Util.h"
+
 namespace aapt {
 namespace xml {
 
-std::string buildPackageNamespace(const StringPiece& package, bool privateReference) {
-    std::string result = privateReference ? kSchemaPrivatePrefix : kSchemaPublicPrefix;
-    result.append(package.data(), package.size());
-    return result;
+std::string BuildPackageNamespace(const StringPiece& package,
+                                  bool private_reference) {
+  std::string result =
+      private_reference ? kSchemaPrivatePrefix : kSchemaPublicPrefix;
+  result.append(package.data(), package.size());
+  return result;
 }
 
-Maybe<ExtractedPackage> extractPackageFromNamespace(const std::string& namespaceUri) {
-    if (util::stringStartsWith(namespaceUri, kSchemaPublicPrefix)) {
-        StringPiece schemaPrefix = kSchemaPublicPrefix;
-        StringPiece package = namespaceUri;
-        package = package.substr(schemaPrefix.size(), package.size() - schemaPrefix.size());
-        if (package.empty()) {
-            return {};
-        }
-        return ExtractedPackage{ package.toString(), false /* isPrivate */ };
-
-    } else if (util::stringStartsWith(namespaceUri, kSchemaPrivatePrefix)) {
-        StringPiece schemaPrefix = kSchemaPrivatePrefix;
-        StringPiece package = namespaceUri;
-        package = package.substr(schemaPrefix.size(), package.size() - schemaPrefix.size());
-        if (package.empty()) {
-            return {};
-        }
-        return ExtractedPackage{ package.toString(), true /* isPrivate */ };
-
-    } else if (namespaceUri == kSchemaAuto) {
-        return ExtractedPackage{ std::string(), true /* isPrivate */ };
+Maybe<ExtractedPackage> ExtractPackageFromNamespace(
+    const std::string& namespace_uri) {
+  if (util::StartsWith(namespace_uri, kSchemaPublicPrefix)) {
+    StringPiece schema_prefix = kSchemaPublicPrefix;
+    StringPiece package = namespace_uri;
+    package = package.substr(schema_prefix.size(),
+                             package.size() - schema_prefix.size());
+    if (package.empty()) {
+      return {};
     }
-    return {};
-}
+    return ExtractedPackage{package.ToString(), false /* is_private */};
 
-void transformReferenceFromNamespace(IPackageDeclStack* declStack,
-                                     const StringPiece& localPackage, Reference* inRef) {
-    if (inRef->name) {
-        if (Maybe<ExtractedPackage> transformedPackage =
-                   declStack->transformPackageAlias(inRef->name.value().package, localPackage)) {
-            ExtractedPackage& extractedPackage = transformedPackage.value();
-            inRef->name.value().package = std::move(extractedPackage.package);
-
-            // If the reference was already private (with a * prefix) and the namespace is public,
-            // we keep the reference private.
-            inRef->privateReference |= extractedPackage.privateNamespace;
-        }
+  } else if (util::StartsWith(namespace_uri, kSchemaPrivatePrefix)) {
+    StringPiece schema_prefix = kSchemaPrivatePrefix;
+    StringPiece package = namespace_uri;
+    package = package.substr(schema_prefix.size(),
+                             package.size() - schema_prefix.size());
+    if (package.empty()) {
+      return {};
     }
+    return ExtractedPackage{package.ToString(), true /* is_private */};
+
+  } else if (namespace_uri == kSchemaAuto) {
+    return ExtractedPackage{std::string(), true /* is_private */};
+  }
+  return {};
 }
 
-} // namespace xml
-} // namespace aapt
+void TransformReferenceFromNamespace(IPackageDeclStack* decl_stack,
+                                     const StringPiece& local_package,
+                                     Reference* in_ref) {
+  if (in_ref->name) {
+    if (Maybe<ExtractedPackage> transformed_package =
+            decl_stack->TransformPackageAlias(in_ref->name.value().package,
+                                              local_package)) {
+      ExtractedPackage& extracted_package = transformed_package.value();
+      in_ref->name.value().package = std::move(extracted_package.package);
+
+      // If the reference was already private (with a * prefix) and the
+      // namespace is public,
+      // we keep the reference private.
+      in_ref->private_reference |= extracted_package.private_namespace;
+    }
+  }
+}
+
+}  // namespace xml
+}  // namespace aapt
diff --git a/tools/aapt2/xml/XmlUtil.h b/tools/aapt2/xml/XmlUtil.h
index 96de654c98770..536540162d07b 100644
--- a/tools/aapt2/xml/XmlUtil.h
+++ b/tools/aapt2/xml/XmlUtil.h
@@ -17,11 +17,11 @@
 #ifndef AAPT_XML_XMLUTIL_H
 #define AAPT_XML_XMLUTIL_H
 
+#include <string>
+
 #include "ResourceValues.h"
 #include "util/Maybe.h"
 
-#include <string>
-
 namespace aapt {
 namespace xml {
 
@@ -51,7 +51,7 @@ struct ExtractedPackage {
    * private resources
    * are made visible.
    */
-  bool privateNamespace;
+  bool private_namespace;
 };
 
 /**
@@ -62,8 +62,8 @@ struct ExtractedPackage {
  * Special case: if namespaceUri is http://schemas.android.com/apk/res-auto,
  * returns an empty package name.
  */
-Maybe<ExtractedPackage> extractPackageFromNamespace(
-    const std::string& namespaceUri);
+Maybe<ExtractedPackage> ExtractPackageFromNamespace(
+    const std::string& namespace_uri);
 
 /**
  * Returns an XML Android namespace for the given package of the form:
@@ -74,8 +74,8 @@ Maybe<ExtractedPackage> extractPackageFromNamespace(
  *
  * http://schemas.android.com/apk/prv/res/<package>
  */
-std::string buildPackageNamespace(const StringPiece& package,
-                                  bool privateReference = false);
+std::string BuildPackageNamespace(const StringPiece& package,
+                                  bool private_reference = false);
 
 /**
  * Interface representing a stack of XML namespace declarations. When looking up
@@ -89,20 +89,19 @@ struct IPackageDeclStack {
    * Returns an ExtractedPackage struct if the alias given corresponds with a
    * package declaration.
    */
-  virtual Maybe<ExtractedPackage> transformPackageAlias(
-      const StringPiece& alias, const StringPiece& localPackage) const = 0;
+  virtual Maybe<ExtractedPackage> TransformPackageAlias(
+      const StringPiece& alias, const StringPiece& local_package) const = 0;
 };
 
 /**
  * Helper function for transforming the original Reference inRef to a fully
  * qualified reference
  * via the IPackageDeclStack. This will also mark the Reference as private if
- * the namespace of
- * the package declaration was private.
+ * the namespace of the package declaration was private.
  */
-void transformReferenceFromNamespace(IPackageDeclStack* declStack,
-                                     const StringPiece& localPackage,
-                                     Reference* inRef);
+void TransformReferenceFromNamespace(IPackageDeclStack* decl_stack,
+                                     const StringPiece& local_package,
+                                     Reference* in_ref);
 
 }  // namespace xml
 }  // namespace aapt
diff --git a/tools/aapt2/xml/XmlUtil_test.cpp b/tools/aapt2/xml/XmlUtil_test.cpp
index cbeb8bcda9e0a..5eecc8f5fb20c 100644
--- a/tools/aapt2/xml/XmlUtil_test.cpp
+++ b/tools/aapt2/xml/XmlUtil_test.cpp
@@ -14,38 +14,46 @@
  * limitations under the License.
  */
 
-#include "test/Test.h"
 #include "xml/XmlUtil.h"
 
+#include "test/Test.h"
+
 namespace aapt {
 
 TEST(XmlUtilTest, ExtractPackageFromNamespace) {
-    AAPT_ASSERT_FALSE(xml::extractPackageFromNamespace("com.android"));
-    AAPT_ASSERT_FALSE(xml::extractPackageFromNamespace("http://schemas.android.com/apk"));
-    AAPT_ASSERT_FALSE(xml::extractPackageFromNamespace("http://schemas.android.com/apk/res"));
-    AAPT_ASSERT_FALSE(xml::extractPackageFromNamespace("http://schemas.android.com/apk/res/"));
-    AAPT_ASSERT_FALSE(xml::extractPackageFromNamespace("http://schemas.android.com/apk/prv/res/"));
+  AAPT_ASSERT_FALSE(xml::ExtractPackageFromNamespace("com.android"));
+  AAPT_ASSERT_FALSE(
+      xml::ExtractPackageFromNamespace("http://schemas.android.com/apk"));
+  AAPT_ASSERT_FALSE(
+      xml::ExtractPackageFromNamespace("http://schemas.android.com/apk/res"));
+  AAPT_ASSERT_FALSE(
+      xml::ExtractPackageFromNamespace("http://schemas.android.com/apk/res/"));
+  AAPT_ASSERT_FALSE(xml::ExtractPackageFromNamespace(
+      "http://schemas.android.com/apk/prv/res/"));
 
-    Maybe<xml::ExtractedPackage> p =
-            xml::extractPackageFromNamespace("http://schemas.android.com/apk/res/a");
-    AAPT_ASSERT_TRUE(p);
-    EXPECT_EQ(std::string("a"), p.value().package);
-    EXPECT_FALSE(p.value().privateNamespace);
+  Maybe<xml::ExtractedPackage> p =
+      xml::ExtractPackageFromNamespace("http://schemas.android.com/apk/res/a");
+  AAPT_ASSERT_TRUE(p);
+  EXPECT_EQ(std::string("a"), p.value().package);
+  EXPECT_FALSE(p.value().private_namespace);
 
-    p = xml::extractPackageFromNamespace("http://schemas.android.com/apk/prv/res/android");
-    AAPT_ASSERT_TRUE(p);
-    EXPECT_EQ(std::string("android"), p.value().package);
-    EXPECT_TRUE(p.value().privateNamespace);
+  p = xml::ExtractPackageFromNamespace(
+      "http://schemas.android.com/apk/prv/res/android");
+  AAPT_ASSERT_TRUE(p);
+  EXPECT_EQ(std::string("android"), p.value().package);
+  EXPECT_TRUE(p.value().private_namespace);
 
-    p = xml::extractPackageFromNamespace("http://schemas.android.com/apk/prv/res/com.test");
-    AAPT_ASSERT_TRUE(p);
-    EXPECT_EQ(std::string("com.test"), p.value().package);
-    EXPECT_TRUE(p.value().privateNamespace);
+  p = xml::ExtractPackageFromNamespace(
+      "http://schemas.android.com/apk/prv/res/com.test");
+  AAPT_ASSERT_TRUE(p);
+  EXPECT_EQ(std::string("com.test"), p.value().package);
+  EXPECT_TRUE(p.value().private_namespace);
 
-    p = xml::extractPackageFromNamespace("http://schemas.android.com/apk/res-auto");
-    AAPT_ASSERT_TRUE(p);
-    EXPECT_EQ(std::string(), p.value().package);
-    EXPECT_TRUE(p.value().privateNamespace);
+  p = xml::ExtractPackageFromNamespace(
+      "http://schemas.android.com/apk/res-auto");
+  AAPT_ASSERT_TRUE(p);
+  EXPECT_EQ(std::string(), p.value().package);
+  EXPECT_TRUE(p.value().private_namespace);
 }
 
-} // namespace aapt
+}  // namespace aapt