Request now has the same body model as Response

lib/src/request.dart

 // Copyright (c) 2014, 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.
 
 library shelf.request;
 
 import 'dart:async';
+import 'dart:convert';
 
 import 'package:http_parser/http_parser.dart';
 
 import 'hijack_exception.dart';
 import 'message.dart';
 import 'util.dart';
 
 /// A callback provided by a Shelf handler that's passed to [Request.hijack].
 typedef void HijackCallback(
     Stream<List<int>> stream, StreamSink<List<int>> sink);
@@ skipping 63 matching lines @@
   DateTime _ifModifiedSinceCache;
 
   /// Creates a new [Request].
   ///
   /// If [url] and [scriptName] are omitted, they are inferred from
   /// [requestedUri].
   ///
   /// Setting one of [url] or [scriptName] and not the other will throw an
   /// [ArgumentError].
   ///
+  /// [body] is the request body. It may be either a [String], a
+  /// [Stream<List<int>>], or `null` to indicate no body.
+  /// If it's a [String], [encoding] is used to encode it to a
+  /// [Stream<List<int>>]. The default encoding is UTF-8.
+  ///
+  /// If [encoding] is passed, the "encoding" field of the Content-Type header
+  /// in [headers] will be set appropriately. If there is no existing
+  /// Content-Type header, it will be set to "application/octet-stream".
+  ///
   /// The default value for [protocolVersion] is '1.1'.
   ///
   /// ## `onHijack`
   ///
   /// [onHijack] allows handlers to take control of the underlying socket for
   /// the request. It should be passed by adapters that can provide access to
   /// the bidirectional socket underlying the HTTP connection stream.
   ///
   /// The [onHijack] callback will only be called once per request. It will be
   /// passed another callback which takes a byte stream and a byte sink.
   /// [onHijack] must pass the stream and sink for the connection stream to this
   /// callback, although it may do so asynchronously. Both parameters may be the
   /// same object. If the user closes the sink, the adapter should ensure that
   /// the stream is closed as well.
   ///
   /// If a request is hijacked, the adapter should expect to receive a
   /// [HijackException] from the handler. This is a special exception used to
   /// indicate that hijacking has occurred. The adapter should avoid either
   /// sending a response or notifying the user of an error if a
   /// [HijackException] is caught.
   ///
   /// An adapter can check whether a request was hijacked using [canHijack],
   /// which will be `false` for a hijacked request. The adapter may throw an
   /// error if a [HijackException] is received for a non-hijacked request, or if
   /// no [HijackException] is received for a hijacked request.
   ///
   /// See also [hijack].
   // TODO(kevmoo) finish documenting the rest of the arguments.
   Request(String method, Uri requestedUri, {String protocolVersion,
-      Map<String, String> headers, Uri url, String scriptName,
-      Stream<List<int>> body, Map<String, Object> context,
+      Map<String, String> headers, Uri url, String scriptName, body,
+      Encoding encoding, Map<String, Object> context,
       OnHijackCallback onHijack})
       : this._(method, requestedUri,
           protocolVersion: protocolVersion,
           headers: headers,
           url: url,
           scriptName: scriptName,
           body: body,
+          encoding: encoding,
           context: context,
           onHijack: onHijack == null ? null : new _OnHijack(onHijack));
 
   /// This constructor has the same signature as [new Request] except that
   /// accepts [onHijack] as [_OnHijack].
   ///
   /// Any [Request] created by calling [change] will pass [_onHijack] from the
   /// source [Request] to ensure that [hijack] can only be called once, even
   /// from a changed [Request].
   Request._(this.method, Uri requestedUri, {String protocolVersion,
-      Map<String, String> headers, Uri url, String scriptName,
-      Stream<List<int>> body, Map<String, Object> context, _OnHijack onHijack})
+      Map<String, String> headers, Uri url, String scriptName, body,
+      Encoding encoding, Map<String, Object> context, _OnHijack onHijack})
       : this.requestedUri = requestedUri,
         this.protocolVersion = protocolVersion == null
             ? '1.1'
             : protocolVersion,
         this.url = _computeUrl(requestedUri, url, scriptName),
         this.scriptName = _computeScriptName(requestedUri, url, scriptName),
         this._onHijack = onHijack,
-        super(body == null ? new Stream.fromIterable([]) : body,
-            headers: headers, context: context) {
+        super(body, encoding: encoding, headers: headers, context: context) {
     if (method.isEmpty) throw new ArgumentError('method cannot be empty.');
 
     if (!requestedUri.isAbsolute) {
       throw new ArgumentError('requstedUri must be an absolute URI.');
     }
 
     // TODO(kevmoo) if defined, check that scriptName is a fully-encoded, valid
     // path component
     if (this.scriptName.isNotEmpty && !this.scriptName.startsWith('/')) {
       throw new ArgumentError('scriptName must be empty or start with "/".');
@@ skipping 143 matching lines @@
     return '';
   }
 
   if (url != null && scriptName != null) {
     return scriptName;
   }
 
   throw new ArgumentError(
       'url and scriptName must both be null or both be set.');
 }