Run clang-format on ui/webui/resources

ui/webui/resources/js/cr/ui/touch_handler.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.
 
 /**
  * @fileoverview Touch Handler. Class that handles all touch events and
  * uses them to interpret higher level gestures and behaviors. TouchEvent is a
  * built in mobile safari type:
  * http://developer.apple.com/safari/library/documentation/UserExperience/Reference/TouchEventClassReference/TouchEvent/TouchEvent.html.
  * This class is intended to work with all webkit browsers, tested on Chrome and
@@ skipping 120 matching lines @@
    * The type of event sent by TouchHandler
    * @constructor
    * @extends {Event}
    * @param {string} type The type of event (one of cr.ui.Grabber.EventType).
    * @param {boolean} bubbles Whether or not the event should bubble.
    * @param {number} clientX The X location of the touch.
    * @param {number} clientY The Y location of the touch.
    * @param {!Element} touchedElement The element at the current location of the
    *        touch.
    */
-  TouchHandler.Event = function(type, bubbles, clientX, clientY,
-      touchedElement) {
+  TouchHandler.Event = function(
+      type, bubbles, clientX, clientY, touchedElement) {
     var event = document.createEvent('Event');
     event.initEvent(type, bubbles, true);
     event.__proto__ = TouchHandler.Event.prototype;
 
     /**
      * The X location of the touch affected
      * @type {number}
      */
     event.clientX = clientX;
 
@@ skipping 195 matching lines @@
      *      during the capture phase.
      * @param {boolean=} opt_mouse True if the TouchHandler should generate
      *      events for mouse input (in addition to touch input).
      */
     enable: function(opt_capture, opt_mouse) {
       var capture = !!opt_capture;
 
       // Just listen to start events for now. When a touch is occuring we'll
       // want to be subscribed to move and end events on the document, but we
       // don't want to incur the cost of lots of no-op handlers on the document.
-      this.events_.add(this.element_, 'touchstart', this.onStart_.bind(this),
-                       capture);
+      this.events_.add(
+          this.element_, 'touchstart', this.onStart_.bind(this), capture);
       if (opt_mouse) {
-        this.events_.add(this.element_, 'mousedown',
-                         this.mouseToTouchCallback_(this.onStart_.bind(this)),
-                         capture);
+        this.events_.add(
+            this.element_, 'mousedown',
+            this.mouseToTouchCallback_(this.onStart_.bind(this)), capture);
       }
 
       // If the element is long-pressed, we may need to swallow a click
       this.events_.add(this.element_, 'click', this.onClick_.bind(this), true);
     },
 
     /**
      * Stop listening to all events.
      */
     disable: function() {
@@ skipping 33 matching lines @@
           e.targetTouches[0] = touch;
         }
         callback(e);
       };
     },
 
     /**
      * Begin tracking the touchable element, it is eligible for dragging.
      * @private
      */
