Handle Security Key requests from outside the remoted session correctly

remoting/host/security_key/fake_security_key_ipc_client.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/fake_security_key_ipc_client.h"
 
 #include <memory>
 
 #include "base/callback.h"
 #include "base/macros.h"
@@ skipping 19 matching lines @@
 
 base::WeakPtr<FakeSecurityKeyIpcClient> FakeSecurityKeyIpcClient::AsWeakPtr() {
   return weak_factory_.GetWeakPtr();
 }
 
 bool FakeSecurityKeyIpcClient::CheckForSecurityKeyIpcServerChannel() {
   return check_for_ipc_channel_return_value_;
 }
 
 void FakeSecurityKeyIpcClient::EstablishIpcConnection(
-    const base::Closure& connection_ready_callback,
+    const ConnectedCallback& connected_callback,
     const base::Closure& connection_error_callback) {
   if (establish_ipc_connection_should_succeed_) {
-    connection_ready_callback.Run();
+    connected_callback.Run(/*connection_usable=*/true);
   } else {
     connection_error_callback.Run();
   }
 }
 
 bool FakeSecurityKeyIpcClient::SendSecurityKeyRequest(
     const std::string& request_payload,
     const ResponseCallback& response_callback) {
   if (send_security_request_should_succeed_) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
@@ skipping 25 matching lines @@
     const std::string& request_payload) {
   client_channel_->Send(
       new ChromotingRemoteSecurityKeyToNetworkMsg_Request(request_payload));
 }
 
 bool FakeSecurityKeyIpcClient::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(FakeSecurityKeyIpcClient, message)
     IPC_MESSAGE_HANDLER(ChromotingNetworkToRemoteSecurityKeyMsg_Response,
                         OnSecurityKeyResponse)
+    IPC_MESSAGE_HANDLER(ChromotingNetworkToRemoteSecurityKeyMsg_ConnectionReady,
+                        OnConnectionReady)
+    IPC_MESSAGE_HANDLER(ChromotingNetworkToRemoteSecurityKeyMsg_InvalidSession,
+                        OnInvalidSession)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   CHECK(handled) << "Received unexpected IPC type: " << message.type();
   return handled;
 }
 
+void FakeSecurityKeyIpcClient::OnConnectionReady() {
+  connection_ready_ = true;
+  channel_event_callback_.Run();
+}
+
+void FakeSecurityKeyIpcClient::OnInvalidSession() {
+  invalid_session_error_ = true;
+  channel_event_callback_.Run();
+}
+
 void FakeSecurityKeyIpcClient::OnChannelConnected(int32_t peer_pid) {
   ipc_channel_connected_ = true;
   channel_event_callback_.Run();
 }
 
 void FakeSecurityKeyIpcClient::OnChannelError() {
   ipc_channel_connected_ = false;
   channel_event_callback_.Run();
 }
 
 void FakeSecurityKeyIpcClient::OnSecurityKeyResponse(
     const std::string& request_data) {
   last_message_received_ = request_data;
   channel_event_callback_.Run();
 }
 
 }  // namespace remoting