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

remoting/host/win/worker_process_launcher_unittest.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 "remoting/host/win/worker_process_launcher.h"
 
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/scoped_process_information.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_message.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/host/chromoting_messages.h"
 #include "remoting/host/host_exit_codes.h"
+#include "remoting/host/ipc_util.h"
 #include "remoting/host/win/launch_process_with_token.h"
 #include "remoting/host/worker_process_ipc_delegate.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gmock_mutant.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::win::ScopedHandle;
 using testing::_;
 using testing::AnyNumber;
 using testing::CreateFunctor;
 using testing::DoAll;
 using testing::Expectation;
 using testing::Invoke;
 using testing::InvokeWithoutArgs;
 using testing::Return;
 
 namespace remoting {
 
 namespace {
 
+const char kIpcSecurityDescriptor[] = "D:(A;;GA;;;AU)";
+
 class MockProcessLauncherDelegate : public WorkerProcessLauncher::Delegate {
  public:
   MockProcessLauncherDelegate() {}
   ~MockProcessLauncherDelegate() override {}
 
   // WorkerProcessLauncher::Delegate interface.
   MOCK_METHOD1(LaunchProcess, void(WorkerProcessLauncher*));
   MOCK_METHOD1(Send, void(IPC::Message*));
   MOCK_METHOD0(CloseChannel, void());
   MOCK_METHOD0(KillProcess, void());
@@ skipping 105 matching lines @@
 
   // Receives messages sent to the worker process.
   MockWorkerListener client_listener_;
 
   // Receives messages sent from the worker process.
   MockIpcDelegate server_listener_;
 
   // Implements WorkerProcessLauncher::Delegate.
   std::unique_ptr<MockProcessLauncherDelegate> launcher_delegate_;
 
-  // The client handle to the channel.
-  mojo::ScopedMessagePipeHandle client_channel_handle_;
+  // The name of the IPC channel.
+  std::string channel_name_;
 
   // Client and server ends of the IPC channel.
   std::unique_ptr<IPC::ChannelProxy> channel_client_;
   std::unique_ptr<IPC::ChannelProxy> channel_server_;
 
   WorkerProcessLauncher* event_handler_;
 
   // The worker process launcher.
   std::unique_ptr<WorkerProcessLauncher> launcher_;
 
@@ skipping 88 matching lines @@
     worker_process_.Close();
   }
 }
 
 void WorkerProcessLauncherTest::TerminateWorker(DWORD exit_code) {
   if (worker_process_.IsValid())
     TerminateProcess(worker_process_.Get(), exit_code);
 }
 
 void WorkerProcessLauncherTest::ConnectClient() {
-  channel_client_ = IPC::ChannelProxy::Create(client_channel_handle_.release(),
+  channel_client_ = IPC::ChannelProxy::Create(IPC::ChannelHandle(channel_name_),
                                               IPC::Channel::MODE_CLIENT,
-                                              &client_listener_, task_runner_);
+                                              &client_listener_,
+                                              task_runner_);
 
   // Pretend that |kLaunchSuccessTimeoutSeconds| passed since launching
   // the worker process. This will make the backoff algorithm think that this
   // launch attempt was successful and it will not delay the next launch.
   launcher_->RecordSuccessfulLaunchForTest();
 }
 
 void WorkerProcessLauncherTest::DisconnectClient() {
   channel_client_.reset();
 }
@@ skipping 25 matching lines @@
 void WorkerProcessLauncherTest::StartWorker() {
   launcher_.reset(new WorkerProcessLauncher(std::move(launcher_delegate_),
                                             &server_listener_));
 
   launcher_->SetKillProcessTimeoutForTest(base::TimeDelta::FromMilliseconds(0));
 }
 
 void WorkerProcessLauncherTest::StopWorker() {
   launcher_.reset();
   DisconnectClient();
-  client_channel_handle_.reset();
+  channel_name_.clear();
   channel_server_.reset();
   task_runner_ = nullptr;
 }
 
 void WorkerProcessLauncherTest::QuitMainMessageLoop() {
   message_loop_.task_runner()->PostTask(
       FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
 }
 
 void WorkerProcessLauncherTest::DoLaunchProcess() {
@@ skipping 15 matching lines @@
                             FALSE,  // do not inherit handles
                             CREATE_SUSPENDED,
                             nullptr,   // no environment
                             nullptr,   // default current directory
                             &startup_info,
                             &temp_process_info));
   base::win::ScopedProcessInformation process_information(temp_process_info);
   worker_process_.Set(process_information.TakeProcessHandle());
   ASSERT_TRUE(worker_process_.IsValid());
 
-  mojo::MessagePipe pipe;
-  client_channel_handle_ = std::move(pipe.handle0);
+  channel_name_ = IPC::Channel::GenerateUniqueRandomChannelID();
+  ScopedHandle pipe;
+  ASSERT_TRUE(CreateIpcChannel(channel_name_, kIpcSecurityDescriptor, &pipe));
 
   // Wrap the pipe into an IPC channel.
   channel_server_ = IPC::ChannelProxy::Create(
-      pipe.handle1.release(), IPC::Channel::MODE_SERVER, this, task_runner_);
+      IPC::ChannelHandle(pipe.Get()), IPC::Channel::MODE_SERVER, this,
+      task_runner_);
 
   HANDLE temp_handle;
   ASSERT_TRUE(DuplicateHandle(GetCurrentProcess(), worker_process_.Get(),
                               GetCurrentProcess(), &temp_handle, 0, FALSE,
                               DUPLICATE_SAME_ACCESS));
   event_handler_->OnProcessLaunched(ScopedHandle(temp_handle));
 }
 
 TEST_F(WorkerProcessLauncherTest, Start) {
   EXPECT_CALL(*launcher_delegate_, LaunchProcess(_))
@@ skipping 143 matching lines @@
   EXPECT_CALL(client_listener_, OnCrash(_, _, _))
       .Times(1)
       .WillOnce(InvokeWithoutArgs(
           this, &WorkerProcessLauncherTest::SendFakeMessageToLauncher));
 
   StartWorker();
   base::RunLoop().Run();
 }
 
 }  // namespace remoting