- Implement resource loading via the Resource class.

runtime/bin/builtin.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 builtin;
 // NOTE: Do not import 'dart:io' in builtin.
+import 'dart:async';
 import 'dart:collection';
+import 'dart:_internal';
 import 'dart:isolate';
 import 'dart:typed_data';
 
+
+// Before handling an embedder entrypoint we finalize the setup of the
+// dart:_builtin library.
+bool _setupCompleted = false;
+
+
 // The root library (aka the script) is imported into this library. The
 // standalone embedder uses this to lookup the main entrypoint in the
 // root library's namespace.
 Function _getMainClosure() => main;
 
 
 // 'print' implementation.
 // The standalone embedder registers the closurized _print function with the
 // dart:core library.
 void _printString(String s) native "Builtin_PrintString";
@@ skipping 21 matching lines @@
 }
 
 
 _getUriBaseClosure() => _uriBase;
 
 
 // Asynchronous loading of resources.
 // The embedder forwards most loading requests to this library.
 
 // See Dart_LibraryTag in dart_api.h
-const Dart_kScriptTag = null;
-const Dart_kImportTag = 0;
-const Dart_kSourceTag = 1;
-const Dart_kCanonicalizeUrl = 2;
+const _Dart_kScriptTag = null;
+const _Dart_kImportTag = 0;
+const _Dart_kSourceTag = 1;
+const _Dart_kCanonicalizeUrl = 2;
+const _Dart_kResourceLoad = 3;
 
 // Embedder sets this to true if the --trace-loading flag was passed on the
 // command line.
 bool _traceLoading = false;
 
 // A port for communicating with the service isolate for I/O.
 SendPort _loadPort;
 // The receive port for a load request. Multiple sources can be fetched in
 // a single load request.
 RawReceivePort _receivePort;
@@ skipping 46 matching lines @@
   _LoadError(this.uri, this.message);
 
   String toString() => 'Load Error for "$uri": $message';
 }
 
 // Class collecting all of the information about a particular load request.
 class _LoadRequest {
   final int _id;
   final int _tag;
   final String _uri;
-  final String _libraryUri;
   final Uri _resourceUri;
+  final _context;
 
   _LoadRequest(this._id,
                this._tag,
                this._uri,
-               this._libraryUri,
-               this._resourceUri);
+               this._resourceUri,
+               this._context);
 
-  toString() => "LoadRequest($_id, $_tag, $_uri, $_libraryUri, $_resourceUri)";
+  toString() => "LoadRequest($_id, $_tag, $_uri, $_resourceUri, $_context)";
 }
 
 
 // Native calls provided by the embedder.
 void _signalDoneLoading() native "Builtin_DoneLoading";
 void _loadScriptCallback(int tag, String uri, String libraryUri, Uint8List data)
     native "Builtin_LoadSource";
 void _asyncLoadErrorCallback(uri, libraryUri, error)
     native "Builtin_AsyncLoadError";
 
