Update GnubbyAuthHandler to use the current session ID

remoting/host/security_key/gnubby_auth_handler_linux.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/gnubby_auth_handler.h"
 
 #include <stdint.h>
 #include <unistd.h>
 
 #include <memory>
@@ skipping 48 matching lines @@
  private:
   typedef std::map<int, GnubbySocket*> ActiveSockets;
 
   // GnubbyAuthHandler interface.
   void CreateGnubbyConnection() override;
   bool IsValidConnectionId(int gnubby_connection_id) const override;
   void SendClientResponse(int gnubby_connection_id,
                           const std::string& response) override;
   void SendErrorAndCloseConnection(int gnubby_connection_id) override;
   void SetSendMessageCallback(const SendMessageCallback& callback) override;
+  void SetSessionIdCallback(const SessionIdCallback& callback) override;
   size_t GetActiveConnectionCountForTest() const override;
   void SetRequestTimeoutForTest(base::TimeDelta timeout) override;
 
   // Starts listening for connection.
   void DoAccept();
 
   // Called when a connection is accepted.
   void OnAccepted(int result);
 
   // Called when a GnubbySocket has done reading.
@@ skipping 27 matching lines @@
   // Sockets by connection id used to process gnubbyd requests.
   ActiveSockets active_sockets_;
 
   // Timeout used for a request.
   base::TimeDelta request_timeout_;
 
   DISALLOW_COPY_AND_ASSIGN(GnubbyAuthHandlerLinux);
 };
 
 std::unique_ptr<GnubbyAuthHandler> GnubbyAuthHandler::Create(
-    const SendMessageCallback& callback) {
+    const SendMessageCallback& send_message_callback,
+    const SessionIdCallback& session_id_callback) {
   std::unique_ptr<GnubbyAuthHandler> auth_handler(new GnubbyAuthHandlerLinux());
-  auth_handler->SetSendMessageCallback(callback);
+  auth_handler->SetSendMessageCallback(send_message_callback);
   return auth_handler;
 }
 
 void GnubbyAuthHandler::SetGnubbySocketName(
     const base::FilePath& gnubby_socket_name) {
   g_gnubby_socket_name.Get() = gnubby_socket_name;
 }
 
 GnubbyAuthHandlerLinux::GnubbyAuthHandlerLinux()
     : last_connection_id_(0),
@@ skipping 63 matching lines @@
     LOG(WARNING) << "Unknown gnubby-auth data connection: '"
                  << gnubby_connection_id << "'";
   }
 }
 
 void GnubbyAuthHandlerLinux::SetSendMessageCallback(
     const SendMessageCallback& callback) {
   send_message_callback_ = callback;
 }
 
+void GnubbyAuthHandlerLinux::SetSessionIdCallback(
+    const SessionIdCallback& callback) {
+  // SessionIdCallback is not currently used for this platform.
+  NOTREACHED();
+}
+
 size_t GnubbyAuthHandlerLinux::GetActiveConnectionCountForTest() const {
   return active_sockets_.size();
 }
 
 void GnubbyAuthHandlerLinux::SetRequestTimeoutForTest(base::TimeDelta timeout) {
   request_timeout_ = timeout;
 }
 
 void GnubbyAuthHandlerLinux::DoAccept() {
   int result = auth_socket_->Accept(
@@ skipping 61 matching lines @@
 
 void GnubbyAuthHandlerLinux::RequestTimedOut(int gnubby_connection_id) {
   HOST_LOG << "Gnubby request timed out";
   ActiveSockets::const_iterator iter =
       active_sockets_.find(gnubby_connection_id);
   if (iter != active_sockets_.end())
     SendErrorAndCloseActiveSocket(iter);
 }
 
 }  // namespace remoting