| // 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/fake_security_key_ipc_server.h" |
| |
| #include <cstdint> |
| #include <memory> |
| #include <string> |
| |
| #include "base/callback.h" |
| #include "base/macros.h" |
| #include "ipc/ipc_channel.h" |
| #include "ipc/ipc_message.h" |
| #include "ipc/ipc_message_macros.h" |
| #include "mojo/public/cpp/platform/named_platform_channel.h" |
| #include "mojo/public/cpp/system/isolated_connection.h" |
| #include "remoting/host/chromoting_messages.h" |
| #include "remoting/host/security_key/security_key_auth_handler.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| namespace remoting { |
| |
| FakeSecurityKeyIpcServer::FakeSecurityKeyIpcServer( |
| int connection_id, |
| ClientSessionDetails* client_session_details, |
| base::TimeDelta initial_connect_timeout, |
| const SecurityKeyAuthHandler::SendMessageCallback& send_message_callback, |
| const base::Closure& connect_callback, |
| const base::Closure& channel_closed_callback) |
| : connection_id_(connection_id), |
| send_message_callback_(send_message_callback), |
| connect_callback_(connect_callback), |
| channel_closed_callback_(channel_closed_callback), |
| weak_factory_(this) {} |
| |
| FakeSecurityKeyIpcServer::~FakeSecurityKeyIpcServer() = default; |
| |
| void FakeSecurityKeyIpcServer::SendRequest(const std::string& message_data) { |
| send_message_callback_.Run(connection_id_, message_data); |
| } |
| |
| void FakeSecurityKeyIpcServer::CloseChannel() { |
| ipc_channel_.reset(); |
| mojo_connection_.reset(); |
| channel_closed_callback_.Run(); |
| } |
| |
| base::WeakPtr<FakeSecurityKeyIpcServer> FakeSecurityKeyIpcServer::AsWeakPtr() { |
| return weak_factory_.GetWeakPtr(); |
| } |
| |
| bool FakeSecurityKeyIpcServer::OnMessageReceived(const IPC::Message& message) { |
| bool handled = true; |
| IPC_BEGIN_MESSAGE_MAP(FakeSecurityKeyIpcServer, message) |
| IPC_MESSAGE_HANDLER(ChromotingRemoteSecurityKeyToNetworkMsg_Request, |
| SendRequest) |
| IPC_MESSAGE_UNHANDLED(handled = false) |
| IPC_END_MESSAGE_MAP() |
| |
| EXPECT_TRUE(handled); |
| return handled; |
| } |
| |
| void FakeSecurityKeyIpcServer::OnChannelConnected(int32_t peer_pid) { |
| connect_callback_.Run(); |
| } |
| |
| bool FakeSecurityKeyIpcServer::CreateChannel( |
| const mojo::NamedPlatformChannel::ServerName& server_name, |
| base::TimeDelta request_timeout) { |
| mojo::NamedPlatformChannel::Options options; |
| options.server_name = server_name; |
| #if defined(OS_WIN) |
| options.enforce_uniqueness = false; |
| #endif |
| mojo::NamedPlatformChannel channel(options); |
| |
| mojo_connection_ = std::make_unique<mojo::IsolatedConnection>(); |
| ipc_channel_ = IPC::Channel::CreateServer( |
| mojo_connection_->Connect(channel.TakeServerEndpoint()).release(), this, |
| base::ThreadTaskRunnerHandle::Get()); |
| EXPECT_NE(nullptr, ipc_channel_); |
| return ipc_channel_->Connect(); |
| } |
| |
| bool FakeSecurityKeyIpcServer::SendResponse(const std::string& message_data) { |
| last_message_received_ = message_data; |
| |
| // This class works in two modes: one in which the test wants the IPC channel |
| // to be created and used for notification and the second mode where the test |
| // wants to notified of a response via a callback. If a callback is set then |
| // we use it, otherwise we will use the IPC connection to send a message. |
| if (!send_response_callback_.is_null()) { |
| send_response_callback_.Run(); |
| return true; |
| } |
| |
| return ipc_channel_->Send( |
| new ChromotingNetworkToRemoteSecurityKeyMsg_Response(message_data)); |
| } |
| |
| void FakeSecurityKeyIpcServer::SendConnectionReadyMessage() { |
| ipc_channel_->Send( |
| new ChromotingNetworkToRemoteSecurityKeyMsg_ConnectionReady()); |
| } |
| |
| void FakeSecurityKeyIpcServer::SendInvalidSessionMessage() { |
| ipc_channel_->Send( |
| new ChromotingNetworkToRemoteSecurityKeyMsg_InvalidSession()); |
| } |
| |
| FakeSecurityKeyIpcServerFactory::FakeSecurityKeyIpcServerFactory() { |
| SecurityKeyIpcServer::SetFactoryForTest(this); |
| } |
| |
| FakeSecurityKeyIpcServerFactory::~FakeSecurityKeyIpcServerFactory() { |
| SecurityKeyIpcServer::SetFactoryForTest(nullptr); |
| } |
| |
| std::unique_ptr<SecurityKeyIpcServer> FakeSecurityKeyIpcServerFactory::Create( |
| int connection_id, |
| ClientSessionDetails* client_session_details, |
| base::TimeDelta initial_connect_timeout, |
| const SecurityKeyAuthHandler::SendMessageCallback& send_message_callback, |
| const base::Closure& connect_callback, |
| const base::Closure& done_callback) { |
| auto fake_ipc_server = std::make_unique<FakeSecurityKeyIpcServer>( |
| connection_id, client_session_details, initial_connect_timeout, |
| send_message_callback, connect_callback, done_callback); |
| |
| ipc_server_map_[connection_id] = fake_ipc_server->AsWeakPtr(); |
| |
| return std::move(fake_ipc_server); |
| } |
| |
| base::WeakPtr<FakeSecurityKeyIpcServer> |
| FakeSecurityKeyIpcServerFactory::GetIpcServerObject(int connection_id) { |
| return ipc_server_map_[connection_id]; |
| } |
| |
| } // namespace remoting |