Bring back initPolymer, allow boot.js only if using "polymer_experimental.html".

pkg/polymer/lib/src/loader.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;
 
 /// Annotation used to automatically register polymer elements.
 class CustomTag {
   final String tagName;
   const CustomTag(this.tagName);
 }
 
 /// Metadata used to label static or top-level methods that are called
 /// automatically when loading the library of a custom element.
 const initMethod = const InitMethodAnnotation();
 
 /// Implementation behind [initMethod]. Only exposed for internal implementation
 /// details
 class InitMethodAnnotation {
   const InitMethodAnnotation();
 }
 
-/// This method is deprecated. It used to be where polymer initialization
-/// happens, now this is done automatically from bootstrap.dart.
-@deprecated
+/// Initializes a polymer application as follows:
+///   * if running in development mode, set up a dirty-checking zone that polls
+///     for observable changes
+///   * initialize template binding and polymer-element
+///   * Include some style to prevent flash of unstyled content (FOUC)

[Jennifer Messerly, 2014/05/23 07:20:06]

just curious, is the FOUC code still there? I thought it was mostly gone now
(well, it's there but handled purely in JS). I could be wrong tho.... maybe I'm
thinking of my ported changes

[Siggi Cherem (dart-lang), 2014/05/23 17:56:33]

Good point. This commment came with the revert, but I didn't check if it was
accurate still. Done.

+///   * for each library included transitively from HTML and HTML imports,
+///   register custom elements declared there (labeled with [CustomTag]) and
+///   invoke the initialization method on it (top-level functions annotated with
+///   [initMethod]).
 Zone initPolymer() {
-  window.console.error(_ERROR);
-  return Zone.current;
+  if (loader.deployMode) {
+    startPolymer(loader.initializers, loader.deployMode);
+    return Zone.current;
+  }
+  return dirtyCheckZone()..run(
+      () => startPolymer(loader.initializers, loader.deployMode));
 }
 
-const _ERROR = '''
-initPolymer is now deprecated. To initialize a polymer app:
-  * add to your page: <link rel="import" href="packages/polymer/polymer.html">
-  * replace "application/dart" mime-types with "application/dart;component=1"
-  * if you use "init.dart", remove it
-  * if you have a main, change it into a method annotated with @initMethod
-''';
-
 /// True if we're in deployment mode.
 bool _deployMode = false;
 
+bool _startPolymerCalled = false;
+
 /// Starts polymer by running all [initializers] and hooking the polymer.js
 /// code. **Note**: this function is not meant to be invoked directly by
-/// application developers. It is invoked by a bootstrap entry point that is
-/// automatically generated. During development, this entry point is generated
-/// dynamically in `boot.js`. Similarly, pub-build generates this entry point
-/// for deployment.
+/// application developers. It is invoked either by [initPolymer] or, if you are
+/// using the experimental bootstrap API, this would be invoked by an entry
+/// point that is automatically generated somehow. In particular, during
+/// development, the entry point would be generated dynamically in `boot.js`.
+/// Similarly, pub-build would generate the entry point for deployment.
 void startPolymer(List<Function> initializers, [bool deployMode = true]) {
+  if (_startPolymerCalled) throw 'Initialization was already done.';
+  _startPolymerCalled = true;
   _hookJsPolymer();
   _deployMode = deployMode;
 
   for (var initializer in initializers) {
     initializer();
   }
 }
 
+/// Configures [initPolymer] making it optimized for deployment to the internet.
+/// With this setup the initializer list is supplied instead of searched for
+/// at runtime. Additionally, after this method is called [initPolymer] omits
+/// the [Zone] that automatically invokes [Observable.dirtyCheck].
+void configureForDeployment(List<Function> initializers) {
+  loader.initializers = initializers;
+  loader.deployMode = true;
+}
+
 /// To ensure Dart can interoperate with polymer-element registered by
 /// polymer.js, we need to be able to execute Dart code if we are registering
 /// a Dart class for that element. We trigger Dart logic by patching
 /// polymer-element's register function and:
 ///
 /// * if it has a Dart class, run PolymerDeclaration's register.
 /// * otherwise it is a JS prototype, run polymer-element's normal register.
 void _hookJsPolymer() {
   var polymerJs = js.context['Polymer'];
   if (polymerJs == null) {
@@ skipping 31 matching lines @@
       final extendsDecl = _getDeclaration(extendee);
       return zone.run(() =>
           new PolymerDeclaration(jsElem, name, type, extendsDecl).register());
     }
     // It's a JavaScript polymer element, fall back to the original register.
     return originalRegister.apply([name, extendee], thisArg: jsElem);
   }
 
   proto['register'] = new JsFunction.withThis(registerDart);
 }