Add trace-to-file support for base::TestSuite

Passing --trace-to-file on the command line will trace a default set of
categories to a default trace file name (trace.json).
--trace-to-file=categories --trace-to-file-name=somefile.json allow for
more configuration.

BUG=none

Review URL: https://codereview.chromium.org/542893002

Cr-Commit-Position: refs/heads/master@{#296770}

base/base.gyp

@@ -959,6 +959,8 @@
         'test/thread_test_helper.h',
         'test/trace_event_analyzer.cc',
         'test/trace_event_analyzer.h',
+        'test/trace_to_file.cc',
+        'test/trace_to_file.h',
         'test/values_test_util.cc',
         'test/values_test_util.h',
       ],

base/base_switches.cc

@@ -50,6 +50,14 @@ const char kWaitForDebugger[]               = "wait-for-debugger";
 // Sends a pretty-printed version of tracing info to the console.
 const char kTraceToConsole[]                = "trace-to-console";
 
+// Sends trace events from these categories to a file.
+// --trace-to-file on its own sends to default categories.
+const char kTraceToFile[]                   = "trace-to-file";
+
+// Specifies the file name for --trace-to-file. If unspecified, it will
+// go to a default file name.
+const char kTraceToFileName[]               = "trace-to-file-name";
+
 // Configure whether chrome://profiler will contain timing information. This
 // option is enabled by default. A value of "0" will disable profiler timing,
 // while all other values will enable it.

base/base_switches.h

@@ -20,6 +20,8 @@ extern const char kProfilerTiming[];
 extern const char kProfilerTimingDisabledValue[];
 extern const char kTestChildProcess[];
 extern const char kTraceToConsole[];
+extern const char kTraceToFile[];
+extern const char kTraceToFileName[];
 extern const char kV[];
 extern const char kVModule[];
 extern const char kWaitForDebugger[];

base/test/BUILD.gn

@@ -96,6 +96,8 @@ source_set("test_support") {
     "thread_test_helper.h",
     "trace_event_analyzer.cc",
     "trace_event_analyzer.h",
+    "trace_to_file.cc",
+    "trace_to_file.h",
     "values_test_util.cc",
     "values_test_util.h",
   ]

base/test/test_suite.cc

@@ -337,6 +337,8 @@ void TestSuite::Initialize() {
 #endif  // !defined(OS_IOS)
 
   TestTimeouts::Initialize();
+
+  trace_to_file_.BeginTracingFromCommandLineOptions();
 }
 
 void TestSuite::Shutdown() {

base/test/test_suite.h

@@ -13,6 +13,7 @@
 
 #include "base/at_exit.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/test/trace_to_file.h"
 
 namespace testing {
 class TestInfo;
@@ -80,6 +81,8 @@ class TestSuite {
   // Basic initialization for the test suite happens here.
   void PreInitialize(bool create_at_exit_manager);
 
+  test::TraceToFile trace_to_file_;
+
   bool initialized_command_line_;
 
   DISALLOW_COPY_AND_ASSIGN(TestSuite);

base/test/trace_to_file.cc

+// Copyright (c) 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/test/trace_to_file.h"
+
+#include "base/base_switches.h"
+#include "base/command_line.h"
+#include "base/debug/trace_event_impl.h"
+#include "base/files/file_util.h"
+#include "base/run_loop.h"
+
+namespace base {
+namespace test {
+
+TraceToFile::TraceToFile() : started_(false) {
+}
+
+TraceToFile::~TraceToFile() {
+  EndTracingIfNeeded();
+}
+
+void TraceToFile::BeginTracingFromCommandLineOptions() {
+  DCHECK(CommandLine::InitializedForCurrentProcess());
+  DCHECK(!started_);
+
+  if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kTraceToFile))
+    return;
+
+  // Empty filter (i.e. just --trace-to-file) turns into default categories in
+  // TraceEventImpl
+  std::string filter = CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
+      switches::kTraceToFile);
+
+  FilePath path;
+  if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kTraceToFileName)) {
+    path = FilePath(CommandLine::ForCurrentProcess()
+                        ->GetSwitchValuePath(switches::kTraceToFileName));
+  } else {
+    path = FilePath(FILE_PATH_LITERAL("trace.json"));
+  }
+
+  BeginTracing(path, filter);
+}
+
+void TraceToFile::BeginTracing(const FilePath& path,
+                               const std::string& categories) {
+  DCHECK(!started_);
+  started_ = true;
+  path_ = path;
+  WriteFileHeader();
+
+  debug::TraceLog::GetInstance()->SetEnabled(
+      debug::CategoryFilter(categories),
+      debug::TraceLog::RECORDING_MODE,
+      debug::TraceOptions(debug::RECORD_UNTIL_FULL));
+}
+
+void TraceToFile::WriteFileHeader() {
+  const char str[] = "{\"traceEvents\": [";
+  WriteFile(path_, str, static_cast<int>(strlen(str)));
+}
+
+void TraceToFile::AppendFileFooter() {
+  const char str[] = "]}";
+  AppendToFile(path_, str, static_cast<int>(strlen(str)));
+}
+
+void TraceToFile::TraceOutputCallback(const std::string& data) {
+  int ret = AppendToFile(path_, data.c_str(), static_cast<int>(data.size()));
+  DCHECK_NE(-1, ret);
+}
+
+static void OnTraceDataCollected(
+    Closure quit_closure,
+    debug::TraceResultBuffer* buffer,
+    const scoped_refptr<RefCountedString>& json_events_str,
+    bool has_more_events) {
+  buffer->AddFragment(json_events_str->data());
+  if (!has_more_events)
+    quit_closure.Run();
+}
+
+void TraceToFile::EndTracingIfNeeded() {
+  if (!started_)
+    return;
+  started_ = false;
+
+  debug::TraceLog::GetInstance()->SetDisabled();
+
+  debug::TraceResultBuffer buffer;
+  buffer.SetOutputCallback(
+      Bind(&TraceToFile::TraceOutputCallback, Unretained(this)));
+
+  RunLoop run_loop;
+  debug::TraceLog::GetInstance()->Flush(
+      Bind(&OnTraceDataCollected, run_loop.QuitClosure(), Unretained(&buffer)));
+  run_loop.Run();
+
+  AppendFileFooter();
+}
+
+}  // namespace test
+}  // namespace base

base/test/trace_to_file.h

+// Copyright (c) 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_TEST_TRACE_TO_FILE_H_
+#define BASE_TEST_TRACE_TO_FILE_H_
+
+#include "base/files/file_path.h"
+
+namespace base {
+namespace test {
+
+class TraceToFile {
+ public:
+  TraceToFile();
+  ~TraceToFile();
+
+  void BeginTracingFromCommandLineOptions();
+  void BeginTracing(const base::FilePath& path, const std::string& categories);
+  void EndTracingIfNeeded();
+
+ private:
+  void WriteFileHeader();
+  void AppendFileFooter();
+
+  void TraceOutputCallback(const std::string& data);
+
+  base::FilePath path_;
+  bool started_;
+};
+
+}  // namespace test
+}  // namespace base
+
+#endif  // BASE_TEST_TRACE_TO_FILE_H_