1diff --git a/src/tests/perf_tests/third_party/perf/angle-mods.patch b/src/tests/perf_tests/third_party/perf/angle-mods.patch
2index a758818c0..e69de29bb 100644
3--- a/src/tests/perf_tests/third_party/perf/angle-mods.patch
4+++ b/src/tests/perf_tests/third_party/perf/angle-mods.patch
5@@ -1,176 +0,0 @@
6-diff --git a/src/tests/perf_tests/third_party/perf/angle-mods.patch b/src/tests/perf_tests/third_party/perf/angle-mods.patch
7-index d0b640289..e69de29bb 100644
8---- a/src/tests/perf_tests/third_party/perf/angle-mods.patch
9-+++ b/src/tests/perf_tests/third_party/perf/angle-mods.patch
10-@@ -1,61 +0,0 @@
11--diff --git a/tests/perf_tests/third_party/perf/perf_test.cc b/tests/perf_tests/third_party/perf/perf_test.cc
12--index 0d5abc0..7364330 100644
13----- a/tests/perf_tests/third_party/perf/perf_test.cc
14--+++ b/tests/perf_tests/third_party/perf/perf_test.cc
15--@@ -2,16 +2,51 @@
16-- // Use of this source code is governed by a BSD-style license that can be
17-- // found in the LICENSE file.
18--
19---#include "testing/perf/perf_test.h"
20--+#include "perf_test.h"
21--
22-- #include <stdio.h>
23---
24---#include "base/logging.h"
25---#include "base/strings/string_number_conversions.h"
26---#include "base/strings/stringprintf.h"
27--+#include <stdarg.h>
28--+#include <vector>
29--
30-- namespace {
31--
32--+namespace base {
33--+
34--+std::string FormatString(const char *fmt, va_list vararg) {
35--+  static std::vector<char> buffer(512);
36--+
37--+  // Attempt to just print to the current buffer
38--+  int len = vsnprintf(&buffer[0], buffer.size(), fmt, vararg);
39--+  if (len < 0 || static_cast<size_t>(len) >= buffer.size()) {
40--+    // Buffer was not large enough, calculate the required size and resize the buffer
41--+    len = vsnprintf(NULL, 0, fmt, vararg);
42--+    buffer.resize(len + 1);
43--+
44--+    // Print again
45--+    vsnprintf(&buffer[0], buffer.size(), fmt, vararg);
46--+  }
47--+
48--+  return std::string(buffer.data(), len);
49--+}
50--+
51--+std::string StringPrintf(const char *fmt, ...) {
52--+  va_list vararg;
53--+  va_start(vararg, fmt);
54--+  std::string result = FormatString(fmt, vararg);
55--+  va_end(vararg);
56--+  return result;
57--+}
58--+
59--+std::string UintToString(unsigned int value) {
60--+  return StringPrintf("%u", value);
61--+}
62--+
63--+std::string DoubleToString(double value) {
64--+  return StringPrintf("%.10lf", value);
65--+}
66--+
67--+}
68--+
69-- std::string ResultsToString(const std::string& measurement,
70--                             const std::string& modifier,
71--                             const std::string& trace,
72-diff --git a/src/tests/perf_tests/third_party/perf/perf_result_reporter.cc b/src/tests/perf_tests/third_party/perf/perf_result_reporter.cc
73-index 272e6ca17..3a6a41f01 100644
74---- a/src/tests/perf_tests/third_party/perf/perf_result_reporter.cc
75-+++ b/src/tests/perf_tests/third_party/perf/perf_result_reporter.cc
76-@@ -2,9 +2,9 @@
77- // Use of this source code is governed by a BSD-style license that can be
78- // found in the LICENSE file.
79-
80--#include "testing/perf/perf_result_reporter.h"
81--#include "base/logging.h"
82--#include "testing/perf/perf_test.h"
83-+#include "perf_result_reporter.h"
84-+#include "anglebase/logging.h"
85-+#include "perf_test.h"
86-
87- namespace perf_test {
88-
89-diff --git a/src/tests/perf_tests/third_party/perf/perf_test.cc b/src/tests/perf_tests/third_party/perf/perf_test.cc
90-index 0b0b666db..bc3a6bb8d 100644
91---- a/src/tests/perf_tests/third_party/perf/perf_test.cc
92-+++ b/src/tests/perf_tests/third_party/perf/perf_test.cc
93-@@ -2,16 +2,47 @@
94- // Use of this source code is governed by a BSD-style license that can be
95- // found in the LICENSE file.
96-
97--#include "testing/perf/perf_test.h"
98-+#include "perf_test.h"
99-
100-+#include <stdarg.h>
101- #include <stdio.h>
102--
103--#include "base/logging.h"
104--#include "base/strings/string_number_conversions.h"
105--#include "base/strings/stringprintf.h"
106-+#include <vector>
107-
108- namespace {
109-
110-+std::string FormatString(const char *fmt, va_list vararg) {
111-+  static std::vector<char> buffer(512);
112-+
113-+  // Attempt to just print to the current buffer
114-+  int len = vsnprintf(&buffer[0], buffer.size(), fmt, vararg);
115-+  if (len < 0 || static_cast<size_t>(len) >= buffer.size()) {
116-+    // Buffer was not large enough, calculate the required size and resize the buffer
117-+    len = vsnprintf(NULL, 0, fmt, vararg);
118-+    buffer.resize(len + 1);
119-+
120-+    // Print again
121-+    vsnprintf(&buffer[0], buffer.size(), fmt, vararg);
122-+  }
123-+
124-+  return std::string(buffer.data(), len);
125-+}
126-+
127-+std::string StringPrintf(const char *fmt, ...) {
128-+  va_list vararg;
129-+  va_start(vararg, fmt);
130-+  std::string result = FormatString(fmt, vararg);
131-+  va_end(vararg);
132-+  return result;
133-+}
134-+
135-+std::string NumberToString(size_t value) {
136-+  return StringPrintf("%u", value);
137-+}
138-+
139-+std::string NumberToString(double value) {
140-+  return StringPrintf("%.10lf", value);
141-+}
142-+
143- std::string ResultsToString(const std::string& measurement,
144-                             const std::string& modifier,
145-                             const std::string& trace,
146-@@ -23,7 +54,7 @@ std::string ResultsToString(const std::string& measurement,
147-   // <*>RESULT <graph_name>: <trace_name>= <value> <units>
148-   // <*>RESULT <graph_name>: <trace_name>= {<mean>, <std deviation>} <units>
149-   // <*>RESULT <graph_name>: <trace_name>= [<value>,value,value,...,] <units>
150--  return base::StringPrintf("%sRESULT %s%s: %s= %s%s%s %s\n",
151-+  return StringPrintf("%sRESULT %s%s: %s= %s%s%s %s\n",
152-          important ? "*" : "", measurement.c_str(), modifier.c_str(),
153-          trace.c_str(), prefix.c_str(), values.c_str(), suffix.c_str(),
154-          units.c_str());
155-@@ -53,7 +84,7 @@ void PrintResult(const std::string& measurement,
156-                  size_t value,
157-                  const std::string& units,
158-                  bool important) {
159--  PrintResultsImpl(measurement, modifier, trace, base::NumberToString(value),
160-+  PrintResultsImpl(measurement, modifier, trace, NumberToString(value),
161-                    std::string(), std::string(), units, important);
162- }
163-
164-@@ -63,7 +94,7 @@ void PrintResult(const std::string& measurement,
165-                  double value,
166-                  const std::string& units,
167-                  bool important) {
168--  PrintResultsImpl(measurement, modifier, trace, base::NumberToString(value),
169-+  PrintResultsImpl(measurement, modifier, trace, NumberToString(value),
170-                    std::string(), std::string(), units, important);
171- }
172-
173-@@ -75,7 +106,7 @@ void AppendResult(std::string& output,
174-                   const std::string& units,
175-                   bool important) {
176-   output +=
177--      ResultsToString(measurement, modifier, trace, base::NumberToString(value),
178-+      ResultsToString(measurement, modifier, trace, NumberToString(value),
179-                       std::string(), std::string(), units, important);
180- }
181-
182diff --git a/src/tests/perf_tests/third_party/perf/perf_result_reporter.cc b/src/tests/perf_tests/third_party/perf/perf_result_reporter.cc
183index 272e6ca17..fcbfa78b3 100644
184--- a/src/tests/perf_tests/third_party/perf/perf_result_reporter.cc
185+++ b/src/tests/perf_tests/third_party/perf/perf_result_reporter.cc
186@@ -2,72 +2,77 @@
187 // Use of this source code is governed by a BSD-style license that can be
188 // found in the LICENSE file.
189
190-#include "testing/perf/perf_result_reporter.h"
191-#include "base/logging.h"
192-#include "testing/perf/perf_test.h"
193+#include "perf_result_reporter.h"
194+#include "anglebase/logging.h"
195+#include "perf_test.h"
196
197-namespace perf_test {
198+namespace perf_test
199+{
200
201-PerfResultReporter::PerfResultReporter(const std::string& metric_basename,
202-                                       const std::string& story_name)
203-    : metric_basename_(metric_basename), story_name_(story_name) {}
204+PerfResultReporter::PerfResultReporter(const std::string &metric_basename,
205+                                       const std::string &story_name)
206+    : metric_basename_(metric_basename), story_name_(story_name)
207+{}
208
209 PerfResultReporter::~PerfResultReporter() = default;
210
211-void PerfResultReporter::RegisterFyiMetric(const std::string& metric_suffix,
212-                                           const std::string& units) {
213-  RegisterMetric(metric_suffix, units, false);
214+void PerfResultReporter::RegisterFyiMetric(const std::string &metric_suffix,
215+                                           const std::string &units)
216+{
217+    RegisterMetric(metric_suffix, units, false);
218 }
219
220-void PerfResultReporter::RegisterImportantMetric(
221-    const std::string& metric_suffix,
222-    const std::string& units) {
223-  RegisterMetric(metric_suffix, units, true);
224+void PerfResultReporter::RegisterImportantMetric(const std::string &metric_suffix,
225+                                                 const std::string &units)
226+{
227+    RegisterMetric(metric_suffix, units, true);
228 }
229
230-void PerfResultReporter::AddResult(const std::string& metric_suffix,
231-                                   size_t value) {
232-  auto iter = metric_map_.find(metric_suffix);
233-  CHECK(iter != metric_map_.end());
234+void PerfResultReporter::AddResult(const std::string &metric_suffix, size_t value)
235+{
236+    auto iter = metric_map_.find(metric_suffix);
237+    CHECK(iter != metric_map_.end());
238
239-  PrintResult(metric_basename_, metric_suffix, story_name_, value,
240-              iter->second.units, iter->second.important);
241+    PrintResult(metric_basename_, metric_suffix, story_name_, value, iter->second.units,
242+                iter->second.important);
243 }
244
245-void PerfResultReporter::AddResult(const std::string& metric_suffix,
246-                                   double value) {
247-  auto iter = metric_map_.find(metric_suffix);
248-  CHECK(iter != metric_map_.end());
249+void PerfResultReporter::AddResult(const std::string &metric_suffix, double value)
250+{
251+    auto iter = metric_map_.find(metric_suffix);
252+    CHECK(iter != metric_map_.end());
253
254-  PrintResult(metric_basename_, metric_suffix, story_name_, value,
255-              iter->second.units, iter->second.important);
256+    PrintResult(metric_basename_, metric_suffix, story_name_, value, iter->second.units,
257+                iter->second.important);
258 }
259
260-void PerfResultReporter::AddResult(const std::string& metric_suffix,
261-                                   const std::string& value) {
262-  auto iter = metric_map_.find(metric_suffix);
263-  CHECK(iter != metric_map_.end());
264+void PerfResultReporter::AddResult(const std::string &metric_suffix, const std::string &value)
265+{
266+    auto iter = metric_map_.find(metric_suffix);
267+    CHECK(iter != metric_map_.end());
268
269-  PrintResult(metric_basename_, metric_suffix, story_name_, value,
270-              iter->second.units, iter->second.important);
271+    PrintResult(metric_basename_, metric_suffix, story_name_, value, iter->second.units,
272+                iter->second.important);
273 }
274
275-bool PerfResultReporter::GetMetricInfo(const std::string& metric_suffix,
276-                                       MetricInfo* out) {
277-  auto iter = metric_map_.find(metric_suffix);
278-  if (iter == metric_map_.end()) {
279-    return false;
280-  }
281+bool PerfResultReporter::GetMetricInfo(const std::string &metric_suffix, MetricInfo *out)
282+{
283+    auto iter = metric_map_.find(metric_suffix);
284+    if (iter == metric_map_.end())
285+    {
286+        return false;
287+    }
288
289-  *out = iter->second;
290-  return true;
291+    *out = iter->second;
292+    return true;
293 }
294
295-void PerfResultReporter::RegisterMetric(const std::string& metric_suffix,
296-                                        const std::string& units,
297-                                        bool important) {
298-  CHECK(metric_map_.count(metric_suffix) == 0);
299-  metric_map_.insert({metric_suffix, {units, important}});
300+void PerfResultReporter::RegisterMetric(const std::string &metric_suffix,
301+                                        const std::string &units,
302+                                        bool important)
303+{
304+    CHECK(metric_map_.count(metric_suffix) == 0);
305+    metric_map_.insert({metric_suffix, {units, important}});
306 }
307
308 }  // namespace perf_test
309diff --git a/src/tests/perf_tests/third_party/perf/perf_result_reporter.h b/src/tests/perf_tests/third_party/perf/perf_result_reporter.h
310index 3188d90c9..2620eab3d 100644
311--- a/src/tests/perf_tests/third_party/perf/perf_result_reporter.h
312+++ b/src/tests/perf_tests/third_party/perf/perf_result_reporter.h
313@@ -8,11 +8,13 @@
314 #include <string>
315 #include <unordered_map>
316
317-namespace perf_test {
318+namespace perf_test
319+{
320
321-struct MetricInfo {
322-  std::string units;
323-  bool important;
324+struct MetricInfo
325+{
326+    std::string units;
327+    bool important;
328 };
329
330 // A helper class for using the perf test printing functions safely, as
331@@ -32,32 +34,28 @@ struct MetricInfo {
332 // a single "100_chars" story. If an additional story run is added, e.g.
333 // "200_chars", then the metrics will be averaged over both runs with the
334 // ability to drill down into results for specific stories.
335-class PerfResultReporter {
336- public:
337-  PerfResultReporter(const std::string& metric_basename,
338-                     const std::string& story_name);
339-  ~PerfResultReporter();
340-
341-  void RegisterFyiMetric(const std::string& metric_suffix,
342-                         const std::string& units);
343-  void RegisterImportantMetric(const std::string& metric_suffix,
344-                               const std::string& units);
345-  void AddResult(const std::string& metric_suffix, size_t value);
346-  void AddResult(const std::string& metric_suffix, double value);
347-  void AddResult(const std::string& metric_suffix, const std::string& value);
348-
349-  // Returns true and fills the pointer if the metric is registered, otherwise
350-  // returns false.
351-  bool GetMetricInfo(const std::string& metric_suffix, MetricInfo* out);
352-
353- private:
354-  void RegisterMetric(const std::string& metric_suffix,
355-                      const std::string& units,
356-                      bool important);
357-
358-  std::string metric_basename_;
359-  std::string story_name_;
360-  std::unordered_map<std::string, MetricInfo> metric_map_;
361+class PerfResultReporter
362+{
363+  public:
364+    PerfResultReporter(const std::string &metric_basename, const std::string &story_name);
365+    ~PerfResultReporter();
366+
367+    void RegisterFyiMetric(const std::string &metric_suffix, const std::string &units);
368+    void RegisterImportantMetric(const std::string &metric_suffix, const std::string &units);
369+    void AddResult(const std::string &metric_suffix, size_t value);
370+    void AddResult(const std::string &metric_suffix, double value);
371+    void AddResult(const std::string &metric_suffix, const std::string &value);
372+
373+    // Returns true and fills the pointer if the metric is registered, otherwise
374+    // returns false.
375+    bool GetMetricInfo(const std::string &metric_suffix, MetricInfo *out);
376+
377+  private:
378+    void RegisterMetric(const std::string &metric_suffix, const std::string &units, bool important);
379+
380+    std::string metric_basename_;
381+    std::string story_name_;
382+    std::unordered_map<std::string, MetricInfo> metric_map_;
383 };
384
385 }  // namespace perf_test
386diff --git a/src/tests/perf_tests/third_party/perf/perf_test.cc b/src/tests/perf_tests/third_party/perf/perf_test.cc
387index 0b0b666db..1131faf27 100644
388--- a/src/tests/perf_tests/third_party/perf/perf_test.cc
389+++ b/src/tests/perf_tests/third_party/perf/perf_test.cc
390@@ -2,16 +2,49 @@
391 // Use of this source code is governed by a BSD-style license that can be
392 // found in the LICENSE file.
393
394-#include "testing/perf/perf_test.h"
395+#include "perf_test.h"
396
397+#include <stdarg.h>
398 #include <stdio.h>
399-
400-#include "base/logging.h"
401-#include "base/strings/string_number_conversions.h"
402-#include "base/strings/stringprintf.h"
403+#include <vector>
404
405 namespace {
406
407+std::string FormatString(const char *fmt, va_list vararg) {
408+  static std::vector<char> buffer(512);
409+
410+  // Attempt to just print to the current buffer
411+  int len = vsnprintf(&buffer[0], buffer.size(), fmt, vararg);
412+  if (len < 0 || static_cast<size_t>(len) >= buffer.size()) {
413+    // Buffer was not large enough, calculate the required size and resize the buffer
414+    len = vsnprintf(NULL, 0, fmt, vararg);
415+    buffer.resize(len + 1);
416+
417+    // Print again
418+    vsnprintf(&buffer[0], buffer.size(), fmt, vararg);
419+  }
420+
421+  return std::string(buffer.data(), len);
422+}
423+
424+std::string StringPrintf(const char *fmt, ...) {
425+  va_list vararg;
426+  va_start(vararg, fmt);
427+  std::string result = FormatString(fmt, vararg);
428+  va_end(vararg);
429+  return result;
430+}
431+
432+std::string NumberToString(size_t value)
433+{
434+    return StringPrintf("%u", value);
435+}
436+
437+std::string NumberToString(double value)
438+{
439+    return StringPrintf("%.10lf", value);
440+}
441+
442 std::string ResultsToString(const std::string& measurement,
443                             const std::string& modifier,
444                             const std::string& trace,
445@@ -23,10 +56,9 @@ std::string ResultsToString(const std::string& measurement,
446   // <*>RESULT <graph_name>: <trace_name>= <value> <units>
447   // <*>RESULT <graph_name>: <trace_name>= {<mean>, <std deviation>} <units>
448   // <*>RESULT <graph_name>: <trace_name>= [<value>,value,value,...,] <units>
449-  return base::StringPrintf("%sRESULT %s%s: %s= %s%s%s %s\n",
450-         important ? "*" : "", measurement.c_str(), modifier.c_str(),
451-         trace.c_str(), prefix.c_str(), values.c_str(), suffix.c_str(),
452-         units.c_str());
453+  return StringPrintf("%sRESULT %s%s: %s= %s%s%s %s\n", important ? "*" : "", measurement.c_str(),
454+                      modifier.c_str(), trace.c_str(), prefix.c_str(), values.c_str(),
455+                      suffix.c_str(), units.c_str());
456 }
457
458 void PrintResultsImpl(const std::string& measurement,
459@@ -53,8 +85,8 @@ void PrintResult(const std::string& measurement,
460                  size_t value,
461                  const std::string& units,
462                  bool important) {
463-  PrintResultsImpl(measurement, modifier, trace, base::NumberToString(value),
464-                   std::string(), std::string(), units, important);
465+    PrintResultsImpl(measurement, modifier, trace, NumberToString(value), std::string(),
466+                     std::string(), units, important);
467 }
468
469 void PrintResult(const std::string& measurement,
470@@ -63,8 +95,8 @@ void PrintResult(const std::string& measurement,
471                  double value,
472                  const std::string& units,
473                  bool important) {
474-  PrintResultsImpl(measurement, modifier, trace, base::NumberToString(value),
475-                   std::string(), std::string(), units, important);
476+    PrintResultsImpl(measurement, modifier, trace, NumberToString(value), std::string(),
477+                     std::string(), units, important);
478 }
479
480 void AppendResult(std::string& output,
481@@ -74,9 +106,8 @@ void AppendResult(std::string& output,
482                   size_t value,
483                   const std::string& units,
484                   bool important) {
485-  output +=
486-      ResultsToString(measurement, modifier, trace, base::NumberToString(value),
487-                      std::string(), std::string(), units, important);
488+    output += ResultsToString(measurement, modifier, trace, NumberToString(value), std::string(),
489+                              std::string(), units, important);
490 }
491
492 void PrintResult(const std::string& measurement,
493diff --git a/src/tests/perf_tests/third_party/perf/perf_test.h b/src/tests/perf_tests/third_party/perf/perf_test.h
494index 36e2916c5..d269a34cf 100644
495--- a/src/tests/perf_tests/third_party/perf/perf_test.h
496+++ b/src/tests/perf_tests/third_party/perf/perf_test.h
497@@ -7,7 +7,8 @@
498
499 #include <string>
500
501-namespace perf_test {
502+namespace perf_test
503+{
504
505 // Prints numerical information to stdout in a controlled format, for
506 // post-processing. |measurement| is a description of the quantity being
507@@ -22,94 +23,90 @@ namespace perf_test {
508 // produced for various builds, using the combined |measurement| + |modifier|
509 // string to specify a particular graph and the |trace| to identify a trace
510 // (i.e., data series) on that graph.
511-void PrintResult(const std::string& measurement,
512-                 const std::string& modifier,
513-                 const std::string& trace,
514+void PrintResult(const std::string &measurement,
515+                 const std::string &modifier,
516+                 const std::string &trace,
517                  size_t value,
518-                 const std::string& units,
519+                 const std::string &units,
520                  bool important);
521-void PrintResult(const std::string& measurement,
522-                 const std::string& modifier,
523-                 const std::string& trace,
524+void PrintResult(const std::string &measurement,
525+                 const std::string &modifier,
526+                 const std::string &trace,
527                  double value,
528-                 const std::string& units,
529+                 const std::string &units,
530                  bool important);
531
532-void AppendResult(std::string& output,
533-                  const std::string& measurement,
534-                  const std::string& modifier,
535-                  const std::string& trace,
536+void AppendResult(std::string &output,
537+                  const std::string &measurement,
538+                  const std::string &modifier,
539+                  const std::string &trace,
540                   size_t value,
541-                  const std::string& units,
542+                  const std::string &units,
543                   bool important);
544
545 // Like the above version of PrintResult(), but takes a std::string value
546 // instead of a size_t.
547-void PrintResult(const std::string& measurement,
548-                 const std::string& modifier,
549-                 const std::string& trace,
550-                 const std::string& value,
551-                 const std::string& units,
552+void PrintResult(const std::string &measurement,
553+                 const std::string &modifier,
554+                 const std::string &trace,
555+                 const std::string &value,
556+                 const std::string &units,
557                  bool important);
558
559-void AppendResult(std::string& output,
560-                  const std::string& measurement,
561-                  const std::string& modifier,
562-                  const std::string& trace,
563-                  const std::string& value,
564-                  const std::string& units,
565+void AppendResult(std::string &output,
566+                  const std::string &measurement,
567+                  const std::string &modifier,
568+                  const std::string &trace,
569+                  const std::string &value,
570+                  const std::string &units,
571                   bool important);
572
573 // Like PrintResult(), but prints a (mean, standard deviation) result pair.
574 // The |<values>| should be two comma-separated numbers, the mean and
575 // standard deviation (or other error metric) of the measurement.
576-void PrintResultMeanAndError(const std::string& measurement,
577-                             const std::string& modifier,
578-                             const std::string& trace,
579-                             const std::string& mean_and_error,
580-                             const std::string& units,
581+void PrintResultMeanAndError(const std::string &measurement,
582+                             const std::string &modifier,
583+                             const std::string &trace,
584+                             const std::string &mean_and_error,
585+                             const std::string &units,
586                              bool important);
587
588-void AppendResultMeanAndError(std::string& output,
589-                              const std::string& measurement,
590-                              const std::string& modifier,
591-                              const std::string& trace,
592-                              const std::string& mean_and_error,
593-                              const std::string& units,
594+void AppendResultMeanAndError(std::string &output,
595+                              const std::string &measurement,
596+                              const std::string &modifier,
597+                              const std::string &trace,
598+                              const std::string &mean_and_error,
599+                              const std::string &units,
600                               bool important);
601
602 // Like PrintResult(), but prints an entire list of results. The |values|
603 // will generally be a list of comma-separated numbers. A typical
604 // post-processing step might produce plots of their mean and standard
605 // deviation.
606-void PrintResultList(const std::string& measurement,
607-                     const std::string& modifier,
608-                     const std::string& trace,
609-                     const std::string& values,
610-                     const std::string& units,
611+void PrintResultList(const std::string &measurement,
612+                     const std::string &modifier,
613+                     const std::string &trace,
614+                     const std::string &values,
615+                     const std::string &units,
616                      bool important);
617
618-void AppendResultList(std::string& output,
619-                      const std::string& measurement,
620-                      const std::string& modifier,
621-                      const std::string& trace,
622-                      const std::string& values,
623-                      const std::string& units,
624+void AppendResultList(std::string &output,
625+                      const std::string &measurement,
626+                      const std::string &modifier,
627+                      const std::string &trace,
628+                      const std::string &values,
629+                      const std::string &units,
630                       bool important);
631
632 // Prints memory commit charge stats for use by perf graphs.
633-void PrintSystemCommitCharge(const std::string& test_name,
634-                             size_t charge,
635-                             bool important);
636+void PrintSystemCommitCharge(const std::string &test_name, size_t charge, bool important);
637
638-void PrintSystemCommitCharge(FILE* target,
639-                             const std::string& test_name,
640+void PrintSystemCommitCharge(FILE *target,
641+                             const std::string &test_name,
642                              size_t charge,
643                              bool important);
644
645-std::string SystemCommitChargeToString(const std::string& test_name,
646-                                       size_t charge,
647-                                       bool important);
648+std::string SystemCommitChargeToString(const std::string &test_name, size_t charge, bool important);
649
650 }  // namespace perf_test
651
652