Introduce test output snippet byte limit

base/test/launcher/test_launcher.cc

 // Copyright 2013 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/launcher/test_launcher.h"
 
 #include <memory>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
@@ skipping 72 matching lines @@
 // the test launcher to people looking at the output (no output for a long
 // time is mysterious and gives no info about what is happening) 3) help
 // debugging in case the process hangs anyway.
 const int kOutputTimeoutSeconds = 15;
 
 // Limit of output snippet lines when printing to stdout.
 // Avoids flooding the logs with amount of output that gums up
 // the infrastructure.
 const size_t kOutputSnippetLinesLimit = 5000;
 
+// Limit of output snippet size. Exceeding this limit
+// results in truncating the output and failing the test.
+const size_t kOutputSnippetBytesLimit = 10 * 1024 * 1024;
+
 // Set of live launch test processes with corresponding lock (it is allowed
 // for callers to launch processes on different threads).
 LazyInstance<std::map<ProcessHandle, CommandLine> > g_live_processes
     = LAZY_INSTANCE_INITIALIZER;
 LazyInstance<Lock> g_live_processes_lock = LAZY_INSTANCE_INITIALIZER;
 
 // Performance trace generator.
 LazyInstance<TestLauncherTracer> g_tracer = LAZY_INSTANCE_INITIALIZER;
 
 #if defined(OS_POSIX)
@@ skipping 458 matching lines @@
 
   GetTaskRunner()->PostTask(
       FROM_HERE,
       Bind(&DoLaunchChildTestProcess, new_command_line, timeout, options,
            redirect_stdio, RetainedRef(ThreadTaskRunnerHandle::Get()),
            Bind(&TestLauncher::OnLaunchTestProcessFinished, Unretained(this),
                 completed_callback),
            launched_callback));
 }
 
-void TestLauncher::OnTestFinished(const TestResult& result) {
+void TestLauncher::OnTestFinished(const TestResult& original_result) {
   ++test_finished_count_;
 
+  TestResult result(original_result);
+
+  if (result.output_snippet.length() > kOutputSnippetBytesLimit) {
+    if (result.status == TestResult::TEST_SUCCESS)
+      result.status = TestResult::TEST_EXCESSIVE_OUTPUT;
+    result.output_snippet = "<truncated>\n";

[Dirk Pranke, 2016/10/12 23:33:27]

Maybe this should include at least some of the snippet? 

Also, it seems like even 10MB is much too generous, I would want to understand
why any test would need more than a KB or two of output. But, it's fine to start
high and ratchet down.

[Paweł Hajdan Jr., 2016/10/13 14:55:59]

Done.
It turns out (tested on trybots) we need 2.5 MB limit. I'll probably work on
reducing that. Only a limited number of tests are affected.

+  }
+
   bool print_snippet = false;
   std::string print_test_stdio("auto");
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kTestLauncherPrintTestStdio)) {
     print_test_stdio = CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
         switches::kTestLauncherPrintTestStdio);
   }
   if (print_test_stdio == "auto") {
     print_snippet = (result.status != TestResult::TEST_SUCCESS);
   } else if (print_test_stdio == "always") {
@@ skipping 558 matching lines @@
   }
 
   std::string snippet(full_output.substr(run_pos));
   if (end_pos != std::string::npos)
     snippet = full_output.substr(run_pos, end_pos - run_pos);
 
   return snippet;
 }
 
 }  // namespace base