Experimental support for SSL in platform apps sockets.

chrome/common/extensions/api/experimental_socket.idl

 // Copyright (c) 2012 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.
 
 // File-level comment to appease parser. Eventually this will not be necessary.
 
 namespace experimental.socket {
   enum SocketType {
     tcp,
-    udp
+    udp,
+    ssl
   };
 
   // The socket options.
   dictionary CreateOptions {
     // The schema generator does not support dictionaries without any fields.
     // Ignore this field.
     [nodoc] long? dummyValue;
   };
 
   dictionary CreateInfo {
     // The id of the newly created socket.
     long socketId;
   };
 
   callback CreateCallback = void (CreateInfo createInfo);
 
   callback ConnectCallback = void (long result);
 
+  callback HandshakeCallback = void (long result);
+
   callback BindCallback = void (long result);
 
   dictionary ReadInfo {
     // The resultCode returned from the underlying read() call.
     long resultCode;
 
     ArrayBuffer data;
   };
 
   callback ReadCallback = void (ReadInfo readInfo);
@@ skipping 40 matching lines @@
     // Connects the socket to the remote machine.
     // |socketId| : The socketId.
     // |hostname| : The hostname or IP address of the remote machine.
     // |port| : The port of the remote machine.
     // |callback| : Called when the connection attempt is complete.
     static void connect(long socketId,
                         DOMString hostname,
                         long port,
                         ConnectCallback callback);
 
+    // Performs an SSL handshake. While a handshake is in flight, calls to
+    // read and write using the socket will fail.
+    // |socketId| : The socketId of an SSL socket.
+    // |hostname| : The hostname to check against the name(s) in the server's
+    //              certificate during the SSL handshake.
+    // |port|     : The port to check during the SSL handshake.
+    // |callback| : Called when the connection attempt is complete.
+    //              Zero signifies success. Non-'ssl' sockets always pass -1.
+    static void handshake(long socketId,
+                          DOMString hostname,
+                          long port,
+                          HandshakeCallback callback);
+
     // Binds the local address for socket. Currently, it does not support
     // TCP socket.
     // |socketId| : The socketId.
     // |address| : The address of the local machine.
     // |port| : The port of the local machine.
     // |callback| : Called when the bind attempt is complete.
     static void bind(long socketId,
                      DOMString address,
                      long port,
                      BindCallback callback);
@@ skipping 41 matching lines @@
     // write operation completes without blocking, the write operation blocked
     // before completion (in which case onEvent() will eventually be called with
     // a <code>writeComplete</code> event), or an error occurred.
     static void sendTo(long socketId,
                        ArrayBuffer data,
                        DOMString address,
                        long port,
                        SendToCallback callback);
 
     // Enable/disable keep-alive functionality for a TCP connection.
+    // Invalid on SSL sockets after the handshake has completed.
     // |socketId| : The socketId.
     // |enable| : If true, enable keep-alive functionality.
     // |delay| : Set the delay seconds between the last data packet received
     // and the first keepalive probe. Default is 0.
     // |callback| : Called when the setKeepAlive attempt is complete.
     static void setKeepAlive(long socketId,
                              boolean enable,
                              optional long delay,
                              SetKeepAliveCallback callback);
 
-    // Enable/disable Nagle algorithm.
+    // Enable/disable Nagle algorithm. Invalid on SSL sockets after the
+    // handshake has completed.
     // |socketId| : The socketId.
     // |noDelay| : If true, disable Nagle algorithm.
     // |callback| : Called when the setNoDelay attempt is complete.
     static void setNoDelay(long socketId,
                            boolean noDelay,
                            SetNoDelayCallback callback);
   };
 
 };