Reorganize mdv and observe packages

pkg/observe/lib/src/observable_list.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 mdv_observe;
+part of observe;
 
 /**
  * Represents an observable list of model values. If any items are added,
  * removed, or replaced, then observers that are listening to [changes]
  * will be notified.
  */
 // TODO(jmesserly): remove implements List<E> once we can extend ListBase<E>
 class ObservableList<E> extends _ListBaseWorkaround with ObservableMixin
     implements List<E> {
   List<ListChangeRecord> _records;
 
-  static const _LENGTH = const Symbol('length');
-
   /** The inner [List<E>] with the actual storage. */
   final List<E> _list;
 
   /**
    * Creates an observable list of the given [length].
    *
    * If no [length] argument is supplied an extendable list of
    * length 0 is created.
    *
    * If a [length] argument is supplied, a fixed size list of that
    * length is created.
    */
   ObservableList([int length])
       : _list = length != null ? new List<E>(length) : <E>[];
 
   /**
    * Creates an observable list with the elements of [other]. The order in
    * the list will be the order provided by the iterator of [other].
    */
   factory ObservableList.from(Iterable<E> other) =>
       new ObservableList<E>()..addAll(other);
 
-  // TODO(jmesserly): remove once we have mirrors
-  getValueWorkaround(key) => key == _LENGTH ? length : null;
-
-  setValueWorkaround(key, value) {
-    if (key == _LENGTH) length = value;
-  }
-
   int get length => _list.length;
 
   set length(int value) {
     int len = _list.length;
     if (len == value) return;
 
     // Produce notifications if needed
     if (hasObservers) {
       if (value < len) {
         // Remove items, then adjust length. Note the reverse order.
@@ skipping 165 matching lines @@
   // list modifications.
   // One simple idea: we can simply update the index map as we do the operations
   // to the list, then produce the records at the end.
   void _summarizeRecords() {
     int oldLength = length;
     for (var r in _records) {
       oldLength += r.removedCount - r.addedCount;
     }
 
     if (length != oldLength) {
-      notifyPropertyChange(_LENGTH, oldLength, length);
+      notifyPropertyChange(const Symbol('length'), oldLength, length);
     }
 
     if (_records.length == 1) {
       notifyChange(_records[0]);
       _records = null;
       return;
     }
 
     var items = [];
     for (int i = 0; i < oldLength; i++) items.add(i);
@@ skipping 36 matching lines @@
       }
 
       offset += removed - added;
     }
   }
 }
 
 // TODO(jmesserly): bogus type to workaround spurious VM bug with generic base
 // class and mixins.
 abstract class _ListBaseWorkaround extends ListBase<dynamic> {}