Support loading binary data in dart2js

pkg/compiler/lib/src/apiimpl.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 leg_apiimpl;
 
 import 'dart:async';
 
 import 'package:package_config/packages.dart';
 import 'package:package_config/packages_file.dart' as pkgs;
@@ skipping 55 matching lines @@
       userPackagesDiscoveryTask =
           new GenericTask('Package discovery', measurer),
     ]);
   }
 
   void log(message) {
     callUserHandler(
         null, null, null, null, message, api.Diagnostic.VERBOSE_INFO);
   }
 
+  /// Report [exception] reading [uri]. Use [element] and [node] to compute
+  /// the error location.
+  void _reportReadError(
+      Uri uri, elements.Element element, Spannable node, exception) {
+    if (element == null || node == null) {
+      reporter.reportErrorMessage(new SourceSpan(uri, 0, 0),
+          MessageKind.READ_SELF_ERROR, {'uri': uri, 'exception': exception});
+    } else {
+      reporter.withCurrentElement(element, () {
+        reporter.reportErrorMessage(node, MessageKind.READ_URI_ERROR,
+            {'uri': uri, 'exception': exception});
+      });
+    }
+  }
+
   /**
    * Reads the script designated by [readableUri].
    */
   Future<Script> readScript(Uri readableUri, [Spannable node]) {
     if (!readableUri.isAbsolute) {
       if (node == null) node = NO_LOCATION_SPANNABLE;
       reporter.internalError(
           node, 'Relative uri $readableUri provided to readScript(Uri).');
     }
 
     // We need to store the current element since we are reporting read errors
     // asynchronously and therefore need to restore the current element for
     // [node] to be valid.
     elements.Element element = currentElement;
-    void reportReadError(exception) {
-      if (element == null || node == null) {
-        reporter.reportErrorMessage(
-            new SourceSpan(readableUri, 0, 0),
-            MessageKind.READ_SELF_ERROR,
-            {'uri': readableUri, 'exception': exception});
-      } else {
-        reporter.withCurrentElement(element, () {
-          reporter.reportErrorMessage(node, MessageKind.READ_SCRIPT_ERROR,
-              {'uri': readableUri, 'exception': exception});
-        });
-      }
-    }
 
     Uri resourceUri = translateUri(node, readableUri);
     if (resourceUri == null) return _synthesizeScript(readableUri);
     if (resourceUri.scheme == 'dart-ext') {
       if (!options.allowNativeExtensions) {
         reporter.withCurrentElement(element, () {
           reporter.reportErrorMessage(node, MessageKind.DART_EXT_NOT_SUPPORTED);
         });
       }
       return _synthesizeScript(readableUri);
     }
 
     // TODO(johnniwinther): Wrap the result from [provider] in a specialized
     // [Future] to ensure that we never execute an asynchronous action without
     // setting up the current element of the compiler.
-    return new Future.sync(() => callUserProvider(resourceUri))
+    return new Future.sync(
+            () => callUserProvider(resourceUri, api.InputKind.utf8))
         .then((SourceFile sourceFile) {
       // We use [readableUri] as the URI for the script since need to preserve
       // the scheme in the script because [Script.uri] is used for resolving
       // relative URIs mentioned in the script. See the comment on
       // [LibraryLoader] for more details.
       return new Script(readableUri, resourceUri, sourceFile);
     }).catchError((error) {
-      reportReadError(error);
+      _reportReadError(readableUri, element, node, error);
       return _synthesizeScript(readableUri);
     });
   }
 
   Future<Script> _synthesizeScript(Uri readableUri) {
     return new Future.value(new Script.synthetic(readableUri));
   }
 
