Timeline: move SegmentedRange into the WebInspector namespace and a file of its own

third_party/WebKit/Source/devtools/front_end/timeline/TimelineIRModel.js

 // Copyright 2016 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.
 
 /**
  * @constructor
  */
 WebInspector.TimelineIRModel = function()
 {
     this.reset();
@@ skipping 64 matching lines @@
 
         var groups = WebInspector.TimelineUIUtils.asyncEventGroups();
         var asyncEventsByGroup = timelineModel.mainThreadAsyncEvents();
         var inputLatencies = asyncEventsByGroup.get(groups.input);
         if (!inputLatencies)
             return;
         this._processInputLatencies(inputLatencies);
         var animations = asyncEventsByGroup.get(groups.animation);
         if (animations)
             this._processAnimations(animations);
-        var range = new SegmentedRange();
+        var range = new WebInspector.SegmentedRange();
         range.appendRange(this._drags); // Drags take lower precedence than animation, as we can't detect them reliably.
         range.appendRange(this._cssAnimations);
         range.appendRange(this._scrolls);
         range.appendRange(this._responses);
         this._segments = range.segments();
     },
 
     /**
      * @param {!Array<!WebInspector.TracingModel.AsyncEvent>} events
      */
@@ skipping 26 matching lines @@
                     WebInspector.console.error(WebInspector.UIString("Two flings at the same time? %s vs %s", flingStart.startTime, event.startTime));
                     break;
                 }
                 flingStart = event;
                 break;
 
             case eventTypes.FlingCancel:
                 // FIXME: also process renderer fling events.
                 if (!flingStart)
                     break;
-                this._scrolls.append(new Segment(flingStart.startTime, event.endTime, phases.Fling));
+                this._scrolls.append(new WebInspector.Segment(flingStart.startTime, event.endTime, phases.Fling));
                 flingStart = null;
                 break;
 
             case eventTypes.ImplSideFling:
                 this._scrolls.append(this._segmentForEvent(event, phases.Fling));
                 break;
 
             case eventTypes.ShowPress:
             case eventTypes.Tap:
             case eventTypes.KeyDown:
@@ skipping 18 matching lines @@
 
             case eventTypes.TouchCancel:
                 touchStart = null;
                 break;
 
             case eventTypes.TouchMove:
                 if (firstTouchMove) {
                     this._drags.append(this._segmentForEvent(event, phases.Drag));
                 } else if (touchStart) {
                     firstTouchMove = event;
-                    this._responses.append(new Segment(touchStart.startTime, event.endTime, phases.Response));
+                    this._responses.append(new WebInspector.Segment(touchStart.startTime, event.endTime, phases.Response));
                 }
                 break;
 
             case eventTypes.TouchEnd:
                 touchStart = null;
                 break;
 
             case eventTypes.MouseDown:
                 mouseDown = event;
                 mouseMove = null;
@@ skipping 10 matching lines @@
                 break;
 
             case eventTypes.MouseUp:
                 this._responses.append(this._segmentForEvent(event, phases.Response));
                 mouseDown = null;
                 break;
 
             case eventTypes.MouseWheel:
                 // Do not consider first MouseWheel as trace viewer's implementation does -- in case of MouseWheel it's not really special.
                 if (mouseWheel && canMerge(thresholdsMs.mouse, mouseWheel, event))
-                    this._scrolls.append(new Segment(mouseWheel.endTime, event.startTime, phases.Scroll));
+                    this._scrolls.append(new WebInspector.Segment(mouseWheel.endTime, event.startTime, phases.Scroll));
                 this._scrolls.append(this._segmentForEvent(event, phases.Scroll));
                 mouseWheel = event;
                 break;
             }
         }
 
         /**
          * @param {number} threshold
          * @param {!WebInspector.TracingModel.AsyncEvent} first
          * @param {!WebInspector.TracingModel.AsyncEvent} second
@@ skipping 10 matching lines @@
      */
     _processAnimations: function(events)
     {
         for (var i = 0; i < events.length; ++i)
             this._cssAnimations.append(this._segmentForEvent(events[i], WebInspector.TimelineIRModel.Phases.Animation));
     },
 
     /**
      * @param {!WebInspector.TracingModel.AsyncEvent} event
      * @param {!WebInspector.TimelineIRModel.Phases} phase
-     * @return {!Segment}
+     * @return {!WebInspector.Segment}
      */
     _segmentForEvent: function(event, phase)
     {
-        return new Segment(event.startTime, event.endTime, phase);
+        return new WebInspector.Segment(event.startTime, event.endTime, phase);
     },
 
     /**
-     * @return {!Array<!Segment>}
+     * @return {!Array<!WebInspector.Segment>}
      */
     interactionRecords: function()
     {
         return this._segments;
     },
 
     reset: function()
     {
         var thresholdsMs = WebInspector.TimelineIRModel._mergeThresholdsMs;
 
         this._segments = [];
-        this._drags = new SegmentedRange(merge.bind(null, thresholdsMs.mouse));
-        this._cssAnimations = new SegmentedRange(merge.bind(null, thresholdsMs.animation));
-        this._responses = new SegmentedRange(merge.bind(null, 0));
-        this._scrolls = new SegmentedRange(merge.bind(null, thresholdsMs.animation));
+        this._drags = new WebInspector.SegmentedRange(merge.bind(null, thresholdsMs.mouse));
+        this._cssAnimations = new WebInspector.SegmentedRange(merge.bind(null, thresholdsMs.animation));
+        this._responses = new WebInspector.SegmentedRange(merge.bind(null, 0));
+        this._scrolls = new WebInspector.SegmentedRange(merge.bind(null, thresholdsMs.animation));
 
         /**
          * @param {number} threshold
-         * @param {!Segment} first
-         * @param {!Segment} second
+         * @param {!WebInspector.Segment} first
+         * @param {!WebInspector.Segment} second
          */
         function merge(threshold, first, second)
         {
             return first.end + threshold >= second.begin && first.data === second.data ? first : null;
         }
     },
 
     /**
      * @param {string} eventName
      * @return {?WebInspector.TimelineIRModel.InputEvents}
      */
     _inputEventType: function(eventName)
     {
         var prefix = "InputLatency::";
         if (!eventName.startsWith(prefix)) {
             if (eventName === WebInspector.TimelineIRModel.InputEvents.ImplSideFling)
                 return /** @type {!WebInspector.TimelineIRModel.InputEvents} */ (eventName);
             console.error("Unrecognized input latency event: " + eventName);
             return null;
         }
         return /** @type {!WebInspector.TimelineIRModel.InputEvents} */ (eventName.substr(prefix.length));
     }
 };