Multiprocess test client: Android child process launcher rework.

mojo/edk/embedder/platform_channel_pair_posix.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 "mojo/edk/embedder/platform_channel_pair.h"
 
 #include <fcntl.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <sys/types.h>
@@ skipping 17 matching lines @@
 
 #if !defined(SO_PEEK_OFF)
 #define SO_PEEK_OFF 42
 #endif
 
 namespace mojo {
 namespace edk {
 
 namespace {
 
+#if !defined(OS_ANDROID)
 bool IsTargetDescriptorUsed(
     const base::FileHandleMappingVector& file_handle_mapping,
     int target_fd) {
   for (size_t i = 0; i < file_handle_mapping.size(); i++) {
     if (file_handle_mapping[i].second == target_fd)
       return true;
   }
   return false;
 }
+#endif
 
 }  // namespace
 
 PlatformChannelPair::PlatformChannelPair(bool client_is_blocking) {
   // Create the Unix domain socket.
   int fds[2];
   // TODO(vtl): Maybe fail gracefully if |socketpair()| fails.
 
 #if defined(OS_NACL_SFI)
   PCHECK(imc_socketpair(fds) == 0);
@@ skipping 24 matching lines @@
 }
 
 // static
 ScopedPlatformHandle PlatformChannelPair::PassClientHandleFromParentProcess(
     const base::CommandLine& command_line) {
   std::string client_fd_string =
       command_line.GetSwitchValueASCII(kMojoPlatformChannelHandleSwitch);
   return PassClientHandleFromParentProcessFromString(client_fd_string);
 }
 
+#if !defined(OS_ANDROID)
 ScopedPlatformHandle
 PlatformChannelPair::PassClientHandleFromParentProcessFromString(
     const std::string& value) {
   int client_fd = -1;
   if (value.empty() ||
       !base::StringToInt(value, &client_fd) ||
       client_fd < base::GlobalDescriptors::kBaseDescriptor) {
     LOG(ERROR) << "Missing or invalid --" << kMojoPlatformChannelHandleSwitch;
     return ScopedPlatformHandle();
   }
 
   return ScopedPlatformHandle(PlatformHandle(client_fd));
 }
+#endif
 
 void PlatformChannelPair::PrepareToPassClientHandleToChildProcess(
     base::CommandLine* command_line,
     base::FileHandleMappingVector* handle_passing_info) const {
   DCHECK(command_line);
 
   // Log a warning if the command line already has the switch, but "clobber" it
   // anyway, since it's reasonably likely that all the switches were just copied
   // from the parent.
   LOG_IF(WARNING, command_line->HasSwitch(kMojoPlatformChannelHandleSwitch))
       << "Child command line already has switch --"
       << kMojoPlatformChannelHandleSwitch << "="
       << command_line->GetSwitchValueASCII(kMojoPlatformChannelHandleSwitch);
   // (Any existing switch won't actually be removed from the command line, but
   // the last one appended takes precedence.)
   command_line->AppendSwitchASCII(
       kMojoPlatformChannelHandleSwitch,
       PrepareToPassClientHandleToChildProcessAsString(handle_passing_info));
 }
 
+#if !defined(OS_ANDROID)
 std::string
 PlatformChannelPair::PrepareToPassClientHandleToChildProcessAsString(
       HandlePassingInformation* handle_passing_info) const {
   DCHECK(handle_passing_info);
   // This is an arbitrary sanity check. (Note that this guarantees that the loop
   // below will terminate sanely.)
   CHECK_LT(handle_passing_info->size(), 1000u);
 
   DCHECK(client_handle_.is_valid());
 
   // Find a suitable FD to map our client handle to in the child process.
   // This has quadratic time complexity in the size of |*handle_passing_info|,
   // but |*handle_passing_info| should be very small (usually/often empty).
   int target_fd = base::GlobalDescriptors::kBaseDescriptor;
   while (IsTargetDescriptorUsed(*handle_passing_info, target_fd))
     target_fd++;
 
   handle_passing_info->push_back(
       std::pair<int, int>(client_handle_.get().handle, target_fd));
   return base::IntToString(target_fd);
 }
+#endif
 
 }  // namespace edk
 }  // namespace mojo