Fix Android multi-process tests on M.

base/test/multiprocess_test_android.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 "base/test/multiprocess_test.h"
 
 #include <errno.h>
 #include <string.h>
 #include <sys/types.h>
 #include <sys/socket.h>
@@ skipping 85 matching lines @@
   // Starts a child test helper process.
   Process StartChildTestHelper(const std::string& procname,
                                const CommandLine& base_command_line,
                                const LaunchOptions& options);
 
   // Waits for a child test helper process.
   bool WaitForChildExitWithTimeout(const Process& process, TimeDelta timeout,
                                    int* exit_code);
 
   bool IsReady() const { return child_fd_ != -1; }
-  bool IsChild() const { return parent_fd_ != -1; }
+  bool IsChild() const { return is_child_; }
 
  private:
   // Wrappers around sendmsg/recvmsg that supports message fragmentation.
   void Send(int fd, const MessageHeader* msg, const std::vector<int>& fds);
   ssize_t Recv(int fd, void* buf, std::vector<ScopedFD>* fds);
 
   // Parent process implementation.
   void DoParent(int fd);
   // Helper process implementation.
   void DoHelper(int fd);
 
   void StartProcessInHelper(const StartProcessRequest* request,
                            std::vector<ScopedFD> fds);
   void WaitForChildInHelper(const WaitProcessRequest* request);
 
+  bool is_child_ = false;
+
   // Parent vars.
   int child_fd_ = -1;
 
   // Helper vars.
   int parent_fd_ = -1;
   MainFunction main_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(LaunchHelper);
 };
 
@@ skipping 65 matching lines @@
   }
   return header->size;
 }
 
 void LaunchHelper::DoParent(int fd) {
   child_fd_ = fd;
 }
 
 void LaunchHelper::DoHelper(int fd) {
   parent_fd_ = fd;
+  is_child_ = true;
   std::unique_ptr<char[]> buf(new char[kMaxMessageSize]);
   while (true) {
     // Wait for a message from the parent.
     std::vector<ScopedFD> fds;
     ssize_t size = Recv(parent_fd_, buf.get(), &fds);
     if (size == 0 || (size < 0 && errno == ECONNRESET)) {
       _exit(0);
     }
     PCHECK(size > 0);
 
@@ skipping 23 matching lines @@
   PCHECK(pid >= 0) << "Fork failed";
   if (pid) {
     // Helper.
     StartProcessResponse resp;
     resp.child_pid = pid;
     Send(parent_fd_, reinterpret_cast<const MessageHeader*>(&resp),
          std::vector<int>());
   } else {
     // Child.
     PCHECK(close(parent_fd_) == 0);
+    parent_fd_ = -1;
     CommandLine::Reset();
 
     Pickle serialised_extra(reinterpret_cast<const char*>(request + 1),
                             request->header.size - sizeof(StartProcessRequest));
     PickleIterator iter(serialised_extra);
     std::vector<std::string> args;
     for (size_t i = 0; i < request->num_args; i++) {
       std::string arg;
       CHECK(iter.ReadString(&arg));
       args.push_back(std::move(arg));
     }
 
     CHECK_EQ(request->num_fds, fds.size());
     for (size_t i = 0; i < request->num_fds; i++) {
       int new_fd;
       CHECK(iter.ReadInt(&new_fd));
       int old_fd = fds[i].release();
-      if (dup2(old_fd, new_fd) < 0) {
-        PLOG(FATAL) << "dup2";
+      if (new_fd != old_fd) {
+        if (dup2(old_fd, new_fd) < 0) {
+          PLOG(FATAL) << "dup2";
+        }
+        PCHECK(close(old_fd) == 0);
       }
-      PCHECK(close(old_fd) == 0);
     }
 
     std::unique_ptr<char*[]> argv(new char*[args.size()]);
     for (size_t i = 0; i < args.size(); i++) {
       argv[i] = const_cast<char*>(args[i].c_str());
     }
     _exit(main_(args.size(), argv.get()));
     NOTREACHED();
   }
 }
@@ skipping 82 matching lines @@
 }  // namespace
 
 void InitAndroidMultiProcessTestHelper(int (*main)(int, char**)) {
   DCHECK(main);
   // Don't allow child processes to themselves create new child processes.
   if (g_launch_helper.Get().IsChild())
     return;
   g_launch_helper.Get().Init(main);
 }
 
+bool AndroidIsChildProcess() {
+  return g_launch_helper.Get().IsChild();
+}
+
 bool AndroidWaitForChildExitWithTimeout(
     const Process& process, TimeDelta timeout, int* exit_code) {
   CHECK(g_launch_helper.Get().IsReady());
   return g_launch_helper.Get().WaitForChildExitWithTimeout(
       process, timeout, exit_code);
 }
 
 // A very basic implementation for Android. On Android tests can run in an APK
 // and we don't have an executable to exec*. This implementation does the bare
 // minimum to execute the method specified by procname (in the child process).
@@ skipping 50 matching lines @@
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   command_line->InitFromArgv(base_command_line.argv());
   if (!command_line->HasSwitch(switches::kTestChildProcess))
     command_line->AppendSwitchASCII(switches::kTestChildProcess, procname);
 
   _exit(multi_process_function_list::InvokeChildProcessTest(procname));
   return Process();
 }
 
 }  // namespace base