Practically remove boot.js, adds the initialization from the Dart side of

pkg/polymer/lib/src/instance.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 polymer;
 
 /**
  * Use this annotation to publish a field as an attribute. For example:
  *
  *     class MyPlaybackElement extends PolymerElement {
@@ skipping 390 matching lines @@
     } else {
       // Cannot call super.bind because of
       // https://code.google.com/p/dart/issues/detail?id=13156
       // https://code.google.com/p/dart/issues/detail?id=12456
       return TemplateElement.mdvPackage(this).bind(name, model, path);
     }
   }
 
   void asyncUnbindAll() {
     if (_unbound == true) return;
-    _unbindLog.info('[$localName] asyncUnbindAll');
+    _unbindLog.fine('[$localName] asyncUnbindAll');
     _unbindAllJob = job(_unbindAllJob, unbindAll, const Duration(seconds: 0));
   }
 
   void unbindAll() {
     if (_unbound == true) return;
 
     unbindAllProperties();
     // Cannot call super.bind because of
     // https://code.google.com/p/dart/issues/detail?id=13156
     // https://code.google.com/p/dart/issues/detail?id=12456
     TemplateElement.mdvPackage(this).unbindAll();
 
     _unbindNodeTree(shadowRoot);
     // TODO(sjmiles): must also unbind inherited shadow roots
     _unbound = true;
   }
 
   void cancelUnbindAll({bool preventCascade}) {
     if (_unbound == true) {
       _unbindLog.warning(
           '[$localName] already unbound, cannot cancel unbindAll');
       return;
     }
-    _unbindLog.info('[$localName] cancelUnbindAll');
+    _unbindLog.fine('[$localName] cancelUnbindAll');
     if (_unbindAllJob != null) {
       _unbindAllJob.stop();
       _unbindAllJob = null;
     }
 
     // cancel unbinding our shadow tree iff we're not in the process of
     // cascading our tree (as we do, for example, when the element is inserted).
     if (preventCascade == true) return;
     _forNodeTree(shadowRoot, (n) {
       if (n is Polymer) {
@@ skipping 38 matching lines @@
     if (publish != null) {
       publish.forEach((name, value) {
         if (observe == null || !observe.containsKey(name)) {
           observeAttributeProperty(name);
         }
       });
     }
   }
 
   void _observe(String name, void callback(newValue, oldValue)) {
-    _observeLog.info('[$localName] watching [$name]');
+    _observeLog.fine('[$localName] watching [$name]');
     // TODO(jmesserly): this is a little different than the JS version so we
     // can pass the oldValue, which is missing from Dart's PathObserver.
     // This probably gives us worse performance.
     var path = new PathObserver(this, name);
     Object oldValue = null;
     _registerObserver(name, path.changes.listen((_) {
       final newValue = path.value;
       final old = oldValue;
       oldValue = newValue;
       callback(newValue, old);
@@ skipping 53 matching lines @@
       // apply Polymer two-way reference binding
       _bindProperties(this, name, model, path);
 
   /**
    * bind a property in A to a path in B by converting A[property] to a
    * getter/setter pair that accesses B[...path...]
    */
   static NodeBinding _bindProperties(Polymer inA, Symbol inProperty,
         Object inB, String inPath) {
 
-    if (_bindLog.isLoggable(Level.INFO)) {
-      _bindLog.info('[$inB]: bindProperties: [$inPath] to '
+    if (_bindLog.isLoggable(Level.FINE)) {
+      _bindLog.fine('[$inB]: bindProperties: [$inPath] to '
           '[${inA.localName}].[$inProperty]');
     }
 
     // Dart note: normally we only reach this code when we know it's a
     // property, but if someone uses bindProperty directly they might get a
     // NoSuchMethodError either from the getField below, or from the setField
     // inside PolymerBinding. That doesn't seem unreasonable, but it's a slight
     // difference from Polymer.js behavior.
 
     // capture A's value if B's value is null or undefined,
     // otherwise use B's value
     var path = new PathObserver(inB, inPath);
     if (path.value == null) {
       path.value = reflect(inA).getField(inProperty).reflectee;
     }
     return new _PolymerBinding(inA, inProperty, inB, inPath);
   }
 
   /** Attach event listeners on the host (this) element. */
   void addHostListeners() {
     var events = _declaration._eventDelegates;
     if (events.isEmpty) return;
 
-    if (_eventsLog.isLoggable(Level.INFO)) {
-      _eventsLog.info('[$localName] addHostListeners: $events');
+    if (_eventsLog.isLoggable(Level.FINE)) {
+      _eventsLog.fine('[$localName] addHostListeners: $events');
     }
     addNodeListeners(this, events.keys, hostEventListener);
   }
 
   /** Attach event listeners inside a shadow [root]. */
   void addInstanceListeners(ShadowRoot root, Element template) {
     var templateDelegates = _declaration._templateDelegates;
     if (templateDelegates == null) return;
     var events = templateDelegates[template];
     if (events == null) return;
 
-    if (_eventsLog.isLoggable(Level.INFO)) {
-      _eventsLog.info('[$localName] addInstanceListeners: $events');
+    if (_eventsLog.isLoggable(Level.FINE)) {
+      _eventsLog.fine('[$localName] addInstanceListeners: $events');
     }
     addNodeListeners(root, events, instanceEventListener);
   }
 
   void addNodeListeners(Node node, Iterable<String> events,
       void listener(Event e)) {
 
     for (var name in events) {
       addNodeListener(node, name, listener);
     }
   }
 
   void addNodeListener(Node node, String event, void listener(Event e)) {
     node.on[event].listen(listener);
   }
 
   void hostEventListener(Event event) {
     // TODO(jmesserly): do we need this check? It was using cancelBubble, see:
     // https://github.com/Polymer/polymer/issues/292
     if (!event.bubbles) return;
 
-    bool log = _eventsLog.isLoggable(Level.INFO);
+    bool log = _eventsLog.isLoggable(Level.FINE);
     if (log) {
-      _eventsLog.info('>>> [$localName]: hostEventListener(${event.type})');
+      _eventsLog.fine('>>> [$localName]: hostEventListener(${event.type})');
     }
 
     var h = findEventDelegate(event);
     if (h != null) {
-      if (log) _eventsLog.info('[$localName] found host handler name [$h]');
+      if (log) _eventsLog.fine('[$localName] found host handler name [$h]');
       var detail = event is CustomEvent ?
           (event as CustomEvent).detail : null;
       // TODO(jmesserly): cache the symbols?
       dispatchMethod(new Symbol(h), [event, detail, this]);
     }
 
     if (log) {
-      _eventsLog.info('<<< [$localName]: hostEventListener(${event.type})');
+      _eventsLog.fine('<<< [$localName]: hostEventListener(${event.type})');
     }
   }
 
   String findEventDelegate(Event event) =>
       _declaration._eventDelegates[_eventNameFromType(event.type)];
 
   /** Call [methodName] method on [this] with [args], if the method exists. */
   // TODO(jmesserly): I removed the [node] argument as it was unused. Reconcile.
   void dispatchMethod(Symbol methodName, List args) {
-    bool log = _eventsLog.isLoggable(Level.INFO);
-    if (log) _eventsLog.info('>>> [$localName]: dispatch $methodName');
+    bool log = _eventsLog.isLoggable(Level.FINE);
+    if (log) _eventsLog.fine('>>> [$localName]: dispatch $methodName');
 
     // TODO(sigmund): consider making event listeners list all arguments
     // explicitly. Unless VM mirrors are optimized first, this reflectClass call
     // will be expensive once custom elements extend directly from Element (see
     // dartbug.com/11108).
     var self = reflect(this);
     var method = self.type.methods[methodName];
     if (method != null) {
       // This will either truncate the argument list or extend it with extra
       // null arguments, so it will match the signature.
       // TODO(sigmund): consider accepting optional arguments when we can tell
       // them appart from named arguments (see http://dartbug.com/11334)
       args.length = method.parameters.where((p) => !p.isOptional).length;
     }
     self.invoke(methodName, args);
 
-    if (log) _eventsLog.info('<<< [$localName]: dispatch $methodName');
+    if (log) _eventsLog.fine('<<< [$localName]: dispatch $methodName');
 
     // TODO(jmesserly): workaround for HTML events not supporting zones.
     performMicrotaskCheckpoint();
   }
 
   void instanceEventListener(Event event) {
     _listenLocal(this, event);
   }
 
   // TODO(sjmiles): much of the below privatized only because of the vague
   // notion this code is too fiddly and we need to revisit the core feature
   void _listenLocal(Polymer host, Event event) {
     // TODO(jmesserly): do we need this check? It was using cancelBubble, see:
     // https://github.com/Polymer/polymer/issues/292
     if (!event.bubbles) return;
 
-    bool log = _eventsLog.isLoggable(Level.INFO);
-    if (log) _eventsLog.info('>>> [$localName]: listenLocal [${event.type}]');
+    bool log = _eventsLog.isLoggable(Level.FINE);
+    if (log) _eventsLog.fine('>>> [$localName]: listenLocal [${event.type}]');
 
     final eventOn = '$_EVENT_PREFIX${_eventNameFromType(event.type)}';
     if (event.path == null) {
       _listenLocalNoEventPath(host, event, eventOn);
     } else {
       _listenLocalEventPath(host, event, eventOn);
     }
 
-    if (log) _eventsLog.info('<<< [$localName]: listenLocal [${event.type}]');
+    if (log) _eventsLog.fine('<<< [$localName]: listenLocal [${event.type}]');
   }
 
   static void _listenLocalEventPath(Polymer host, Event event, String eventOn) {
     var c = null;
     for (var target in event.path) {
       // if we hit host, stop
       if (identical(target, host)) return;
 
       // find a controller for the target, unless we already found `host`
       // as a controller
       c = identical(c, host) ? c : _findController(target);
 
       // if we have a controller, dispatch the event, and stop if the handler
       // returns true
       if (c != null && _handleEvent(c, target, event, eventOn)) {
         return;
       }
     }
   }
 
   // TODO(sorvell): remove when ShadowDOM polyfill supports event path.
   // Note that _findController will not return the expected controller when the
   // event target is a distributed node.  This is because we cannot traverse
   // from a composed node to a node in shadowRoot.
   // This will be addressed via an event path api
   // https://www.w3.org/Bugs/Public/show_bug.cgi?id=21066
   static void _listenLocalNoEventPath(Polymer host, Event event,
       String eventOn) {
 
-    if (_eventsLog.isLoggable(Level.INFO)) {
-      _eventsLog.info('event.path() not supported for ${event.type}');
+    if (_eventsLog.isLoggable(Level.FINE)) {
+      _eventsLog.fine('event.path() not supported for ${event.type}');
     }
 
     var target = event.target;
     var c = null;
     // if we hit dirt or host, stop
     while (target != null && target != host) {
       // find a controller for target `t`, unless we already found `host`
       // as a controller
       c = identical(c, host) ? c : _findController(target);
 
@@ skipping 16 matching lines @@
   }
 
   static bool _handleEvent(Polymer ctrlr, Node node, Event event,
       String eventOn) {
 
     // Note: local events are listened only in the shadow root. This dynamic
     // lookup is used to distinguish determine whether the target actually has a
     // listener, and if so, to determine lazily what's the target method.
     var name = node is Element ? (node as Element).attributes[eventOn] : null;
     if (name != null && _handleIfNotHandled(node, event)) {
-      if (_eventsLog.isLoggable(Level.INFO)) {
-        _eventsLog.info('[${ctrlr.localName}] found handler name [$name]');
+      if (_eventsLog.isLoggable(Level.FINE)) {
+        _eventsLog.fine('[${ctrlr.localName}] found handler name [$name]');
       }
       var detail = event is CustomEvent ?
           (event as CustomEvent).detail : null;
 
       if (node != null) {
         // TODO(jmesserly): cache symbols?
         ctrlr.dispatchMethod(new Symbol(name), [event, detail, node]);
       }
     }
 
@@ skipping 161 matching lines @@
 /**
  * Base class for PolymerElements deriving from HtmlElement.
  *
  * See [Polymer].
  */
 class PolymerElement extends HtmlElement with Polymer, ObservableMixin {
   PolymerElement.created() : super.created() {
     polymerCreated();
   }
 }