AAPT2: Rename to match new style
Use Google3 naming style to match new
projects' and open source google projects' style.
Preferred to do this in a massive CL so as to avoid
style inconsistencies that plague legacy code bases.
This is a relatively NEW code base, may as well keep
it up to date.
Test: name/style refactor - existing tests pass
Change-Id: Ie80ecb78d46ec53efdfca2336bb57d96cbb7fb87
diff --git a/tools/aapt2/test/Builders.h b/tools/aapt2/test/Builders.h
index c647159..9377306 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 @@
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 2d571e7..3689201 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 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 6c7f6f7..7986329 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 c9188bf..ec07432 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