Update documentation for secure networking classes. Remove certificateName parameter.

sdk/lib/io/secure_server_socket.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of dart.io;
 
 /**
  * The [SecureServerSocket] is a server socket, providing a stream of high-level
  * [Socket]s.
  *
@@ skipping 23 matching lines @@
    * If [port] has the value [:0:] an ephemeral port will be chosen by
    * the system. The actual port used can be retrieved using the
    * [port] getter.
    *
    * The optional argument [backlog] can be used to specify the listen
    * backlog for the underlying OS listen setup. If [backlog] has the
    * value of [:0:] (the default) a reasonable value will be chosen by
    * the system.
    *
    * Incoming client connections are promoted to secure connections, using
-   * the server certificate given by [certificateName].
+   * the server certificate and key set in [context].
    *
    * [address] must be given as a numeric address, not a host name.
    *
    * To request or require that clients authenticate by providing an SSL (TLS)
    * client certificate, set the optional parameter [requestClientCertificate]
    * or [requireClientCertificate] to true.  Requiring a certificate implies
-   * requesting a certificate, so one doesn't need to set both to true.
+   * requesting a certificate, so setting both is redundant.
    * To check whether a client certificate was received, check
    * SecureSocket.peerCertificate after connecting.  If no certificate
    * was received, the result will be null.
    *
-   * The optional argument [shared] specify whether additional binds
-   * to the same `address`, `port` and `v6Only` combination is
-   * possible from the same Dart process. If `shared` is `true` and
-   * additional binds are performed, then the incoming connections
-   * will be distributed between that set of
-   * `SecureServerSocket`s. One way of using this is to have number of
-   * isolates between which incoming connections are distributed.
+   * The optional argument [shared] specifies whether additional
+   * SecureServerSocket objects can bind to the same combination of `address`,
+   * `port` and `v6Only`.  If `shared` is `true` and more `SecureServerSocket`s
+   * from this isolate or other isolates are bound to the port, then the
+   * incoming connections will be distributed among all the bound
+   * `SecureServerSocket`s. Connections can be distributed over multiple
+   * isolates this way.
    */
   static Future<SecureServerSocket> bind(
       address,
       int port,
       SecurityContext context,
       {int backlog: 0,
        bool v6Only: false,
        bool requestClientCertificate: false,
        bool requireClientCertificate: false,
        List<String> supportedProtocols,
@@ skipping 90 matching lines @@
    * If [port] has the value [:0:] an ephemeral port will be chosen by
    * the system. The actual port used can be retrieved using the
    * [port] getter.
    *
    * The optional argument [backlog] can be used to specify the listen
    * backlog for the underlying OS listen setup. If [backlog] has the
    * value of [:0:] (the default) a reasonable value will be chosen by
    * the system.
    *
    * Incoming client connections are promoted to secure connections,
-   * using the server certificate given by [certificateName].
+   * using the server certificate and key set in [context].
    *
    * [address] must be given as a numeric address, not a host name.
    *
-   * [certificateName] is the nickname or the distinguished name (DN) of
-   * the certificate in the certificate database. It is looked up in the
-   * NSS certificate database set by SecureSocket.setCertificateDatabase.
-   * If [certificateName] contains "CN=", it is assumed to be a distinguished
-   * name.  Otherwise, it is looked up as a nickname.
-   *
    * To request or require that clients authenticate by providing an SSL (TLS)
    * client certificate, set the optional parameters requestClientCertificate or
    * requireClientCertificate to true.  Require implies request, so one doesn't
    * need to specify both.  To check whether a client certificate was received,
    * check SecureSocket.peerCertificate after connecting.  If no certificate
    * was received, the result will be null.
    *
-   * The optional argument [shared] specify whether additional binds
-   * to the same `address`, `port` and `v6Only` combination is
-   * possible from the same Dart process. If `shared` is `true` and
-   * additional binds are performed, then the incoming connections
-   * will be distributed between that set of
-   * `RawSecureServerSocket`s. One way of using this is to have number
-   * of isolates between which incoming connections are distributed.
+   * The optional argument [shared] specifies whether additional
+   * RawSecureServerSocket objects can bind to the same combination of
+   * `address`, `port` and `v6Only`.  If `shared` is `true` and more
+   * `RawSecureServerSocket`s from this isolate or other isolates are bound to
+   * the port, then the incoming connections will be distributed among all the
+   * bound `RawSecureServerSocket`s. Connections can be distributed over
+   * multiple isolates this way.
    */
   static Future<RawSecureServerSocket> bind(
       address,
       int port,
       SecurityContext context,
       {int backlog: 0,
        bool v6Only: false,
        bool requestClientCertificate: false,
        bool requireClientCertificate: false,
        List<String> supportedProtocols,
@@ skipping 85 matching lines @@
       close();
     }
   }
 
   void set _owner(owner) {
     (_socket as dynamic)._owner = owner;
   }
 }