Switch FirefoxImporterTest to ChannelMojo.

chrome/utility/importer/firefox_importer_unittest_utils_mac.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 "chrome/utility/importer/firefox_importer_unittest_utils.h"
 
 #include "base/base_switches.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_file.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop.h"
 #include "base/posix/global_descriptors.h"
 #include "base/process/kill.h"
 #include "base/process/launch.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/common/importer/firefox_importer_utils.h"
+#include "content/public/common/mojo_channel_switches.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_descriptors.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_multiprocess_test.h"
+#include "mojo/edk/embedder/embedder.h"
+#include "mojo/edk/embedder/platform_channel_pair.h"
+#include "mojo/edk/embedder/scoped_platform_handle.h"
 #include "testing/multiprocess_func_list.h"
 
 #define IPC_MESSAGE_IMPL
 #include "chrome/utility/importer/firefox_importer_unittest_messages_internal.h"
 
 namespace {
 
-// Name of IPC Channel to use for Server<-> Child Communications.
-const char kTestChannelID[] = "T1";
-
 // Launch the child process:
 // |nss_path| - path to the NSS directory holding the decryption libraries.
-// |channel| - IPC Channel to use for communication.
-base::Process LaunchNSSDecrypterChildProcess(const base::FilePath& nss_path,
-                                             IPC::Channel* channel) {
+// |mojo_handle| - platform handle for Mojo transport.
+// |mojo_channel_token| - token for creating the IPC channel over Mojo.
+base::Process LaunchNSSDecrypterChildProcess(
+    const base::FilePath& nss_path,
+    mojo::edk::ScopedPlatformHandle mojo_handle,
+    const std::string& mojo_channel_token) {
   base::CommandLine cl(*base::CommandLine::ForCurrentProcess());
   cl.AppendSwitchASCII(switches::kTestChildProcess, "NSSDecrypterChildProcess");
+  cl.AppendSwitchASCII(switches::kMojoChannelToken, mojo_channel_token);
 
   // Set env variable needed for FF encryption libs to load.
   // See "chrome/utility/importer/nss_decryptor_mac.mm" for an explanation of
   // why we need this.
   base::LaunchOptions options;
   options.environ["DYLD_FALLBACK_LIBRARY_PATH"] = nss_path.value();
 
-  base::ScopedFD ipcfd(channel->TakeClientFileDescriptor());
-  if (!ipcfd.is_valid())
-    return base::Process();
-
   base::FileHandleMappingVector fds_to_map;
-  fds_to_map.push_back(std::pair<int,int>(ipcfd.get(),
+  fds_to_map.push_back(std::pair<int,int>(mojo_handle.get().handle,
       kPrimaryIPCChannel + base::GlobalDescriptors::kBaseDescriptor));
 
   options.fds_to_remap = &fds_to_map;
   return base::LaunchProcess(cl.argv(), options);
 }
 
 }  // namespace
 
 //----------------------- Server --------------------
 
@@ skipping 66 matching lines @@
 };
 
 FFUnitTestDecryptorProxy::FFUnitTestDecryptorProxy() {
 }
 
 bool FFUnitTestDecryptorProxy::Setup(const base::FilePath& nss_path) {
   // Create a new message loop and spawn the child process.
   message_loop_.reset(new base::MessageLoopForIO());
 
   listener_.reset(new FFDecryptorServerChannelListener());
-  channel_ = IPC::Channel::CreateServer(kTestChannelID, listener_.get());
+
+  // Setup IPC channel using ChannelMojo.

[Ilya Sherman, 2016/07/07 20:14:24]

nit: s/Setup/Set up

[Anand Mistry (off Chromium), 2016/07/11 06:59:59]

Done.

+  const std::string mojo_child_token = mojo::edk::GenerateRandomToken();
+  const std::string mojo_channel_token = mojo::edk::GenerateRandomToken();
+  mojo::ScopedMessagePipeHandle parent_handle =
+      mojo::edk::CreateParentMessagePipe(mojo_channel_token, mojo_child_token);
+  channel_ = IPC::Channel::CreateServer(parent_handle.release(),
+                                        listener_.get());
   CHECK(channel_->Connect());
   listener_->SetSender(channel_.get());
 
   // Spawn child and set up sync IPC connection.
-  child_process_ = LaunchNSSDecrypterChildProcess(nss_path, channel_.get());
+  mojo::edk::PlatformChannelPair channel_pair;
+  child_process_ = LaunchNSSDecrypterChildProcess(
+      nss_path, channel_pair.PassClientHandle(), mojo_channel_token);
+  if (child_process_.IsValid()) {
+    mojo::edk::ChildProcessLaunched(child_process_.Handle(),
+                                    channel_pair.PassServerHandle(),
+                                    mojo_child_token);
+  } else {
+    mojo::edk::ChildProcessLaunchFailed(mojo_child_token);
+  }
+
   return child_process_.IsValid();
 }
 
 FFUnitTestDecryptorProxy::~FFUnitTestDecryptorProxy() {
   listener_->QuitClient();
   channel_->Close();
 
   if (child_process_.IsValid()) {
     int exit_code;
     child_process_.WaitForExitWithTimeout(base::TimeDelta::FromSeconds(5),
@@ skipping 120 matching lines @@
  private:
   NSSDecryptor decryptor_;
   IPC::Sender* sender_;
 };
 
 // Entry function in child process.
 MULTIPROCESS_IPC_TEST_MAIN(NSSDecrypterChildProcess) {
   base::MessageLoopForIO main_message_loop;
   FFDecryptorClientChannelListener listener;
 
+  mojo::edk::SetParentPipeHandle(
+      mojo::edk::ScopedPlatformHandle(mojo::edk::PlatformHandle(
+          base::GlobalDescriptors::GetInstance()->Get(kPrimaryIPCChannel))));
+  mojo::ScopedMessagePipeHandle mojo_handle =
+      mojo::edk::CreateChildMessagePipe(
+          base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
+              switches::kMojoChannelToken));
+
   std::unique_ptr<IPC::Channel> channel =
-      IPC::Channel::CreateClient(kTestChannelID, &listener);
+      IPC::Channel::CreateClient(mojo_handle.release(), &listener);
   CHECK(channel->Connect());
   listener.SetSender(channel.get());
 
   // run message loop
   base::RunLoop().Run();
 
   return 0;
 }