Re-implement http sessions.

sdk/lib/io/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 _HttpIncoming extends StreamController<List<int>> {
   final Function _pause;
   final Function _resume;
   bool _ignore = false;
   final SignalCompleter _dataCompleter = new SignalCompleter();
@@ skipping 48 matching lines @@
     super.close();
   }
 
   void add(List<int> data) {
     if (!_ignore) super.add(data);
   }
 }
 
 class _HttpInboundMessage extends Stream<List<int>> {
   final _HttpIncoming _incoming;
+  List<Cookie> _cookies;
 
   _HttpInboundMessage(_HttpIncoming this._incoming);
 
+  List<Cookie> get cookies {
+    if (_cookies != null) return _cookies;
+    return _cookies = headers._parseCookies();
+  }
+
   HttpHeaders get headers => _incoming.headers;
   String get protocolVersion => headers.protocolVersion;
   int get contentLength => headers.contentLength;
 }
 
 
 class _HttpRequest extends _HttpInboundMessage implements HttpRequest {
   final HttpResponse response;
 
   // Lazy initialized parsed query parameters.
   Map<String, String> _queryParameters;
 
-  _HttpRequest(_HttpResponse this.response, _HttpIncoming _incoming)
+  final _HttpServer _httpServer;
+
+  HttpSession _session;
+
+  _HttpRequest(_HttpResponse this.response,
+               _HttpIncoming _incoming,
+               _HttpServer this._httpServer)
       : super(_incoming) {
     response.headers.persistentConnection = headers.persistentConnection;
+
+    if (_httpServer._sessionManagerInstance != null) {
+      // Map to session if exists.
+      var sessionId = cookies.reduce(null, (last, cookie) {
+        if (last != null) return last;
+        return cookie.name.toUpperCase() == _DART_SESSION_ID ?
+            cookie.value : null;
+      });
+      if (sessionId != null) {
+        _session = _httpServer._sessionManager.getSession(sessionId);
+        if (_session != null) {
+          _session._markSeen();
+        }
+      }
+    }
   }
 
   StreamSubscription<T> listen(void onData(List<int> event),
                                {void onError(AsyncError error),
                                 void onDone(),
                                 bool unsubscribeOnError}) {
     return _incoming.listen(onData,
                             onError: onError,
                             onDone: onDone,
                             unsubscribeOnError: unsubscribeOnError);
   }
 
   Map<String, String> get queryParameters {
     if (_queryParameters == null) {
       _queryParameters = _HttpUtils.splitQueryString(uri.query);
     }
     return _queryParameters;
   }
 
   Uri get uri => _incoming.uri;
 
   String get method => _incoming.method;
+
+  HttpSession session([init(HttpSession session)]) {
+    if (_session != null) {
+      // It's already mapped, use it.
+      return _session;
+    }
+    // Create session, store it in connection, and return.
+    return _session = _httpServer._sessionManager.createSession(init);
+  }
 }
 
 
 class _HttpClientResponse
     extends _HttpInboundMessage implements HttpClientResponse {
   List<RedirectInfo> get redirects => _httpRequest._responseRedirects;
 
   // The HttpClient this response belongs to.
   final _HttpClient _httpClient;
 
   // The HttpClientRequest of this response.
   final _HttpClientRequest _httpRequest;
 
+  List<Cookie> _cookies;
+
   _HttpClientResponse(_HttpIncoming _incoming,
                       _HttpClientRequest this._httpRequest,
                       _HttpClient this._httpClient)
       : super(_incoming);
 
   int get statusCode => _incoming.statusCode;
   String get reasonPhrase => _incoming.reasonPhrase;
 
+  List<Cookie> get cookies {
+    if (_cookies != null) return _cookies;
+    _cookies = new List<Cookie>();
+    List<String> values = headers["set-cookie"];
+    if (values != null) {
+      values.forEach((value) {
+        _cookies.add(new Cookie.fromSetCookieValue(value));
+      });
+    }
+    return _cookies;
+  }
+
   bool get isRedirect {
     if (_httpRequest.method == "GET" || _httpRequest.method == "HEAD") {
       return statusCode == HttpStatus.MOVED_PERMANENTLY ||
              statusCode == HttpStatus.FOUND ||
              statusCode == HttpStatus.SEE_OTHER ||
              statusCode == HttpStatus.TEMPORARY_REDIRECT;
     } else if (_httpRequest.method == "POST") {
       return statusCode == HttpStatus.SEE_OTHER;
     }
     return false;
@@ skipping 169 matching lines @@
   final _HttpHeaders headers;
 
   final _HttpOutgoing _outgoing;
   bool _headersWritten = false;
   bool _chunked = false;
 }
 
 
 class _HttpResponse extends _HttpOutboundMessage<HttpResponse>
     implements HttpResponse {
-  _HttpResponse(String protocolVersion, _HttpOutgoing _outgoing)
+  int statusCode = 200;
+  String reasonPhrase = "OK";
+
+  List<Cookie> _cookies;
+  _HttpRequest _httpRequest;
+
+  _HttpResponse(String protocolVersion,
+                _HttpOutgoing _outgoing)
       : super(protocolVersion, _outgoing);
 
-  int statusCode = 200;
-
-  String reasonPhrase = "OK";
+  List<Cookie> get cookies {
+    if (_cookies == null) _cookies = new List<Cookie>();
+    return _cookies;
+  }
 
   void _writeHeader() {
     writeSP() => add([_CharCode.SP]);
     writeCRLF() => add([_CharCode.CR, _CharCode.LF]);
 
     // Write status line.
     if (headers.protocolVersion == "1.1") {
       add(_Const.HTTP11);
     } else {
       add(_Const.HTTP10);
     }
     writeSP();
     addString(statusCode.toString());
     writeSP();
     addString(reasonPhrase);
     writeCRLF();
 
+    var session = _httpRequest._session;
+    if (session != null && !session._destroyed) {
+      // Make sure we only send the current session id.
+      bool found = false;
+      for (int i = 0; i < cookies.length; i++) {
+        if (cookies[i].name.toUpperCase() == _DART_SESSION_ID) {
+          cookies[i].value = session.id;
+          cookies[i].httpOnly = true;
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        cookies.add(new Cookie(_DART_SESSION_ID, session.id)..httpOnly = true);
+      }
+    }
+    // Add all the cookies set to the headers.
+    if (_cookies != null) {
+      _cookies.forEach((cookie) {
+        headers.add("set-cookie", cookie);
+      });
+    }
+
     headers._finalize();
 
     // Write headers.
     headers._write(this);
     writeCRLF();
   }
 }
 
 
 class _HttpClientRequest extends _HttpOutboundMessage<HttpClientRequest>
@@ skipping 491 matching lines @@
   void _removeCredentials(_Credentials cr) {
     int index = _credentials.indexOf(cr);
     if (index != -1) {
       _credentials.removeAt(index);
     }
   }
 }
 
 
 class _HttpConnection {
-  _HttpConnection(Socket this._socket, Function this._handleRequest) {
+  final Socket _socket;
+  final _HttpServer _httpServer;
+
+  _HttpConnection(Socket this._socket, _HttpServer this._httpServer) {
     var parser = new _HttpParser.requestParser();
     _socket.pipe(parser);
     parser.listen(
         (incoming) {
           var outgoing = new _HttpOutgoing();
           outgoing.stream.then(_socket.writeStream);
           var response = new _HttpResponse(
               incoming.headers.protocolVersion,
               outgoing);
-          var request = new _HttpRequest(response, incoming);
+          var request = new _HttpRequest(response, incoming, _httpServer);
+          response._httpRequest = request;
           outgoing.dataDone.then(() {
             if (response.headers.persistentConnection) {
               // Mark incoming as done, preparing for next HTTP request.
               incoming.done();
             } else {
               // Close socket, keep-alive not used.
               _socket.destroy();
             }
           });
-          _handleRequest(request);
+          _httpServer._handleRequest(request);
         },
         onDone: () {
           // TODO(ajohnsen): Remove connection from active connection queue.
         },
         onError: (error) {
           // TODO(ajohnsen): Handle errors.
         });
   }
-
-  final Function _handleRequest;
-
-  final Socket _socket;
 }
 
 
 // HTTP server waiting for socket connections.
 class _HttpServer extends Stream<HttpRequest> implements HttpServer {
   _HttpServer(String host, int port, int backlog)
       : _serverSocket = new ServerSocket(host, port, backlog),
         _closeServer = true;
 
   _HttpServer.listenOn(ServerSocket this._serverSocket)
       : _closeServer = false;
 
   StreamSubscription<T> listen(void onData(T event),
                                {void onError(AsyncError error),
                                 void onDone(),
                                 bool unsubscribeOnError}) {
     _serverSubscription = _serverSocket.listen((Socket socket) {
       // Accept the client connection.
-      _HttpConnection connection = new _HttpConnection(socket, _handleRequest);
+      _HttpConnection connection = new _HttpConnection(socket, this);
       _connections.add(connection);
       // TODO(ajohnsen): Listen to closed sockets.
     });
     return _controller.listen(onData,
                               onError: onError,
                               onDone: onDone,
                               unsubscribeOnError: unsubscribeOnError);
   }
 
   void close() {
@@ skipping 247 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;
 }