Start switching hijacking to use StreamChannel.

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.
 
 import 'dart:async';
 import 'dart:convert';
 
 import 'package:http_parser/http_parser.dart';
+import 'package:stream_channel/stream_channel.dart';
 
 import 'hijack_exception.dart';
 import 'message.dart';
 import 'util.dart';
 
 /// A callback provided by a Shelf handler that's passed to [Request.hijack].
+@Deprecated("Will be removed in shelf 0.7.0.")
 typedef void HijackCallback(
     Stream<List<int>> stream, StreamSink<List<int>> sink);
 
 /// A callback provided by a Shelf adapter that's used by [Request.hijack] to
 /// provide a [HijackCallback] with a socket.
+@Deprecated("Will be removed in shelf 0.7.0.")
 typedef void OnHijackCallback(HijackCallback callback);
 
 /// Represents an HTTP request to be processed by a Shelf application.
 class Request extends Message {
   /// The URL path from the current handler to the requested resource, relative
   /// to [handlerPath], plus any query parameters.
   ///
   /// This should be used by handlers for determining which resource to serve,
   /// in preference to [requestedUri]. This allows handlers to do the right
   /// thing when they're mounted anywhere in the application. Routers should be
@@ skipping 96 matching lines @@
   /// 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, String handlerPath, Uri url, body,
       Encoding encoding, Map<String, Object> context,
-      OnHijackCallback onHijack})
+      void onHijack(void hijack(
+          Stream<List<int>> stream, StreamSink<List<int>> sink))})
       : this._(method, requestedUri,
           protocolVersion: protocolVersion,
           headers: headers,
           url: url,
           handlerPath: handlerPath,
           body: body,
           encoding: encoding,
           context: context,
           onHijack: onHijack == null ? null : new _OnHijack(onHijack));
 
@@ skipping 72 matching lines @@
         handlerPath: handlerPath,
         body: body,
         context: context,
         onHijack: _onHijack);
   }
 
   /// Takes control of the underlying request socket.
   ///
   /// Synchronously, this throws a [HijackException] that indicates to the
   /// adapter that it shouldn't emit a response itself. Asynchronously,
-  /// [callback] is called with a [Stream<List<int>>] and
-  /// [StreamSink<List<int>>], respectively, that provide access to the
-  /// underlying request socket.
+  /// [callback] is called with a [StreamChannel<List<int>>] that provides
+  /// access to the underlying request socket.
   ///
-  /// If the sink is closed, the stream will be closed as well. The stream and
-  /// sink may be the same object, as in the case of a `dart:io` `Socket`
-  /// object.
+  /// For backwards compatibility, if the callback takes two arguments, it will
+  /// be passed a `Stream<List<int>>` and a `StreamSink<List<int>>` separately,
+  /// but this behavior is deprecated.
   ///
   /// This may only be called when using a Shelf adapter that supports
   /// hijacking, such as the `dart:io` adapter. In addition, a given request may
   /// only be hijacked once. [canHijack] can be used to detect whether this
   /// request can be hijacked.
-  void hijack(HijackCallback callback) {
+  void hijack(Function callback) {
     if (_onHijack == null) {
       throw new StateError("This request can't be hijacked.");
     }
 
+    if (callback is ZoneUnaryCallback) {
+      var oldCallback = callback;
+      callback = (stream, sink) {
+        oldCallback(new StreamChannel<List<int>>(stream, sink));
+      };
+    }
+
     _onHijack.run(callback);
     throw const HijackException();
   }
 }
 
 /// A class containing a callback for [Request.hijack] that also tracks whether
 /// the callback has been called.
 class _OnHijack {
   /// The callback.
   final OnHijackCallback _callback;
@@ skipping 88 matching lines @@
     return handlerPath;
   } else if (url != null) {
     if (url.path.isEmpty) return requestedUri.path;
 
     var index = requestedUri.path.indexOf(url.path);
     return requestedUri.path.substring(0, index);
   } else {
     return '/';
   }
 }