Roll Chrome into Mojo.

base/test/launcher/test_launcher_ios.cc

 // Copyright 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/launcher/test_launcher.h"
 
 #include "base/at_exit.h"
 #include "base/base_paths.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/format_macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/process/launch.h"
+#include "base/strings/string_util.h"
 #include "base/test/launcher/unit_test_launcher.h"
 #include "base/test/test_switches.h"
 #include "base/test/test_timeouts.h"
 
 namespace {
 
 const char kHelpFlag[] = "help";
 
 void PrintUsage() {
   fprintf(stdout,
@@ skipping 19 matching lines @@
           "    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");
   fflush(stdout);
 }
 
-class IOSUnitTestLauncherDelegate : public base::UnitTestLauncherDelegate {
+class IOSUnitTestPlatformDelegate : public base::UnitTestPlatformDelegate {
  public:
-  IOSUnitTestLauncherDelegate() : base::UnitTestLauncherDelegate(0, false) {
+  IOSUnitTestPlatformDelegate() {
   }
 
   bool Init() WARN_UNUSED_RESULT {
     if (!PathService::Get(base::DIR_EXE, &dir_exe_)) {
       LOG(ERROR) << "Failed to get directory of current executable.";
       return false;
     }
 
     base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
     std::vector<std::string> args(command_line->GetArgs());
@@ skipping 30 matching lines @@
 
     base::LaunchOptions launch_options;
     launch_options.wait = true;
 
     if (!base::LaunchProcess(cmd_line, launch_options).IsValid())
       return false;
 
     return base::ReadTestNamesFromFile(test_list_path, output);
   }
 
+  bool CreateTemporaryFile(base::FilePath* path) override {
+    if (!CreateTemporaryDirInDir(writable_path_, std::string(), path))
+      return false;
+    *path = path->AppendASCII("test_results.xml");
+    return true;
+  }
+
+  base::CommandLine GetCommandLineForChildGTestProcess(
+      const std::vector<std::string>& test_names,
+      const base::FilePath& output_file) override {
+    base::CommandLine cmd_line(dir_exe_.AppendASCII(test_name_ + ".app"));
+    cmd_line.AppendSwitchPath(switches::kTestLauncherOutput, output_file);
+    cmd_line.AppendSwitchASCII(base::kGTestFilterFlag,
+                               JoinString(test_names, ":"));
+    return cmd_line;
+  }
+
+  std::string GetWrapperForChildGTestProcess() override {
+    return dir_exe_.AppendASCII("iossim").value();
+  }
+
  private:
   // Directory containing test launcher's executable.
   base::FilePath dir_exe_;
 
   // Name of the test executable to run.
   std::string test_name_;
 
   // Path that launched test binary can write to.
   base::FilePath writable_path_;
 
-  DISALLOW_COPY_AND_ASSIGN(IOSUnitTestLauncherDelegate);
+  DISALLOW_COPY_AND_ASSIGN(IOSUnitTestPlatformDelegate);
 };
 
 }  // namespace
 
 int main(int argc, char** argv) {
   base::AtExitManager at_exit;
 
   base::CommandLine::Init(argc, argv);
 
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(kHelpFlag)) {
     PrintUsage();
     return 0;
   }
 
   base::TimeTicks start_time(base::TimeTicks::Now());
 
   TestTimeouts::Initialize();
 
   base::MessageLoopForIO message_loop;
 
-  IOSUnitTestLauncherDelegate delegate;
-  if (!delegate.Init()) {
-    fprintf(stderr, "Failed to intialize test launcher delegate.\n");
+  IOSUnitTestPlatformDelegate platform_delegate;
+  if (!platform_delegate.Init()) {
+    fprintf(stderr, "Failed to intialize test launcher platform delegate.\n");
     fflush(stderr);
     return 1;
   }
+  base::UnitTestLauncherDelegate delegate(&platform_delegate, 0, false);
   // Force one job since we can't run multiple simulators in parallel.
   base::TestLauncher launcher(&delegate, 1);
   bool success = launcher.Run();
 
   fprintf(stdout, "Tests took %" PRId64 " seconds.\n",
           (base::TimeTicks::Now() - start_time).InSeconds());
   fflush(stdout);
 
   return (success ? 0 : 1);
 }