[dart:html] rename register to registerElement per spec

tests/html/custom/created_callback_test.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.
 
 library created_callback_test;
 import 'package:unittest/unittest.dart';
 import 'package:unittest/html_config.dart';
 import 'dart:html';
 import 'dart:js' as js;
 import '../utils.dart';
@@ skipping 47 matching lines @@
   useHtmlConfiguration();
 
   // Adapted from Blink's
   // fast/dom/custom/created-callback test.
 
   var registered = false;
   setUp(() {
     return customElementsReady.then((_) {
       if (!registered) {
         registered = true;
-        document.register(B.tag, B);
-        document.register(C.tag, C);
-        ErrorConstructorElement.register();
+        document.registerElement(B.tag, B);
+        document.registerElement(C.tag, C);
+        ErrorConstructorElement.registerElement();
       }
     });
   });
 
   test('transfer created callback', () {
-    document.register(A.tag, A);
+    document.registerElement(A.tag, A);
     var x = new A();
     expect(A.createdInvocations, 1);
   });
 
   test('unresolved and created callback timing', () {
     var div = new DivElement();
     C.div = div;
     div.setInnerHtml("""
 <x-c id="t"></x-c>
 <x-b id="u"></x-b>
@@ skipping 13 matching lines @@
       AccessWhileUpgradingElement.test);
 
   test('cannot call created constructor', () {
     expect(() {
       new B.created();
     }, throws);
   });
 
   test('cannot register without created', () {
     expect(() {
-      document.register(MissingCreatedElement.tag, MissingCreatedElement);
+      document.registerElement(MissingCreatedElement.tag,
+          MissingCreatedElement);
     }, throws);
   });
 
   test('throw on createElement does not upgrade', () {
     ErrorConstructorElement.callCount = 0;
 
     var e;
     expectGlobalError(() {
       e = new Element.tag(ErrorConstructorElement.tag);
     });
@@ skipping 21 matching lines @@
 
     var e = dummy.firstChild;
     // Accessing should not re-run the constructor.
     expect(ErrorConstructorElement.callCount, 1);
     expect(e is HtmlElement, isTrue);
     expect(e is ErrorConstructorElement, isFalse);
   });
 
   test('cannot register created with params', () {
     expect(() {
-      document.register('x-created-with-params', CreatedWithParametersElement);
+      document.registerElement('x-created-with-params',
+          CreatedWithParametersElement);
     }, throws);
   });
 
   test('created cannot be called from nested constructor',
       NestedCreatedConstructorElement.test);
 
 
   // TODO(vsm): Port additional test from upstream here:
   // http://src.chromium.org/viewvc/blink/trunk/LayoutTests/fast/dom/custom/created-callback.html?r1=156141&r2=156185
 }
 
 
 class NestedElement extends HtmlElement {
   static final tag = 'x-nested';
 
   final Element b = new B();
 
   factory NestedElement() => new Element.tag(tag);
   NestedElement.created() : super.created();
 
   static void register() {
-    document.register(tag, NestedElement);
+    document.registerElement(tag, NestedElement);
   }
 
   static void test() {
     register();
 
     var e = new NestedElement();
     expect(e.b, isNotNull);
     expect(e.b is B, isTrue);
     expect(e is NestedElement, isTrue);
   }
@@ skipping 11 matching lines @@
   factory AccessWhileUpgradingElement() => new Element.tag(tag);
   AccessWhileUpgradingElement.created() : super.created();
 
   static runInitializerCode() {
     upgradingContextChild = upgradingContext.firstChild;
 
     return 666;
   }
 
   static void register() {
-    document.register(tag, AccessWhileUpgradingElement);
+    document.registerElement(tag, AccessWhileUpgradingElement);
   }
 
   static void test() {
     register();
 
     upgradingContext = new DivElement();
     upgradingContext.setInnerHtml('<$tag></$tag>',
         treeSanitizer: new NullTreeSanitizer());
     var child = upgradingContext.firstChild;
 
@@ skipping 15 matching lines @@
   static int callCount = 0;
 
   factory ErrorConstructorElement() => new Element.tag(tag);
 
   ErrorConstructorElement.created() : super.created() {
     ++callCount;
     throw new Exception('Just messin with ya');
   }
 
   static void register() {
-    document.register(tag, ErrorConstructorElement);
+    document.registerElement(tag, ErrorConstructorElement);
   }
 }
 
 class NestedCreatedConstructorElement extends HtmlElement {
   static final tag = 'x-nested-created-constructor';
 
   // Should not be able to call this here.
   final B b = constructB();
   static B constructedB;
 
   factory NestedCreatedConstructorElement() => new Element.tag(tag);
   NestedCreatedConstructorElement.created() : super.created();
 
   static void register() {
-    document.register(tag, NestedCreatedConstructorElement);
+    document.registerElement(tag, NestedCreatedConstructorElement);
   }
 
   // Try to run the created constructor, and record the results.
   static constructB() {
     // This should throw an exception.
     constructedB = new B.created();
     return constructedB;
   }
 
   static void test() {
@@ skipping 22 matching lines @@
   } catch(e) {
     rethrow;
   } finally {
     js.context['testExpectsGlobalError'] = false;
   }
   var errors = js.context['testSuppressedGlobalErrors'];
   expect(errors['length'], 1);
   // Clear out the errors;
   js.context['testSuppressedGlobalErrors']['length'] = 0;
 }