Fixing SecurityKeySocket unit test issues and cleanup

remoting/host/security_key/security_key_auth_handler_posix.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_auth_handler.h"
 
 #include <unistd.h>
 
 #include <cstdint>
 #include <map>
@@ skipping 174 matching lines @@
       new net::UnixDomainServerSocket(base::Bind(MatchUid), false));
   int rv = auth_socket_->BindAndListen(g_security_key_socket_name.Get().value(),
                                        /*backlog=*/1);
   if (rv != net::OK) {
     LOG(ERROR) << "Failed to open socket for auth requests: '" << rv << "'";
     return;
   }
   DoAccept();
 }
 
-bool SecurityKeyAuthHandlerPosix::IsValidConnectionId(
-    int security_key_connection_id) const {
-  return GetSocketForConnectionId(security_key_connection_id) !=
-         active_sockets_.end();
+bool SecurityKeyAuthHandlerPosix::IsValidConnectionId(int connection_id) const {
+  return GetSocketForConnectionId(connection_id) != active_sockets_.end();
 }
 
 void SecurityKeyAuthHandlerPosix::SendClientResponse(
-    int security_key_connection_id,
+    int connection_id,
     const std::string& response) {
-  ActiveSockets::const_iterator iter =
-      GetSocketForConnectionId(security_key_connection_id);
+  ActiveSockets::const_iterator iter = GetSocketForConnectionId(connection_id);
   if (iter != active_sockets_.end()) {
     iter->second->SendResponse(response);
   } else {
-    LOG(WARNING) << "Unknown gnubby-auth data connection: '"
-                 << security_key_connection_id << "'";
+    LOG(WARNING) << "Unknown gnubby-auth connection id: " << connection_id;
   }
 }
 
-void SecurityKeyAuthHandlerPosix::SendErrorAndCloseConnection(
-    int security_key_connection_id) {
-  ActiveSockets::const_iterator iter =
-      GetSocketForConnectionId(security_key_connection_id);
+void SecurityKeyAuthHandlerPosix::SendErrorAndCloseConnection(int id) {
+  ActiveSockets::const_iterator iter = GetSocketForConnectionId(id);
   if (iter != active_sockets_.end()) {
     HOST_LOG << "Sending security key error";
     SendErrorAndCloseActiveSocket(iter);
   } else {
-    LOG(WARNING) << "Unknown gnubby-auth data connection: '"
-                 << security_key_connection_id << "'";
+    LOG(WARNING) << "Unknown gnubby-auth connection id: " << id;
   }
 }
 
 void SecurityKeyAuthHandlerPosix::SetSendMessageCallback(
     const SendMessageCallback& callback) {
   send_message_callback_ = callback;
 }
 
 size_t SecurityKeyAuthHandlerPosix::GetActiveConnectionCountForTest() const {
   return active_sockets_.size();
 }
 
 void SecurityKeyAuthHandlerPosix::SetRequestTimeoutForTest(
     base::TimeDelta timeout) {
   request_timeout_ = timeout;
 }
 
 void SecurityKeyAuthHandlerPosix::DoAccept() {
   DCHECK(thread_checker_.CalledOnValidThread());
   int result = auth_socket_->Accept(
       &accept_socket_, base::Bind(&SecurityKeyAuthHandlerPosix::OnAccepted,
                                   base::Unretained(this)));
-  if (result != net::ERR_IO_PENDING)
+  if (result != net::ERR_IO_PENDING) {
     OnAccepted(result);
+  }
 }
 
 void SecurityKeyAuthHandlerPosix::OnAccepted(int result) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_NE(net::ERR_IO_PENDING, result);
 
   if (result < 0) {
     LOG(ERROR) << "Error in accepting a new connection";
     return;
   }
 
   int security_key_connection_id = ++last_connection_id_;
   SecurityKeySocket* socket = new SecurityKeySocket(
       std::move(accept_socket_), request_timeout_,
       base::Bind(&SecurityKeyAuthHandlerPosix::RequestTimedOut,
                  base::Unretained(this), security_key_connection_id));
   active_sockets_[security_key_connection_id] = base::WrapUnique(socket);
   socket->StartReadingRequest(
       base::Bind(&SecurityKeyAuthHandlerPosix::OnReadComplete,
                  base::Unretained(this), security_key_connection_id));
 
   // Continue accepting new connections.
   DoAccept();
 }
 
-void SecurityKeyAuthHandlerPosix::OnReadComplete(
-    int security_key_connection_id) {
+void SecurityKeyAuthHandlerPosix::OnReadComplete(int connection_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  ActiveSockets::const_iterator iter =
-      active_sockets_.find(security_key_connection_id);
+  ActiveSockets::const_iterator iter = active_sockets_.find(connection_id);
   DCHECK(iter != active_sockets_.end());
   std::string request_data;
   if (!iter->second->GetAndClearRequestData(&request_data)) {
     SendErrorAndCloseActiveSocket(iter);
     return;
   }
 
   HOST_LOG << "Received security key request: " << GetCommandCode(request_data);
-  send_message_callback_.Run(security_key_connection_id, request_data);
+  send_message_callback_.Run(connection_id, request_data);
 
   iter->second->StartReadingRequest(
       base::Bind(&SecurityKeyAuthHandlerPosix::OnReadComplete,
-                 base::Unretained(this), security_key_connection_id));
+                 base::Unretained(this), connection_id));
 }
 
 SecurityKeyAuthHandlerPosix::ActiveSockets::const_iterator
-SecurityKeyAuthHandlerPosix::GetSocketForConnectionId(
-    int security_key_connection_id) const {
-  return active_sockets_.find(security_key_connection_id);
+SecurityKeyAuthHandlerPosix::GetSocketForConnectionId(int connection_id) const {
+  return active_sockets_.find(connection_id);
 }
 
 void SecurityKeyAuthHandlerPosix::SendErrorAndCloseActiveSocket(
     const ActiveSockets::const_iterator& iter) {
   iter->second->SendSshError();
   active_sockets_.erase(iter);
 }
 
-void SecurityKeyAuthHandlerPosix::RequestTimedOut(
-    int security_key_connection_id) {
-  HOST_LOG << "SecurityKey request timed out";
-  ActiveSockets::const_iterator iter =
-      active_sockets_.find(security_key_connection_id);
-  if (iter != active_sockets_.end())
+void SecurityKeyAuthHandlerPosix::RequestTimedOut(int connection_id) {
+  HOST_LOG << "SecurityKey request timed out: " << connection_id;
+  ActiveSockets::const_iterator iter = active_sockets_.find(connection_id);
+  if (iter != active_sockets_.end()) {
     SendErrorAndCloseActiveSocket(iter);
+  }
 }
 
 }  // namespace remoting