+  Future<Binary> readBinary(Uri resourceUri, [Spannable node]) {
+    if (!resourceUri.isAbsolute) {
+      if (node == null) node = NO_LOCATION_SPANNABLE;
+      reporter.internalError(
+          node, 'Relative uri $resourceUri provided to readScript(Uri).');
+    }
+
+    // We need to store the current element since we are reporting read errors
+    // asynchronously and therefore need to restore the current element for
+    // [node] to be valid.
+    elements.Element element = currentElement;
+
+    return new Future.sync(
+            () => callUserProvider(resourceUri, api.InputKind.binary))
+        .catchError((error) {
+      _reportReadError(resourceUri, element, node, error);
+      return new Binary(resourceUri, null);
+    });
+  }
+
   /**
    * Translates a readable URI into a resource URI.
    *
    * See [LibraryLoader] for terminology on URIs.
    */
   Uri translateUri(Spannable node, Uri uri) =>
       uri.scheme == 'package' ? translatePackageUri(node, uri) : uri;
 
   Uri translatePackageUri(Spannable node, Uri uri) {
     try {
@@ skipping 24 matching lines @@
           .analyzeUri(uri, skipLibraryWithPartOfTag: skipLibraryWithPartOfTag);
     });
   }
 
   Future setupPackages(Uri uri) {
     if (options.packageRoot != null) {
       // Use "non-file" packages because the file version requires a [Directory]
       // and we can't depend on 'dart:io' classes.
       packages = new NonFilePackagesDirectoryPackages(options.packageRoot);
     } else if (options.packageConfig != null) {
-      return callUserProvider(options.packageConfig)
-          .then((SourceFile sourceFile) {
-        List<int> configContents = sourceFile.slowUtf8ZeroTerminatedBytes();
-        // The input provider may put a trailing 0 byte when it reads a source
-        // file, which confuses the package config parser.
-        if (configContents.length > 0 && configContents.last == 0) {
-          configContents = configContents.sublist(0, configContents.length - 1);
-        }
+      return callUserProvider(options.packageConfig, api.InputKind.binary)
+          .then((Binary binary) {
         packages =
-            new MapPackages(pkgs.parse(configContents, options.packageConfig));
+            new MapPackages(pkgs.parse(binary.data, options.packageConfig));
       }).catchError((error) {
         reporter.reportErrorMessage(
             NO_LOCATION_SPANNABLE,
             MessageKind.INVALID_PACKAGE_CONFIG,
             {'uri': options.packageConfig, 'exception': error});
         packages = Packages.noPackages;
       });
     } else {
       if (options.packagesDiscoveryProvider == null) {
         packages = Packages.noPackages;
       } else {
         return callUserPackagesDiscovery(uri).then((p) {
           packages = p;
         });
       }
     }
     return new Future.value();
   }
 
   Future<Null> setupSdk() {
     Future future = new Future.value(null);
     if (options.resolutionInputs != null) {
       future = Future.forEach(options.resolutionInputs, (Uri resolutionInput) {
         reporter.log('Reading serialized data from ${resolutionInput}');
-        return callUserProvider(resolutionInput).then((SourceFile sourceFile) {
+        return callUserProvider(resolutionInput, api.InputKind.utf8)
+            .then((SourceFile sourceFile) {
           serialization.deserializeFromText(
               resolutionInput, sourceFile.slowText());
         });
       });
     }
     if (resolvedUriTranslator.isNotSet) {
       future = future.then((_) {
         return platform_configuration
             .load(options.platformConfigUri, provider)
             .then((Map<String, Uri> mapping) {
@@ skipping 91 matching lines @@
     try {
       userHandlerTask.measure(() {
         handler.report(message, uri, begin, end, text, kind);
       });
     } catch (ex, s) {
       reportCrashInUserCode('Uncaught exception in diagnostic handler', ex, s);
       rethrow;
     }
   }
 
-  Future<SourceFile> callUserProvider(Uri uri) {
+  Future<api.Input> callUserProvider(Uri uri, api.InputKind inputKind) {
     try {
       return userProviderTask
-          .measureIo(() => provider.readFromUri(uri))
-          .then((data) {
-        SourceFile sourceFile;
-        if (data is List<int>) {
-          sourceFile = new Utf8BytesSourceFile(uri, data);
-        } else if (data is String) {
-          sourceFile = new StringSourceFile.fromUri(uri, data);
-        } else {
-          throw "Expected a 'String' or a 'List<int>' from the input "
-              "provider, but got: ${Error.safeToString(data)}.";
-        }
-        return sourceFile;
-      });
+          .measureIo(() => provider.readFromUri(uri, inputKind: inputKind));
     } catch (ex, s) {
       reportCrashInUserCode('Uncaught exception in input provider', ex, s);
       rethrow;
     }
   }
 
   Future<Packages> callUserPackagesDiscovery(Uri uri) {
     try {
       return userPackagesDiscoveryTask
           .measureIo(() => options.packagesDiscoveryProvider(uri));
@@ skipping 60 matching lines @@
   }
 }
 
 /// For every 'dart:' library, a corresponding environment variable is set
 /// to "true". The environment variable's name is the concatenation of
 /// this prefix and the name (without the 'dart:'.
 ///
 /// For example 'dart:html' has the environment variable 'dart.library.html' set
 /// to "true".
 const String _dartLibraryEnvironmentPrefix = 'dart.library.';