- Add getters for the current packageRoot or packageMap.

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';
@@ skipping 53 matching lines @@
 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;
-SendPort _sendPort;
+RawReceivePort _dataPort;
 // A request id valid only for the current load cycle (while the number of
 // outstanding load requests is greater than 0). Can be reset when loading is
 // completed.
 int _reqId = 0;
 // An unordered hash map mapping from request id to a particular load request.
 // Once there are no outstanding load requests the current load has finished.
 HashMap _reqMap = new HashMap();
 
 // The current working directory when the embedder was launched.
 Uri _workingDirectory;
@@ skipping 32 matching lines @@
 class _LoadError extends Error {
   final String message;
   final String uri;
   _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 _id = _reqId++;
   final int _tag;
   final String _uri;
   final Uri _resourceUri;
   final _context;
 
-  _LoadRequest(this._id,
-               this._tag,
-               this._uri,
-               this._resourceUri,
-               this._context);
+  _LoadRequest(this._tag, this._uri, this._resourceUri, this._context) {
+    assert(_reqMap[_id] == null);
+    _reqMap[_id] = this;
+  }
 
   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)
@@ skipping 164 matching lines @@
     // Now that we are done with loading remove the request from the map.
     var tmp = _reqMap.remove(req._id);
     assert(tmp == req);
     if (_traceLoading) {
       _log("Loading of ${req._uri} finished: "
            "${_reqMap.length} requests remaining, "
            "${_pendingPackageLoads.length} packages pending.");
     }
   }
 
