Expose the HttpRequest object in HttpRequestBody, making all request properties available.

pkg/http_server/lib/src/http_body_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 http_server;
 
 class _HttpBodyHandlerTransformer
     implements StreamTransformer<HttpRequest, HttpRequestBody> {
   final Encoding _defaultEncoding;
 
@@ skipping 46 matching lines @@
   }
 
   static Future<HttpBody> process(Stream<List<int>> stream,
                                   HttpHeaders headers,
                                   Encoding defaultEncoding) {
     ContentType contentType = headers.contentType;
 
     Future<HttpBody> asBinary() {
       return stream
           .fold(new BytesBuilder(), (builder, data) => builder..add(data))
-          .then((builder) => new _HttpBody(contentType,
-                                           "binary",
-                                           builder.takeBytes()));
+          .then((builder) => new _HttpBody("binary", builder.takeBytes()));
     }
 
     Future<HttpBody> asText(Encoding defaultEncoding) {
       var encoding;
       var charset = contentType.charset;
       if (charset != null) encoding = Encoding.getByName(charset);
       if (encoding == null) encoding = defaultEncoding;
       return stream
           .transform(encoding.decoder)
           .fold(new StringBuffer(), (buffer, data) => buffer..write(data))
-          .then((buffer) => new _HttpBody(contentType,
-                                          "text",
-                                          buffer.toString()));
+          .then((buffer) => new _HttpBody("text", buffer.toString()));
     }
 
     Future<HttpBody> asFormData() {
       return stream
           .transform(new MimeMultipartTransformer(
                 contentType.parameters['boundary']))
           .map((part) => HttpMultipartFormData.parse(
                 part, defaultEncoding: defaultEncoding))
           .map((multipart) {
             var future;
@@ skipping 17 matching lines @@
               return [multipart.contentDisposition.parameters['name'], data];
             });
           })
           .fold([], (l, f) => l..add(f))
           .then(Future.wait)
           .then((parts) {
             Map<String, dynamic> map = new Map<String, dynamic>();
             for (var part in parts) {
               map[part[0]] = part[1];  // Override existing entries.
             }
-            return new _HttpBody(contentType, 'form', map);
+            return new _HttpBody('form', map);
           });
     }
 
     if (contentType == null) {
       return asBinary();
     }
 
     switch (contentType.primaryType) {
       case "text":
         return asText(defaultEncoding);
 
       case "application":
         switch (contentType.subType) {
           case "json":
             return asText(UTF8)
-                .then((body) => new _HttpBody(contentType,
-                                              "json",
-                                              JSON.decode(body.body)));
+                .then((body) => new _HttpBody("json", JSON.decode(body.body)));
 
           case "x-www-form-urlencoded":
             return asText(ASCII)
                 .then((body) {
                   var map = Uri.splitQueryString(body.body,
                       encoding: defaultEncoding);
                   var result = {};
                   for (var key in map.keys) {
                     result[key] = map[key];
                   }
-                  return new _HttpBody(contentType, "form", result);
+                  return new _HttpBody("form", result);
                 });
 
           default:
             break;
         }
         break;
 
       case "multipart":
         switch (contentType.subType) {
           case "form-data":
@@ skipping 13 matching lines @@
 }
 
 class _HttpBodyFileUpload implements HttpBodyFileUpload {
   final ContentType contentType;
   final String filename;
   final dynamic content;
   _HttpBodyFileUpload(this.contentType, this.filename, this.content);
 }
 
 class _HttpBody implements HttpBody {
-  final ContentType contentType;
   final String type;
   final dynamic body;
 
-  _HttpBody(ContentType this.contentType,
-            String this.type,
-            dynamic this.body);
+  _HttpBody(this.type, this.body);
 }
 
 class _HttpRequestBody extends _HttpBody implements HttpRequestBody {
-  final String method;
-  final Uri uri;
-  final HttpHeaders headers;
-  final HttpResponse response;
+  final HttpRequest request;
 
-  _HttpRequestBody(HttpRequest request, HttpBody body)
-      : super(body.contentType, body.type, body.body),
-        method = request.method,
-        uri = request.uri,
-        headers = request.headers,
-        response = request.response;
+  _HttpRequestBody(this.request, HttpBody body)
+      : super(body.type, body.body);
 }
 
 class _HttpClientResponseBody
     extends _HttpBody implements HttpClientResponseBody {
   final HttpClientResponse response;
 
-  _HttpClientResponseBody(HttpClientResponse response, HttpBody body)
-      : super(body.contentType, body.type, body.body),
-        this.response = response;
-
-  int get statusCode => response.statusCode;
-
-  String get reasonPhrase => response.reasonPhrase;
-
-  HttpHeaders get headers => response.headers;
+  _HttpClientResponseBody(this.response, HttpBody body)
+      : super(body.type, body.body);
 }