@@ skipping 46 matching lines @@
   if (!uri.endsWith('/')) {
     return '$uri/';
   }
   return uri;
 }
 
 
 // Embedder Entrypoint:
 // The embedder calls this method with the current working directory.
 void _setWorkingDirectory(cwd) {
+  if (!_setupCompleted) {
+    _setupHooks();
+  }
   if (_traceLoading) {
     _log('Setting working directory: $cwd');
   }
   _workingDirectory = new Uri.directory(cwd);
   if (_traceLoading) {
     _log('Working directory URI: $_workingDirectory');
   }
 }
 
 
 // Embedder Entrypoint:
 // The embedder calls this method with a custom package root.
 _setPackageRoot(String packageRoot) {
+  if (!_setupCompleted) {
+    _setupHooks();
+  }
   if (_traceLoading) {
     _log('Setting package root: $packageRoot');
   }
   packageRoot = _enforceTrailingSlash(packageRoot);
   if (packageRoot.startsWith('file:') ||
       packageRoot.startsWith('http:') ||
       packageRoot.startsWith('https:')) {
     _packageRoot = _workingDirectory.resolve(packageRoot);
   } else {
     packageRoot = _sanitizeWindowsPath(packageRoot);
@@ skipping 95 matching lines @@
 }
 
 
 void _handleLoaderReply(msg) {
   int id = msg[0];
   var dataOrError = msg[1];
   assert((id >= 0) && (id < _reqId));
   var req = _reqMap[id];
   try {
     if (dataOrError is Uint8List) {
-      _loadScript(req, dataOrError);
+      // Successfully loaded the data.
+      if (req._tag == _Dart_kResourceLoad) {
+        Completer c = req._context;
+        c.complete(dataOrError);
+      } else {
+        // TODO: Currently a compilation error while loading the script is
+        // fatal for the isolate. _loadScriptCallback() does not return and
+        // the number of requests remains out of sync.
+        _loadScriptCallback(req._tag, req._uri, req._context, dataOrError);
+      }
+      _finishLoadRequest(req);
     } else {
       assert(dataOrError is String);
       var error = new _LoadError(req._uri, dataOrError.toString());
-      _asyncLoadError(req, error);
+      _asyncLoadError(req, error, null);
     }
   } catch(e, s) {
     // Wrap inside a _LoadError unless we are already propagating a
     // previous _LoadError.
     var error = (e is _LoadError) ? e : new _LoadError(req._uri, e.toString());
     assert(req != null);
-    _asyncLoadError(req, error);
+    _asyncLoadError(req, error, s);
   }
 }
 
 
-void _startLoadRequest(int tag,
-                       String uri,
-                       String libraryUri,
-                       Uri resourceUri) {
+void _startLoadRequest(int tag, String uri, Uri resourceUri, context) {
   if (_receivePort == null) {
     if (_traceLoading) {
       _log("Initializing load port.");
     }
     assert(_receivePort == null);
     assert(_sendPort == null);
     _receivePort = new RawReceivePort(_handleLoaderReply);
     _sendPort = _receivePort.sendPort;
   }
   // Register the load request and send it to the VM service isolate.
   var curId = _reqId++;
 
   assert(_reqMap[curId] == null);
-  _reqMap[curId] = new _LoadRequest(curId, tag, uri, libraryUri, resourceUri);
+  _reqMap[curId] = new _LoadRequest(curId, tag, uri, resourceUri, context);
 
   assert(_receivePort != null);
   assert(_sendPort != null);
 
   var msg = new List(4);
   msg[0] = _sendPort;
   msg[1] = _traceLoading;
   msg[2] = curId;
   msg[3] = resourceUri.toString();
   _loadPort.send(msg);
 
   if (_traceLoading) {
-    _log("Loading of $resourceUri for $uri started with id: $curId, "
-         "${_reqMap.length} requests outstanding");
+    _log("Loading of $resourceUri for $uri started with id: $curId. "
+         "${_reqMap.length} requests remaining, "
+         "${_pendingPackageLoads.length} packages pending.");
   }
 }
 
 
 RawReceivePort _packagesPort;
 
 void _handlePackagesReply(msg) {
   // Make sure to close the _packagePort before any other action.
   _packagesPort.close();
 
@@ skipping 17 matching lines @@
     for (var i = 0; i < msg.length; i+=2) {
       // TODO(iposva): Complain about duplicate entries.
       _packageMap[msg[i]] = Uri.parse(msg[i+1]);
     }
     if (_traceLoading) {
       _log("Setup package map: $_packageMap");
     }
   }
 
   // Resolve all pending package loads now that we know how to resolve them.
-  for (var i = 0; i < _pendingPackageLoads.length; i++) {
-    var req = _pendingPackageLoads[i];
+  while (_pendingPackageLoads.length > 0) {
+    var req = _pendingPackageLoads.removeLast();
     if (req != null) {
       if (_traceLoading) {
         _log("Handling deferred load request: $req");
       }
-      _loadPackage(req._tag, req._uri, req._libraryUri, req._resourceUri);
+      _loadPackage(req._tag, req._uri, req._resourceUri, req._context);
+    } else {
+      if (_traceLoading) {
+        _log("Skipping dummy deferred request.");
+      }
     }
   }
   // Reset the pending package loads to empty. So that we eventually can
   // finish loading.
   _pendingPackageLoads = [];
 }
 
 
 void _requestPackagesMap() {
   assert(_packagesPort == null);
@@ skipping 11 matching lines @@
 
   if (_traceLoading) {
     _log("Requested packages map for '$_rootScript'.");
   }
 }
 
 
 // Embedder Entrypoint:
 // Request the load of a particular packages map.
 void _loadPackagesMap(String packagesParam) {
+  if (!_setupCompleted) {
+    _setupHooks();
+  }
   // First convert the packages parameter from the command line to a URI which
   // can be handled by the loader code.
   // TODO(iposva): Consider refactoring the common code below which is almost
   // shared with resolution of the root script.
   if (_traceLoading) {
     _log("Resolving packages map: $packagesParam");
   }
   if (_workingDirectory == null) {
     throw 'No current working directory set.';
   }
@@ skipping 24 matching lines @@
   // Signal that the resolution of the packages map has started. But in this
   // case it is not tied to a particular request.
   _pendingPackageLoads.add(null);
 
   if (_traceLoading) {
     _log("Requested packages map at '$packagesUri'.");
   }
 }
 
 
-void _loadScript(_LoadRequest req, Uint8List data) {
-  // TODO: Currently a compilation error while loading the script is
-  // fatal for the isolate. _loadScriptCallback() does not return and
-  // the number of requests remains out of sync.
-  _loadScriptCallback(req._tag, req._uri, req._libraryUri, data);
+void _asyncLoadError(_LoadRequest req, _LoadError error, StackTrace stack) {
+  if (_traceLoading) {
+    _log("_asyncLoadError(${req._uri}), error: $error\nstack: $stack");
+  }
+  if (req._tag == _Dart_kResourceLoad) {
+    Completer c = req._context;
+    c.completeError(error, stack);
+  } else {
+    Uri libraryUri = req._context;
+    if (req._tag == _Dart_kImportTag) {
+      // When importing a library, the libraryUri is the imported
+      // uri.
+      libraryUri = req._uri;
+    }
+    _asyncLoadErrorCallback(req._uri, libraryUri, error);
+  }
   _finishLoadRequest(req);
 }
 
 
-void _asyncLoadError(_LoadRequest req, _LoadError error) {
-  if (_traceLoading) {
-    _log("_asyncLoadError(${req._uri}), error: $error");
-  }
-  var libraryUri = req._libraryUri;
-  if (req._tag == Dart_kImportTag) {
-    // When importing a library, the libraryUri is the imported
-    // uri.
-    libraryUri = req._uri;
-  }
-  _asyncLoadErrorCallback(req._uri, libraryUri, error);
-  _finishLoadRequest(req);
-}
-
-
-_loadDataFromLoadPort(int tag,
-                      String uri,
-                      String libraryUri,
-                      Uri resourceUri) {
+_loadDataFromLoadPort(int tag, String uri, Uri resourceUri, context) {
   try {
-    _startLoadRequest(tag, uri, libraryUri, resourceUri);
-  } catch (e) {
+    _startLoadRequest(tag, uri, resourceUri, context);
+  } catch (e, s) {
     if (_traceLoading) {
       _log("Exception when communicating with service isolate: $e");
     }
     // Wrap inside a _LoadError unless we are already propagating a previously
     // seen _LoadError.
     var error = (e is _LoadError) ? e : new _LoadError(e.toString());
-    _asyncLoadError(tag, uri, libraryUri, error);
+    _asyncLoadError(tag, uri, context, error, s);
   }
 }
 
 
 // Loading a package URI needs to first map the package name to a loadable
 // URI.
-_loadPackage(int tag, String uri, String libraryUri, Uri resourceUri) {
+_loadPackage(int tag, String uri, Uri resourceUri, context) {
   if (_packagesReady()) {
-    _loadData(tag, uri, libraryUri, _resolvePackageUri(resourceUri));
+    _loadData(tag, uri, _resolvePackageUri(resourceUri), context);
   } else {
     if (_pendingPackageLoads.isEmpty) {
       // Package resolution has not been setup yet, and this is the first
       // request for package resolution & loading.
       _requestPackagesMap();
     }
-    var req = new _LoadRequest(-1, tag, uri, libraryUri, resourceUri);
+    var req = new _LoadRequest(-1, tag, uri, resourceUri, context);
     _pendingPackageLoads.add(req);
     if (_traceLoading) {
       _log("Pending package load of '$uri': "
       "${_pendingPackageLoads.length} pending");
     }
   }
 }
 
 
 // Load the data associated with the resourceUri.
-_loadData(int tag, String uri, String libraryUri, Uri resourceUri) {
+_loadData(int tag, String uri, Uri resourceUri, context) {
   if (resourceUri.scheme == 'package') {
     // package based uris need to be resolved to the correct loadable location.
     // The logic of which is handled seperately, and then _loadData is called
     // recursively.
-    _loadPackage(tag, uri, libraryUri, resourceUri);
+    _loadPackage(tag, uri, resourceUri, context);
   } else {
-    _loadDataFromLoadPort(tag, uri, libraryUri, resourceUri);
+    _loadDataFromLoadPort(tag, uri, resourceUri, context);
   }
 }
 
 
 // Embedder Entrypoint:
 // Asynchronously loads script data through a http[s] or file uri.
 _loadDataAsync(int tag, String uri, String libraryUri) {
+  if (!_setupCompleted) {
+    _setupHooks();
+  }
   var resourceUri;
-  if (tag == Dart_kScriptTag) {
+  if (tag == _Dart_kScriptTag) {
     resourceUri = _resolveScriptUri(uri);
     uri = resourceUri.toString();
   } else {
     resourceUri = Uri.parse(uri);
   }
-  _loadData(tag, uri, libraryUri, resourceUri);
+  _loadData(tag, uri, resourceUri, libraryUri);
 }
 
 
 // Embedder Entrypoint:
 // Function called by standalone embedder to resolve uris when the VM requests
 // Dart_kCanonicalizeUrl from the tag handler.
 String _resolveUri(String base, String userString) {
+  if (!_setupCompleted) {
+    _setupHooks();
+  }
   if (_traceLoading) {
     _log('Resolving: $userString from $base');
   }
   var baseUri = Uri.parse(base);
   var result;
   if (userString.startsWith(_DART_EXT)) {
     var uri = userString.substring(_DART_EXT.length);
     result = '$_DART_EXT${baseUri.resolve(uri)}';
   } else {
     result = baseUri.resolve(userString).toString();
   }
   if (_traceLoading) {
     _log('Resolved $userString in $base to $result');
   }
   return result;
 }
 
 
+// Handling of Resource class by dispatching to the load port.
+Future<List<int>> _resourceReadAsBytes(Uri uri) {
+  var completer = new Completer<List<int>>();
+  // Request the load of the resource associating the completer as the context
+  // for the load.
+  _loadData(_Dart_kResourceLoad, uri.toString(), uri, completer);
+  // Return the future that will be triggered once the resource has been loaded.
+  return completer.future;
+}
+
+
 // Embedder Entrypoint (gen_snapshot):
 // Resolve relative paths relative to working directory.
 String _resolveInWorkingDirectory(String fileName) {
+  if (!_setupCompleted) {
+    _setupHooks();
+  }
   if (_workingDirectory == null) {
     throw 'No current working directory set.';
   }
   var name = _sanitizeWindowsPath(fileName);
 
   var uri = Uri.parse(name);
   if (uri.scheme != '') {
     throw 'Schemes are not supported when resolving filenames.';
   }
   uri = _workingDirectory.resolveUri(uri);
@@ skipping 54 matching lines @@
 
 // Embedder Entrypoint:
 // When loading an extension the embedder calls this method to get the
 // different components.
 // Returns the directory part, the filename part, and the name
 // of a native extension URL as a list [directory, filename, name].
 // The directory part is either a file system path or an HTTP(S) URL.
 // The filename part is the extension name, with the platform-dependent
 // prefixes and extensions added.
 _extensionPathFromUri(String userUri) {
+  if (!_setupCompleted) {
+    _setupHooks();
+  }
   if (!userUri.startsWith(_DART_EXT)) {
     throw 'Unexpected internal error: Extension URI $userUri missing dart-ext:';
   }
   userUri = userUri.substring(_DART_EXT.length);
 
   if (userUri.contains('\\')) {
     throw 'Unexpected internal error: Extension URI $userUri contains \\';
   }
 
   String name;
   String path;  // Will end in '/'.
   int index = userUri.lastIndexOf('/');
   if (index == -1) {
     name = userUri;
     path = './';
   } else if (index == userUri.length - 1) {
     throw 'Extension name missing in $extensionUri';
   } else {
     name = userUri.substring(index + 1);
     path = userUri.substring(0, index + 1);
   }
 
   path = _filePathFromUri(path);
   var filename = _platformExtensionFileName(name);
 
   return [path, filename, name];
 }
+
+
+// Register callbacks and hooks with the rest of the core libraries.
+_setupHooks() {
+  _setupCompleted = true;
+  VMLibraryHooks.resourceReadAsBytes = _resourceReadAsBytes;
+}