pkg/logging: removed deprecated 'on' API

pkg/logging/lib/logging.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.
 
 /**
  * Provides APIs for debugging and error logging. This library introduces
  * abstractions similar to those used in other languages, such as the Closure JS
  * Logger and java.util.logging.Logger.
  */
 library logging;
 
 import 'dart:async';
 
-import '../../meta/lib/meta.dart';
-
 /**
  * Whether to allow fine-grain logging and configuration of loggers in a
  * hierarchy. When false, all logging is merged in the root logger.
  */
 bool hierarchicalLoggingEnabled = false;
 
 /**
  * Level for the root-logger. This will be the level of all loggers if
  * [hierarchicalLoggingEnabled] is false.
  */
@@ skipping 17 matching lines @@
 
   /** Logging [Level] used for entries generated on this logger. */
   Level _level;
 
   /** Children in the hierarchy of loggers, indexed by their simple names. */
   Map<String, Logger> children;
 
   /** Controller used to notify when log entries are added to this logger. */
   StreamController<LogRecord> _controller;
 
-  // TODO(sigmund): remove together with the deprecated [on] API.
-  Map<LoggerHandler, StreamSubscription> _deprecatedSubscriptions;
-
   /**
    * Singleton constructor. Calling `new Logger(name)` will return the same
    * actual instance whenever it is called with the same string name.
    */
   factory Logger(String name) {
     if (name.startsWith('.')) {
       throw new ArgumentError("name shouldn't start with a '.'");
     }
     if (_loggers == null) _loggers = <String, Logger>{};
     if (_loggers.containsKey(name)) return _loggers[name];
@@ skipping 39 matching lines @@
       if (parent != null) {
         throw new UnsupportedError(
             'Please set "hierarchicalLoggingEnabled" to true if you want to '
             'change the level on a non-root logger.');
       }
       _rootLevel = value;
     }
   }
 
   /**
-   * Returns an event manager for this [Logger]. You can listen for log messages
-   * by adding a [LoggerHandler] to an event from the event manager, for
-   * instance:
-   *    logger.on.record.add((record) { ... });
-   *
-   * This API is Deprecated. Use [onRecord] instead.
-   */
-  @deprecated
-  LoggerEvents get on => new LoggerEvents(this);
-
-  /**
    * Returns an stream of messages added to this [Logger]. You can listen for
    * messages using the standard stream APIs, for instance:
    *    logger.onRecord.listen((record) { ... });
    */
   Stream<LogRecord> get onRecord => _getStream();
 
   void clearListeners() {
     if (hierarchicalLoggingEnabled || parent == null) {
       if (_controller != null) {
         _controller.close();
@@ skipping 58 matching lines @@
     if (hierarchicalLoggingEnabled || parent == null) {
       if (_controller == null) {
         _controller = new StreamController<LogRecord>.broadcast();
       }
       return _controller.stream;
     } else {
       return root._getStream();
     }
   }
 
-  /** Adds a handler to listen whenever a log record is added to this logger. */
-  void _addHandler(LoggerHandler handler) {
-    if (_deprecatedSubscriptions == null) {
-      _deprecatedSubscriptions = new Map<LoggerHandler, StreamSubscription>();
-    }
-
-    _deprecatedSubscriptions[handler] = onRecord.listen(handler);
-  }
-
-  void _removeHandler(LoggerHandler handler) {
-    if (_deprecatedSubscriptions != null) {
-      var sub = _deprecatedSubscriptions.remove(handler);
-      if (sub != null) {
-        sub.cancel();
-      }
-      if (_deprecatedSubscriptions.isEmpty) {
-        _deprecatedSubscriptions = null;
-      }
-    }
-  }
-
   void _publish(LogRecord record) {
     if (_controller != null) {
       _controller.add(record);
     }
   }
 
   /** Top-level root [Logger]. */
   static Logger get root => new Logger('');
 
   /** All [Logger]s in the system. */
   static Map<String, Logger> _loggers;
 }
 
 
 /** Handler callback to process log entries as they are added to a [Logger]. */
 typedef void LoggerHandler(LogRecord);
 
-
-/** Event manager for a [Logger] (holds events that a [Logger] can fire). */
-class LoggerEvents {
-  final Logger _logger;
-
-  LoggerEvents(this._logger);
-
-  /** Event fired when a log record is added to a [Logger]. */
-  LoggerHandlerList get record => new LoggerHandlerList(_logger);
-}
-
-
-/** List of handlers that will be called on a logger event. */
-class LoggerHandlerList {
-  Logger _logger;
-
-  LoggerHandlerList(this._logger);
-
-  void add(LoggerHandler handler) => _logger._addHandler(handler);
-  void remove(LoggerHandler handler) => _logger._removeHandler(handler);
-  void clear() => _logger.clearListeners();
-}
-
-
 /**
  * [Level]s to control logging output. Logging can be enabled to include all
  * levels above certain [Level]. [Level]s are ordered using an integer
  * value [Level.value]. The predefined [Level] constants below are sorted as
  * follows (in descending order): [Level.SHOUT], [Level.SEVERE],
  * [Level.WARNING], [Level.INFO], [Level.CONFIG], [Level.FINE], [Level.FINER],
  * [Level.FINEST], and [Level.ALL].
  *
  * We recommend using one of the predefined logging levels. If you define your
  * own level, make sure you use a value between those used in [Level.ALL] and
@@ skipping 77 matching lines @@
 
   /** Associated exception message (if any) when recording errors messages. */
   String exceptionText;
 
   LogRecord(
       this.level, this.message, this.loggerName,
       [time, this.exception, this.exceptionText]) :
     this.time = (time == null) ? new DateTime.now() : time,
     this.sequenceNumber = LogRecord._nextNumber++;
 }