Make print interceptable.

sdk/lib/async/zone.dart

 // Copyright (c) 2013, 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.
 
 part of dart.async;
 
 typedef dynamic ZoneCallback();
 typedef dynamic ZoneUnaryCallback(arg);
 typedef dynamic ZoneBinaryCallback(arg1, arg2);
 
@@ skipping 13 matching lines @@
 typedef void ScheduleMicrotaskHandler(
     Zone self, ZoneDelegate parent, Zone zone, f());
 @deprecated
 typedef void RunAsyncHandler(
     Zone self, ZoneDelegate parent, Zone zone, f());
 typedef Timer CreateTimerHandler(
     Zone self, ZoneDelegate parent, Zone zone, Duration duration, void f());
 typedef Timer CreatePeriodicTimerHandler(
     Zone self, ZoneDelegate parent, Zone zone,
     Duration period, void f(Timer timer));
+typedef void PrintHandler(
+    Zone self, ZoneDelegate parent, Zone zone, String line);
 typedef Zone ForkHandler(Zone self, ZoneDelegate parent, Zone zone,
                          ZoneSpecification specification,
                          Map<Symbol, dynamic> zoneValues);
 
 /**
  * This class provides the specification for a forked zone.
  *
  * When forking a new zone (see [Zone.fork]) one can override the default
  * behavior of the zone by providing callbacks. These callbacks must be
  * given in an instance of this class.
@@ skipping 31 matching lines @@
     ZoneBinaryCallback registerBinaryCallback(
         Zone self, ZoneDelegate parent, Zone zone, f(arg1, arg2)): null,
     void scheduleMicrotask(
         Zone self, ZoneDelegate parent, Zone zone, f()): null,
     void runAsync(
         Zone self, ZoneDelegate parent, Zone zone, f()): null,
     Timer createTimer(Zone self, ZoneDelegate parent, Zone zone,
                       Duration duration, void f()): null,
     Timer createPeriodicTimer(Zone self, ZoneDelegate parent, Zone zone,
                               Duration period, void f(Timer timer)): null,
+    void print(Zone self, ZoneDelegate parent, Zone zone, String line): null,
     Zone fork(Zone self, ZoneDelegate parent, Zone zone,
               ZoneSpecification specification, Map zoneValues): null
   }) = _ZoneSpecification;
 
   /**
    * Creates a specification from [other] with the provided handlers overriding
    * the ones in [other].
    */
   factory ZoneSpecification.from(ZoneSpecification other, {
     dynamic handleUncaughtError(Zone self, ZoneDelegate parent, Zone zone,
@@ skipping 10 matching lines @@
     ZoneBinaryCallback registerBinaryCallback(
         Zone self, ZoneDelegate parent, Zone zone, f(arg1, arg2)): null,
     void scheduleMicrotask(
         Zone self, ZoneDelegate parent, Zone zone, f()): null,
     void runAsync(
         Zone self, ZoneDelegate parent, Zone zone, f()): null,
     Timer createTimer(Zone self, ZoneDelegate parent, Zone zone,
                       Duration duration, void f()): null,
     Timer createPeriodicTimer(Zone self, ZoneDelegate parent, Zone zone,
                               Duration period, void f(Timer timer)): null,
+    void print(Zone self, ZoneDelegate parent, Zone zone, String line): null,
     Zone fork(Zone self, ZoneDelegate parent, Zone zone,
               ZoneSpecification specification,
               Map<Symbol, dynamic> zoneValues): null
   }) {
     return new ZoneSpecification(
       handleUncaughtError: handleUncaughtError != null
                            ? handleUncaughtError
                            : other.handleUncaughtError,
       run: run != null ? run : other.run,
       runUnary: runUnary != null ? runUnary : other.runUnary,
       runBinary: runBinary != null ? runBinary : other.runBinary,
       registerCallback: registerCallback != null
                         ? registerCallback
                         : other.registerCallback,
       registerUnaryCallback: registerUnaryCallback != null
                          ? registerUnaryCallback
                          : other.registerUnaryCallback,
       registerBinaryCallback: registerBinaryCallback != null
                          ? registerBinaryCallback
                          : other.registerBinaryCallback,
       scheduleMicrotask: scheduleMicrotask != null
                          ? scheduleMicrotask
                          : (runAsync != null
                             ? runAsync
                             : other.scheduleMicrotask),
       createTimer : createTimer != null ? createTimer : other.createTimer,
       createPeriodicTimer: createPeriodicTimer != null
                            ? createPeriodicTimer
                            : other.createPeriodicTimer,
+      print : print != null ? print : other.print,
       fork: fork != null ? fork : other.fork);
   }
 
   HandleUncaughtErrorHandler get handleUncaughtError;
   RunHandler get run;
   RunUnaryHandler get runUnary;
   RunBinaryHandler get runBinary;
   RegisterCallbackHandler get registerCallback;
   RegisterUnaryCallbackHandler get registerUnaryCallback;
   RegisterBinaryCallbackHandler get registerBinaryCallback;
   ScheduleMicrotaskHandler get scheduleMicrotask;
   @deprecated
   RunAsyncHandler get runAsync;
   CreateTimerHandler get createTimer;
   CreatePeriodicTimerHandler get createPeriodicTimer;
+  PrintHandler get print;
   ForkHandler get fork;
 }
 
 /**
  * Internal [ZoneSpecification] class.
  *
  * The implementation wants to rely on the fact that the getters cannot change
  * dynamically. We thus require users to go through the redirecting
  * [ZoneSpecification] constructor which instantiates this class.
  */
 class _ZoneSpecification implements ZoneSpecification {
   const _ZoneSpecification({
     this.handleUncaughtError: null,
     this.run: null,
     this.runUnary: null,
     this.runBinary: null,
     this.registerCallback: null,
     this.registerUnaryCallback: null,
     this.registerBinaryCallback: null,
     this.scheduleMicrotask: null,
     this.runAsync: null,
     this.createTimer: null,
     this.createPeriodicTimer: null,
+    this.print: null,
     this.fork: null
   });
 
   // TODO(13406): Enable types when dart2js supports it.
   final /*HandleUncaughtErrorHandler*/ handleUncaughtError;
   final /*RunHandler*/ run;
   final /*RunUnaryHandler*/ runUnary;
   final /*RunBinaryHandler*/ runBinary;
   final /*RegisterCallbackHandler*/ registerCallback;
   final /*RegisterUnaryCallbackHandler*/ registerUnaryCallback;
   final /*RegisterBinaryCallbackHandler*/ registerBinaryCallback;
   final /*ScheduleMicrotaskHandler*/ scheduleMicrotask;
   @deprecated
   final /*RunAsyncHandler*/ runAsync;
   final /*CreateTimerHandler*/ createTimer;
   final /*CreatePeriodicTimerHandler*/ createPeriodicTimer;
+  final /*PrintHandler*/ print;
   final /*ForkHandler*/ fork;
 }
 
 /**
  * This class wraps zones for delegation.
  *
  * When forwarding to parent zones one can't just invoke the parent zone's
  * exposed functions (like [Zone.run]), but one needs to provide more
  * information (like the zone the `run` was initiated). Zone callbacks thus
  * receive more information including this [ZoneDelegate] class. When delegating
  * to the parent zone one should go through the given instance instead of
  * directly invoking the parent zone.
  */
 abstract class ZoneDelegate {
   /// The [Zone] this class wraps.
   Zone get _zone;
 
   dynamic handleUncaughtError(Zone zone, error, StackTrace stackTrace);
   dynamic run(Zone zone, f());
   dynamic runUnary(Zone zone, f(arg), arg);
   dynamic runBinary(Zone zone, f(arg1, arg2), arg1, arg2);
   ZoneCallback registerCallback(Zone zone, f());
   ZoneUnaryCallback registerUnaryCallback(Zone zone, f(arg));
   ZoneBinaryCallback registerBinaryCallback(Zone zone, f(arg1, arg2));
   @deprecated
   void runAsync(Zone zone, f());
   void scheduleMicrotask(Zone zone, f());
   Timer createTimer(Zone zone, Duration duration, void f());
   Timer createPeriodicTimer(Zone zone, Duration period, void f(Timer timer));
+  void print(Zone zone, String line);
   Zone fork(Zone zone, ZoneSpecification specification, Map zoneValues);
 }
 
 /**
  * A Zone represents the asynchronous version of a dynamic extent. Asynchronous
  * callbacks are executed in the zone they have been queued in. For example,
  * the callback of a `future.then` is executed in the same zone as the one where
  * the `then` was invoked.
  */
 abstract class Zone {
@@ skipping 142 matching lines @@
    * Creates a Timer where the callback is executed in this zone.
    */
   Timer createTimer(Duration duration, void callback());
 
   /**
    * Creates a periodic Timer where the callback is executed in this zone.
    */
   Timer createPeriodicTimer(Duration period, void callback(Timer timer));
 
   /**
+   * Prints the given [line].
+   */
+  void print(String line);
+
+  /**
    * The error zone is the one that is responsible for dealing with uncaught
    * errors. Errors are not allowed to cross zones with different error-zones.
    */
   Zone get _errorZone;
 
   /**
    * Retrieves the zone-value associated with [key].
    *
    * If this zone does not contain the value looks up the same key in the
    * parent zone. If the [key] is not found returns `null`.
@@ skipping 101 matching lines @@
 
   Timer createPeriodicTimer(Zone zone, Duration period, void f(Timer timer)) {
     _BaseZone parent = _degelationTarget;
     while (parent._specification.createPeriodicTimer == null) {
       parent = parent.parent;
     }
     return (parent._specification.createPeriodicTimer)(
         parent, new _ZoneDelegate(parent.parent), zone, period, f);
   }
 
+  void print(Zone zone, String line) {
+    _CustomizedZone parent = _degelationTarget;

[Ivan Posva, 2013/10/16 07:19:51]

Why is this a _CustomizedZone when all the other code expects a _BaseZone for
the _delegationTarget?

[floitsch, 2013/10/16 07:38:56]

That was a bad merge and mistake. Had to do a follow-up CL to unbreak the build.

+    while (parent._specification.print == null) {
+      parent = parent.parent;
+    }
+    (parent._specification.print)(
+        parent, new _ZoneDelegate(parent.parent), zone, line);

[Ivan Posva, 2013/10/16 07:19:51]

See question below about repeatedly allocating _ZoneDelegates.

+  }
+
   Zone fork(Zone zone, ZoneSpecification specification,
             Map<Symbol, dynamic> zoneValues) {
     _BaseZone parent = _degelationTarget;
     while (parent._specification.fork == null) {
       parent = parent.parent;
     }
     _ZoneDelegate grandParent = new _ZoneDelegate(parent.parent);
     return (parent._specification.fork)(
         parent, grandParent, zone, specification, zoneValues);
   }
@@ skipping 143 matching lines @@
     scheduleMicrotask(f);
   }
 
   Timer createTimer(Duration duration, void f()) {
     return new _ZoneDelegate(this).createTimer(this, duration, f);
   }
 
   Timer createPeriodicTimer(Duration duration, void f(Timer timer)) {
     return new _ZoneDelegate(this).createPeriodicTimer(this, duration, f);
   }
+
+  void print(String line) {
+    new _ZoneDelegate(this).print(this, line);

[Ivan Posva, 2013/10/16 07:19:51]

I am wondering whether it is really necessary to allocate a new _ZoneDelegate
for each operation in a _CustomizedZone.

[floitsch, 2013/10/16 07:38:56]

It's not and on my TODO list.

+  }
 }
 
 void _rootHandleUncaughtError(
     Zone self, ZoneDelegate parent, Zone zone, error, StackTrace stackTrace) {
   _scheduleAsyncCallback(() {
     print("Uncaught Error: ${error}");
     var trace = stackTrace;
     if (trace == null) trace = getAttachedStackTrace(error);
     // Clear the attached stack trace (if any).
     _attachStackTrace(error, null);
@@ skipping 64 matching lines @@
                        Duration duration, void callback()) {
   return _createTimer(duration, callback);
 }
 
 Timer _rootCreatePeriodicTimer(
     Zone self, ZoneDelegate parent, Zone zone,
     Duration duration, void callback(Timer timer)) {
   return _createPeriodicTimer(duration, callback);
 }
 
+void _rootPrint(Zone self, ZoneDelegate parent, Zone zone, String line) {
+  printToConsole(line);
+}
+
+void _printToZone(String line) {
+  Zone.current.print(line);
+}
+
 Zone _rootFork(Zone self, ZoneDelegate parent, Zone zone,
                ZoneSpecification specification,
                Map<Symbol, dynamic> zoneValues) {
+  // TODO(floitsch): it would be nice if we could get rid of this hack.
+  // Change the static zoneOrDirectPrint function to go through zones
+  // from now on.
+  printToZone = _printToZone;
+
   if (specification == null) {
     specification = const ZoneSpecification();
   } else if (specification is! _ZoneSpecification) {
     throw new ArgumentError("ZoneSpecifications must be instantiated"
         " with the provided constructor.");
   }
   Map<Symbol, dynamic> copiedMap = new HashMap();
   if (zoneValues != null) {
     zoneValues.forEach((Symbol key, value) {
       if (key == null) {
@@ skipping 17 matching lines @@
   RegisterUnaryCallbackHandler get registerUnaryCallback =>
       _rootRegisterUnaryCallback;
   RegisterBinaryCallbackHandler get registerBinaryCallback =>
       _rootRegisterBinaryCallback;
   ScheduleMicrotaskHandler get scheduleMicrotask => _rootScheduleMicrotask;
   @deprecated
   RunAsyncHandler get runAsync => null;
   CreateTimerHandler get createTimer => _rootCreateTimer;
   CreatePeriodicTimerHandler get createPeriodicTimer =>
       _rootCreatePeriodicTimer;
+  PrintHandler get print => _rootPrint;
   ForkHandler get fork => _rootFork;
 }
 
 class _RootZone extends _BaseZone {
   const _RootZone();
 
   Zone get parent => null;
   ZoneSpecification get _specification => const _RootZoneSpecification();
   Zone get _errorZone => this;
 
@@ skipping 32 matching lines @@
   @deprecated
   void runAsync(void f()) {
     scheduleMicrotask(f);
   }
 
   Timer createTimer(Duration duration, void f()) =>
       _rootCreateTimer(this, null, this, duration, f);
 
   Timer createPeriodicTimer(Duration duration, void f(Timer timer)) =>
       _rootCreatePeriodicTimer(this, null, this, duration, f);
+
+  void print(String line) => _rootPrint(this, null, this, line);
 }
 
 const _ROOT_ZONE = const _RootZone();
 
 
 /**
  * Runs [body] in its own zone.
  *
  * If [onError] is non-null the zone is considered an error zone. All uncaught
  * errors, synchronous or asynchronous, in the zone are caught and handled
@@ skipping 109 matching lines @@
   ZoneSpecification specification =
     new ZoneSpecification(handleUncaughtError: errorHandler,
                           scheduleMicrotask: asyncHandler);
   Zone zone = Zone.current.fork(specification: specification);
   if (onError != null) {
     return zone.runGuarded(body);
   } else {
     return zone.run(body);
   }
 }