Run clang-format on ui/webui/resources

ui/webui/resources/js/cr/ui/bubble.js

 // Copyright (c) 2012 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.
 
 // require: event_tracker.js
 
 // TODO(vitalyp): Inline the enums below into cr.ui definition function, remove
 // cr.exportPath() call and remove exportPath from exports in cr.js when this
 // issue will be fixed:
 // https://github.com/google/closure-compiler/issues/544
@@ skipping 80 matching lines @@
      * @type {Node}
      * @private
      */
     anchorNode_: null,
 
     /**
      * Initialization function for the cr.ui framework.
      */
     decorate: function() {
       this.className = 'bubble';
-      this.innerHTML =
-          '<div class="bubble-content"></div>' +
+      this.innerHTML = '<div class="bubble-content"></div>' +
           '<div class="bubble-shadow"></div>' +
           '<div class="bubble-arrow"></div>';
       this.hidden = true;
       this.bubbleAlignment = cr.ui.BubbleAlignment.ENTIRELY_VISIBLE;
     },
 
     /**
      * Set the anchor node, i.e. the node that this bubble points at. Only
      * available when the bubble is not being shown.
      * @param {HTMLElement} node The new anchor node.
@@ skipping 22 matching lines @@
     /**
      * Set the arrow location. Only available when the bubble is not being
      * shown.
      * @param {cr.ui.ArrowLocation} location The new arrow location.
      */
     set arrowLocation(location) {
       if (!this.hidden)
         return;
 
       this.arrowAtRight_ = location == cr.ui.ArrowLocation.TOP_END ||
-                           location == cr.ui.ArrowLocation.BOTTOM_END;
+          location == cr.ui.ArrowLocation.BOTTOM_END;

[dpapad, 2016/12/22 00:56:29]

+dschuyler
This change is a surprise to me. Per the new JS styleguide this violates the
"rectangle rule", see
https://google.github.io/styleguide/jsguide.html#formatting-rectangle-rule.

[Dan Beam, 2016/12/22 01:05:13]

I think the style guide is intentionally ambiguous here, read 4.5*:
https://google.github.io/styleguide/jsguide.html#formatting-line-wrapping

"4+ spaces" is said repeatedly.  Meaning: the old code was valid. And the new
code is valid.  But the new code is more resilient to changes, as it's not based
on another line's indent as much.

[dschuyler, 2016/12/22 01:24:25]

In my reading, both the new and old were valid prior to the newest style guide.
If I understand the guide correctly, the lines should read:

this.arrowAtRight_ = 
    location == cr.ui.ArrowLocation.TOP_END ||
        location == cr.ui.ArrowLocation.BOTTOM_END;

It looks like a fairly direct match to the example given in 4.5.6, which is:

currentEstimate =
    (currentEstimate + x / currentEstimate)
        / 2.0f;
That's a big advantage imo.

       if (document.documentElement.dir == 'rtl')
         this.arrowAtRight_ = !this.arrowAtRight_;
       this.arrowAtTop_ = location == cr.ui.ArrowLocation.TOP_START ||
-                         location == cr.ui.ArrowLocation.TOP_END;
+          location == cr.ui.ArrowLocation.TOP_END;
     },
 
     /**
      * Set the bubble alignment. Only available when the bubble is not being
      * shown.
      * @param {cr.ui.BubbleAlignment} alignment The new bubble alignment.
      */
     set bubbleAlignment(alignment) {
       if (!this.hidden)
         return;
@@ skipping 14 matching lines @@
       var bubble = this.getBoundingClientRect();
       var arrow = this.querySelector('.bubble-arrow').getBoundingClientRect();
 
       if (this.bubbleAlignment_ == cr.ui.BubbleAlignment.ENTIRELY_VISIBLE) {
         // Work out horizontal placement. The bubble is initially positioned so
         // that the arrow tip points toward the midpoint of the anchor and is
         // BubbleBase.ARROW_OFFSET pixels from the reference edge and (as
         // specified by the arrow location). If the bubble is not entirely
         // within view, it is then shifted, preserving the arrow tip position.
         var left = this.arrowAtRight_ ?
-           anchorMid + BubbleBase.ARROW_OFFSET - bubble.width :
-           anchorMid - BubbleBase.ARROW_OFFSET;
+            anchorMid + BubbleBase.ARROW_OFFSET - bubble.width :
+            anchorMid - BubbleBase.ARROW_OFFSET;
         var max_left_pos =
             documentWidth - bubble.width - BubbleBase.MIN_VIEWPORT_EDGE_MARGIN;
         var min_left_pos = BubbleBase.MIN_VIEWPORT_EDGE_MARGIN;
         if (document.documentElement.dir == 'rtl')
           left = Math.min(Math.max(left, min_left_pos), max_left_pos);
         else
           left = Math.max(Math.min(left, max_left_pos), min_left_pos);
         var arrowTip = Math.min(
-            Math.max(arrow.width / 2,
-                     this.arrowAtRight_ ? left + bubble.width - anchorMid :
-                                          anchorMid - left),
+            Math.max(
+                arrow.width / 2, this.arrowAtRight_ ?
+                    left + bubble.width - anchorMid :
+                    anchorMid - left),
             bubble.width - arrow.width / 2);
 
         // Work out the vertical placement, attempting to fit the bubble
         // entirely into view. The following placements are considered in
         // decreasing order of preference:
         // * Outside the anchor, arrow tip touching the anchor (arrow at
         //   top/bottom as specified by the arrow location).
         // * Outside the anchor, arrow tip touching the anchor (arrow at
         //   bottom/top, opposite the specified arrow location).
         // * Outside the anchor, arrow tip overlapping the anchor (arrow at
         //   top/bottom as specified by the arrow location).
         // * Outside the anchor, arrow tip overlapping the anchor (arrow at
         //   bottom/top, opposite the specified arrow location).
         // * Overlapping the anchor.
-        var offsetTop = Math.min(documentHeight - anchor.bottom - bubble.height,
-                                 arrow.height / 2);
-        var offsetBottom = Math.min(anchor.top - bubble.height,
-                                    arrow.height / 2);
+        var offsetTop = Math.min(
+            documentHeight - anchor.bottom - bubble.height, arrow.height / 2);
+        var offsetBottom =
+            Math.min(anchor.top - bubble.height, arrow.height / 2);
         if (offsetTop < 0 && offsetBottom < 0) {
           var top = 0;
           this.updateArrowPosition_(false, false, arrowTip);
-        } else if (offsetTop > offsetBottom ||
-                   offsetTop == offsetBottom && this.arrowAtTop_) {
+        } else if (
+            offsetTop > offsetBottom ||
+            offsetTop == offsetBottom && this.arrowAtTop_) {
           var top = anchor.bottom + offsetTop;
           this.updateArrowPosition_(true, true, arrowTip);
         } else {
           var top = anchor.top - bubble.height - offsetBottom;
           this.updateArrowPosition_(true, false, arrowTip);
         }
       } else {
         if (this.bubbleAlignment_ ==
             cr.ui.BubbleAlignment.BUBBLE_EDGE_TO_ANCHOR_EDGE) {
-          var left = this.arrowAtRight_ ? anchor.right - bubble.width :
-              anchor.left;
+          var left =
+              this.arrowAtRight_ ? anchor.right - bubble.width : anchor.left;
         } else {
           var left = this.arrowAtRight_ ?
               anchorMid - this.clientWidth + BubbleBase.ARROW_OFFSET :
               anchorMid - BubbleBase.ARROW_OFFSET;
         }
-        var top = this.arrowAtTop_ ? anchor.bottom + arrow.height / 2 :
+        var top = this.arrowAtTop_ ?
+            anchor.bottom + arrow.height / 2 :
             anchor.top - this.clientHeight - arrow.height / 2;
-        this.updateArrowPosition_(true, this.arrowAtTop_,
-                                  BubbleBase.ARROW_OFFSET);
+        this.updateArrowPosition_(
+            true, this.arrowAtTop_, BubbleBase.ARROW_OFFSET);
       }
 
       this.style.left = left + 'px';
       this.style.top = top + 'px';
     },
 
     /**
      * Show the bubble.
      */
     show: function() {
@@ skipping 32 matching lines @@
         this.hide();
         event.preventDefault();
         event.stopPropagation();
       }
     },
 
     /**
      * Attach the bubble to the document's DOM.
      * @private
      */
