Support loading binary data in dart2js

pkg/compiler/lib/src/io/source_file.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.
 
 library dart2js.io.source_file;
 
 import 'dart:convert' show UTF8;
 import 'dart:math';
 import 'dart:typed_data' show Uint8List;
 
 import 'package:kernel/ast.dart' as kernel show Location, Source;
-
 import 'location_provider.dart' show LocationProvider;
+import '../../compiler_new.dart';
 
 /// Represents a file of source code. The content can be either a [String] or
 /// a UTF-8 encoded [List<int>] of bytes.
-abstract class SourceFile implements LocationProvider {
+abstract class SourceFile<T> implements Input<T>, LocationProvider {
   /// The absolute URI of the source file.
   Uri get uri;
 
+  InputKind get inputKind => InputKind.utf8;
+
   kernel.Source cachedKernelSource;
 
   kernel.Source get kernelSource {
     return cachedKernelSource ??=
         new kernel.Source(lineStarts, slowUtf8ZeroTerminatedBytes())
           ..cachedText = slowText();
   }
 
   /// The name of the file.
   ///
@@ skipping 128 matching lines @@
 }
 
 List<int> _zeroTerminateIfNecessary(List<int> bytes) {
   if (bytes.length > 0 && bytes.last == 0) return bytes;
   List<int> result = new Uint8List(bytes.length + 1);
   result.setRange(0, bytes.length, bytes);
   result[result.length - 1] = 0;
   return result;
 }
 
-class Utf8BytesSourceFile extends SourceFile {
+class Utf8BytesSourceFile extends SourceFile<List<int>> {
   final Uri uri;
 
   /// The UTF-8 encoded content of the source file.
   final List<int> zeroTerminatedContent;
 
   /// Creates a Utf8BytesSourceFile.
   ///
   /// If possible, the given [content] should be zero-terminated. If it isn't,
   /// the constructor clones the content and adds a trailing 0.
   Utf8BytesSourceFile(this.uri, List<int> content)
       : this.zeroTerminatedContent = _zeroTerminateIfNecessary(content);
 
+  List<int> get data => zeroTerminatedContent;
+
   String slowText() {
     // Don't convert the trailing zero byte.
     return UTF8.decoder
         .convert(zeroTerminatedContent, 0, zeroTerminatedContent.length - 1);
   }
 
   List<int> slowUtf8ZeroTerminatedBytes() => zeroTerminatedContent;
 
   String slowSubstring(int start, int end) {
     // TODO(lry): to make this faster, the scanner could record the UTF-8 slack
@@ skipping 21 matching lines @@
       : super(uri, content);
 
   String slowText() {
     if (cachedText == null) {
       cachedText = super.slowText();
     }
     return cachedText;
   }
 }
 
-class StringSourceFile extends SourceFile {
+class StringSourceFile extends SourceFile<String> {
   final Uri uri;
   final String filename;
   final String text;
 
   StringSourceFile(this.uri, this.filename, this.text);
 
   StringSourceFile.fromUri(Uri uri, String text)
       : this(uri, uri.toString(), text);
 
   StringSourceFile.fromName(String filename, String text)
       : this(new Uri(path: filename), filename, text);
 
+  String get data => text;
+
   int get length => text.length;
   set length(int v) {}
 
   String slowText() => text;
 
   List<int> slowUtf8ZeroTerminatedBytes() {
     return _zeroTerminateIfNecessary(UTF8.encode(text));
   }
 
   String slowSubstring(int start, int end) => text.substring(start, end);
 }
+
+/// Binary input data.
+class Binary implements Input<List<int>> {
+  final Uri uri;
+  final List<int> data;
+
+  Binary(this.uri, this.data);
+
+  InputKind get inputKind => InputKind.binary;
+}