-  if (!_pendingLoads()) {
+  if (!_pendingLoads() && (_dataPort != null)) {
+    // Close the _dataPort now that there are no more requests outstanding.
     if (_traceLoading) {
       _log("Closing loading port.");
     }
-    _receivePort.close();
-    _receivePort = null;
-    _sendPort = null;
+    _dataPort.close();
+    _dataPort = null;
     _reqId = 0;
     _signalDoneLoading();
   }
 }
 
 
 void _handleLoaderReply(msg) {
   int id = msg[0];
   var dataOrError = msg[1];
   assert((id >= 0) && (id < _reqId));
@@ skipping 20 matching lines @@
     // 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, s);
   }
 }
 
 
 void _startLoadRequest(int tag, String uri, Uri resourceUri, context) {
-  if (_receivePort == null) {
+  if (_dataPort == null) {
     if (_traceLoading) {
       _log("Initializing load port.");
     }
-    assert(_receivePort == null);
-    assert(_sendPort == null);
-    _receivePort = new RawReceivePort(_handleLoaderReply);
-    _sendPort = _receivePort.sendPort;
+    assert(_dataPort == null);
+    _dataPort = new RawReceivePort(_handleLoaderReply);
   }
   // Register the load request and send it to the VM service isolate.
-  var curId = _reqId++;
+  var req = new _LoadRequest(tag, uri, resourceUri, context);
 
-  assert(_reqMap[curId] == null);
-  _reqMap[curId] = new _LoadRequest(curId, tag, uri, resourceUri, context);
-
-  assert(_receivePort != null);
-  assert(_sendPort != null);
-
+  assert(_dataPort != null);
   var msg = new List(4);
-  msg[0] = _sendPort;
+  msg[0] = _dataPort.sendPort;
   msg[1] = _traceLoading;
-  msg[2] = curId;
+  msg[2] = req._id;
   msg[3] = resourceUri.toString();
   _loadPort.send(msg);
 
   if (_traceLoading) {
-    _log("Loading of $resourceUri for $uri started with id: $curId. "
+    _log("Loading of $resourceUri for $uri started with id: ${req._id}. "
          "${_reqMap.length} requests remaining, "
          "${_pendingPackageLoads.length} packages pending.");
   }
 }
 
 
 RawReceivePort _packagesPort;
 
 void _handlePackagesReply(msg) {
   // Make sure to close the _packagePort before any other action.
@@ skipping 20 matching lines @@
       // 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.
   while (_pendingPackageLoads.length > 0) {
+    // Order does not matter as we queue all of the requests up right now.
     var req = _pendingPackageLoads.removeLast();
-    if (req != null) {
-      if (_traceLoading) {
-        _log("Handling deferred load request: $req");
-      }
-      _loadPackage(req._tag, req._uri, req._resourceUri, req._context);
-    } else {
-      if (_traceLoading) {
-        _log("Skipping dummy deferred request.");
-      }
-    }
+    // Call the registered closure, to handle the delayed action.
+    req();
   }
   // Reset the pending package loads to empty. So that we eventually can
   // finish loading.
   _pendingPackageLoads = [];
   // Make sure that the receive port is closed if no other loads are pending.
   _finishLoadRequest(null);
 }
 
 
 void _requestPackagesMap() {
@@ skipping 51 matching lines @@
 
   var msg = new List(4);
   msg[0] = sp;
   msg[1] = _traceLoading;
   msg[2] = -2;
   msg[3] = packagesUri.toString();
   _loadPort.send(msg);
 
   // 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);
+  _pendingPackageLoads.add(() {
+    // Nothing to be done beyond registering that there is pending package
+    // resolution requested by having an empty entry.
+    if (_traceLoading) {
+      _log("Skipping dummy deferred request.");
+    }
+  });
 
   if (_traceLoading) {
     _log("Requested packages map at '$packagesUri'.");
   }
 }
 
 
 void _asyncLoadError(_LoadRequest req, _LoadError error, StackTrace stack) {
   if (_traceLoading) {
     _log("_asyncLoadError(${req._uri}), error: $error\nstack: $stack");
@@ skipping 16 matching lines @@
 
 _loadDataFromLoadPort(int tag, String uri, Uri resourceUri, context) {
   try {
     _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, context, error, s);
+    var error = (e is _LoadError) ? e : new _LoadError(uri, e.toString());
+    // Register a dummy load request and fail to load it.
+    var req = new _LoadRequest(tag, uri, resourceUri, context);
+    _asyncLoadError(req, error, s);
   }
 }
 
 
 // Loading a package URI needs to first map the package name to a loadable
 // URI.
 _loadPackage(int tag, String uri, Uri resourceUri, context) {
   if (_packagesReady()) {
     _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, resourceUri, context);
-    _pendingPackageLoads.add(req);
+    // Register the action of loading this package once the package resolution
+    // is ready.
+    _pendingPackageLoads.add(() {
+      if (_traceLoading) {
+        _log("Handling deferred package request: "
+             "$tag, $uri, $resourceUri, $context");
+      }
+      _loadPackage(tag, uri, resourceUri, context);
+    });
     if (_traceLoading) {
       _log("Pending package load of '$uri': "
       "${_pendingPackageLoads.length} pending");
     }
   }
 }
 
 
 // Load the data associated with the resourceUri.
 _loadData(int tag, String uri, Uri resourceUri, context) {
@@ skipping 43 matching lines @@
   } else {
     result = baseUri.resolve(userString).toString();
   }
   if (_traceLoading) {
     _log('Resolved $userString in $base to $result');
   }
   return result;
 }
 
 
+// Handling of access to the package root or package map from user code.
+_triggerPackageResolution(action) {
+  if (_packagesReady()) {
+    // Packages are ready. Execute the action now.
+    action();
+  } else {
+    if (_pendingPackageLoads.isEmpty) {
+      // Package resolution has not been setup yet, and this is the first
+      // request for package resolution & loading.
+      _requestPackagesMap();
+    }
+    // Register the action for when the package resolution is ready.
+    _pendingPackageLoads.add(action);
+  }
+}
+
+
+Future<Uri> _getPackageRoot() {
+  if (_traceLoading) {
+    _log("Request for package root from user code.");
+  }
+  var completer = new Completer<Uri>();
+  _triggerPackageResolution(() {
+    completer.complete(_packageRoot);
+  });
+  return completer.future;
+}
+
+
+Future<Map<String, Uri>> _getPackageMap() {
+  if (_traceLoading) {
+    _log("Request for package map from user code.");
+  }
+  var completer = new Completer<Map<String, Uri>>();
+  _triggerPackageResolution(() {
+    var result = (_packageMap != null) ? new Map.from(_packageMap) : {};
+    completer.complete(result);
+  });
+  return completer.future;
+}
+
+
 // 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;
 }
 
@@ skipping 107 matching lines @@
   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;
+  VMLibraryHooks.getPackageRoot = _getPackageRoot;
+  VMLibraryHooks.getPackageMap = _getPackageMap;
 }