Remove debug logging from builtin.

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) {
   _Logger._printString(arg.toString());
 }
 
 
 class _Logger {
   static void _printString(String s) native "Logger_PrintString";
 }
 
 
 _getPrintClosure() => _print;
 
-
-void _logResolution(String msg) {
-  final enabled = false;
-  if (enabled) {
-    _Logger._printString(msg);
-  }
-}
-
+const _logBuiltin = false;
 
 // Corelib 'Uri.base' implementation.
 Uri _uriBase() {
   return new Uri.file(Directory.current.path + "/");
 }
 
 
 _getUriBaseClosure() => _uriBase;
 
 
@@ skipping 57 matching lines @@
   }
   return null;
 }
 
 
 void _setWorkingDirectory(cwd) {
   _workingWindowsDrivePrefix = _extractDriveLetterPrefix(cwd);
   cwd = _sanitizeWindowsPath(cwd);
   cwd = _enforceTrailingSlash(cwd);
   _workingDirectoryUri = new Uri(scheme: 'file', path: cwd);
-  _logResolution('# Working Directory: $cwd');
+  if (_logBuiltin) {
+    _print('# Working Directory: $cwd');
+  }
 }
 
 
 _setPackageRoot(String packageRoot) {
   packageRoot = _enforceTrailingSlash(packageRoot);
   if (packageRoot.startsWith('file:') ||
       packageRoot.startsWith('http:') ||
       packageRoot.startsWith('https:')) {
     _packageRoot = _workingDirectoryUri.resolve(packageRoot);
   } else {
     _packageRoot = _workingDirectoryUri.resolveUri(new Uri.file(packageRoot));
   }
-  _logResolution('# Package root: $packageRoot -> $_packageRoot');
+  if (_logBuiltin) {
+    _print('# Package root: $packageRoot -> $_packageRoot');
+  }
 }
 
 
 String _resolveScriptUri(String scriptName) {
   if (_workingDirectoryUri == null) {
     throw 'No current working directory set.';
   }
   scriptName = _sanitizeWindowsPath(scriptName);
 
   var scriptUri = Uri.parse(scriptName);
   if (scriptUri.scheme != '') {
     // Script has a scheme, assume that it is fully formed.
     _entryPointScript = scriptUri;
   } else {
     // Script does not have a scheme, assume that it is a path,
     // resolve it against the working directory.
     _entryPointScript = _workingDirectoryUri.resolve(scriptName);
   }
-  _logResolution('# Resolved entry point to: $_entryPointScript');
+  if (_logBuiltin) {
+    _print('# Resolved entry point to: $_entryPointScript');
+  }
   return _entryPointScript.toString();
 }
 
 const _DART_EXT = 'dart-ext:';
 
 String _resolveUri(String base, String userString) {
-  _logResolution('# Resolving: $userString from $base');
+  if (_logBuiltin) {
+    _print('# Resolving: $userString from $base');
+  }
   var baseUri = Uri.parse(base);
   if (userString.startsWith(_DART_EXT)) {
     var uri = userString.substring(_DART_EXT.length);
     return '$_DART_EXT${baseUri.resolve(uri)}';
   } else {
     return baseUri.resolve(userString).toString();
   }
 }
 
 
 // Returns either a file path or a URI starting with http:, as a String.
 String _filePathFromUri(String userUri) {
   var uri = Uri.parse(userUri);
-  _logResolution('# Getting file path from: $uri');
+  if (_logBuiltin) {
+    _print('# Getting file path from: $uri');
+  }
 
   var path;
   switch (uri.scheme) {
     case '':
     case 'file':
       return uri.toFilePath();
     case 'package':
       return _filePathFromPackageUri(uri);
     case 'http':
       return uri.toString();
     default:
       // Only handling file, http, and package URIs
       // in standalone binary.
-      _logResolution('# Unknown scheme (${uri.scheme}) in $uri.');
+      if (_logBuiltin) {
+        _print('# Unknown scheme (${uri.scheme}) in $uri.');
+      }
       throw 'Not a known scheme: $uri';
   }
 }
 
 
 String _filePathFromPackageUri(Uri uri) {
   if (!uri.host.isEmpty) {
     var path = '${uri.host}${uri.path}';
     var right = 'package:$path';
     var wrong = 'package://$path';
@@ skipping 56 matching lines @@
 void _loadScriptCallback(int tag, String uri, String libraryUri, List<int> data)
     native "Builtin_LoadScript";
 
 void _loadScript(int tag, String uri, String libraryUri, List<int> data) {
   // TODO: Currently a compilation error while loading the script is
   // fatal for the isolate. _loadScriptCallback() does not return and
   // the _numOutstandingLoadRequests counter remains out of sync.
   _loadScriptCallback(tag, uri, libraryUri, data);
   assert(_numOutstandingLoadRequests > 0);
   _numOutstandingLoadRequests--;
-  _logResolution("native Builtin_LoadScript($uri) completed, "
-                 "${_numOutstandingLoadRequests} requests remaining");
+  if (_logBuiltin) {
+    _print("native Builtin_LoadScript($uri) completed, "
+           "${_numOutstandingLoadRequests} requests remaining");
+  }
   if (_numOutstandingLoadRequests == 0) {
     _signalDoneLoading();
     _cleanup();
   }
 }
 
 
 void _asyncLoadErrorCallback(uri, libraryUri, error)
     native "Builtin_AsyncLoadError";
 
 void _asyncLoadError(uri, libraryUri, error) {
   assert(_numOutstandingLoadRequests > 0);
-  _logResolution("_asyncLoadError($uri), error: $error");
+  if (_logBuiltin) {
+    _print("_asyncLoadError($uri), error: $error");
+  }
   _numOutstandingLoadRequests--;
   _asyncLoadErrorCallback(uri, libraryUri, error);
   if (_numOutstandingLoadRequests == 0) {
     _signalDoneLoading();
     _cleanup();
   }
 }
 
 
 // Create a Uri of 'userUri'. If the input uri is a package uri, then the
 // package uri is resolved.
 Uri _createUri(String userUri) {
   var uri = Uri.parse(userUri);
-  _logResolution('# Creating uri for: $uri');
+  if (_logBuiltin) {
+    _print('# Creating uri for: $uri');
+  }
 
   switch (uri.scheme) {
     case '':
     case 'file':
     case 'http':
       return uri;
     case 'package':
       return Uri.parse(_filePathFromPackageUri(uri));
     default:
       // Only handling file, http, and package URIs
       // in standalone binary.
       _logResolution('# Unknown scheme (${uri.scheme}) in $uri.');
       throw 'Not a known scheme: $uri';
   }
 }
 
 
 // Asynchronously loads script data through a http or file uri.
 _loadDataAsync(int tag, String uri, String libraryUri) {
   if (tag == null) {
     uri = _resolveScriptUri(uri);
   }
   Uri resourceUri = _createUri(uri);
   _numOutstandingLoadRequests++;
-  _logResolution("_loadDataAsync($uri), "
-                 "${_numOutstandingLoadRequests} requests outstanding");
+  if (_logBuiltin) {
+    _print("_loadDataAsync($uri), "
+           "${_numOutstandingLoadRequests} requests outstanding");
+  }
   if (resourceUri.scheme == 'http') {
     _httpGet(resourceUri, libraryUri, (data) {
       _loadScript(tag, uri, libraryUri, data);
     });
   } else {
     var sourceFile = new File(resourceUri.toFilePath());
     sourceFile.readAsBytes().then((data) {
       _loadScript(tag, uri, libraryUri, data);
     },
     onError: (e) {
@@ skipping 33 matching lines @@
 
   path = _filePathFromUri(path);
 
   if (Platform.isLinux || Platform.isAndroid) {
     filename = 'lib$name.so';
   } else if (Platform.isMacOS) {
     filename = 'lib$name.dylib';
   } else if (Platform.isWindows) {
     filename = '$name.dll';
   } else {
-    _logResolution(
-        'Native extensions not supported on ${Platform.operatingSystem}');
+    if (_logBuiltin) {
+      _print('Native extensions not supported on ${Platform.operatingSystem}');
+    }
     throw 'Native extensions not supported on ${Platform.operatingSystem}';
   }
 
   return [path, filename, name];
 }