Use Google3 style guide with .clang-format

Test: style change only, builds ok
Change-Id: I885180e24cb2e7b58cfb4967c3bcb40058ce4078

1 files changed, 88 insertions, 87 deletions

diff --git a/tools/aapt2/ValueVisitor.h b/tools/aapt2/ValueVisitor.h
index 9dc6a9c2b0d2..121c33709eef 100644
--- a/tools/aapt2/ValueVisitor.h
+++ b/tools/aapt2/ValueVisitor.h
@@ -17,91 +17,94 @@
 #ifndef AAPT_VALUE_VISITOR_H
 #define AAPT_VALUE_VISITOR_H
 
-#include "ResourceValues.h"
 #include "ResourceTable.h"
+#include "ResourceValues.h"
 
 namespace aapt {
 
 /**
- * Visits a value and invokes the appropriate method based on its type. Does not traverse
+ * Visits a value and invokes the appropriate method based on its type. Does not
+ * 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 visit(Attribute* value) {}
-    virtual void visit(Style* value) {}
-    virtual void visit(Array* value) {}
-    virtual void visit(Plural* value) {}
-    virtual void visit(Styleable* value) {}
+  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 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) { /* NOLINT */ \
+    visitSubValues(value);                    \
+  }
 
 /**
- * Visits values, and if they are compound values, visits the components as well.
+ * Visits values, and if they are compound values, visits the components as
+ * well.
  */
 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;
-
-    void visitSubValues(Attribute* attribute) {
-        for (Attribute::Symbol& symbol : attribute->symbols) {
-            visit(&symbol.symbol);
-        }
+  // 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;
+
+  void visitSubValues(Attribute* attribute) {
+    for (Attribute::Symbol& symbol : attribute->symbols) {
+      visit(&symbol.symbol);
     }
+  }
 
-    void visitSubValues(Style* style) {
-        if (style->parent) {
-            visit(&style->parent.value());
-        }
+  void visitSubValues(Style* style) {
+    if (style->parent) {
+      visit(&style->parent.value());
+    }
 
-        for (Style::Entry& entry : style->entries) {
-            visit(&entry.key);
-            entry.value->accept(this);
-        }
+    for (Style::Entry& entry : style->entries) {
+      visit(&entry.key);
+      entry.value->accept(this);
     }
+  }
 
-    void visitSubValues(Array* array) {
-        for (std::unique_ptr<Item>& item : array->items) {
-            item->accept(this);
-        }
+  void visitSubValues(Array* array) {
+    for (std::unique_ptr<Item>& item : array->items) {
+      item->accept(this);
     }
+  }
 
-    void visitSubValues(Plural* plural) {
-        for (std::unique_ptr<Item>& item : plural->values) {
-            if (item) {
-                item->accept(this);
-            }
-        }
+  void visitSubValues(Plural* plural) {
+    for (std::unique_ptr<Item>& item : plural->values) {
+      if (item) {
+        item->accept(this);
+      }
     }
+  }
 
-    void visitSubValues(Styleable* styleable) {
-        for (Reference& reference : styleable->entries) {
-            visit(&reference);
-        }
+  void visitSubValues(Styleable* styleable) {
+    for (Reference& reference : styleable->entries) {
+      visit(&reference);
     }
+  }
 
-    DECL_VISIT_COMPOUND_VALUE(Attribute);
-    DECL_VISIT_COMPOUND_VALUE(Style);
-    DECL_VISIT_COMPOUND_VALUE(Array);
-    DECL_VISIT_COMPOUND_VALUE(Plural);
-    DECL_VISIT_COMPOUND_VALUE(Styleable);
+  DECL_VISIT_COMPOUND_VALUE(Attribute);
+  DECL_VISIT_COMPOUND_VALUE(Style);
+  DECL_VISIT_COMPOUND_VALUE(Array);
+  DECL_VISIT_COMPOUND_VALUE(Plural);
+  DECL_VISIT_COMPOUND_VALUE(Styleable);
 };
 
 /**
@@ -109,11 +112,9 @@ struct ValueVisitor : public RawValueVisitor {
  */
 template <typename T>
 struct DynCastVisitor : public RawValueVisitor {
-    T* value = nullptr;
+  T* value = nullptr;
 
-    void visit(T* v) override {
-        value = v;
-    }
+  void visit(T* v) override { value = v; }
 };
 
 /**
@@ -121,16 +122,14 @@ struct DynCastVisitor : public RawValueVisitor {
  */
 template <>
 struct DynCastVisitor<Item> : public RawValueVisitor {
-    Item* value = nullptr;
+  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));
+  return valueCast<T>(const_cast<Value*>(value));
 }
 
 /**
@@ -139,30 +138,32 @@ const T* valueCast(const Value* value) {
  */
 template <typename T>
 T* valueCast(Value* value) {
-    if (!value) {
-        return nullptr;
-    }
-    DynCastVisitor<T> visitor;
-    value->accept(&visitor);
-    return visitor.value;
+  if (!value) {
+    return nullptr;
+  }
+  DynCastVisitor<T> visitor;
+  value->accept(&visitor);
+  return visitor.value;
 }
 
-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);
-            }
-        }
+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);
+      }
     }
+  }
 }
 
-inline void visitAllValuesInTable(ResourceTable* table, RawValueVisitor* visitor) {
-    for (auto& pkg : table->packages) {
-        visitAllValuesInPackage(pkg.get(), visitor);
-    }
+inline void visitAllValuesInTable(ResourceTable* table,
+                                  RawValueVisitor* visitor) {
+  for (auto& pkg : table->packages) {
+    visitAllValuesInPackage(pkg.get(), visitor);
+  }
 }
 
-} // namespace aapt
+}  // namespace aapt
 
-#endif // AAPT_VALUE_VISITOR_H
+#endif  // AAPT_VALUE_VISITOR_H