Format all files under tools and utils directory.

tools/dom/src/dart2js_CustomElementSupport.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 dart.dom.html;
 
 _callConstructor(constructor, interceptor) {
   return (receiver) {
     setNativeSubclassDispatchRecord(receiver, interceptor);
 
     // Mirrors uses the constructor property to cache lookups, so we need it to
     // be set correctly, including on IE where it is not automatically picked
     // up from the __proto__.
     JS('', '#.constructor = #.__proto__.constructor', receiver, receiver);
     return JS('', '#(#)', constructor, receiver);
   };
 }
 
 _callAttached(receiver) {
   return receiver.attached();
 }
 
 _callDetached(receiver) {
   return receiver.detached();
 }
- _callAttributeChanged(receiver, name, oldValue, newValue) {
+
+_callAttributeChanged(receiver, name, oldValue, newValue) {
   return receiver.attributeChanged(name, oldValue, newValue);
 }
 
 _makeCallbackMethod(callback) {
-  return JS('',
+  return JS(
+      '',
       '''((function(invokeCallback) {
              return function() {
                return invokeCallback(this);
              };
           })(#))''',
       convertDartClosureToJS(callback, 1));
 }
 
 _makeCallbackMethod3(callback) {
-  return JS('',
+  return JS(
+      '',
       '''((function(invokeCallback) {
              return function(arg1, arg2, arg3) {
                return invokeCallback(this, arg1, arg2, arg3);
              };
           })(#))''',
       convertDartClosureToJS(callback, 4));
 }
 
 /// Checks whether the given [element] correctly extends from the native class
 /// with the given [baseClassName]. This method will throw if the base class
 /// doesn't match, except when the element extends from `template` and it's base
 /// class is `HTMLUnknownElement`. This exclusion is needed to support extension
 /// of template elements (used heavily in Polymer 1.0) on IE11 when using the
 /// webcomponents-lite.js polyfill.
 void _checkExtendsNativeClassOrTemplate(
     Element element, String extendsTag, String baseClassName) {
   if (!JS('bool', '(# instanceof window[#])', element, baseClassName) &&
       !((extendsTag == 'template' &&
-       JS('bool', '(# instanceof window["HTMLUnknownElement"])', element)))) {
+          JS('bool', '(# instanceof window["HTMLUnknownElement"])',
+              element)))) {
     throw new UnsupportedError('extendsTag does not match base native class');
   }
 }
 
-void _registerCustomElement(context, document, String tag, Type type,
-    String extendsTagName) {
+void _registerCustomElement(
+    context, document, String tag, Type type, String extendsTagName) {
   // Function follows the same pattern as the following JavaScript code for
   // registering a custom element.
   //
   //    var proto = Object.create(HTMLElement.prototype, {
   //        createdCallback: {
   //          value: function() {
   //            window.console.log('here');
   //          }
   //        }
   //    });
@@ skipping 29 matching lines @@
     }
   } else {
     var element = document.createElement(extendsTagName);
     _checkExtendsNativeClassOrTemplate(element, extendsTagName, baseClassName);
   }
 
   var baseConstructor = JS('=Object', '#[#]', context, baseClassName);
 
   var properties = JS('=Object', '{}');
 
-  JS('void', '#.createdCallback = #', properties,
+  JS(
+      'void',
+      '#.createdCallback = #',
+      properties,
       JS('=Object', '{value: #}',
           _makeCallbackMethod(_callConstructor(constructor, interceptor))));
   JS('void', '#.attachedCallback = #', properties,
       JS('=Object', '{value: #}', _makeCallbackMethod(_callAttached)));
   JS('void', '#.detachedCallback = #', properties,
       JS('=Object', '{value: #}', _makeCallbackMethod(_callDetached)));
   JS('void', '#.attributeChangedCallback = #', properties,
       JS('=Object', '{value: #}', _makeCallbackMethod3(_callAttributeChanged)));
 
   var baseProto = JS('=Object', '#.prototype', baseConstructor);
@@ skipping 60 matching lines @@
     // Only exact type matches are supported- cannot be a subclass.
     if (element.runtimeType != _nativeType) {
       throw new ArgumentError('element is not subclass of $_nativeType');
     }
 
     setNativeSubclassDispatchRecord(element, _interceptor);
     JS('', '#(#)', _constructor, element);
     return element;
   }
 }