fix PathObserver to avoid try+catch

pkg/observe/lib/src/change_notifier.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 observe;
+library observe.src.change_notifier;
+
+import 'dart:async';
+import 'dart:collection' show UnmodifiableListView;
+import 'package:observe/observe.dart';
+import 'package:observe/src/observable.dart' show notifyPropertyChangeHelper;
 
 /**
  * Mixin and base class for implementing an [Observable] object that performs
  * its own change notifications, and does not need to be considered by
  * [Observable.dirtyCheck].
  *
  * When a field, property, or indexable item is changed, a derived class should
  * call [notifyPropertyChange]. See that method for an example.
  */
 abstract class ChangeNotifier implements Observable {
   StreamController _changes;
   List<ChangeRecord> _records;
 
   Stream<List<ChangeRecord>> get changes {
     if (_changes == null) {
       _changes = new StreamController.broadcast(sync: true,
-          onListen: _observed, onCancel: _unobserved);
+          onListen: observed, onCancel: unobserved);
     }
     return _changes.stream;
   }
 
   // TODO(jmesserly): should these be public? They're useful lifecycle methods
   // for subclasses. Ideally they'd be protected.
   /**
    * Override this method to be called when the [changes] are first observed.
    */
-  void _observed() {}
+  void observed() {}
 
   /**
    * Override this method to be called when the [changes] are no longer being
    * observed.
    */
-  void _unobserved() {}
+  void unobserved() {}
 
   bool deliverChanges() {
     var records = _records;
     _records = null;
     if (hasObservers && records != null) {
       _changes.add(new UnmodifiableListView<ChangeRecord>(records));
       return true;
     }
     return false;
   }
@@ skipping 13 matching lines @@
    * For convenience this returns [newValue]. This makes it easy to use in a
    * setter:
    *
    *     var _myField;
    *     @reflectable get myField => _myField;
    *     @reflectable set myField(value) {
    *       _myField = notifyPropertyChange(#myField, _myField, value);
    *     }
    */
   notifyPropertyChange(Symbol field, Object oldValue, Object newValue)
-      => _notifyPropertyChange(this, field, oldValue, newValue);
+      => notifyPropertyChangeHelper(this, field, oldValue, newValue);
 
   void notifyChange(ChangeRecord record) {
     if (!hasObservers) return;
 
     if (_records == null) {
       _records = [];
       scheduleMicrotask(deliverChanges);
     }
     _records.add(record);
   }
 }