-    attachToDOM_: function() {
-      document.body.appendChild(this);
-    },
+    attachToDOM_: function() { document.body.appendChild(this); },
 
     /**
      * Update the arrow so that it appears at the correct position.
      * @param {boolean} visible Whether the arrow should be visible.
      * @param {boolean} atTop Whether the arrow should be at the top of the
      * bubble.
      * @param {number} tipOffset The horizontal distance between the tip of the
      * arrow and the reference edge of the bubble (as specified by the arrow
      * location).
      * @private
@@ skipping 95 matching lines @@
      * TODO(vitalyp): remove suppression when the extern
      * Node.prototype.contains() will be fixed.
      */
     handleEvent: function(event) {
       BubbleBase.prototype.handleEvent.call(this, event);
 
       if (event.type == 'mousedown') {
         // Dismiss the bubble when the user clicks on the close button.
         if (event.target == this.querySelector('.bubble-close')) {
           this.handleCloseEvent_();
-        // Dismiss the bubble when the user clicks outside it after the
-        // specified delay has passed.
-        } else if (!this.contains(event.target) &&
+          // Dismiss the bubble when the user clicks outside it after the
+          // specified delay has passed.
+        } else if (
+            !this.contains(event.target) &&
             Date.now() - this.showTime_ >= this.deactivateToDismissDelay_) {
           this.hide();
         }
       }
     },
   };
 
   /**
    * A bubble that closes automatically when the user clicks or moves the focus
    * outside the bubble and its target element, scrolls the underlying document
@@ skipping 108 matching lines @@
     },
   };
 
 
   return {
     BubbleBase: BubbleBase,
     Bubble: Bubble,
     AutoCloseBubble: AutoCloseBubble
   };
 });