An implementation of chrome.socket.secure().

chrome/browser/extensions/api/socket/tls_socket.h

+// Copyright (c) 2013 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 CHROME_BROWSER_EXTENSIONS_API_SOCKET_TLS_SOCKET_H_
+#define CHROME_BROWSER_EXTENSIONS_API_SOCKET_TLS_SOCKET_H_
+
+#include <string>
+
+#include "chrome/browser/extensions/api/socket/socket.h"
+
+namespace net {
+class Socket;
+}
+
+namespace extensions {
+
+// TLS Sockets from the chrome.socket API.  A regular TCPSocket is converted
+// to a TLSSocket via chrome.socket.secure().
+class TLSSocket : public Socket {
+ public:
+  TLSSocket(net::StreamSocket* tls_socket,
+            net::TCPClientSocket* underlying_tcp_socket,
+            const std::string& owner_extension_id);
+
+  virtual ~TLSSocket();
+
+  // Most of these methods either fail or forward the method call on to the
+  // inner net::StreamSocket.  The remaining few do actual TLS work.

[Ryan Sleevi, 2013/11/25 17:30:13]

This definitely violates the SOLID design of is-a inheritance, particularly
around the Connect/Bind use case.

All of these Forwards / Fails comments really seem to highlight that TLSSocket
is-not-a Socket - Forwards shouldn't need to be documented (it's an
implementation detail), and Fails seems a violation of the API contract.

[Lally Singh, 2013/12/05 17:07:12]

No disagreement here, but this is an artifact of secure()'s
convert-after-connect and Socket's union-of-interfaces semantics.  No
implementation of Socket will have both RecvFrom and SetKeepAlive() implemented.
 The existing extensions::(TCP|UDP)Socket have the same forward/fail semantics
for their methods.

+
+  // Fails.
+  virtual void Connect(const std::string& address,
+                       int port,
+                       const CompletionCallback& callback) OVERRIDE;
+  // Forwards.
+  virtual void Disconnect() OVERRIDE;
+
+  // Fails.
+  virtual int Bind(const std::string& address, int port) OVERRIDE;
+
+  // The |callback| will be called with the number of bytes read into the
+  // buffer, or a negative number if an error occurred.  Does TLS work.
+  virtual void Read(int count,
+                    const ReadCompletionCallback& callback) OVERRIDE;
+
+  // Fails.
+  virtual void RecvFrom(int count,
+                        const RecvFromCompletionCallback& callback) OVERRIDE;
+  // Fails.
+  virtual void SendTo(scoped_refptr<net::IOBuffer> io_buffer,
+                      int byte_count,
+                      const std::string& address,
+                      int port,
+                      const CompletionCallback& callback) OVERRIDE;
+
+  // Forwards.
+  virtual bool SetKeepAlive(bool enable, int delay) OVERRIDE;
+
+  // Forwards.
+  virtual bool SetNoDelay(bool no_delay) OVERRIDE;
+
+  // Fails.
+  virtual int Listen(const std::string& address, int port, int backlog,
+                     std::string* error_msg) OVERRIDE;
+  // Fails.
+  virtual void Accept(const AcceptCompletionCallback &callback) OVERRIDE;
+
+  // Forwards.
+  virtual bool IsConnected() OVERRIDE;
+
+  // Forwards.
+  virtual bool GetPeerAddress(net::IPEndPoint* address) OVERRIDE;
+  // Forwards.
+  virtual bool GetLocalAddress(net::IPEndPoint* address) OVERRIDE;
+
+  // Forwards.
+  virtual SocketType GetSocketType() const OVERRIDE;
+
+ private:
+  virtual int WriteImpl(net::IOBuffer* io_buffer, int io_buffer_size,
+                        const net::CompletionCallback& callback) OVERRIDE;
+  void OnReadComplete(scoped_refptr<net::IOBuffer> io_buffer,
+                      int result);
+
+  scoped_ptr<net::StreamSocket> tls_socket_;
+  scoped_ptr<net::TCPClientSocket> underlying_socket_;
+
+  ReadCompletionCallback read_callback_;
+};
+
+}  // namespace extensions
+
+#endif  // CHROME_BROWSER_EXTENSIONS_API_SOCKET_TLS_SOCKET_H_