Add 'Server' and 'User-Agent' default header fields.

sdk/lib/io/http_impl.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;
 
 class _HttpIncoming extends Stream<List<int>> {
   final int _transferLength;
   final Completer _dataCompleter = new Completer();
   Stream<List<int>> _stream;
@@ skipping 658 matching lines @@
 
 
 class _HttpResponse extends _HttpOutboundMessage<HttpResponse>
     implements HttpResponse {
   int statusCode = 200;
   String _reasonPhrase;
   List<Cookie> _cookies;
   _HttpRequest _httpRequest;
 
   _HttpResponse(String protocolVersion,
-                _HttpOutgoing _outgoing)
-      : super(protocolVersion, _outgoing);
+                _HttpOutgoing _outgoing,
+                String serverHeader)
+      : super(protocolVersion, _outgoing) {
+    if (serverHeader != null) headers.set('Server', serverHeader);
+  }
 
   List<Cookie> get cookies {
     if (_cookies == null) _cookies = new List<Cookie>();
     return _cookies;
   }
 
   String get reasonPhrase => _findReasonPhrase(statusCode);
   void set reasonPhrase(String reasonPhrase) {
     if (_headersWritten) throw new StateError("Header already sent");
     _reasonPhrase = reasonPhrase;
@@ skipping 451 matching lines @@
     // Create new request object, wrapping the outgoing connection.
     var request = new _HttpClientRequest(outgoing,
                                          uri,
                                          method,
                                          proxy,
                                          _httpClient,
                                          this);
     request.headers.host = uri.host;
     request.headers.port = port;
     request.headers.set(HttpHeaders.ACCEPT_ENCODING, "gzip");
+    if (_httpClient.userAgent != null) {
+      request.headers.set('User-Agent', _httpClient.userAgent);
+    }
     if (proxy.isAuthenticated) {
       // If the proxy configuration contains user information use that
       // for proxy basic authorization.
       String auth = _CryptoUtils.bytesToBase64(
           _encodeString("${proxy.username}:${proxy.password}"));
       request.headers.set(HttpHeaders.PROXY_AUTHORIZATION, "Basic $auth");
     } else if (!proxy.isDirect && _httpClient._proxyCredentials.length > 0) {
       proxyCreds = _httpClient._findProxyCredentials(proxy);
       if (proxyCreds != null) {
         proxyCreds.authorize(request);
@@ skipping 177 matching lines @@
   final List<_ProxyCredentials> _proxyCredentials = [];
   Function _authenticate;
   Function _authenticateProxy;
   Function _findProxy = HttpClient.findProxyFromEnvironment;
   Duration _idleTimeout = const Duration(seconds: 15);
 
   Timer _noActiveTimer;
 
   Duration get idleTimeout => _idleTimeout;
 
+  String userAgent = _getHttpVersion();
+
   void set idleTimeout(Duration timeout) {
     _idleTimeout = timeout;
     _idleConnections.values.forEach(
         (l) => l.forEach((c) {
           // Reset timer. This is fine, as it's not happening often.
           c.stopTimer();
           c.startTimer();
         }));
   }
 
+
   Future<HttpClientRequest> open(String method,
                                  String host,
                                  int port,
                                  String path) {
     // TODO(sgjesse): The path set here can contain both query and
     // fragment. They should be cracked and set correctly.
     return _openUrl(method, new Uri(
         scheme: "http", host: host, port: port, path: path));
   }
 
@@ skipping 379 matching lines @@
           // If the incoming was closed, close the connection.
           incoming.dataDone.then((closing) {
             if (closing) destroy();
           });
           // Only handle one incoming request at the time. Keep the
           // stream paused until the request has been send.
           _subscription.pause();
           _state = _ACTIVE;
           var outgoing = new _HttpOutgoing(_socket);
           var response = new _HttpResponse(incoming.headers.protocolVersion,
-                                           outgoing);
+                                           outgoing,
+                                           _httpServer.serverHeader);
           var request = new _HttpRequest(response, incoming, _httpServer, this);
           _streamFuture = outgoing.done
               .then((_) {
                 if (_state == _DETACHED) return;
                 if (response.persistentConnection &&
                     request.persistentConnection &&
                     incoming.fullBodyRead) {
                   _state = _IDLE;
                   // Resume the subscription for incoming requests as the
                   // request is now processed.
@@ skipping 43 matching lines @@
 
   bool get _isActive => _state == _ACTIVE;
   bool get _isIdle => _state == _IDLE;
   bool get _isClosing => _state == _CLOSING;
   bool get _isDetached => _state == _DETACHED;
 }
 
 
 // HTTP server waiting for socket connections.
 class _HttpServer extends Stream<HttpRequest> implements HttpServer {
+  String serverHeader = _getHttpVersion();
 
   static Future<HttpServer> bind(address, int port, int backlog) {
     return ServerSocket.bind(address, port, backlog: backlog).then((socket) {
       return new _HttpServer._(socket, true);
     });
   }
 
   static Future<HttpServer> bindSecure(address,
                                        int port,
                                        int backlog,
@@ skipping 510 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;
 }
+
+String _getHttpVersion() {
+  var version = new Options().version;
+  // Only include major and minor version numbers.
+  int index = version.indexOf('.', version.indexOf('.') + 1);
+  version = version.substring(0, index);
+  return 'Dart/$version (dart:io)';
+}