DO NOT SUBMIT: what chrome/browser/resources/ could eventually look like with clang-format

chrome/browser/resources/extensions/extension_options_overlay.js

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Returns the width of a scrollbar in logical pixels.
 function getScrollbarWidth() {
   // Create nested divs with scrollbars.
   var outer = document.createElement('div');
   outer.style.width = '100px';
   outer.style.overflow = 'scroll';
@@ skipping 57 matching lines @@
 
     setInitialFocus: function() {
       this.getExtensionOptions_().focus();
     },
 
     /**
      * @return {?Element}
      * @private
      */
     getExtensionOptions_: function() {
-      return $('extension-options-overlay-guest').querySelector(
-          'extensionoptions');
+      return $('extension-options-overlay-guest')
+          .querySelector('extensionoptions');
     },
 
     /**
      * Handles a click on the close button.
      * @param {Event} event The click event.
      * @private
      */
     handleDismiss_: function(event) {
       this.setVisible_(false);
       var extensionoptions = this.getExtensionOptions_();
@@ skipping 10 matching lines @@
      * @param {string} extensionName The name of the extension, which is used
      *     as the header of the overlay.
      * @param {string} extensionIcon The URL of the extension's icon.
      * @param {function():void} shownCallback A function called when
      *     showing completes.
      * @suppress {checkTypes}
      * TODO(vitalyp): remove the suppression after adding
      * chrome/renderer/resources/extensions/extension_options.js
      * to dependencies.
      */
-    setExtensionAndShow: function(extensionId,
-                                  extensionName,
-                                  extensionIcon,
-                                  shownCallback) {
+    setExtensionAndShow: function(
+        extensionId, extensionName, extensionIcon, shownCallback) {
       var overlay = $('extension-options-overlay');
       var overlayHeader = $('extension-options-overlay-header');
       var overlayGuest = $('extension-options-overlay-guest');
       var overlayStyle = window.getComputedStyle(overlay);
 
       $('extension-options-overlay-title').textContent = extensionName;
       $('extension-options-overlay-icon').src = extensionIcon;
 
       this.setVisible_(true);
 
       var extensionoptions = new window.ExtensionOptions();
       extensionoptions.extension = extensionId;
       this.extensionId_ = extensionId;
 
       // The <extensionoptions> content's size needs to be restricted to the
       // bounds of the overlay window. The overlay gives a minWidth and
       // maxHeight, but the maxHeight does not include our header height (title
       // and close button), so we need to subtract that to get the maxHeight
       // for the extension options.
-      var maxHeight = parseInt(overlayStyle.maxHeight, 10) -
-                      overlayHeader.offsetHeight;
+      var maxHeight =
+          parseInt(overlayStyle.maxHeight, 10) - overlayHeader.offsetHeight;
       var minWidth = parseInt(overlayStyle.minWidth, 10);
 
       extensionoptions.onclose = function() {
         cr.dispatchSimpleEvent($('overlay'), 'cancelOverlay');
       }.bind(this);
 
       // Track the current animation (used to grow/shrink the overlay content),
       // if any. Preferred size changes can fire more rapidly than the
       // animation speed, and multiple animations running at the same time has
       // undesirable effects.
@@ skipping 19 matching lines @@
         // Enforce |minWidth| and |maxHeight|.
         newOverlayWidth = Math.max(newOverlayWidth, minWidth);
         newOverlayHeight = Math.min(newOverlayHeight, maxHeight);
 
         // animationTime is the amount of time in ms that will be used to resize
         // the overlay. It is calculated by multiplying the pythagorean distance
         // between old and the new size (in px) with a constant speed of
         // 0.25 ms/px.
         var loading = document.documentElement.classList.contains('loading');
         var animationTime = loading ? 0 :
-            0.25 * Math.sqrt(Math.pow(newOverlayWidth - oldOverlayWidth, 2) +
-                             Math.pow(newOverlayHeight - oldOverlayHeight, 2));
+                                      0.25 *
+                Math.sqrt(
+                    Math.pow(newOverlayWidth - oldOverlayWidth, 2) +
+                    Math.pow(newOverlayHeight - oldOverlayHeight, 2));
 
         if (animation)
           animation.cancel();
 
         // The header height must be added to the (old and new) preferred
         // heights to get the full overlay heights.
-        animation = overlay.animate([
-          {width: oldOverlayWidth + 'px', height: oldOverlayHeight + 'px'},
-          {width: newOverlayWidth + 'px', height: newOverlayHeight + 'px'}
-        ], {
-          duration: animationTime,
-          delay: 0
-        });
+        animation = overlay.animate(
+            [
+              {width: oldOverlayWidth + 'px', height: oldOverlayHeight + 'px'},
+              {width: newOverlayWidth + 'px', height: newOverlayHeight + 'px'}
+            ],
+            {duration: animationTime, delay: 0});
 
         animation.onfinish = function(e) {
           animation = null;
 
           // The <extensionoptions> element is ready to place back in the
           // overlay. Make sure that it's sized to take up the full width/height
           // of the overlay.
           overlayGuest.style.position = '';
           overlayGuest.style.left = '';
           overlayGuest.style.width = newOverlayWidth + 'px';
@@ skipping 38 matching lines @@
     getExtensionId: function() {
       return this.extensionId_;
     },
 
     /**
      * Toggles the visibility of the ExtensionOptionsOverlay.
      * @param {boolean} isVisible Whether the overlay should be visible.
      * @private
      */
     setVisible_: function(isVisible) {
-      this.showOverlay_(isVisible ?
-          /** @type {HTMLDivElement} */($('extension-options-overlay')) :
-          null);
+      this.showOverlay_(
+          isVisible ?
+              /** @type {HTMLDivElement} */ ($('extension-options-overlay')) :
+              null);
     }
   };
 
   // Export
-  return {
-    ExtensionOptionsOverlay: ExtensionOptionsOverlay
-  };
+  return {ExtensionOptionsOverlay: ExtensionOptionsOverlay};
 });