Revert of Use ChannelMojo between the remoting daemon and network processes.

remoting/host/remoting_me2me_host.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 file implements a standalone host process for Me2Me.
 
 #include <stddef.h>
 
 #include <cstdint>
 #include <memory>
@@ skipping 15 matching lines @@
 #include "base/strings/string_util.h"
 #include "base/strings/stringize_macros.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "components/policy/policy_constants.h"
 #include "ipc/attachment_broker_unprivileged.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_listener.h"
 #include "jingle/glue/thread_wrapper.h"
-#include "mojo/edk/embedder/embedder.h"
-#include "mojo/edk/embedder/platform_channel_pair.h"
-#include "mojo/edk/embedder/scoped_ipc_support.h"
 #include "net/base/network_change_notifier.h"
 #include "net/base/url_util.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/url_request/url_fetcher.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/base/breakpad.h"
 #include "remoting/base/chromium_url_request.h"
 #include "remoting/base/constants.h"
 #include "remoting/base/logging.h"
 #include "remoting/base/rsa_key_pair.h"
@@ skipping 357 matching lines @@
   std::unique_ptr<HostStatusLogger> host_status_logger_;
   std::unique_ptr<HostEventLogger> host_event_logger_;
   std::unique_ptr<HostPowerSaveBlocker> power_save_blocker_;
 
   std::unique_ptr<ChromotingHost> host_;
 
   // Used to keep this HostProcess alive until it is shutdown.
   scoped_refptr<HostProcess> self_;
 
 #if defined(REMOTING_MULTI_PROCESS)
-  std::unique_ptr<mojo::edk::ScopedIPCSupport> ipc_support_;
-
   // Accessed on the UI thread.
   std::unique_ptr<IPC::ChannelProxy> daemon_channel_;
 
   // Owned as |desktop_environment_factory_|.
   DesktopSessionConnector* desktop_session_connector_ = nullptr;
 #endif  // defined(REMOTING_MULTI_PROCESS)
 
   int* exit_code_out_;
   bool signal_parent_ = false;
 
@@ skipping 24 matching lines @@
   // threads it contains.  This will go away when we move to AutoThread.
   // |context_release()| will null |context_| before the method is invoked, so
   // we need to pull out the task-runner on which to call DeleteSoon first.
   scoped_refptr<base::SingleThreadTaskRunner> task_runner =
       context_->ui_task_runner();
   task_runner->DeleteSoon(FROM_HERE, context_.release());
 }
 
 bool HostProcess::InitWithCommandLine(const base::CommandLine* cmd_line) {
 #if defined(REMOTING_MULTI_PROCESS)
-  // Mojo keeps the task runner passed to it alive forever, so an
-  // AutoThreadTaskRunner should not be passed to it. Otherwise, the process may
-  // never shut down cleanly.
-  ipc_support_ = base::MakeUnique<mojo::edk::ScopedIPCSupport>(
-      context_->network_task_runner()->task_runner());
-  mojo::edk::SetParentPipeHandle(
-      mojo::edk::PlatformChannelPair::PassClientHandleFromParentProcess(
-          *cmd_line));
+  // Parse the handle value and convert it to a handle/file descriptor.
+  std::string channel_name =
+      cmd_line->GetSwitchValueASCII(kDaemonPipeSwitchName);
+
+  int pipe_handle = 0;
+  if (channel_name.empty() ||
+      !base::StringToInt(channel_name, &pipe_handle)) {
+    LOG(ERROR) << "Invalid '" << kDaemonPipeSwitchName
+               << "' value: " << channel_name;
+    return false;
+  }
+
+#if defined(OS_WIN)
+  base::win::ScopedHandle pipe(reinterpret_cast<HANDLE>(pipe_handle));
+  IPC::ChannelHandle channel_handle(pipe.Get());
+#elif defined(OS_POSIX)
+  base::FileDescriptor pipe(pipe_handle, true);
+  IPC::ChannelHandle channel_handle(channel_name, pipe);
+#endif  // defined(OS_POSIX)
 
   // Connect to the daemon process.
   daemon_channel_.reset(
       new IPC::ChannelProxy(this, context_->network_task_runner()));
   IPC::AttachmentBrokerUnprivileged::CreateBrokerIfNeeded();
   IPC::AttachmentBroker* broker = IPC::AttachmentBroker::GetGlobal();
   if (broker && !broker->IsPrivilegedBroker())
     broker->RegisterBrokerCommunicationChannel(daemon_channel_.get());
-  daemon_channel_->Init(mojo::edk::CreateChildMessagePipe(
-                            cmd_line->GetSwitchValueASCII(kMojoPipeToken))
-                            .release(),
-                        IPC::Channel::MODE_CLIENT,
+  daemon_channel_->Init(channel_handle, IPC::Channel::MODE_CLIENT,
                         /*create_pipe_now=*/true);
 
 #else  // !defined(REMOTING_MULTI_PROCESS)
   if (cmd_line->HasSwitch(kHostConfigSwitchName)) {
     host_config_path_ = cmd_line->GetSwitchValuePath(kHostConfigSwitchName);
 
     // Read config from stdin if necessary.
     if (host_config_path_ == base::FilePath(kStdinConfigPath)) {
       const size_t kBufferSize = 4096;
       std::unique_ptr<char[]> buf(new char[kBufferSize]);
@@ skipping 1167 matching lines @@
       base::TimeDelta::FromSeconds(kShutdownTimeoutSeconds));
   new HostProcess(std::move(context), &exit_code, &shutdown_watchdog);
 
   // Run the main (also UI) message loop until the host no longer needs it.
   base::RunLoop().Run();
 
   return exit_code;
 }
 
 }  // namespace remoting