Adds option to run browser tests in mash

content/public/test/test_launcher.cc

 // Copyright (c) 2012 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 "content/public/test/test_launcher.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
+#include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/containers/hash_tables.h"
 #include "base/environment.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 83 matching lines @@
           "    Controls when full test output is printed.\n"
           "    auto means to print it when the test failed.\n"
           "\n"
           "  --test-launcher-total-shards=N\n"
           "    Sets the total number of shards to N.\n"
           "\n"
           "  --test-launcher-shard-index=N\n"
           "    Sets the shard index to run to N (from 0 to TOTAL - 1).\n");
 }
 
+void CallChildProcessLaunched(TestState* test_state,
+                              base::ProcessHandle handle,
+                              base::ProcessId pid) {
+  if (test_state)
+    test_state->ChildProcessLaunched(handle, pid);
+}
+
 // Implementation of base::TestLauncherDelegate. This is also a test launcher,
 // wrapping a lower-level test launcher with content-specific code.
 class WrapperTestLauncherDelegate : public base::TestLauncherDelegate {
  public:
   explicit WrapperTestLauncherDelegate(
       content::TestLauncherDelegate* launcher_delegate)
       : launcher_delegate_(launcher_delegate) {
     CHECK(temp_dir_.CreateUniqueTempDir());
   }
 
@@ skipping 10 matching lines @@
   void DoRunTests(base::TestLauncher* test_launcher,
                   const std::vector<std::string>& test_names);
 
   // Launches test named |test_name| using parallel launcher,
   // given result of PRE_ test |pre_test_result|.
   void RunDependentTest(base::TestLauncher* test_launcher,
                         const std::string test_name,
                         const base::TestResult& pre_test_result);
 
   // Callback to receive result of a test.
-  void GTestCallback(
-      base::TestLauncher* test_launcher,
-      const std::vector<std::string>& test_names,
-      const std::string& test_name,
-      int exit_code,
-      const base::TimeDelta& elapsed_time,
-      bool was_timeout,
-      const std::string& output);
+  void GTestCallback(base::TestLauncher* test_launcher,
+                     const std::vector<std::string>& test_names,
+                     const std::string& test_name,
+                     scoped_ptr<TestState> test_state,
+                     int exit_code,
+                     const base::TimeDelta& elapsed_time,
+                     bool was_timeout,
+                     const std::string& output);
 
   content::TestLauncherDelegate* launcher_delegate_;
 
   // Store dependent test name (map is indexed by full test name).
   typedef std::map<std::string, std::string> DependentTestMap;
   DependentTestMap dependent_test_map_;
   DependentTestMap reverse_dependent_test_map_;
 
   // Store unique data directory prefix for test names (without PRE_ prefixes).
   // PRE_ tests and tests that depend on them must share the same
@@ skipping 169 matching lines @@
   if (test_names.empty())
     return;
 
   std::string test_name(test_names.front());
   std::vector<std::string> test_names_copy(
       test_names.begin() + 1, test_names.end());
 
   std::string test_name_no_pre(RemoveAnyPrePrefixes(test_name));
 
   base::CommandLine cmd_line(*base::CommandLine::ForCurrentProcess());
+  base::TestLauncher::LaunchOptions test_launch_options;
+  test_launch_options.flags = base::TestLauncher::USE_JOB_OBJECTS |
+                              base::TestLauncher::ALLOW_BREAKAWAY_FROM_JOB;
+  scoped_ptr<TestState> test_state_ptr =
+      launcher_delegate_->PreRunTest(&cmd_line, &test_launch_options);
   CHECK(launcher_delegate_->AdjustChildProcessCommandLine(
             &cmd_line, user_data_dir_map_[test_name_no_pre]));
 
   base::CommandLine new_cmd_line(cmd_line.GetProgram());
   base::CommandLine::SwitchMap switches = cmd_line.GetSwitches();
 
   // Strip out gtest_output flag because otherwise we would overwrite results
   // of the other tests.
   switches.erase(base::kGTestOutputFlag);
 
   for (base::CommandLine::SwitchMap::const_iterator iter = switches.begin();
        iter != switches.end(); ++iter) {
     new_cmd_line.AppendSwitchNative(iter->first, iter->second);
   }
 
   // Always enable disabled tests.  This method is not called with disabled
   // tests unless this flag was specified to the browser test executable.
   new_cmd_line.AppendSwitch("gtest_also_run_disabled_tests");
   new_cmd_line.AppendSwitchASCII("gtest_filter", test_name);
   new_cmd_line.AppendSwitch(kSingleProcessTestsFlag);
 
   char* browser_wrapper = getenv("BROWSER_WRAPPER");
 
-  base::TestLauncher::LaunchOptions test_launch_options;
-  test_launch_options.flags = base::TestLauncher::USE_JOB_OBJECTS |
-                              base::TestLauncher::ALLOW_BREAKAWAY_FROM_JOB;
+  TestState* test_state = test_state_ptr.get();
   test_launcher->LaunchChildGTestProcess(
       new_cmd_line, browser_wrapper ? browser_wrapper : std::string(),
       TestTimeouts::action_max_timeout(), test_launch_options,
       base::Bind(&WrapperTestLauncherDelegate::GTestCallback,
                  base::Unretained(this), test_launcher, test_names_copy,
-                 test_name),
-      base::TestLauncher::GTestProcessLaunchedCallback());
+                 test_name, base::Passed(&test_state_ptr)),
+      base::Bind(&CallChildProcessLaunched, base::Unretained(test_state)));
 }
 
 void WrapperTestLauncherDelegate::RunDependentTest(
     base::TestLauncher* test_launcher,
     const std::string test_name,
     const base::TestResult& pre_test_result) {
   if (pre_test_result.status == base::TestResult::TEST_SUCCESS) {
     // Only run the dependent test if PRE_ test succeeded.
     std::vector<std::string> test_list;
     test_list.push_back(test_name);
@@ skipping 10 matching lines @@
                        dependent_test_map_[test_name],
                        test_result);
     }
   }
 }
 
 void WrapperTestLauncherDelegate::GTestCallback(
     base::TestLauncher* test_launcher,
     const std::vector<std::string>& test_names,
     const std::string& test_name,
+    scoped_ptr<TestState> test_state,
     int exit_code,
     const base::TimeDelta& elapsed_time,
     bool was_timeout,
     const std::string& output) {
   base::TestResult result;
   result.full_name = test_name;
 
   // TODO(phajdan.jr): Recognize crashes.
   if (exit_code == 0)
     result.status = base::TestResult::TEST_SUCCESS;
@@ skipping 30 matching lines @@
 
 const char kHelpFlag[]   = "help";
 
 const char kLaunchAsBrowser[] = "as-browser";
 
 // See kManualTestPrefix above.
 const char kRunManualTestsFlag[] = "run-manual";
 
 const char kSingleProcessTestsFlag[]   = "single_process";
 
+scoped_ptr<TestState> TestLauncherDelegate::PreRunTest(
+    base::CommandLine* command_line,
+    base::TestLauncher::LaunchOptions* test_launch_options) {
+  return nullptr;
+}
 
 TestLauncherDelegate::~TestLauncherDelegate() {
 }
 
 int LaunchTests(TestLauncherDelegate* launcher_delegate,
                 int default_jobs,
                 int argc,
                 char** argv) {
   DCHECK(!g_launcher_delegate);
   g_launcher_delegate = launcher_delegate;
@@ skipping 62 matching lines @@
 
 TestLauncherDelegate* GetCurrentTestLauncherDelegate() {
   return g_launcher_delegate;
 }
 
 ContentMainParams* GetContentMainParams() {
   return g_params;
 }
 
 }  // namespace content