-    beginTracking_: function() {
-      this.tracking_ = true;
-    },
+    beginTracking_: function() { this.tracking_ = true; },
 
     /**
      * Stop tracking the touchable element, it is no longer dragging.
      * @private
      */
     endTracking_: function() {
       this.tracking_ = false;
       this.dragging_ = false;
       this.totalMoveY_ = 0;
       this.totalMoveX_ = 0;
@@ skipping 59 matching lines @@
       // We've just started touching so shouldn't swallow any upcoming click
       if (this.swallowNextClick_)
         this.swallowNextClick_ = false;
 
       this.disableTap_ = false;
 
       // Sign up for end/cancel notifications for this touch.
       // Note that we do this on the document so that even if the user drags
       // their finger off the element, we'll still know what they're doing.
       if (e.type == 'mousedown') {
-        this.events_.add(document, 'mouseup',
+        this.events_.add(
+            document, 'mouseup',
             this.mouseToTouchCallback_(this.onEnd_.bind(this)), false);
       } else {
         this.events_.add(document, 'touchend', this.onEnd_.bind(this), false);
-        this.events_.add(document, 'touchcancel', this.onEnd_.bind(this),
-            false);
+        this.events_.add(
+            document, 'touchcancel', this.onEnd_.bind(this), false);
       }
 
       // This timeout is cleared on touchEnd and onDrag
       // If we invoke the function then we have a real long press
       window.clearTimeout(this.longPressTimeout_);
       this.longPressTimeout_ = window.setTimeout(
-          this.onLongPress_.bind(this),
-          TouchHandler.TIME_FOR_LONG_PRESS_);
+          this.onLongPress_.bind(this), TouchHandler.TIME_FOR_LONG_PRESS_);
 
       // Dispatch the TOUCH_START event
       this.draggingEnabled_ =
           !!this.dispatchEvent_(TouchHandler.EventType.TOUCH_START, touch);
 
       // We want dragging notifications
       if (e.type == 'mousedown') {
-        this.events_.add(document, 'mousemove',
+        this.events_.add(
+            document, 'mousemove',
             this.mouseToTouchCallback_(this.onMove_.bind(this)), false);
       } else {
         this.events_.add(document, 'touchmove', this.onMove_.bind(this), false);
       }
 
       this.startTouchX_ = this.lastTouchX_ = touch.clientX;
       this.startTouchY_ = this.lastTouchY_ = touch.clientY;
       this.startTime_ = e.timeStamp;
 
       this.recentTouchesX_ = [];
@@ skipping 43 matching lines @@
       var clientX = touch.clientX;
       var clientY = touch.clientY;
 
       var moveX = this.lastTouchX_ - clientX;
       var moveY = this.lastTouchY_ - clientY;
       this.totalMoveX_ += Math.abs(moveX);
       this.totalMoveY_ += Math.abs(moveY);
       this.lastTouchX_ = clientX;
       this.lastTouchY_ = clientY;
 
-      var couldBeTap =
-          this.totalMoveY_ <= TouchHandler.MAX_TRACKING_FOR_TAP_ ||
+      var couldBeTap = this.totalMoveY_ <= TouchHandler.MAX_TRACKING_FOR_TAP_ ||
           this.totalMoveX_ <= TouchHandler.MAX_TRACKING_FOR_TAP_;
 
       if (!couldBeTap)
         this.disableTap_ = true;
 
       if (this.draggingEnabled_ && !this.dragging_ && !couldBeTap) {
         // If we're waiting for a long press, stop
         window.clearTimeout(this.longPressTimeout_);
 
         // Dispatch the DRAG_START event and record whether dragging should be
         // allowed or not.  Note that this relies on the current value of
         // startTouchX/Y - handlers may use the initial drag delta to determine
         // if dragging should be permitted.
-        this.dragging_ = this.dispatchEvent_(
-            TouchHandler.EventType.DRAG_START, touch);
+        this.dragging_ =
+            this.dispatchEvent_(TouchHandler.EventType.DRAG_START, touch);
 
         if (this.dragging_) {
           // Update the start position here so that drag deltas have better
           // values but don't touch the recent positions so that velocity
           // calculations can still use touchstart position in the time and
           // distance delta.
           this.startTouchX_ = clientX;
           this.startTouchY_ = clientY;
           this.startTime_ = e.timeStamp;
         } else {
           this.endTracking_();
         }
       }
 
       if (this.dragging_) {
         this.dispatchEvent_(TouchHandler.EventType.DRAG_MOVE, touch);
 
-        this.removeTouchesInWrongDirection_(this.recentTouchesX_,
-            this.lastMoveX_, moveX);
-        this.removeTouchesInWrongDirection_(this.recentTouchesY_,
-            this.lastMoveY_, moveY);
+        this.removeTouchesInWrongDirection_(
+            this.recentTouchesX_, this.lastMoveX_, moveX);
+        this.removeTouchesInWrongDirection_(
+            this.recentTouchesY_, this.lastMoveY_, moveY);
         this.removeOldTouches_(this.recentTouchesX_, e.timeStamp);
         this.removeOldTouches_(this.recentTouchesY_, e.timeStamp);
         this.recentTouchesX_.push(clientX, e.timeStamp);
         this.recentTouchesY_.push(clientY, e.timeStamp);
       }
 
       this.lastMoveX_ = moveX;
       this.lastMoveY_ = moveY;
     },
 
     /**
      * Filters the provided recent touches array to remove all touches except
      * the last if the move direction has changed.
      * @param {!Array<number>} recentTouches An array of tuples where the first
      *     item is the x or y component of the recent touch and the second item
      *     is the touch time stamp.
      * @param {number|undefined} lastMove The x or y component of the previous
      *     move.
      * @param {number} recentMove The x or y component of the most recent move.
      * @private
      */
-    removeTouchesInWrongDirection_: function(recentTouches, lastMove,
-        recentMove) {
+    removeTouchesInWrongDirection_: function(
+        recentTouches, lastMove, recentMove) {
       if (lastMove && recentMove && recentTouches.length > 2 &&
           (lastMove > 0 ^ recentMove > 0)) {
         recentTouches.splice(0, recentTouches.length - 2);
       }
     },
 
     /**
      * Filters the provided recent touches array to remove all touches older
      * than the max tracking time or the 5th most recent touch.
      * @param {!Array<number>} recentTouches An array of tuples where the first
      *     item is the x or y component of the recent touch and the second item
      *     is the touch time stamp.
      * @param {number} recentTime The time of the most recent event.
      * @private
      */
     removeOldTouches_: function(recentTouches, recentTime) {
-      while (recentTouches.length && recentTime - recentTouches[1] >
-          TouchHandler.MAX_TRACKING_TIME_ ||
-          recentTouches.length >
-              TouchHandler.MAX_TRACKING_TOUCHES_ * 2) {
+      while (recentTouches.length &&
+                 recentTime - recentTouches[1] >
+                     TouchHandler.MAX_TRACKING_TIME_ ||
+             recentTouches.length > TouchHandler.MAX_TRACKING_TOUCHES_ * 2) {
         recentTouches.splice(0, 2);
       }
     },
 
     /**
      * Touch end handler.
      * @param {!TouchEvent} e The touchend event.
      * @private
      */
     onEnd_: function(e) {
       var that = this;
       assert(this.activeTouch_ !== undefined, 'Expect to already be touching');
 
       // If the touch we're tracking isn't changing here, ignore this touch end.
       var touch = this.findActiveTouch_(e.changedTouches);
       if (!touch) {
         // In most cases, our active touch will be in the 'touches' collection,
         // but we can't assert that because occasionally two touchend events can
         // occur at almost the same time with both having empty 'touches' lists.
         // I.e., 'touches' seems like it can be a bit more up to date than the
         // current event.
         return;
       }
 
       // This is touchEnd for the touch we're monitoring
-      assert(!this.findActiveTouch_(e.touches),
-             'Touch ended also still active');
+      assert(
+          !this.findActiveTouch_(e.touches), 'Touch ended also still active');
 
       // Indicate that touching has finished
       this.stopTouching_();
 
       if (this.tracking_) {
         var clientX = touch.clientX;
         var clientY = touch.clientY;
 
         if (this.dragging_) {
           this.endTime_ = e.timeStamp;
@@ skipping 30 matching lines @@
      * drag behavior. End velocity is defined as deltaXY / deltaTime where
      * deltaXY is the difference between endPosition and the oldest recent
      * position, and deltaTime is the difference between endTime and the oldest
      * recent time stamp.
      * @return {Object} The x and y velocity.
      */
     getEndVelocity: function() {
       // Note that we could move velocity to just be an end-event parameter.
       var velocityX = this.recentTouchesX_.length ?
           (this.endTouchX_ - this.recentTouchesX_[0]) /
-          (this.endTime_ - this.recentTouchesX_[1]) : 0;
+              (this.endTime_ - this.recentTouchesX_[1]) :
+          0;
       var velocityY = this.recentTouchesY_.length ?
           (this.endTouchY_ - this.recentTouchesY_[0]) /
-          (this.endTime_ - this.recentTouchesY_[1]) : 0;
+              (this.endTime_ - this.recentTouchesY_[1]) :
+          0;
 
       velocityX = this.correctVelocity_(velocityX);
       velocityY = this.correctVelocity_(velocityY);
 
-      return {
-        x: velocityX,
-        y: velocityY
-      };
+      return {x: velocityX, y: velocityY};
     },
 
     /**
      * Correct erroneous velocities by capping the velocity if we think it's too
      * high, or setting it to a default velocity if know that the event data is
      * bad.
      * @param {number} velocity The x or y velocity component.
      * @return {number} The corrected velocity.
      * @private
      */
     correctVelocity_: function(velocity) {
       var absVelocity = Math.abs(velocity);
 
       // We add to recent touches for each touchstart and touchmove. If we have
       // fewer than 3 touches (6 entries), we assume that the thread was blocked
       // for the duration of the drag and we received events in quick succession
       // with the wrong time stamps.
       if (absVelocity > TouchHandler.MAXIMUM_VELOCITY_) {
         absVelocity = this.recentTouchesY_.length < 3 ?
             TouchHandler.VELOCITY_FOR_INCORRECT_EVENTS_ :
-                TouchHandler.MAXIMUM_VELOCITY_;
+            TouchHandler.MAXIMUM_VELOCITY_;
       }
       return absVelocity * (velocity < 0 ? -1 : 1);
     },
 
     /**
      * Handler when an element has been pressed for a long time
      * @private
      */
     onLongPress_: function() {
       // Swallow any click that occurs on this element without an intervening
       // touch start event.  This simple click-busting technique should be
       // sufficient here since a real click should have a touchstart first.
       this.swallowNextClick_ = true;
       this.disableTap_ = true;
 
       // Dispatch to the LONG_PRESS
       assert(typeof this.startTouchX_ == 'number');
       assert(typeof this.startTouchY_ == 'number');
-      this.dispatchEventXY_(TouchHandler.EventType.LONG_PRESS, this.element_,
-          /** @type {number} */(this.startTouchX_),
-          /** @type {number} */(this.startTouchY_));
+      this.dispatchEventXY_(
+          TouchHandler.EventType.LONG_PRESS, this.element_,
+          /** @type {number} */ (this.startTouchX_),
+          /** @type {number} */ (this.startTouchY_));
     },
 
     /**
      * Click handler - used to swallow clicks after a long-press
      * @param {!Event} e The click event.
      * @private
      */
     onClick_: function(e) {
       if (this.swallowNextClick_) {
         e.preventDefault();
@@ skipping 16 matching lines @@
       // the event/touch target.  But for touch events, the target is always the
       // target of the touchstart (and it's unlikely we can change this
       // since the common implementation of touch dragging relies on it). Since
       // touch is our primary scenario (which we want to emulate with mouse),
       // we'll treat both cases the same and not depend on the target.
       /** @type {Element} */
       var touchedElement;
       if (eventType == TouchHandler.EventType.TOUCH_START) {
         touchedElement = assertInstanceof(touch.target, Element);
       } else {
-        touchedElement = assert(this.element_.ownerDocument.
-            elementFromPoint(touch.clientX, touch.clientY));
+        touchedElement = assert(this.element_.ownerDocument.elementFromPoint(
+            touch.clientX, touch.clientY));
       }
 
-      return this.dispatchEventXY_(eventType, touchedElement, touch.clientX,
-          touch.clientY);
+      return this.dispatchEventXY_(
+          eventType, touchedElement, touch.clientX, touch.clientY);
     },
 
     /**
      * Dispatch a TouchHandler event to the element
      * @param {string} eventType The event to dispatch.
      * @param {!Element} touchedElement
      * @param {number} clientX The X location for the event.
      * @param {number} clientY The Y location for the event.
      * @return {boolean|undefined} The value of enableDrag after dispatching
      *         the event.
      * @private
      */
     dispatchEventXY_: function(eventType, touchedElement, clientX, clientY) {
-      var isDrag = (eventType == TouchHandler.EventType.DRAG_START ||
-          eventType == TouchHandler.EventType.DRAG_MOVE ||
-          eventType == TouchHandler.EventType.DRAG_END);
+      var isDrag =
+          (eventType == TouchHandler.EventType.DRAG_START ||
+           eventType == TouchHandler.EventType.DRAG_MOVE ||
+           eventType == TouchHandler.EventType.DRAG_END);
 
       // Drag events don't bubble - we're really just dragging the element,
       // not affecting its parent at all.
       var bubbles = !isDrag;
 
-      var event = new TouchHandler.Event(eventType, bubbles, clientX, clientY,
-          touchedElement);
+      var event = new TouchHandler.Event(
+          eventType, bubbles, clientX, clientY, touchedElement);
 
       // Set enableDrag when it can be overridden
       if (eventType == TouchHandler.EventType.TOUCH_START)
         event.enableDrag = false;
       else if (eventType == TouchHandler.EventType.DRAG_START)
         event.enableDrag = true;
 
       if (isDrag) {
         event.dragDeltaX = clientX - this.startTouchX_;
         event.dragDeltaY = clientY - this.startTouchY_;
       }
 
       this.element_.dispatchEvent(event);
       return event.enableDrag;
     }
   };
 
-  return {
-    TouchHandler: TouchHandler
-  };
+  return {TouchHandler: TouchHandler};
 });