Roll to pickup pool changes

packages/barback/lib/src/asset/internal_asset.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.
 
 library barback.asset.internal_asset;
 
 import 'dart:async';
 import 'dart:convert';
 import 'dart:typed_data';
 
 import 'package:async/async.dart';
 import 'package:collection/collection.dart';
 
 import '../serialize.dart';
 import '../utils.dart';
 import '../utils/file_pool.dart';
 import '../utils/stream_replayer.dart';
 import 'asset.dart';
 import 'asset_id.dart';
 
 /// Serialize an asset to a form that's safe to send across isolates.
 Map serializeAsset(Asset asset) {
   var id = serializeId(asset.id);
   if (asset is BinaryAsset) {
-    return {
-      'type': 'binary',
-      'id': id,
-      'contents': asset._contents
-    };
+    return {'type': 'binary', 'id': id, 'contents': asset._contents};
   } else if (asset is FileAsset) {
-    return {
-      'type': 'file',
-      'id': id,
-      'path': asset._path
-    };
+    return {'type': 'file', 'id': id, 'path': asset._path};
   } else if (asset is StringAsset) {
-    return {
-      'type': 'string',
-      'id': id,
-      'contents': asset._contents
-    };
+    return {'type': 'string', 'id': id, 'contents': asset._contents};
   } else {
     // [asset] is probably a [StreamAsset], but it's possible that the user has
     // created a custom subclass, in which case we just serialize the stream
     // anyway.
     return {
       'type': 'stream',
       'id': id,
       'stream': serializeStream(asset.read())
     };
   }
 }
 
 /// Deserialize an asset from the form returned by [serialize].
 Asset deserializeAsset(Map asset) {
   var id = deserializeId(asset['id']);
   switch (asset['type']) {
     case 'binary':
       return new BinaryAsset(
           id, DelegatingList.typed(asset['contents'] as List));
-    case 'file': return new FileAsset(id, asset['path']);
-    case 'string': return new StringAsset(id, asset['contents']);
+    case 'file':
+      return new FileAsset(id, asset['path']);
+    case 'string':
+      return new StringAsset(id, asset['contents']);
     case 'stream':
       return new StreamAsset(
           id, DelegatingStream.typed(deserializeStream(asset['stream'])));
     default:
       throw new FormatException('Unknown asset type "${asset['type']}".');
   }
 }
 
 /// An asset whose data is stored in a list of bytes.
 class BinaryAsset implements Asset {
   final AssetId id;
 
   final Uint8List _contents;
 
-  BinaryAsset(this.id, List<int> contents)
-      : _contents = toUint8List(contents);
+  BinaryAsset(this.id, List<int> contents) : _contents = toUint8List(contents);
 
   Future<String> readAsString({Encoding encoding}) {
     if (encoding == null) encoding = UTF8;
 
     return new Future.value(encoding.decode(_contents));
   }
 
   Stream<List<int>> read() => new Future<List<int>>.value(_contents).asStream();
 
   String toString() {
@@ skipping 57 matching lines @@
   Future<String> readAsString({Encoding encoding}) =>
       new Future.value(_contents);
 
   Stream<List<int>> read() =>
       new Future<List<int>>.value(UTF8.encode(_contents)).asStream();
 
   String toString() {
     // Don't show the whole string if it's long.
     var contents = _contents;
     if (contents.length > 40) {
-      contents = contents.substring(0, 20) + " ... " +
-                 contents.substring(contents.length - 20);
+      contents = contents.substring(0, 20) +
+          " ... " +
+          contents.substring(contents.length - 20);
     }
 
     contents = _escape(contents);
     return 'String "$contents"';
   }
 
   String _escape(String string) {
     return string
         .replaceAll("\"", r'\"')
         .replaceAll("\n", r"\n")
         .replaceAll("\r", r"\r")
         .replaceAll("\t", r"\t");
   }
 }
 
 /// An asset whose data is available from a stream.
 class StreamAsset implements Asset {
   final AssetId id;
 
   /// A stream replayer that records and replays the contents of the input
   /// stream.
   final StreamReplayer<List<int>> _replayer;
 
   StreamAsset(this.id, Stream<List<int>> stream)
       : _replayer = new StreamReplayer(stream);
 
   Future<String> readAsString({Encoding encoding}) {
     if (encoding == null) encoding = UTF8;
-    return _replayer.getReplay().expand((chunk) => chunk).toList()
+    return _replayer
+        .getReplay()
+        .expand((chunk) => chunk)
+        .toList()
         .then((bytes) => encoding.decode(bytes));
   }
 
   Stream<List<int>> read() => _replayer.getReplay();
 
   String toString() => "Stream";
 }