use proper notation for true, false, and null in doc comments

sdk/lib/io/http.dart

 // Copyright (c) 2013, 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;
 
 /**
  * HTTP status codes.
  */
 abstract class HttpStatus {
@@ skipping 828 matching lines @@
 
   /**
    * The HTTP protocol version used in the request,
    * either "1.0" or "1.1" (read-only).
    */
   String get protocolVersion;
 
   /**
    * Information about the client connection (read-only).
    *
-   * Returns [null] if the socket is not available.
+   * Returns [:null:] if the socket is not available.
    */
   HttpConnectionInfo get connectionInfo;
 
   /**
    * The [HttpResponse] object, used for sending back the response to the
    * client (read-only).
    *
    * If the [contentLength] of the body isn't 0, and the body isn't being read,
    * any write calls on the [HttpResponse] automatically drain the request
    * body.
@@ skipping 103 matching lines @@
    * Detaches the underlying socket from the HTTP server. When the
    * socket is detached the HTTP server will no longer perform any
    * operations on it.
    *
    * This is normally used when a HTTP upgrade request is received
    * and the communication should continue with a different protocol.
    */
   Future<Socket> detachSocket();
 
   /**
-   * Gets information about the client connection. Returns [null] if the socket
+   * Gets information about the client connection. Returns [:null:] if the socket

[Lasse Reichstein Nielsen, 2014/01/19 12:40:30]

Long line.
(I guess that's the primary reason for the general preference for `x` over
[:x:]: It's shorter :).

[kevmoo, 2014/01/19 19:22:54]

Done.

    * is not available.
    */
   HttpConnectionInfo get connectionInfo;
 }
 
 
 /**
  * A client that receives content, such as web pages, from
  * a server using the HTTP protocol.
  *
@@ skipping 155 matching lines @@
    */
   Future<HttpClientRequest> postUrl(Uri url);
 
   /**
    * Sets the function to be called when a site is requesting
    * authentication. The URL requested and the security realm from the
    * server are passed in the arguments [url] and [realm].
    *
    * The function returns a [Future] which should complete when the
    * authentication has been resolved. If credentials cannot be
-   * provided the [Future] should complete with [false]. If
+   * provided the [Future] should complete with [:false:]. If
    * credentials are available the function should add these using
    * [addCredentials] before completing the [Future] with the value
-   * [true].
+   * [:true:].
    *
    * If the [Future] completes with true the request will be retried
    * using the updated credentials. Otherwise response processing will
    * continue normally.
    */
   set authenticate(Future<bool> f(Uri url, String scheme, String realm));
 
   /**
    * Add credentials to be used for authorizing HTTP requests.
    */
@@ skipping 83 matching lines @@
   }
 
   /**
    * Sets the function to be called when a proxy is requesting
    * authentication. Information on the proxy in use and the security
    * realm for the authentication are passed in the arguments [host],
    * [port] and [realm].
    *
    * The function returns a [Future] which should complete when the
    * authentication has been resolved. If credentials cannot be
-   * provided the [Future] should complete with [false]. If
+   * provided the [Future] should complete with [:false:]. If
    * credentials are available the function should add these using
    * [addProxyCredentials] before completing the [Future] with the value
-   * [true].
+   * [:true:].
    *
-   * If the [Future] completes with [true] the request will be retried
+   * If the [Future] completes with [:true:] the request will be retried
    * using the updated credentials. Otherwise response processing will
    * continue normally.
    */
   set authenticateProxy(
       Future<bool> f(String host, int port, String scheme, String realm));
 
   /**
    * Add credentials to be used for authorizing HTTP proxies.
    */
   void addProxyCredentials(String host,
                            int port,
                            String realm,
                            HttpClientCredentials credentials);
 
   /**
    * Sets a callback that will decide whether to accept a secure connection
    * with a server certificate that cannot be authenticated by any of our
    * trusted root certificates.
    *
    * When an secure HTTP request if made, using this HttpClient, and the
    * server returns a server certificate that cannot be authenticated, the
    * callback is called asynchronously with the [X509Certificate] object and
    * the server's hostname and port.  If the value of [badCertificateCallback]
-   * is [null], the bad certificate is rejected, as if the callback
-   * returned [false]
+   * is [:null:], the bad certificate is rejected, as if the callback
+   * returned [:false:]
    *
    * If the callback returns true, the secure connection is accepted and the
    * [:Future<HttpClientRequest>:] that was returned from the call making the
    * request completes with a valid HttpRequest object. If the callback returns
    * false, the [:Future<HttpClientRequest>:] completes with an exception.
    *
    * If a bad certificate is received on a connection attempt, the library calls
    * the function that was the value of badCertificateCallback at the time
    * the the request is made, even if the value of badCertificateCallback
    * has changed since then.
@@ skipping 114 matching lines @@
    * future will complete with an error.
    */
   Future<HttpClientResponse> get done;
 
   /**
    * Close the request for input. Returns the value of [done].
    */
   Future<HttpClientResponse> close();
 
   /**
-   * Get information about the client connection. Returns [null] if the socket
+   * Get information about the client connection. Returns [:null:] if the socket
    * is not available.
    */
   HttpConnectionInfo get connectionInfo;
 }
 
 
 /**
  * HTTP response for a client connection. The [HttpClientResponse] is a
  * [Stream] of the body content of the response. Listen to the body to handle
  * the data and be notified once the entire body is received.
@@ skipping 39 matching lines @@
    * Redirects this connection to a new URL. The default value for
    * [method] is the method for the current request. The default value
    * for [url] is the value of the [HttpHeaders.LOCATION] header of
    * the current response. All body data must have been read from the
    * current response before calling [redirect].
    *
    * All headers added to the request will be added to the redirection
    * request. However, any body sent with the request will not be
    * part of the redirection request.
    *
-   * If [followLoops] is set to [true], redirect will follow the redirect,
-   * even if the URL was already visited. The default value is [false].
+   * If [followLoops] is set to [:true:], redirect will follow the redirect,
+   * even if the URL was already visited. The default value is [:false:].
    *
    * [redirect] will ignore [maxRedirects] and will always perform the redirect.
    */
   Future<HttpClientResponse> redirect([String method,
                                        Uri url,
                                        bool followLoops]);
 
 
   /**
    * Returns the response headers.
@@ skipping 15 matching lines @@
    */
   List<Cookie> get cookies;
 
   /**
    * Returns the certificate of the HTTPS server providing the response.
    * Returns null if the connection is not a secure TLS or SSL connection.
    */
   X509Certificate get certificate;
 
   /**
-   * Gets information about the client connection. Returns [null] if the socket
+   * Gets information about the client connection. Returns [:null:] if the socket
    * is not available.
    */
   HttpConnectionInfo get connectionInfo;
 }
 
 
 abstract class HttpClientCredentials { }
 
 
 /**
@@ skipping 83 matching lines @@
 class RedirectException implements HttpException {
   final String message;
   final List<RedirectInfo> redirects;
 
   const RedirectException(this.message, this.redirects);
 
   String toString() => "RedirectException: $message";
 
   Uri get uri => redirects.last.location;
 }