An implementation of chrome.socket.secure().

extensions/browser/api/socket/socket.h

 // Copyright 2014 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 EXTENSIONS_BROWSER_API_SOCKET_SOCKET_H_
 #define EXTENSIONS_BROWSER_API_SOCKET_SOCKET_H_
 
 #include <queue>
 #include <string>
 #include <utility>
@@ skipping 21 matching lines @@
 typedef base::Callback<
     void(int, scoped_refptr<net::IOBuffer> io_buffer, const std::string&, int)>
     RecvFromCompletionCallback;
 typedef base::Callback<void(int, net::TCPClientSocket*)>
     AcceptCompletionCallback;
 
 // A Socket wraps a low-level socket and includes housekeeping information that
 // we need to manage it in the context of an extension.
 class Socket : public ApiResource {
  public:
-  enum SocketType { TYPE_TCP, TYPE_UDP, };
+  enum SocketType { TYPE_TCP, TYPE_UDP, TYPE_TLS };
 
   virtual ~Socket();
+
+  const std::string& hostname() const { return hostname_; }
+
+  // The hostname of the remote host that this socket is connected to. Note:
+  // This may contain an IP literal. In the case of IDNs, this will contain
+  // a series of U-LABELs (UTF-8), not A-LABELs. IP literals for IPv6 will
+  // be unbracketed.

[Ryan Sleevi, 2014/07/15 00:18:45]

This doc-comment documents what hostname_ stores, but it seems like you're
instead documenting what the caller should supply (i.e. what their requirements
are)

Another distinction worth noting is whether or not hostname() is permitted to be
empty / may ever be empty.

[lally, 2014/07/16 16:19:44]

Done.

+  void set_hostname(const std::string& hostname) { hostname_ = hostname; }
+
+  // Note: |address| contains the resolved IP address, not the hostname of
+  // the remote endpoint. In order to upgrade this socket to TLS, callers
+  // must also supply the hostname of the endpoint via set_hostname().
   virtual void Connect(const std::string& address,
                        int port,
                        const CompletionCallback& callback) = 0;
   virtual void Disconnect() = 0;
   virtual int Bind(const std::string& address, int port) = 0;
 
   // The |callback| will be called with the number of bytes read into the
   // buffer, or a negative number if an error occurred.
   virtual void Read(int count, const ReadCompletionCallback& callback) = 0;
 
@@ skipping 38 matching lines @@
 
  protected:
   explicit Socket(const std::string& owner_extension_id_);
 
   void WriteData();
   virtual int WriteImpl(net::IOBuffer* io_buffer,
                         int io_buffer_size,
                         const net::CompletionCallback& callback) = 0;
   virtual void OnWriteComplete(int result);
 
-  const std::string address_;
+  std::string hostname_;
   bool is_connected_;
 
  private:
   friend class ApiResourceManager<Socket>;
   static const char* service_name() { return "SocketManager"; }
 
   struct WriteRequest {
     WriteRequest(scoped_refptr<net::IOBuffer> io_buffer,
                  int byte_count,
                  const CompletionCallback& callback);
     ~WriteRequest();
     scoped_refptr<net::IOBuffer> io_buffer;
     int byte_count;
     CompletionCallback callback;
     int bytes_written;
   };
   std::queue<WriteRequest> write_queue_;
   scoped_refptr<net::IOBuffer> io_buffer_write_;
 };
 
 }  //  namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_API_SOCKET_SOCKET_H_