Revert of Renaming Gnubby and RemoteSecurityKey files/classes/members

remoting/host/security_key/gnubby_socket.h

Index: remoting/host/security_key/gnubby_socket.h
diff --git a/remoting/host/security_key/gnubby_socket.h b/remoting/host/security_key/gnubby_socket.h
new file mode 100644
index 0000000000000000000000000000000000000000..c0e1b4d0aa002a760283a653a17a9bcc50b0697c
--- /dev/null
+++ b/remoting/host/security_key/gnubby_socket.h
@@ -0,0 +1,113 @@
+// 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.
+
+#ifndef REMOTING_HOST_SECURITY_KEY_GNUBBY_SOCKET_H_
+#define REMOTING_HOST_SECURITY_KEY_GNUBBY_SOCKET_H_
+
+#include <stddef.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "base/callback.h"
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "base/threading/thread_checker.h"
+
+namespace base {
+class Timer;
+}  // namespace base
+
+namespace net {
+class DrainableIOBuffer;
+class IOBufferWithSize;
+class StreamSocket;
+}  // namespace net
+
+namespace remoting {
+
+// Class that manages reading requests and sending responses. The socket can
+// only handle receiving one request at a time. It expects to receive no extra
+// bytes over the wire, which is checked by IsRequestTooLarge method.
+class GnubbySocket {
+ public:
+  GnubbySocket(std::unique_ptr<net::StreamSocket> socket,
+               base::TimeDelta timeout,
+               const base::Closure& timeout_callback);
+  ~GnubbySocket();
+
+  // Returns false if the request has not yet completed, or is too large to be
+  // processed. Otherwise, the cached request data is copied into |data_out| and
+  // the internal buffer resets and is ready for the next request.
+  bool GetAndClearRequestData(std::string* data_out);
+
+  // Sends response data to the socket.
+  void SendResponse(const std::string& data);
+
+  // Sends an SSH error code to the socket.
+  void SendSshError();
+
+  // |request_received_callback| is used to notify the caller that request data
+  // has been fully read, and caller is to use GetAndClearRequestData method to
+  // get the request data.
+  void StartReadingRequest(const base::Closure& request_received_callback);
+
+ private:
+  // Called when bytes are written to |socket_|.
+  void OnDataWritten(int result);
+
+  // Continues writing to |socket_| if needed.
+  void DoWrite();
+
+  // Called when bytes are read from |socket_|.
+  void OnDataRead(int bytes_read);
+
+  // Continues to read.
+  void DoRead();
+
+  // Returns true if the current request is complete.
+  bool IsRequestComplete() const;
+
+  // Returns true if the stated request size is larger than the allowed maximum.
+  bool IsRequestTooLarge() const;
+
+  // Returns the stated request length.
+  size_t GetRequestLength() const;
+
+  // Returns the response length bytes.
+  std::string GetResponseLengthAsBytes(const std::string& response) const;
+
+  // Resets the socket activity timer.
+  void ResetTimer();
+
+  // Ensures GnubbySocket methods are called on the same thread.
+  base::ThreadChecker thread_checker_;
+
+  // The socket.
+  std::unique_ptr<net::StreamSocket> socket_;
+
+  // Invoked when request data has been read.
+  base::Closure request_received_callback_;
+
+  // Indicates whether read has completed and |request_received_callback_| is
+  // about to be run.
+  bool read_completed_;
+
+  // Request data.
+  std::vector<char> request_data_;
+
+  scoped_refptr<net::DrainableIOBuffer> write_buffer_;
+
+  scoped_refptr<net::IOBufferWithSize> read_buffer_;
+
+  // The activity timer.
+  std::unique_ptr<base::Timer> timer_;
+
+  DISALLOW_COPY_AND_ASSIGN(GnubbySocket);
+};
+
+}  // namespace remoting
+
+#endif  // REMOTING_HOST_SECURITY_KEY_GNUBBY_SOCKET_H_