Make isEmpty a getter.

runtime/bin/http_impl.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.
 
 class _HttpHeaders implements HttpHeaders {
   _HttpHeaders() : _headers = new Map<String, List<String>>();
 
   List<String> operator[](String name) {
     name = name.toLowerCase();
     return _headers[name];
@@ skipping 2020 matching lines @@
   static const String PROXY_PREFIX = "PROXY ";
   static const String DIRECT_PREFIX = "DIRECT";
 
   _ProxyConfiguration(String configuration) : proxies = new List<_Proxy>() {
     if (configuration == null) {
       throw new HttpException("Invalid proxy configuration $configuration");
     }
     List<String> list = configuration.split(";");
     list.forEach((String proxy) {
       proxy = proxy.trim();
-      if (!proxy.isEmpty()) {
+      if (!proxy.isEmpty) {
         if (proxy.startsWith(PROXY_PREFIX)) {
           int colon = proxy.indexOf(":");
           if (colon == -1 || colon == 0 || colon == proxy.length - 1) {
             throw new HttpException(
                 "Invalid proxy configuration $configuration");
           }
           // Skip the "PROXY " prefix.
           String host = proxy.substring(PROXY_PREFIX.length, colon).trim();
           String portString = proxy.substring(colon + 1).trim();
           int port;
@@ skipping 41 matching lines @@
     // TODO(sgjesse): The path set here can contain both query and
     // fragment. They should be cracked and set correctly.
     return _open(method, new Uri.fromComponents(
         scheme: "http", domain: host, port: port, path: path));
   }
 
   HttpClientConnection _open(String method,
                              Uri uri,
                              [_HttpClientConnection connection]) {
     if (_shutdown) throw new HttpException("HttpClient shutdown");
-    if (method == null || uri.domain.isEmpty()) {
+    if (method == null || uri.domain.isEmpty) {
       throw new ArgumentError(null);
     }
     return _prepareHttpClientConnection(method, uri, connection);
   }
 
   HttpClientConnection openUrl(String method, Uri url) {
     return _openUrl(method, url);
   }
 
   HttpClientConnection _openUrl(String method,
@@ skipping 17 matching lines @@
   HttpClientConnection post(String host, int port, String path) {
     return open("POST", host, port, path);
   }
 
   HttpClientConnection postUrl(Uri url) => _openUrl("POST", url);
 
   set findProxy(String f(Uri uri)) => _findProxy = f;
 
   void shutdown() {
      _openSockets.forEach((String key, Queue<_SocketConnection> connections) {
-       while (!connections.isEmpty()) {
+       while (!connections.isEmpty) {
          _SocketConnection socketConn = connections.removeFirst();
          socketConn._socket.close();
        }
      });
      _activeSockets.forEach((_SocketConnection socketConn) {
        socketConn._socket.close();
      });
     if (_evictionTimer != null) _cancelEvictionTimer();
      _shutdown = true;
   }
@@ skipping 43 matching lines @@
         connectPort = port;
       } else {
         connectHost = proxy.host;
         connectPort = proxy.port;
       }
 
       // If there are active connections for this key get the first one
       // otherwise create a new one.
       String key = _connectionKey(connectHost, connectPort);
       Queue socketConnections = _openSockets[key];
-      if (socketConnections == null || socketConnections.isEmpty()) {
+      if (socketConnections == null || socketConnections.isEmpty) {
         Socket socket = new Socket(connectHost, connectPort);
         // Until the connection is established handle connection errors
         // here as the HttpClientConnection object is not yet associated
         // with the socket.
         socket.onError = (e) {
           proxyIndex++;
           if (proxyIndex < proxyConfiguration.proxies.length) {
             // Try the next proxy in the list.
             _establishConnection(host, port, proxyConfiguration, proxyIndex);
           } else {
@@ skipping 13 matching lines @@
           _activeSockets.add(socketConn);
           _connectionOpened(socketConn, connection, !proxy.isDirect);
         };
       } else {
         _SocketConnection socketConn = socketConnections.removeFirst();
         _activeSockets.add(socketConn);
         new Timer(0, (ignored) =>
                   _connectionOpened(socketConn, connection, !proxy.isDirect));
 
         // Get rid of eviction timer if there are no more active connections.
-        if (socketConnections.isEmpty()) _openSockets.remove(key);
-        if (_openSockets.isEmpty()) _cancelEvictionTimer();
+        if (socketConnections.isEmpty) _openSockets.remove(key);
+        if (_openSockets.isEmpty) _cancelEvictionTimer();
       }
     }
 
     // Find the TCP host and port.
     String host = url.domain;
     int port = url.port == 0 ? HttpClient.DEFAULT_HTTP_PORT : url.port;
 
     // Create a new connection object if we are not re-using an existing one.
     if (connection == null) {
       connection = new _HttpClientConnection(this);
@@ skipping 35 matching lines @@
 
     // If there is currently no eviction timer start one.
     if (_evictionTimer == null) {
       void _handleEviction(Timer timer) {
         Date now = new Date.now();
         List<String> emptyKeys = new List<String>();
         _openSockets.forEach(
             void _(String key, Queue<_SocketConnection> connections) {
               // As returned connections are added at the head of the
               // list remove from the tail.
-              while (!connections.isEmpty()) {
+              while (!connections.isEmpty) {
                 _SocketConnection socketConn = connections.last();
                 if (socketConn._idleTime(now).inMilliseconds >
                     DEFAULT_EVICTION_TIMEOUT) {
                   connections.removeLast();
                   socketConn._socket.close();
-                  if (connections.isEmpty()) emptyKeys.add(key);
+                  if (connections.isEmpty) emptyKeys.add(key);
                 } else {
                   break;
                 }
               }
             });
 
         // Remove the keys for which here are no more open connections.
         emptyKeys.forEach((String key) => _openSockets.remove(key));
 
         // If all connections where evicted cancel the eviction timer.
-        if (_openSockets.isEmpty()) _cancelEvictionTimer();
+        if (_openSockets.isEmpty) _cancelEvictionTimer();
       }
       _evictionTimer = new Timer.repeating(10000, _handleEviction);
     }
 
     // Return connection.
     _activeSockets.remove(socketConn);
     sockets.addFirst(socketConn);
   }
 
   Function _onOpen;
@@ skipping 22 matching lines @@
 
 
 class _RedirectInfo implements RedirectInfo {
   const _RedirectInfo(int this.statusCode,
                       String this.method,
                       Uri this.location);
   final int statusCode;
   final String method;
   final Uri location;
 }