Move CreateFIFO() and RedirectStream() from testing/android/ to base/android/.

testing/android/native_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.
 
 // This class sets up the environment for running the native tests inside an
 // android application. It outputs (to a fifo) markers identifying the
 // START/PASSED/CRASH of the test suite, FAILURE/SUCCESS of individual tests,
 // etc.
 // These markers are read by the test runner script to generate test results.
 // It installs signal handlers to detect crashes.
 
 #include <android/log.h>
 #include <signal.h>
 
 #include "base/android/base_jni_registrar.h"
+#include "base/android/fifo_utils.h"
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/android/scoped_java_ref.h"
 #include "base/at_exit.h"
 #include "base/base_switches.h"
 #include "base/command_line.h"
+#include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "gtest/gtest.h"
 #include "testing/android/native_test_util.h"
 #include "testing/jni/ChromeNativeTestActivity_jni.h"
 
 using testing::native_test_util::ArgsToArgv;
-using testing::native_test_util::CreateFIFO;
 using testing::native_test_util::ParseArgsFromCommandLineFile;
-using testing::native_test_util::RedirectStream;
 using testing::native_test_util::ScopedMainEntryLogger;
 
 // The main function of the program to be wrapped as a test apk.
 extern int main(int argc, char** argv);
 
 namespace {
 
 // These two command line flags are supported for DumpRenderTree, which needs
 // three fifos rather than a combined one: one for stderr, stdin and stdout.
 const char kSeparateStderrFifo[] = "separate-stderr-fifo";
@@ skipping 28 matching lines @@
   memset(&sa, 0, sizeof(sa));
 
   sa.sa_sigaction = SignalHandler;
   sa.sa_flags = SA_SIGINFO;
 
   for (unsigned int i = 0; kExceptionSignals[i] != -1; ++i) {
     sigaction(kExceptionSignals[i], &sa, &g_old_sa[kExceptionSignals[i]]);
   }
 }
 
+// Writes printf() style string to Android's logger where |priority| is one of
+// the levels defined in <android/log.h>.
+void AndroidLog(int priority, const char* format, ...) {
+  va_list args;
+  va_start(args, format);
+  __android_log_vprint(priority, kLogTag, format, args);
+  va_end(args);
+}
+
+// Ensures that the fifo at |path| is created by deleting whatever is at |path|
+// prior to (re)creating the fifo, otherwise logs the error and terminates the
+// program.
+void EnsureCreateFIFO(const base::FilePath& path) {
+  unlink(path.value().c_str());
+  if (base::android::CreateFIFO(path, 0666))
+    return;
+
+  AndroidLog(ANDROID_LOG_ERROR, "Failed to create fifo %s: %s\n",
+             path.value().c_str(), strerror(errno));
+  exit(EXIT_FAILURE);
+}
+
+// Ensures that |stream| is redirected to |path|, otherwise logs the error and
+// terminates the program.
+void EnsureRedirectStream(FILE* stream,
+                          const base::FilePath& path,
+                          const char* mode) {
+  if (base::android::RedirectStream(stream, path, mode))
+    return;
+
+  AndroidLog(ANDROID_LOG_ERROR, "Failed to redirect stream to file: %s: %s\n",
+             path.value().c_str(), strerror(errno));
+  exit(EXIT_FAILURE);
+}
+
 }  // namespace
 
 // This method is called on a separate java thread so that we won't trigger
 // an ANR.
 static void RunTests(JNIEnv* env,
                      jobject obj,
                      jstring jfiles_dir,
                      jobject app_context) {
   base::AtExitManager exit_manager;
 
@@ skipping 17 matching lines @@
   CommandLine::ForCurrentProcess()->AppendArguments(
       CommandLine(argc, &argv[0]), false);
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 
   base::FilePath files_dir(
       base::android::ConvertJavaStringToUTF8(env, jfiles_dir));
 
   // A few options, such "--gtest_list_tests", will just use printf directly
   // Always redirect stdout to a known file.
   base::FilePath fifo_path(files_dir.Append(base::FilePath("test.fifo")));
-  CreateFIFO(fifo_path.value().c_str());
+  EnsureCreateFIFO(fifo_path);
 
   base::FilePath stderr_fifo_path, stdin_fifo_path;
 
   // DumpRenderTree needs a separate fifo for the stderr output. For all
   // other tests, insert stderr content to the same fifo we use for stdout.
   if (command_line.HasSwitch(kSeparateStderrFifo)) {
     stderr_fifo_path = files_dir.Append(base::FilePath("stderr.fifo"));
-    CreateFIFO(stderr_fifo_path.value().c_str());
+    EnsureCreateFIFO(stderr_fifo_path);
   }
 
   // DumpRenderTree uses stdin to receive input about which test to run.
   if (command_line.HasSwitch(kCreateStdinFifo)) {
     stdin_fifo_path = files_dir.Append(base::FilePath("stdin.fifo"));
-    CreateFIFO(stdin_fifo_path.value().c_str());
+    EnsureCreateFIFO(stdin_fifo_path);
   }
 
   // Only redirect the streams after all fifos have been created.
-  RedirectStream(stdout, fifo_path.value().c_str(), "w");
+  EnsureRedirectStream(stdout, fifo_path, "w");
   if (!stdin_fifo_path.empty())
-    RedirectStream(stdin, stdin_fifo_path.value().c_str(), "r");
+    EnsureRedirectStream(stdin, stdin_fifo_path, "r");
   if (!stderr_fifo_path.empty())
-    RedirectStream(stderr, stderr_fifo_path.value().c_str(), "w");
+    EnsureRedirectStream(stderr, stderr_fifo_path, "w");
   else
     dup2(STDOUT_FILENO, STDERR_FILENO);
 
   if (command_line.HasSwitch(switches::kWaitForDebugger)) {
-    std::string msg = base::StringPrintf("Native test waiting for GDB because "
-                                         "flag %s was supplied",
-                                         switches::kWaitForDebugger);
-    __android_log_write(ANDROID_LOG_VERBOSE, kLogTag, msg.c_str());
+    AndroidLog(ANDROID_LOG_VERBOSE,
+               "Native test waiting for GDB because flag %s was supplied",
+               switches::kWaitForDebugger);
     base::debug::WaitForDebugger(24 * 60 * 60, false);
   }
 
   ScopedMainEntryLogger scoped_main_entry_logger;
   main(argc, &argv[0]);
 }
 
 // This is called by the VM when the shared library is first loaded.
 JNI_EXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
   // Install signal handlers to detect crashes.
   InstallHandlers();
 
   base::android::InitVM(vm);
   JNIEnv* env = base::android::AttachCurrentThread();
   if (!RegisterNativesImpl(env)) {
     return -1;
   }
 
   return JNI_VERSION_1_4;
 }