Handle Security Key requests from outside the remoted session correctly

remoting/host/security_key/security_key_message_handler.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 <cstdint>
 #include <string>
 #include <utility>
 
@@ skipping 70 matching lines @@
   }
 }
 
 void SecurityKeyMessageHandler::HandleIpcConnectionChange(
     bool connection_established) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (connection_established) {
     SendMessageWithPayload(SecurityKeyMessageType::CONNECT_RESPONSE,
                            std::string(1, kConnectResponseActiveSession));
   } else {
-    SendMessageWithPayload(
-        SecurityKeyMessageType::CONNECT_ERROR,
-        "Unknown error occurred while establishing connection.");
+    SendMessageWithPayload(SecurityKeyMessageType::CONNECT_RESPONSE,
+                           std::string(1, kConnectResponseNoSession));
+    // We expect the server to close the IPC channel in this scenario.
+    expect_ipc_channel_close_ = true;
   }
 }
 
+void SecurityKeyMessageHandler::HandleIpcConnectionError() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (!expect_ipc_channel_close_) {
+    SendMessageWithPayload(SecurityKeyMessageType::CONNECT_ERROR,
+                           "Unknown error occurred during connection.");
+  }
+}
+
 void SecurityKeyMessageHandler::HandleSecurityKeyResponse(
     const std::string& response_data) {
   if (response_data.compare(kSecurityKeyConnectionError) == 0) {
     SendMessageWithPayload(SecurityKeyMessageType::REQUEST_ERROR,
                            "An error occurred during the request.");
     return;
   }
 
   if (response_data.empty()) {
     SendMessageWithPayload(SecurityKeyMessageType::REQUEST_ERROR,
@@ skipping 11 matching lines @@
   if (!message_payload.empty()) {
     SendMessageWithPayload(SecurityKeyMessageType::CONNECT_ERROR,
                            "Unexpected payload data received.");
     return;
   }
 
   if (ipc_client_->CheckForSecurityKeyIpcServerChannel()) {
     // If we find an IPC server, then attempt to establish a connection.
     ipc_client_->EstablishIpcConnection(
         base::Bind(&SecurityKeyMessageHandler::HandleIpcConnectionChange,
-                   base::Unretained(this), true),
-        base::Bind(&SecurityKeyMessageHandler::HandleIpcConnectionChange,
-                   base::Unretained(this), false));
+                   base::Unretained(this)),
+        base::Bind(&SecurityKeyMessageHandler::HandleIpcConnectionError,
+                   base::Unretained(this)));
   } else {
     SendMessageWithPayload(SecurityKeyMessageType::CONNECT_RESPONSE,
                            std::string(1, kConnectResponseNoSession));
   }
 }
 
 void SecurityKeyMessageHandler::HandleSecurityKeyRequest(
     const std::string& message_payload) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (message_payload.empty()) {
@@ skipping 31 matching lines @@
   ipc_client_.reset();
   writer_.reset();
   reader_.reset();
 
   if (!error_callback_.is_null()) {
     base::ResetAndReturn(&error_callback_).Run();
   }
 }
 
 }  // namespace remoting