First step towards asynchronous loading of sources

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;
 import 'dart:io';
 import 'dart:async';
+import 'dart:convert';
 // import 'root_library'; happens here from C Code
 
 // 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;
 
 
 // Corelib 'print' implementation.
 void _print(arg) {
@@ skipping 82 matching lines @@
   } catch (error) {
     _requestFailed(error);
   }
   // TODO(floitsch): remove this line. It's just here to push an event on the
   // event loop so that we invoke the scheduled microtasks. Also remove the
   // import of dart:async when this line is not needed anymore.
   Timer.run(() {});
 }
 
 
+void _httpGet(Uri uri, loadCallback(List<int> data)) {
+  var httpClient = new HttpClient();
+  try {
+    httpClient.getUrl(uri)
+      .then((HttpClientRequest request) {
+        request.persistentConnection = false;
+        return request.close();
+      })
+      .then((HttpClientResponse response) {
+        // Only create a ByteBuilder if multiple chunks are received.
+        var builder = new BytesBuilder(copy: false);
+        response.listen(
+            builder.add,
+            onDone: () {
+              if (response.statusCode != 200) {
+                var msg = 'Failure getting $uri: '
+                          '${response.statusCode} ${response.reasonPhrase}';
+                _asyncLoadError(uri.toString(), msg);
+              }
+
+              List<int> data = builder.takeBytes();
+              httpClient.close();
+              loadCallback(data);
+            },
+            onError: (error) {
+              _asyncLoadError(uri.toString(), error);
+            });
+      })
+      .catchError((error) {
+        _asyncLoadError(uri.toString(), error);
+      });
+  } catch (error) {
+    _asyncLoadError(uri.toString(), error);
+  }
+  // TODO(floitsch): remove this line. It's just here to push an event on the
+  // event loop so that we invoke the scheduled microtasks. Also remove the
+  // import of dart:async when this line is not needed anymore.
+  Timer.run(() {});
+}
+
+
 // Are we running on Windows?
 var _isWindows = false;
 var _workingWindowsDrivePrefix;
 // The current working directory
 var _workingDirectoryUri;
 // The URI that the entry point script was loaded from. Remembered so that
 // package imports can be resolved relative to it.
 var _entryPointScript;
 // The directory to look in to resolve "package:" scheme URIs.
 var _packageRoot;
@@ skipping 139 matching lines @@
           "'$right', not '$wrong'.";
   }
 
   var packageRoot = _packageRoot == null ?
                     _entryPointScript.resolve('packages/') :
                     _packageRoot;
   return _filePathFromUri(packageRoot.resolve(uri.path).toString());
 }
 
 
+void _loadScript(String uri, List<int> data) native "Builtin_LoadScript";
+
+void _asyncLoadError(uri, error) native "Builtin_AsyncLoadError";
+
+
+// Asynchronously loads script data (source or snapshot) through
+// an http or file uri.
+_loadDataAsync(String uri) {
+  uri = _resolveScriptUri(uri);
+  Uri sourceUri = Uri.parse(uri);
+  if (sourceUri.scheme == 'http') {
+    _httpGet(sourceUri, (data) {
+      _loadScript(uri, data);
+    });
+  } else {
+    _loadDataFromFileAsync(uri);
+  }
+}
+
+_loadDataFromFileAsync(String uri) {
+  var sourceFile = new File(_filePathFromUri(uri));
+  sourceFile.readAsBytes().then((data) {
+    _loadScript(uri, data);
+  },
+  onError: (e) {
+    _asyncLoadError(uri, e);
+  });
+}
+
+
+void _loadLibrarySource(tag, uri, libraryUri, text)
+    native "Builtin_LoadLibrarySource";
+
+_loadSourceAsync(int tag, String uri, String libraryUri) {
+  var filePath = _filePathFromUri(uri);
+  Uri sourceUri = Uri.parse(filePath);
+  if (sourceUri.scheme == 'http') {
+    _httpGet(sourceUri, (data) {
+      var text = UTF8.decode(data);
+      _loadLibrarySource(tag, uri, libraryUri, text);
+    });
+  } else {
+    var sourceFile = new File(filePath);
+    sourceFile.readAsString().then((text) {
+      _loadLibrarySource(tag, uri, libraryUri, text);
+    },
+    onError: (e) {
+      _asyncLoadError(uri, e);
+    });
+  }
+}
+
+
 // 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 (!userUri.startsWith(_DART_EXT)) {
     throw 'Unexpected internal error: Extension URI $userUri missing dart-ext:';
   }
   userUri = userUri.substring(_DART_EXT.length);
@@ skipping 25 matching lines @@
   } else if (Platform.isWindows) {
     filename = '$name.dll';
   } else {
     _logResolution(
         'Native extensions not supported on ${Platform.operatingSystem}');
     throw 'Native extensions not supported on ${Platform.operatingSystem}';
   }
 
   return [path, filename, name];
 }