Change WorkerProcessLauncherTest to use ChannelMojo.

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"

[joedow, 2016/10/27 18:41:42]

Do you want to IWYU here for the mojo class(es)?

[Sam McNally, 2016/10/27 22:22:39]

Done.

 #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 name of the IPC channel.
-  std::string channel_name_;
+  // The client handle to the channel.
+  mojo::ScopedMessagePipeHandle client_channel_handle_;
 
   // 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 76 matching lines @@
 
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&WorkerProcessLauncherTest::StopWorker,
                  base::Unretained(this)));
 }
 
 void WorkerProcessLauncherTest::KillProcess() {
   event_handler_ = nullptr;
 
+  DisconnectClient();
   if (worker_process_.IsValid()) {
     TerminateProcess(worker_process_.Get(), CONTROL_C_EXIT);
     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(IPC::ChannelHandle(channel_name_),
+  channel_client_ = IPC::ChannelProxy::Create(client_channel_handle_.release(),
                                               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();
+  if (channel_client_) {
+    channel_client_->Close();
+    channel_client_.reset();
+  }
 }
 
 void WorkerProcessLauncherTest::DisconnectServer() {
-  channel_server_.reset();
+  if (channel_server_) {
+    channel_server_->Close();
+    channel_server_.reset();
+  }
 }
 
 void WorkerProcessLauncherTest::SendToProcess(IPC::Message* message) {
   if (channel_server_) {
     channel_server_->Send(message);
     return;
   }
 
   delete message;
 }
 
 void WorkerProcessLauncherTest::SendFakeMessageToLauncher() {
   if (channel_client_) {
     channel_client_->Send(
         new ChromotingDesktopNetworkMsg_DisconnectSession(protocol::OK));
   }
 }
 
 void WorkerProcessLauncherTest::CrashWorker() {
   launcher_->Crash(FROM_HERE);
 }
 
 void WorkerProcessLauncherTest::StartWorker() {
   launcher_.reset(new WorkerProcessLauncher(std::move(launcher_delegate_),
                                             &server_listener_));
 
-  launcher_->SetKillProcessTimeoutForTest(base::TimeDelta::FromMilliseconds(0));
+  launcher_->SetKillProcessTimeoutForTest(
+      base::TimeDelta::FromMilliseconds(100));
 }
 
 void WorkerProcessLauncherTest::StopWorker() {
   launcher_.reset();
   DisconnectClient();
-  channel_name_.clear();
+  client_channel_handle_.reset();
   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());
 
-  channel_name_ = IPC::Channel::GenerateUniqueRandomChannelID();
-  ScopedHandle pipe;
-  ASSERT_TRUE(CreateIpcChannel(channel_name_, kIpcSecurityDescriptor, &pipe));
+  mojo::MessagePipe pipe;
+  client_channel_handle_ = std::move(pipe.handle0);
 
   // Wrap the pipe into an IPC channel.
   channel_server_ = IPC::ChannelProxy::Create(
-      IPC::ChannelHandle(pipe.Get()), IPC::Channel::MODE_SERVER, this,
-      task_runner_);
+      pipe.handle1.release(), 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