Use ChannelMojo for remote security key channels.

remoting/host/security_key/security_key_message_handler_unittest.cc

 // Copyright 2016 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/security_key/security_key_message_handler.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 
@@ skipping 98 matching lines @@
     SecurityKeyMessageType message_type,
     const std::string& message_payload) {
   last_message_type_received_ = message_type;
   last_message_payload_received_ = message_payload;
 
   OperationComplete();
 }
 
 TEST_F(SecurityKeyMessageHandlerTest,
        ProcessConnectMessage_SessionExists_ConnectionAttemptSuccess) {
-  ipc_client_weak_ptr_->set_wait_for_ipc_channel_return_value(true);
+  ipc_client_weak_ptr_->set_check_for_ipc_channel_return_value(true);
   ipc_client_weak_ptr_->set_establish_ipc_connection_should_succeed(true);
 
   reader_weak_ptr_->message_callback().Run(
       SecurityKeyMessage::CreateMessageForTest(SecurityKeyMessageType::CONNECT,
                                                std::string()));
   WaitForOperationComplete();
 
   ASSERT_EQ(SecurityKeyMessageType::CONNECT_RESPONSE,
             writer_weak_ptr_->last_message_type());
   ASSERT_EQ(std::string(1, kConnectResponseActiveSession),
             writer_weak_ptr_->last_message_payload());
 }
 
 TEST_F(SecurityKeyMessageHandlerTest,
        ProcessConnectMessage_SessionExists_WriteFails) {
-  ipc_client_weak_ptr_->set_wait_for_ipc_channel_return_value(true);
+  ipc_client_weak_ptr_->set_check_for_ipc_channel_return_value(true);
   ipc_client_weak_ptr_->set_establish_ipc_connection_should_succeed(true);
   writer_weak_ptr_->set_write_request_succeeded(/*should_succeed=*/false);
 
   reader_weak_ptr_->message_callback().Run(
       SecurityKeyMessage::CreateMessageForTest(SecurityKeyMessageType::CONNECT,
                                                std::string()));
   WaitForOperationComplete();
 
   ASSERT_FALSE(ipc_client_weak_ptr_.get());
   ASSERT_FALSE(reader_weak_ptr_.get());
   ASSERT_FALSE(writer_weak_ptr_.get());
 }
 
 TEST_F(SecurityKeyMessageHandlerTest,
        ProcessConnectMessage_SessionExists_ConnectionAttemptFailure) {
-  ipc_client_weak_ptr_->set_wait_for_ipc_channel_return_value(true);
+  ipc_client_weak_ptr_->set_check_for_ipc_channel_return_value(true);
   ipc_client_weak_ptr_->set_establish_ipc_connection_should_succeed(false);
 
   reader_weak_ptr_->message_callback().Run(
       SecurityKeyMessage::CreateMessageForTest(SecurityKeyMessageType::CONNECT,
                                                std::string()));
   WaitForOperationComplete();
 
   ASSERT_EQ(SecurityKeyMessageType::CONNECT_ERROR,
             writer_weak_ptr_->last_message_type());
   ASSERT_FALSE(writer_weak_ptr_->last_message_payload().empty());
 }
 
 TEST_F(SecurityKeyMessageHandlerTest, ProcessConnectMessage_NoSessionExists) {
-  ipc_client_weak_ptr_->set_wait_for_ipc_channel_return_value(false);
+  ipc_client_weak_ptr_->set_check_for_ipc_channel_return_value(false);
   ipc_client_weak_ptr_->set_establish_ipc_connection_should_succeed(false);
 
   reader_weak_ptr_->message_callback().Run(
       SecurityKeyMessage::CreateMessageForTest(SecurityKeyMessageType::CONNECT,
                                                std::string()));
   WaitForOperationComplete();
 
   ASSERT_EQ(SecurityKeyMessageType::CONNECT_RESPONSE,
             writer_weak_ptr_->last_message_type());
   ASSERT_EQ(std::string(1, kConnectResponseNoSession),
             writer_weak_ptr_->last_message_payload());
 }
 
 TEST_F(SecurityKeyMessageHandlerTest, ProcessConnectMessage_IncorrectPayload) {
-  ipc_client_weak_ptr_->set_wait_for_ipc_channel_return_value(true);
+  ipc_client_weak_ptr_->set_check_for_ipc_channel_return_value(true);
   ipc_client_weak_ptr_->set_establish_ipc_connection_should_succeed(false);
 
   reader_weak_ptr_->message_callback().Run(
       SecurityKeyMessage::CreateMessageForTest(SecurityKeyMessageType::CONNECT,
                                                "Invalid request payload"));
   WaitForOperationComplete();
 
   ASSERT_EQ(SecurityKeyMessageType::CONNECT_ERROR,
             writer_weak_ptr_->last_message_type());
   ASSERT_FALSE(writer_weak_ptr_->last_message_payload().empty());
@@ skipping 99 matching lines @@
   reader_weak_ptr_->message_callback().Run(
       SecurityKeyMessage::CreateMessageForTest(
           SecurityKeyMessageType::UNKNOWN_ERROR, std::string()));
   WaitForOperationComplete();
 
   ASSERT_EQ(SecurityKeyMessageType::UNKNOWN_COMMAND,
             writer_weak_ptr_->last_message_type());
 }
 
 }  // namespace remoting