Revert of Renaming Gnubby and RemoteSecurityKey files/classes/members

remoting/host/security_key/security_key_message_handler.cc

Index: remoting/host/security_key/security_key_message_handler.cc
diff --git a/remoting/host/security_key/security_key_message_handler.cc b/remoting/host/security_key/security_key_message_handler.cc
deleted file mode 100644
index 1617f89d30457aa96fc4c9b9ea85588f781a06d5..0000000000000000000000000000000000000000
--- a/remoting/host/security_key/security_key_message_handler.cc
+++ /dev/null
@@ -1,181 +0,0 @@
-// 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>
-
-#include "base/bind.h"
-#include "base/callback.h"
-#include "base/callback_helpers.h"
-#include "remoting/host/security_key/security_key_ipc_client.h"
-#include "remoting/host/security_key/security_key_ipc_constants.h"
-#include "remoting/host/security_key/security_key_message_reader_impl.h"
-#include "remoting/host/security_key/security_key_message_writer_impl.h"
-
-namespace remoting {
-
-SecurityKeyMessageHandler::SecurityKeyMessageHandler() {}
-
-SecurityKeyMessageHandler::~SecurityKeyMessageHandler() {}
-
-void SecurityKeyMessageHandler::Start(
-    base::File message_read_stream,
-    base::File message_write_stream,
-    std::unique_ptr<SecurityKeyIpcClient> ipc_client,
-    const base::Closure& error_callback) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(message_read_stream.IsValid());
-  DCHECK(message_write_stream.IsValid());
-  DCHECK(ipc_client);
-  DCHECK(!error_callback.is_null());
-  DCHECK(error_callback_.is_null());
-
-  if (!reader_) {
-    reader_.reset(
-        new SecurityKeyMessageReaderImpl(std::move(message_read_stream)));
-  }
-
-  if (!writer_) {
-    writer_.reset(
-        new SecurityKeyMessageWriterImpl(std::move(message_write_stream)));
-  }
-
-  ipc_client_ = std::move(ipc_client);
-  error_callback_ = error_callback;
-
-  reader_->Start(
-      base::Bind(&SecurityKeyMessageHandler::ProcessSecurityKeyMessage,
-                 base::Unretained(this)),
-      base::Bind(&SecurityKeyMessageHandler::OnError, base::Unretained(this)));
-}
-
-void SecurityKeyMessageHandler::SetSecurityKeyMessageReaderForTest(
-    std::unique_ptr<SecurityKeyMessageReader> reader) {
-  DCHECK(!reader_);
-  reader_ = std::move(reader);
-}
-
-void SecurityKeyMessageHandler::SetSecurityKeyMessageWriterForTest(
-    std::unique_ptr<SecurityKeyMessageWriter> writer) {
-  DCHECK(!writer_);
-  writer_ = std::move(writer);
-}
-
-void SecurityKeyMessageHandler::ProcessSecurityKeyMessage(
-    std::unique_ptr<SecurityKeyMessage> message) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  SecurityKeyMessageType message_type = message->type();
-  if (message_type == SecurityKeyMessageType::CONNECT) {
-    HandleConnectRequest(message->payload());
-  } else if (message_type == SecurityKeyMessageType::REQUEST) {
-    HandleSecurityKeyRequest(message->payload());
-  } else {
-    LOG(ERROR) << "Unknown message type: "
-               << static_cast<uint8_t>(message_type);
-    SendMessage(SecurityKeyMessageType::UNKNOWN_COMMAND);
-  }
-}
-
-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.");
-  }
-}
-
-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,
-                           "Invalid client response received.");
-    return;
-  }
-
-  SendMessageWithPayload(SecurityKeyMessageType::REQUEST_RESPONSE,
-                         response_data);
-}
-
-void SecurityKeyMessageHandler::HandleConnectRequest(
-    const std::string& message_payload) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  if (!message_payload.empty()) {
-    SendMessageWithPayload(SecurityKeyMessageType::CONNECT_ERROR,
-                           "Unexpected payload data received.");
-    return;
-  }
-
-  if (ipc_client_->WaitForSecurityKeyIpcServerChannel()) {
-    // 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));
-  } 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()) {
-    SendMessageWithPayload(SecurityKeyMessageType::REQUEST_ERROR,
-                           "Request sent without request data.");
-    return;
-  }
-
-  if (!ipc_client_->SendSecurityKeyRequest(
-          message_payload,
-          base::Bind(&SecurityKeyMessageHandler::HandleSecurityKeyResponse,
-                     base::Unretained(this)))) {
-    SendMessageWithPayload(SecurityKeyMessageType::REQUEST_ERROR,
-                           "Failed to send request data.");
-  }
-}
-
-void SecurityKeyMessageHandler::SendMessage(
-    SecurityKeyMessageType message_type) {
-  if (!writer_->WriteMessage(message_type)) {
-    OnError();
-  }
-}
-
-void SecurityKeyMessageHandler::SendMessageWithPayload(
-    SecurityKeyMessageType message_type,
-    const std::string& message_payload) {
-  if (!writer_->WriteMessageWithPayload(message_type, message_payload)) {
-    OnError();
-  }
-}
-
-void SecurityKeyMessageHandler::OnError() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  ipc_client_.reset();
-  writer_.reset();
-  reader_.reset();
-
-  if (!error_callback_.is_null()) {
-    base::ResetAndReturn(&error_callback_).Run();
-  }
-}
-
-}  // namespace remoting