diff --git a/base/third_party/symbolize/demangle.cc b/base/third_party/symbolize/demangle.cc
index 2632646dd4072..8db75f01071e2 100644
--- a/base/third_party/symbolize/demangle.cc
+++ b/base/third_party/symbolize/demangle.cc
@@ -139,8 +139,8 @@ static const AbbrevPair kBuiltinTypeList[] = {
{"g", "__float128", 0},
{"z", "ellipsis", 0},
- {"De", "decimal128", 0}, // IEEE 754r decimal floating point (128 bits)
- {"Dd", "decimal64", 0}, // IEEE 754r decimal floating point (64 bits)
+ {"De", "decimal128", 0}, // IEEE 754r decimal floating point (128 bits)
+ {"Dd", "decimal64", 0}, // IEEE 754r decimal floating point (64 bits)
{"Dc", "decltype(auto)", 0},
{"Da", "auto", 0},
{"Dn", "std::nullptr_t", 0}, // i.e., decltype(nullptr)
@@ -148,7 +148,7 @@ static const AbbrevPair kBuiltinTypeList[] = {
{"Di", "char32_t", 0},
{"Du", "char8_t", 0},
{"Ds", "char16_t", 0},
- {"Dh", "float16", 0}, // IEEE 754r half-precision float (16 bits)
+ {"Dh", "float16", 0}, // IEEE 754r half-precision float (16 bits)
{nullptr, nullptr, 0},
};
@@ -193,8 +193,8 @@ static_assert(sizeof(ParseState) == 4 * sizeof(int),
// Only one copy of this exists for each call to Demangle, so the size of this
// struct is nearly inconsequential.
typedef struct {
- const char *mangled_begin; // Beginning of input string.
- char *out; // Beginning of output string.
+ const char* mangled_begin; // Beginning of input string.
+ char* out; // Beginning of output string.
int out_end_idx; // One past last allowed output character.
int recursion_depth; // For stack exhaustion prevention.
int steps; // Cap how much work we'll do, regardless of depth.
@@ -206,7 +206,7 @@ namespace {
// Also prevent unbounded handling of complex inputs.
class ComplexityGuard {
public:
- explicit ComplexityGuard(State *state) : state_(state) {
+ explicit ComplexityGuard(State* state) : state_(state) {
++state->recursion_depth;
++state->steps;
}
@@ -239,7 +239,7 @@ class ComplexityGuard {
}
private:
- State *state_;
+ State* state_;
};
} // namespace
@@ -255,7 +255,7 @@ static size_t StrLen(const char *str) {
}
// Returns true if "str" has at least "n" characters remaining.
-static bool AtLeastNumCharsRemaining(const char *str, size_t n) {
+static bool AtLeastNumCharsRemaining(const char* str, size_t n) {
for (size_t i = 0; i < n; ++i) {
if (str[i] == '\0') {
return false;
@@ -291,7 +291,7 @@ static void InitState(State* state,
state->parse_state.append = true;
}
-static inline const char *RemainingInput(State *state) {
+static inline const char* RemainingInput(State* state) {
return &state->mangled_begin[state->parse_state.mangled_idx];
}
@@ -300,7 +300,9 @@ static inline const char *RemainingInput(State *state) {
// not contain '\0'.
static bool ParseOneCharToken(State *state, const char one_char_token) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
if (RemainingInput(state)[0] == one_char_token) {
++state->parse_state.mangled_idx;
return true;
@@ -313,7 +315,9 @@ static bool ParseOneCharToken(State *state, const char one_char_token) {
// not contain '\0'.
static bool ParseTwoCharToken(State *state, const char *two_char_token) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
if (RemainingInput(state)[0] == two_char_token[0] &&
RemainingInput(state)[1] == two_char_token[1]) {
state->parse_state.mangled_idx += 2;
@@ -326,7 +330,9 @@ static bool ParseTwoCharToken(State *state, const char *two_char_token) {
// "char_class" at "mangled_cur" position.
static bool ParseCharClass(State *state, const char *char_class) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
if (RemainingInput(state)[0] == '\0') {
return false;
}
@@ -340,7 +346,7 @@ static bool ParseCharClass(State *state, const char *char_class) {
return false;
}
-static bool ParseDigit(State *state, int *digit) {
+static bool ParseDigit(State* state, int* digit) {
char c = RemainingInput(state)[0];
if (ParseCharClass(state, "0123456789")) {
if (digit != nullptr) {
@@ -352,7 +358,9 @@ static bool ParseDigit(State *state, int *digit) {
}
// This function is used for handling an optional non-terminal.
-static bool Optional(bool /*status*/) { return true; }
+static bool Optional(bool /*status*/) {
+ return true;
+}
// This function is used for handling <non-terminal>+ syntax.
typedef bool (*ParseFunc)(State *);
@@ -378,7 +386,7 @@ static bool ZeroOrMore(ParseFunc parse_func, State *state) {
// Append "str" at "out_cur_idx". If there is an overflow, out_cur_idx is
// set to out_end_idx+1. The output string is ensured to
// always terminate with '\0' as long as there is no overflow.
-static void Append(State *state, const char *const str, const size_t length) {
+static void Append(State* state, const char* const str, const size_t length) {
for (size_t i = 0; i < length; ++i) {
if (state->parse_state.out_cur_idx + 1 <
state->out_end_idx) { // +1 for '\0'
@@ -396,13 +404,17 @@ static void Append(State *state, const char *const str, const size_t length) {
}
// We don't use equivalents in libc to avoid locale issues.
-static bool IsLower(char c) { return c >= 'a' && c <= 'z'; }
+static bool IsLower(char c) {
+ return c >= 'a' && c <= 'z';
+}
static bool IsAlpha(char c) {
return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
}
-static bool IsDigit(char c) { return c >= '0' && c <= '9'; }
+static bool IsDigit(char c) {
+ return c >= '0' && c <= '9';
+}
// Returns true if "str" is a function clone suffix. These suffixes are used
// by GCC 4.5.x and later versions (and our locally-modified version of GCC
@@ -428,20 +440,22 @@ static bool IsFunctionCloneSuffix(const char *str) {
++i;
}
}
- if (!parsed)
+ if (!parsed) {
return false;
+ }
}
return true; // Consumed everything in "str".
}
-static bool EndsWith(State *state, const char chr) {
+static bool EndsWith(State* state, const char chr) {
return state->parse_state.out_cur_idx > 0 &&
state->parse_state.out_cur_idx < state->out_end_idx &&
chr == state->out[state->parse_state.out_cur_idx - 1];
}
// Append "str" with some tweaks, iff "append" state is true.
-static void MaybeAppendWithLength(State *state, const char *const str,
+static void MaybeAppendWithLength(State* state,
+ const char* const str,
const size_t length) {
if (state->parse_state.append && length > 0) {
// Append a space if the output buffer ends with '<' and "str"
@@ -461,7 +475,7 @@ static void MaybeAppendWithLength(State *state, const char *const str,
}
// Appends a positive decimal number to the output if appending is enabled.
-static bool MaybeAppendDecimal(State *state, int val) {
+static bool MaybeAppendDecimal(State* state, int val) {
// Max {32-64}-bit unsigned int is 20 digits.
constexpr size_t kMaxLength = 20;
char buf[kMaxLength];
@@ -471,7 +485,7 @@ static bool MaybeAppendDecimal(State *state, int val) {
if (state->parse_state.append) {
// We can't have a one-before-the-beginning pointer, so instead start with
// one-past-the-end and manipulate one character before the pointer.
- char *p = &buf[kMaxLength];
+ char* p = &buf[kMaxLength];
do { // val=0 is the only input that should write a leading zero digit.
*--p = static_cast<char>((val % 10) + '0');
val /= 10;
@@ -486,7 +500,7 @@ static bool MaybeAppendDecimal(State *state, int val) {
// A convenient wrapper around MaybeAppendWithLength().
// Returns true so that it can be placed in "if" conditions.
-static bool MaybeAppend(State *state, const char *const str) {
+static bool MaybeAppend(State* state, const char* const str) {
if (state->parse_state.append) {
size_t length = StrLen(str);
MaybeAppendWithLength(state, str, length);
@@ -501,7 +515,7 @@ static bool EnterNestedName(State *state) {
}
// This function is used for handling nested names.
-static bool LeaveNestedName(State *state, int16_t prev_value) {
+static bool LeaveNestedName(State* state, int16_t prev_value) {
state->parse_state.nest_level = prev_value;
return true;
}
@@ -543,7 +557,7 @@ static void MaybeCancelLastSeparator(State *state) {
// Returns true if the identifier of the given length pointed to by
// "mangled_cur" is anonymous namespace.
-static bool IdentifierIsAnonymousNamespace(State *state, size_t length) {
+static bool IdentifierIsAnonymousNamespace(State* state, size_t length) {
// Returns true if "anon_prefix" is a proper prefix of "mangled_cur".
static const char anon_prefix[] = "_GLOBAL__N_";
return (length > (sizeof(anon_prefix) - 1) &&
@@ -554,25 +568,25 @@ static bool IdentifierIsAnonymousNamespace(State *state, size_t length) {
static bool ParseMangledName(State *state);
static bool ParseEncoding(State *state);
static bool ParseName(State *state);
-static bool ParseUnscopedName(State *state);
+static bool ParseUnscopedName(State* state);
static bool ParseNestedName(State *state);
static bool ParsePrefix(State *state);
static bool ParseUnqualifiedName(State *state);
static bool ParseSourceName(State *state);
static bool ParseLocalSourceName(State *state);
-static bool ParseUnnamedTypeName(State *state);
+static bool ParseUnnamedTypeName(State* state);
static bool ParseNumber(State *state, int *number_out);
static bool ParseFloatNumber(State *state);
static bool ParseSeqId(State *state);
-static bool ParseIdentifier(State *state, size_t length);
-static bool ParseOperatorName(State *state, int *arity);
+static bool ParseIdentifier(State* state, size_t length);
+static bool ParseOperatorName(State* state, int* arity);
static bool ParseSpecialName(State *state);
static bool ParseCallOffset(State *state);
static bool ParseNVOffset(State *state);
static bool ParseVOffset(State *state);
-static bool ParseAbiTags(State *state);
+static bool ParseAbiTags(State* state);
static bool ParseCtorDtorName(State *state);
-static bool ParseDecltype(State *state);
+static bool ParseDecltype(State* state);
static bool ParseType(State *state);
static bool ParseCVQualifiers(State *state);
static bool ParseBuiltinType(State *state);
@@ -585,15 +599,15 @@ static bool ParseTemplateParam(State *state);
static bool ParseTemplateTemplateParam(State *state);
static bool ParseTemplateArgs(State *state);
static bool ParseTemplateArg(State *state);
-static bool ParseBaseUnresolvedName(State *state);
-static bool ParseUnresolvedName(State *state);
+static bool ParseBaseUnresolvedName(State* state);
+static bool ParseUnresolvedName(State* state);
static bool ParseExpression(State *state);
static bool ParseExprPrimary(State *state);
-static bool ParseExprCastValue(State *state);
+static bool ParseExprCastValue(State* state);
static bool ParseLocalName(State *state);
-static bool ParseLocalNameSuffix(State *state);
+static bool ParseLocalNameSuffix(State* state);
static bool ParseDiscriminator(State *state);
-static bool ParseSubstitution(State *state, bool accept_std);
+static bool ParseSubstitution(State* state, bool accept_std);
// Implementation note: the following code is a straightforward
// translation of the Itanium C++ ABI defined in BNF with a couple of
@@ -629,7 +643,9 @@ static bool ParseSubstitution(State *state, bool accept_std);
// <mangled-name> ::= _Z <encoding>
static bool ParseMangledName(State *state) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
return ParseTwoCharToken(state, "_Z") && ParseEncoding(state);
}
@@ -638,7 +654,9 @@ static bool ParseMangledName(State *state) {
// ::= <special-name>
static bool ParseEncoding(State *state) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
// Implementing the first two productions together as <name>
// [<bare-function-type>] avoids exponential blowup of backtracking.
//
@@ -660,7 +678,9 @@ static bool ParseEncoding(State *state) {
// ::= <local-name>
static bool ParseName(State *state) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
if (ParseNestedName(state) || ParseLocalName(state)) {
return true;
}
@@ -690,7 +710,9 @@ static bool ParseName(State *state) {
// ::= St <unqualified-name>
static bool ParseUnscopedName(State *state) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
if (ParseUnqualifiedName(state)) {
return true;
}
@@ -706,7 +728,7 @@ static bool ParseUnscopedName(State *state) {
// <ref-qualifer> ::= R // lvalue method reference qualifier
// ::= O // rvalue method reference qualifier
-static inline bool ParseRefQualifier(State *state) {
+static inline bool ParseRefQualifier(State* state) {
return ParseCharClass(state, "OR");
}
@@ -716,7 +738,9 @@ static inline bool ParseRefQualifier(State *state) {
// <template-args> E
static bool ParseNestedName(State *state) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
ParseState copy = state->parse_state;
if (ParseOneCharToken(state, 'N') && EnterNestedName(state) &&
Optional(ParseCVQualifiers(state)) &&
@@ -742,7 +766,9 @@ static bool ParseNestedName(State *state) {
// ::= <substitution>
static bool ParsePrefix(State *state) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
bool has_something = false;
while (true) {
MaybeAppendSeparator(state);
@@ -773,7 +799,9 @@ static bool ParsePrefix(State *state) {
// <local-source-name> is a GCC extension; see below.
static bool ParseUnqualifiedName(State *state) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
if (ParseOperatorName(state, nullptr) || ParseCtorDtorName(state) ||
ParseSourceName(state) || ParseLocalSourceName(state) ||
ParseUnnamedTypeName(state)) {
@@ -784,9 +812,11 @@ static bool ParseUnqualifiedName(State *state) {
// <abi-tags> ::= <abi-tag> [<abi-tags>]
// <abi-tag> ::= B <source-name>
-static bool ParseAbiTags(State *state) {
+static bool ParseAbiTags(State* state) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
while (ParseOneCharToken(state, 'B')) {
ParseState copy = state->parse_state;
@@ -805,7 +835,9 @@ static bool ParseAbiTags(State *state) {
// <source-name> ::= <positive length number> <identifier>
static bool ParseSourceName(State *state) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
ParseState copy = state->parse_state;
int length = -1;
if (ParseNumber(state, &length) &&
@@ -823,7 +855,9 @@ static bool ParseSourceName(State *state) {
// https://gcc.gnu.org/viewcvs?view=rev&revision=124467
static bool ParseLocalSourceName(State *state) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
ParseState copy = state->parse_state;
if (ParseOneCharToken(state, 'L') && ParseSourceName(state) &&
Optional(ParseDiscriminator(state))) {
@@ -837,9 +871,11 @@ static bool ParseLocalSourceName(State *state) {
// ::= <closure-type-name>
// <closure-type-name> ::= Ul <lambda-sig> E [<(nonnegative) number>] _
// <lambda-sig> ::= <(parameter) type>+
-static bool ParseUnnamedTypeName(State *state) {
+static bool ParseUnnamedTypeName(State* state) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
ParseState copy = state->parse_state;
// Type's 1-based index n is encoded as { "", n == 1; itoa(n-2), otherwise }.
// Optionally parse the encoded value into 'which' and add 2 to get the index.
@@ -878,12 +914,14 @@ static bool ParseUnnamedTypeName(State *state) {
// parsed number on success.
static bool ParseNumber(State *state, int *number_out) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
bool negative = false;
if (ParseOneCharToken(state, 'n')) {
negative = true;
}
- const char *p = RemainingInput(state);
+ const char* p = RemainingInput(state);
uint64_t number = 0;
for (; *p != '\0'; ++p) {
if (IsDigit(*p)) {
@@ -913,8 +951,10 @@ static bool ParseNumber(State *state, int *number_out) {
// hexadecimal string.
static bool ParseFloatNumber(State *state) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
- const char *p = RemainingInput(state);
+ if (guard.IsTooComplex()) {
+ return false;
+ }
+ const char* p = RemainingInput(state);
for (; *p != '\0'; ++p) {
if (!IsDigit(*p) && !(*p >= 'a' && *p <= 'f')) {
break;
@@ -931,8 +971,10 @@ static bool ParseFloatNumber(State *state) {
// using digits and upper case letters
static bool ParseSeqId(State *state) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
- const char *p = RemainingInput(state);
+ if (guard.IsTooComplex()) {
+ return false;
+ }
+ const char* p = RemainingInput(state);
for (; *p != '\0'; ++p) {
if (!IsDigit(*p) && !(*p >= 'A' && *p <= 'Z')) {
break;
@@ -946,9 +988,11 @@ static bool ParseSeqId(State *state) {
}
// <identifier> ::= <unqualified source code identifier> (of given length)
-static bool ParseIdentifier(State *state, size_t length) {
+static bool ParseIdentifier(State* state, size_t length) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
if (!AtLeastNumCharsRemaining(RemainingInput(state), length)) {
return false;
}
@@ -964,9 +1008,11 @@ static bool ParseIdentifier(State *state, size_t length) {
// <operator-name> ::= nw, and other two letters cases
// ::= cv <type> # (cast)
// ::= v <digit> <source-name> # vendor extended operator
-static bool ParseOperatorName(State *state, int *arity) {
+static bool ParseOperatorName(State* state, int* arity) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
if (!AtLeastNumCharsRemaining(RemainingInput(state), 2)) {
return false;
}
@@ -1036,7 +1082,9 @@ static bool ParseOperatorName(State *state, int *arity) {
// stack traces. The are special data.
static bool ParseSpecialName(State *state) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
ParseState copy = state->parse_state;
if (ParseOneCharToken(state, 'T') && ParseCharClass(state, "VTISH") &&
ParseType(state)) {
@@ -1098,7 +1146,9 @@ static bool ParseSpecialName(State *state) {
// ::= v <v-offset> _
static bool ParseCallOffset(State *state) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
ParseState copy = state->parse_state;
if (ParseOneCharToken(state, 'h') && ParseNVOffset(state) &&
ParseOneCharToken(state, '_')) {
@@ -1118,14 +1168,18 @@ static bool ParseCallOffset(State *state) {
// <nv-offset> ::= <(offset) number>
static bool ParseNVOffset(State *state) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
return ParseNumber(state, nullptr);
}
// <v-offset> ::= <(offset) number> _ <(virtual offset) number>
static bool ParseVOffset(State *state) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
ParseState copy = state->parse_state;
if (ParseNumber(state, nullptr) && ParseOneCharToken(state, '_') &&
ParseNumber(state, nullptr)) {
@@ -1144,11 +1198,13 @@ static bool ParseVOffset(State *state) {
// ::= C4 | D4
static bool ParseCtorDtorName(State *state) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
ParseState copy = state->parse_state;
if (ParseOneCharToken(state, 'C')) {
if (ParseCharClass(state, "1234")) {
- const char *const prev_name =
+ const char* const prev_name =
state->out + state->parse_state.prev_name_idx;
MaybeAppendWithLength(state, prev_name,
state->parse_state.prev_name_length);
@@ -1161,7 +1217,7 @@ static bool ParseCtorDtorName(State *state) {
state->parse_state = copy;
if (ParseOneCharToken(state, 'D') && ParseCharClass(state, "0124")) {
- const char *const prev_name = state->out + state->parse_state.prev_name_idx;
+ const char* const prev_name = state->out + state->parse_state.prev_name_idx;
MaybeAppend(state, "~");
MaybeAppendWithLength(state, prev_name,
state->parse_state.prev_name_length);
@@ -1174,9 +1230,11 @@ static bool ParseCtorDtorName(State *state) {
// <decltype> ::= Dt <expression> E # decltype of an id-expression or class
// # member access (C++0x)
// ::= DT <expression> E # decltype of an expression (C++0x)
-static bool ParseDecltype(State *state) {
+static bool ParseDecltype(State* state) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
ParseState copy = state->parse_state;
if (ParseOneCharToken(state, 'D') && ParseCharClass(state, "tT") &&
@@ -1209,7 +1267,9 @@ static bool ParseDecltype(State *state) {
//
static bool ParseType(State *state) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
ParseState copy = state->parse_state;
// We should check CV-qualifers, and PRGC things first.
@@ -1227,7 +1287,9 @@ static bool ParseType(State *state) {
// By consuming the CV-qualifiers first, the former parse is disabled.
if (ParseCVQualifiers(state)) {
const bool result = ParseType(state);
- if (!result) state->parse_state = copy;
+ if (!result) {
+ state->parse_state = copy;
+ }
return result;
}
state->parse_state = copy;
@@ -1238,7 +1300,9 @@ static bool ParseType(State *state) {
// refusing to backtrack the tag characters.
if (ParseCharClass(state, "OPRCG")) {
const bool result = ParseType(state);
- if (!result) state->parse_state = copy;
+ if (!result) {
+ state->parse_state = copy;
+ }
return result;
}
state->parse_state = copy;
@@ -1286,7 +1350,9 @@ static bool ParseType(State *state) {
// ParseType().
static bool ParseCVQualifiers(State *state) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
int num_cv_qualifiers = 0;
num_cv_qualifiers += ParseOneCharToken(state, 'r');
num_cv_qualifiers += ParseOneCharToken(state, 'V');
@@ -1303,7 +1369,9 @@ static bool ParseCVQualifiers(State *state) {
//
static bool ParseBuiltinType(State *state) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
const AbbrevPair *p;
for (p = kBuiltinTypeList; p->abbrev != nullptr; ++p) {
// Guaranteed only 1- or 2-character strings in kBuiltinTypeList.
@@ -1333,11 +1401,15 @@ static bool ParseBuiltinType(State *state) {
// noexcept
// ::= Dw <type>+ E # dynamic exception specification
// with instantiation-dependent types
-static bool ParseExceptionSpec(State *state) {
+static bool ParseExceptionSpec(State* state) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
- if (ParseTwoCharToken(state, "Do")) return true;
+ if (ParseTwoCharToken(state, "Do")) {
+ return true;
+ }
ParseState copy = state->parse_state;
if (ParseTwoCharToken(state, "DO") && ParseExpression(state) &&
@@ -1357,7 +1429,9 @@ static bool ParseExceptionSpec(State *state) {
// <function-type> ::= [exception-spec] F [Y] <bare-function-type> [O] E
static bool ParseFunctionType(State *state) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
ParseState copy = state->parse_state;
if (Optional(ParseExceptionSpec(state)) && ParseOneCharToken(state, 'F') &&
Optional(ParseOneCharToken(state, 'Y')) && ParseBareFunctionType(state) &&
@@ -1372,7 +1446,9 @@ static bool ParseFunctionType(State *state) {
// <bare-function-type> ::= <(signature) type>+
static bool ParseBareFunctionType(State *state) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
ParseState copy = state->parse_state;
DisableAppend(state);
if (OneOrMore(ParseType, state)) {
@@ -1387,7 +1463,9 @@ static bool ParseBareFunctionType(State *state) {
// <class-enum-type> ::= <name>
static bool ParseClassEnumType(State *state) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
return ParseName(state);
}
@@ -1395,7 +1473,9 @@ static bool ParseClassEnumType(State *state) {
// ::= A [<(dimension) expression>] _ <(element) type>
static bool ParseArrayType(State *state) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
ParseState copy = state->parse_state;
if (ParseOneCharToken(state, 'A') && ParseNumber(state, nullptr) &&
ParseOneCharToken(state, '_') && ParseType(state)) {
@@ -1414,7 +1494,9 @@ static bool ParseArrayType(State *state) {
// <pointer-to-member-type> ::= M <(class) type> <(member) type>
static bool ParsePointerToMemberType(State *state) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
ParseState copy = state->parse_state;
if (ParseOneCharToken(state, 'M') && ParseType(state) && ParseType(state)) {
return true;
@@ -1427,7 +1509,9 @@ static bool ParsePointerToMemberType(State *state) {
// ::= T <parameter-2 non-negative number> _
static bool ParseTemplateParam(State *state) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
if (ParseTwoCharToken(state, "T_")) {
MaybeAppend(state, "?"); // We don't support template substitutions.
return true;
@@ -1447,7 +1531,9 @@ static bool ParseTemplateParam(State *state) {
// ::= <substitution>
static bool ParseTemplateTemplateParam(State *state) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
return (ParseTemplateParam(state) ||
// "std" on its own isn't a template.
ParseSubstitution(state, /*accept_std=*/false));
@@ -1456,7 +1542,9 @@ static bool ParseTemplateTemplateParam(State *state) {
// <template-args> ::= I <template-arg>+ E
static bool ParseTemplateArgs(State *state) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
ParseState copy = state->parse_state;
DisableAppend(state);
if (ParseOneCharToken(state, 'I') && OneOrMore(ParseTemplateArg, state) &&
@@ -1475,7 +1563,9 @@ static bool ParseTemplateArgs(State *state) {
// ::= X <expression> E
static bool ParseTemplateArg(State *state) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
ParseState copy = state->parse_state;
if (ParseOneCharToken(state, 'J') && ZeroOrMore(ParseTemplateArg, state) &&
ParseOneCharToken(state, 'E')) {
@@ -1578,14 +1668,14 @@ static bool ParseTemplateArg(State *state) {
// <unresolved-type> ::= <template-param> [<template-args>]
// ::= <decltype>
// ::= <substitution>
-static inline bool ParseUnresolvedType(State *state) {
+static inline bool ParseUnresolvedType(State* state) {
// No ComplexityGuard because we don't copy the state in this stack frame.
return (ParseTemplateParam(state) && Optional(ParseTemplateArgs(state))) ||
ParseDecltype(state) || ParseSubstitution(state, /*accept_std=*/false);
}
// <simple-id> ::= <source-name> [<template-args>]
-static inline bool ParseSimpleId(State *state) {
+static inline bool ParseSimpleId(State* state) {
// No ComplexityGuard because we don't copy the state in this stack frame.
// Note: <simple-id> cannot be followed by a parameter pack; see comment in
@@ -1596,9 +1686,11 @@ static inline bool ParseSimpleId(State *state) {
// <base-unresolved-name> ::= <source-name> [<template-args>]
// ::= on <operator-name> [<template-args>]
// ::= dn <destructor-name>
-static bool ParseBaseUnresolvedName(State *state) {
+static bool ParseBaseUnresolvedName(State* state) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
if (ParseSimpleId(state)) {
return true;
@@ -1626,9 +1718,11 @@ static bool ParseBaseUnresolvedName(State *state) {
// <base-unresolved-name>
// ::= [gs] sr <unresolved-qualifier-level>+ E
// <base-unresolved-name>
-static bool ParseUnresolvedName(State *state) {
+static bool ParseUnresolvedName(State* state) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
ParseState copy = state->parse_state;
if (Optional(ParseTwoCharToken(state, "gs")) &&
@@ -1684,7 +1778,9 @@ static bool ParseUnresolvedName(State *state) {
// ::= fL <number> p <(top-level) CV-qualifiers> <number> _
static bool ParseExpression(State *state) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
if (ParseTemplateParam(state) || ParseExprPrimary(state)) {
return true;
}
@@ -1817,7 +1913,9 @@ static bool ParseExpression(State *state) {
// casts to <local-name> types.
static bool ParseExprPrimary(State *state) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
ParseState copy = state->parse_state;
// The "LZ" special case: if we see LZ, we commit to accept "LZ <encoding> E"
@@ -1848,9 +1946,11 @@ static bool ParseExprPrimary(State *state) {
}
// <number> or <float>, followed by 'E', as described above ParseExprPrimary.
-static bool ParseExprCastValue(State *state) {
+static bool ParseExprCastValue(State* state) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
// We have to be able to backtrack after accepting a number because we could
// have e.g. "7fffE", which will accept "7" as a number but then fail to find
// the 'E'.
@@ -1877,9 +1977,11 @@ static bool ParseExprCastValue(State *state) {
// <local-name-suffix> ::= s [<discriminator>]
// ::= <name> [<discriminator>]
-static bool ParseLocalNameSuffix(State *state) {
+static bool ParseLocalNameSuffix(State* state) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
if (MaybeAppend(state, "::") && ParseName(state) &&
Optional(ParseDiscriminator(state))) {
@@ -1896,9 +1998,11 @@ static bool ParseLocalNameSuffix(State *state) {
return ParseOneCharToken(state, 's') && Optional(ParseDiscriminator(state));
}
-static bool ParseLocalName(State *state) {
+static bool ParseLocalName(State* state) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
ParseState copy = state->parse_state;
if (ParseOneCharToken(state, 'Z') && ParseEncoding(state) &&
ParseOneCharToken(state, 'E') && ParseLocalNameSuffix(state)) {
@@ -1911,7 +2015,9 @@ static bool ParseLocalName(State *state) {
// <discriminator> := _ <(non-negative) number>
static bool ParseDiscriminator(State *state) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
ParseState copy = state->parse_state;
if (ParseOneCharToken(state, '_') && ParseNumber(state, nullptr)) {
return true;
@@ -1931,9 +2037,11 @@ static bool ParseDiscriminator(State *state) {
// an unqualified name and re-parse the same template-args. To block this
// exponential backtracking, we disable it with 'accept_std=false' in
// problematic contexts.
-static bool ParseSubstitution(State *state, bool accept_std) {
+static bool ParseSubstitution(State* state, bool accept_std) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
if (ParseTwoCharToken(state, "S_")) {
MaybeAppend(state, "?"); // We don't support substitutions.
return true;
@@ -1971,7 +2079,9 @@ static bool ParseSubstitution(State *state, bool accept_std) {
// or version suffix. Returns true only if all of "mangled_cur" was consumed.
static bool ParseTopLevelMangledName(State *state) {
ComplexityGuard guard(state);
- if (guard.IsTooComplex()) return false;
+ if (guard.IsTooComplex()) {
+ return false;
+ }
if (ParseMangledName(state)) {
if (RemainingInput(state)[0] != '\0') {
// Drop trailing function clone suffix, if any.
@@ -1991,13 +2101,13 @@ static bool ParseTopLevelMangledName(State *state) {
return false;
}
-static bool Overflowed(const State *state) {
+static bool Overflowed(const State* state) {
return state->parse_state.out_cur_idx >= state->out_end_idx;
}
#endif
// The demangler entry point.
-bool Demangle(const char *mangled, char *out, size_t out_size) {
+bool Demangle(const char* mangled, char* out, size_t out_size) {
#if defined(GLOG_OS_WINDOWS)
#if defined(HAVE_DBGHELP)
// When built with incremental linking, the Windows debugger
diff --git a/base/third_party/symbolize/demangle.h b/base/third_party/symbolize/demangle.h
index 26e821a53c2cb..7d5cfaaabf0dd 100644
--- a/base/third_party/symbolize/demangle.h
+++ b/base/third_party/symbolize/demangle.h
@@ -80,7 +80,7 @@ _START_GOOGLE_NAMESPACE_
// Demangle "mangled". On success, return true and write the
// demangled symbol name to "out". Otherwise, return false.
// "out" is modified even if demangling is unsuccessful.
-bool GLOG_EXPORT Demangle(const char *mangled, char *out, size_t out_size);
+bool GLOG_EXPORT Demangle(const char* mangled, char* out, size_t out_size);
_END_GOOGLE_NAMESPACE_
diff --git a/base/third_party/symbolize/glog/logging.h b/base/third_party/symbolize/glog/logging.h
index 46869226024da..b935e3ec9cded 100644
--- a/base/third_party/symbolize/glog/logging.h
+++ b/base/third_party/symbolize/glog/logging.h
@@ -38,4 +38,4 @@
// Not needed in Chrome.
-#endif // GLOG_LOGGING_H
+#endif // GLOG_LOGGING_H
diff --git a/base/third_party/symbolize/symbolize.cc b/base/third_party/symbolize/symbolize.cc
index b6ddc85d57185..a3b8399f411bf 100644
--- a/base/third_party/symbolize/symbolize.cc
+++ b/base/third_party/symbolize/symbolize.cc
@@ -97,7 +97,7 @@ void InstallSymbolizeOpenObjectFileCallback(
// where the input symbol is demangled in-place.
// To keep stack consumption low, we would like this function to not
// get inlined.
-static ATTRIBUTE_NOINLINE void DemangleInplace(char *out, size_t out_size) {
+static ATTRIBUTE_NOINLINE void DemangleInplace(char* out, size_t out_size) {
char demangled[256]; // Big enough for sane demangled symbols.
if (Demangle(out, demangled, sizeof(demangled))) {
// Demangling succeeded. Copy to out if the space allows.
@@ -121,17 +121,17 @@ _END_GOOGLE_NAMESPACE_
#else
#include <elf.h>
#endif
+#include <fcntl.h>
+#include <stdint.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
#include <cerrno>
#include <climits>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
-#include <fcntl.h>
-#include <stdint.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
#include "symbolize.h"
#include "config.h"
@@ -153,7 +153,8 @@ ssize_t ReadFromOffset(const int fd,
const size_t count,
const size_t offset) {
SAFE_ASSERT(fd >= 0);
- SAFE_ASSERT(count <= static_cast<size_t>(std::numeric_limits<ssize_t>::max()));
+ SAFE_ASSERT(count <=
+ static_cast<size_t>(std::numeric_limits<ssize_t>::max()));
char *buf0 = reinterpret_cast<char *>(buf);
size_t num_bytes = 0;
while (num_bytes < count) {
@@ -176,8 +177,10 @@ ssize_t ReadFromOffset(const int fd,
// pointed by "fd" into the buffer starting at "buf" while handling
// short reads and EINTR. On success, return true. Otherwise, return
// false.
-static bool ReadFromOffsetExact(const int fd, void *buf,
- const size_t count, const size_t offset) {
+static bool ReadFromOffsetExact(const int fd,
+ void* buf,
+ const size_t count,
+ const size_t offset) {
ssize_t len = ReadFromOffset(fd, buf, count, offset);
return static_cast<size_t>(len) == count;
}
@@ -199,9 +202,11 @@ static int FileGetElfType(const int fd) {
// and return true. Otherwise, return false.
// To keep stack consumption low, we would like this function to not get
// inlined.
-static ATTRIBUTE_NOINLINE bool
-GetSectionHeaderByType(const int fd, ElfW(Half) sh_num, const size_t sh_offset,
- ElfW(Word) type, ElfW(Shdr) *out) {
+static ATTRIBUTE_NOINLINE bool GetSectionHeaderByType(const int fd,
+ ElfW(Half) sh_num,
+ const size_t sh_offset,
+ ElfW(Word) type,
+ ElfW(Shdr) * out) {
// Read at most 16 section headers at a time to save read calls.
ElfW(Shdr) buf[16];
for (size_t i = 0; i < sh_num;) {
@@ -248,8 +253,8 @@ bool GetSectionHeaderByName(int fd, const char *name, size_t name_len,
}
for (size_t i = 0; i < elf_header.e_shnum; ++i) {
- size_t section_header_offset = (elf_header.e_shoff +
- elf_header.e_shentsize * i);
+ size_t section_header_offset =
+ (elf_header.e_shoff + elf_header.e_shentsize * i);
if (!ReadFromOffsetExact(fd, out, sizeof(*out), section_header_offset)) {
return false;
}
@@ -281,10 +286,13 @@ bool GetSectionHeaderByName(int fd, const char *name, size_t name_len,
// to out. Otherwise, return false.
// To keep stack consumption low, we would like this function to not get
// inlined.
-static ATTRIBUTE_NOINLINE bool
-FindSymbol(uint64_t pc, const int fd, char *out, size_t out_size,
- uint64_t symbol_offset, const ElfW(Shdr) *strtab,
- const ElfW(Shdr) *symtab) {
+static ATTRIBUTE_NOINLINE bool FindSymbol(uint64_t pc,
+ const int fd,
+ char* out,
+ size_t out_size,
+ uint64_t symbol_offset,
+ const ElfW(Shdr) * strtab,
+ const ElfW(Shdr) * symtab) {
if (symtab == NULL) {
return false;
}
@@ -384,7 +392,7 @@ namespace {
// and snprintf().
class LineReader {
public:
- explicit LineReader(int fd, char *buf, size_t buf_len, size_t offset)
+ explicit LineReader(int fd, char* buf, size_t buf_len, size_t offset)
: fd_(fd),
buf_(buf),
buf_len_(buf_len),
@@ -449,11 +457,12 @@ class LineReader {
}
private:
- LineReader(const LineReader &);
+ LineReader(const LineReader&);
void operator=(const LineReader&);
char *FindLineFeed() {
- return reinterpret_cast<char *>(memchr(bol_, '\n', static_cast<size_t>(eod_ - bol_)));
+ return reinterpret_cast<char*>(
+ memchr(bol_, '\n', static_cast<size_t>(eod_ - bol_)));
}
bool BufferIsEmpty() {
@@ -483,7 +492,8 @@ static char *GetHex(const char *start, const char *end, uint64_t *hex) {
int ch = *p;
if ((ch >= '0' && ch <= '9') ||
(ch >= 'A' && ch <= 'F') || (ch >= 'a' && ch <= 'f')) {
- *hex = (*hex << 4U) | (ch < 'A' ? static_cast<uint64_t>(ch - '0') : (ch & 0xF) + 9U);
+ *hex = (*hex << 4U) |
+ (ch < 'A' ? static_cast<uint64_t>(ch - '0') : (ch & 0xF) + 9U);
} else { // Encountered the first non-hex character.
break;
}
@@ -647,12 +657,11 @@ static int OpenObjectFileContainingPcAndGetStartAddressNoHook(
}
}
-int OpenObjectFileContainingPcAndGetStartAddress(
- uint64_t pc,
- uint64_t& start_address,
- uint64_t& base_address,
- char* out_file_name,
- size_t out_file_name_size) {
+int OpenObjectFileContainingPcAndGetStartAddress(uint64_t pc,
+ uint64_t& start_address,
+ uint64_t& base_address,
+ char* out_file_name,
+ size_t out_file_name_size) {
if (g_symbolize_open_object_file_callback) {
return g_symbolize_open_object_file_callback(
pc, start_address, base_address, out_file_name, out_file_name_size);
@@ -668,7 +677,11 @@ int OpenObjectFileContainingPcAndGetStartAddress(
// bytes. Output will be truncated as needed, and a NUL character is always
// appended.
// NOTE: code from sandbox/linux/seccomp-bpf/demo.cc.
-static char *itoa_r(uintptr_t i, char *buf, size_t sz, unsigned base, size_t padding) {
+static char* itoa_r(uintptr_t i,
+ char* buf,
+ size_t sz,
+ unsigned base,
+ size_t padding) {
// Make sure we can write at least one NUL byte.
size_t n = 1;
if (n > sz) {
@@ -745,7 +758,8 @@ static void SafeAppendHexNumber(uint64_t value, char* dest, size_t dest_size) {
// and "out" is used as its output.
// To keep stack consumption low, we would like this function to not
// get inlined.
-static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(void *pc, char *out,
+static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(void* pc,
+ char* out,
size_t out_size) {
uint64_t pc0 = reinterpret_cast<uintptr_t>(pc);
uint64_t start_address = 0;
@@ -822,14 +836,16 @@ static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(void *pc, char *out,
_END_GOOGLE_NAMESPACE_
-#elif (defined(GLOG_OS_MACOSX) || defined(GLOG_OS_EMSCRIPTEN)) && defined(HAVE_DLADDR)
+#elif (defined(GLOG_OS_MACOSX) || defined(GLOG_OS_EMSCRIPTEN)) && \
+ defined(HAVE_DLADDR)
#include <dlfcn.h>
#include <cstring>
_START_GOOGLE_NAMESPACE_
-static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(void *pc, char *out,
+static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(void* pc,
+ char* out,
size_t out_size) {
Dl_info info;
if (dladdr(pc, &info)) {
@@ -883,7 +899,8 @@ private:
SymInitializer& operator=(const SymInitializer&);
};
-static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(void *pc, char *out,
+static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(void* pc,
+ char* out,
size_t out_size) {
const static SymInitializer symInitializer;
if (!symInitializer.ready) {
@@ -918,7 +935,7 @@ _END_GOOGLE_NAMESPACE_
_START_GOOGLE_NAMESPACE_
-bool Symbolize(void *pc, char *out, size_t out_size) {
+bool Symbolize(void* pc, char* out, size_t out_size) {
return SymbolizeAndDemangle(pc, out, out_size);
}
diff --git a/base/third_party/symbolize/symbolize.h b/base/third_party/symbolize/symbolize.h
index 64ff0509ce57d..987569fdde67f 100644
--- a/base/third_party/symbolize/symbolize.h
+++ b/base/third_party/symbolize/symbolize.h
@@ -127,7 +127,7 @@ ATTRIBUTE_NOINLINE int OpenObjectFileContainingPcAndGetStartAddress(
_END_GOOGLE_NAMESPACE_
-#endif /* __ELF__ */
+#endif /* __ELF__ */
_START_GOOGLE_NAMESPACE_
@@ -140,7 +140,7 @@ struct FileDescriptor {
int get() { return fd_; }
private:
- FileDescriptor(const FileDescriptor &);
+ FileDescriptor(const FileDescriptor&);
void operator=(const FileDescriptor&);
};
diff --git a/base/third_party/symbolize/utilities.h b/base/third_party/symbolize/utilities.h
index 8c61380fad159..bb206a8020315 100644
--- a/base/third_party/symbolize/utilities.h
+++ b/base/third_party/symbolize/utilities.h
@@ -35,13 +35,13 @@
#define UTILITIES_H__
#ifdef HAVE___ATTRIBUTE__
-# define ATTRIBUTE_NOINLINE __attribute__ ((noinline))
-# define HAVE_ATTRIBUTE_NOINLINE
+#define ATTRIBUTE_NOINLINE __attribute__((noinline))
+#define HAVE_ATTRIBUTE_NOINLINE
#elif defined(GLOG_OS_WINDOWS)
-# define ATTRIBUTE_NOINLINE __declspec(noinline)
-# define HAVE_ATTRIBUTE_NOINLINE
+#define ATTRIBUTE_NOINLINE __declspec(noinline)
+#define HAVE_ATTRIBUTE_NOINLINE
#else
-# define ATTRIBUTE_NOINLINE
+#define ATTRIBUTE_NOINLINE
#endif
#endif // UTILITIES_H__
Codebase Browser
chromium