chrome-devtools-frontend 1.0.1040337 → 1.0.1070764

package/front_end/models/timeline_model/TimelineIRModel.ts

@@ -1,317 +0,0 @@
-// 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.
-
-import * as Common from '../../core/common/common.js';
-import * as i18n from '../../core/i18n/i18n.js';
-import type * as SDK from '../../core/sdk/sdk.js';
-
-const UIStrings = {
-  /**
-  * @description Error text in Timeline IRModel of the Performance panel. Indicates that two fling
-  * gestures were detected at the same time, which should not be possible.
-  *@example {2s} PH1
-  *@example {3s} PH2
-  */
-  twoFlingsAtTheSameTimeSVsS: 'Two flings at the same time? {PH1} vs {PH2}',
-  /**
-  *@description Text in Timeline IRModel of the Performance panel
-  *@example {2s} PH1
-  *@example {3s} PH2
-  */
-  twoTouchesAtTheSameTimeSVsS: 'Two touches at the same time? {PH1} vs {PH2}',
-};
-const str_ = i18n.i18n.registerUIStrings('models/timeline_model/TimelineIRModel.ts', UIStrings);
-const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
-const eventToPhase = new WeakMap<SDK.TracingModel.Event, Phases>();
-
-export class TimelineIRModel {
-  private segments!: Common.SegmentedRange.Segment<Phases>[];
-  private drags!: Common.SegmentedRange.SegmentedRange<Phases>;
-  private cssAnimations!: Common.SegmentedRange.SegmentedRange<Phases>;
-  private responses!: Common.SegmentedRange.SegmentedRange<Phases>;
-  private scrolls!: Common.SegmentedRange.SegmentedRange<Phases>;
-
-  constructor() {
-    this.reset();
-  }
-
-  static phaseForEvent(event: SDK.TracingModel.Event): Phases|undefined {
-    return eventToPhase.get(event);
-  }
-
-  populate(inputLatencies: SDK.TracingModel.AsyncEvent[]|null, animations: SDK.TracingModel.AsyncEvent[]|null): void {
-    this.reset();
-    if (!inputLatencies) {
-      return;
-    }
-    this.processInputLatencies(inputLatencies);
-    if (animations) {
-      this.processAnimations(animations);
-    }
-    const range = new Common.SegmentedRange.SegmentedRange<Phases>();
-    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();
-  }
-
-  private processInputLatencies(events: SDK.TracingModel.AsyncEvent[]): void {
-    const eventTypes = InputEvents;
-    const phases = Phases;
-    const thresholdsMs = TimelineIRModel._mergeThresholdsMs;
-
-    let scrollStart;
-    let flingStart;
-    let touchStart;
-    let firstTouchMove;
-    let mouseWheel;
-    let mouseDown;
-    let mouseMove;
-
-    for (let i = 0; i < events.length; ++i) {
-      const event = events[i];
-      if (i > 0 && events[i].startTime < events[i - 1].startTime) {
-        console.assert(false, 'Unordered input events');
-      }
-      const type = this.inputEventType(event.name);
-      switch (type) {
-        case eventTypes.ScrollBegin:
-          this.scrolls.append(this.segmentForEvent(event, phases.Scroll));
-          scrollStart = event;
-          break;
-
-        case eventTypes.ScrollEnd:
-          if (scrollStart) {
-            this.scrolls.append(this.segmentForEventRange(scrollStart, event, phases.Scroll));
-          } else {
-            this.scrolls.append(this.segmentForEvent(event, phases.Scroll));
-          }
-          scrollStart = null;
-          break;
-
-        case eventTypes.ScrollUpdate:
-          touchStart = null;  // Since we're scrolling now, disregard other touch gestures.
-          this.scrolls.append(this.segmentForEvent(event, phases.Scroll));
-          break;
-
-        case eventTypes.FlingStart:
-          if (flingStart) {
-            Common.Console.Console.instance().error(
-                i18nString(UIStrings.twoFlingsAtTheSameTimeSVsS, {PH1: flingStart.startTime, PH2: event.startTime}));
-            break;
-          }
-          flingStart = event;
-          break;
-
-        case eventTypes.FlingCancel:
-          // FIXME: also process renderer fling events.
-          if (!flingStart) {
-            break;
-          }
-          this.scrolls.append(this.segmentForEventRange(flingStart, event, 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:
-        case eventTypes.KeyDownRaw:
-        case eventTypes.KeyUp:
-        case eventTypes.Char:
-        case eventTypes.Click:
-        case eventTypes.ContextMenu:
-          this.responses.append(this.segmentForEvent(event, phases.Response));
-          break;
-
-        case eventTypes.TouchStart:
-          // We do not produce any response segment for TouchStart -- there's either going to be one upon
-          // TouchMove for drag, or one for GestureTap.
-          if (touchStart) {
-            Common.Console.Console.instance().error(
-                i18nString(UIStrings.twoTouchesAtTheSameTimeSVsS, {PH1: touchStart.startTime, PH2: event.startTime}));
-            break;
-          }
-          touchStart = event;
-          this.setPhaseForEvent(event, phases.Response);
-          firstTouchMove = null;
-          break;
-
-        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(this.segmentForEventRange(touchStart, event, phases.Response));
-          }
-          break;
-
-        case eventTypes.TouchEnd:
-          touchStart = null;
-          break;
-
-        case eventTypes.MouseDown:
-          mouseDown = event;
-          mouseMove = null;
-          break;
-
-        case eventTypes.MouseMove:
-          if (mouseDown && !mouseMove && mouseDown.startTime + thresholdsMs.mouse > event.startTime) {
-            this.responses.append(this.segmentForEvent(mouseDown, phases.Response));
-            this.responses.append(this.segmentForEvent(event, phases.Response));
-          } else if (mouseDown) {
-            this.drags.append(this.segmentForEvent(event, phases.Drag));
-          }
-          mouseMove = event;
-          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(this.segmentForEventRange(mouseWheel, event, phases.Scroll));
-          } else {
-            this.scrolls.append(this.segmentForEvent(event, phases.Scroll));
-          }
-          mouseWheel = event;
-          break;
-      }
-    }
-
-    function canMerge(
-        threshold: number, first: SDK.TracingModel.AsyncEvent, second: SDK.TracingModel.AsyncEvent): boolean {
-      if (first.endTime === undefined) {
-        return false;
-      }
-      return first.endTime < second.startTime && second.startTime < first.endTime + threshold;
-    }
-  }
-
-  private processAnimations(events: SDK.TracingModel.AsyncEvent[]): void {
-    for (let i = 0; i < events.length; ++i) {
-      this.cssAnimations.append(this.segmentForEvent(events[i], Phases.Animation));
-    }
-  }
-
-  private segmentForEvent(event: SDK.TracingModel.AsyncEvent, phase: Phases): Common.SegmentedRange.Segment<Phases> {
-    this.setPhaseForEvent(event, phase);
-    return new Common.SegmentedRange.Segment<Phases>(
-        event.startTime, event.endTime !== undefined ? event.endTime : Number.MAX_SAFE_INTEGER, phase);
-  }
-
-  private segmentForEventRange(
-      startEvent: SDK.TracingModel.AsyncEvent, endEvent: SDK.TracingModel.AsyncEvent,
-      phase: Phases): Common.SegmentedRange.Segment<Phases> {
-    this.setPhaseForEvent(startEvent, phase);
-    this.setPhaseForEvent(endEvent, phase);
-    return new Common.SegmentedRange.Segment(
-        startEvent.startTime, startEvent.endTime !== undefined ? startEvent.endTime : Number.MAX_SAFE_INTEGER, phase);
-  }
-
-  private setPhaseForEvent(asyncEvent: SDK.TracingModel.AsyncEvent, phase: Phases): void {
-    eventToPhase.set(asyncEvent.steps[0], phase);
-  }
-
-  interactionRecords(): Common.SegmentedRange.Segment<Phases>[] {
-    return this.segments;
-  }
-
-  reset(): void {
-    const thresholdsMs = TimelineIRModel._mergeThresholdsMs;
-
-    this.segments = [];
-    this.drags = new Common.SegmentedRange.SegmentedRange(merge.bind(null, thresholdsMs.mouse));
-    this.cssAnimations = new Common.SegmentedRange.SegmentedRange(merge.bind(null, thresholdsMs.animation));
-    this.responses = new Common.SegmentedRange.SegmentedRange(merge.bind(null, 0));
-    this.scrolls = new Common.SegmentedRange.SegmentedRange(merge.bind(null, thresholdsMs.animation));
-
-    function merge(
-        threshold: number, first: Common.SegmentedRange.Segment<Phases>,
-        second: Common.SegmentedRange.Segment<Phases>): Common.SegmentedRange.Segment<Phases>|null {
-      return first.end + threshold >= second.begin && first.data === second.data ? first : null;
-    }
-  }
-
-  private inputEventType(eventName: string): InputEvents|null {
-    const prefix = 'InputLatency::';
-    if (!eventName.startsWith(prefix)) {
-      const inputEventName = eventName as InputEvents;
-      if (inputEventName === InputEvents.ImplSideFling) {
-        return inputEventName;
-      }
-      console.error('Unrecognized input latency event: ' + eventName);
-      return null;
-    }
-    return eventName.substr(prefix.length) as InputEvents;
-  }
-}
-
-// TODO(crbug.com/1167717): Make this a const enum again
-// eslint-disable-next-line rulesdir/const_enum
-export enum Phases {
-  Idle = 'Idle',
-  Response = 'Response',
-  Scroll = 'Scroll',
-  Fling = 'Fling',
-  Drag = 'Drag',
-  Animation = 'Animation',
-  Uncategorized = 'Uncategorized',
-}
-
-// TODO(crbug.com/1167717): Make this a const enum again
-// eslint-disable-next-line rulesdir/const_enum
-export enum InputEvents {
-  Char = 'Char',
-  Click = 'GestureClick',
-  ContextMenu = 'ContextMenu',
-  FlingCancel = 'GestureFlingCancel',
-  FlingStart = 'GestureFlingStart',
-  ImplSideFling = 'InputHandlerProxy::HandleGestureFling::started',
-  KeyDown = 'KeyDown',
-  KeyDownRaw = 'RawKeyDown',
-  KeyUp = 'KeyUp',
-  LatencyScrollUpdate = 'ScrollUpdate',
-  MouseDown = 'MouseDown',
-  MouseMove = 'MouseMove',
-  MouseUp = 'MouseUp',
-  MouseWheel = 'MouseWheel',
-  PinchBegin = 'GesturePinchBegin',
-  PinchEnd = 'GesturePinchEnd',
-  PinchUpdate = 'GesturePinchUpdate',
-  ScrollBegin = 'GestureScrollBegin',
-  ScrollEnd = 'GestureScrollEnd',
-  ScrollUpdate = 'GestureScrollUpdate',
-  ScrollUpdateRenderer = 'ScrollUpdate',
-  ShowPress = 'GestureShowPress',
-  Tap = 'GestureTap',
-  TapCancel = 'GestureTapCancel',
-  TapDown = 'GestureTapDown',
-  TouchCancel = 'TouchCancel',
-  TouchEnd = 'TouchEnd',
-  TouchMove = 'TouchMove',
-  TouchStart = 'TouchStart',
-}
-
-export namespace TimelineIRModel {
-  // eslint-disable-next-line @typescript-eslint/naming-convention
-  export const _mergeThresholdsMs = {
-    animation: 1,
-    mouse: 40,
-  };
-
-  // eslint-disable-next-line @typescript-eslint/naming-convention
-  export const _eventIRPhase = Symbol('eventIRPhase');
-}

package/front_end/panels/application/components/originTrialTreeView.css

@@ -1,9 +0,0 @@
-/*
- * Copyright (c) 2021 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.
- */
-
-:host {
-  --legacy-item-selection-bg-color: transparent;
-}

package/front_end/panels/input/InputModel.ts

@@ -1,213 +0,0 @@
-// Copyright 2019 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.
-
-import * as SDK from '../../core/sdk/sdk.js';
-import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
-import * as Protocol from '../../generated/protocol.js';
-
-export class InputModel extends SDK.SDKModel.SDKModel<void> {
-  private readonly inputAgent: ProtocolProxyApi.InputApi;
-  private eventDispatchTimer: number;
-  private dispatchEventDataList: EventData[];
-  private finishCallback: (() => void)|null;
-  private dispatchingIndex!: number;
-  private lastEventTime?: number|null;
-  private replayPaused?: boolean;
-
-  constructor(target: SDK.Target.Target) {
-    super(target);
-    this.inputAgent = target.inputAgent();
-    this.eventDispatchTimer = 0;
-    this.dispatchEventDataList = [];
-    this.finishCallback = null;
-
-    this.reset();
-  }
-
-  private reset(): void {
-    this.lastEventTime = null;
-    this.replayPaused = false;
-    this.dispatchingIndex = 0;
-    window.clearTimeout(this.eventDispatchTimer);
-  }
-
-  setEvents(tracingModel: SDK.TracingModel.TracingModel): void {
-    this.dispatchEventDataList = [];
-    for (const process of tracingModel.sortedProcesses()) {
-      for (const thread of process.sortedThreads()) {
-        this.processThreadEvents(tracingModel, thread);
-      }
-    }
-    function compareTimestamp(a: EventData, b: EventData): number {
-      return a.timestamp - b.timestamp;
-    }
-    this.dispatchEventDataList.sort(compareTimestamp);
-  }
-
-  startReplay(finishCallback: (() => void)|null): void {
-    this.reset();
-    this.finishCallback = finishCallback;
-    if (this.dispatchEventDataList.length) {
-      this.dispatchNextEvent();
-    } else {
-      this.replayStopped();
-    }
-  }
-
-  pause(): void {
-    window.clearTimeout(this.eventDispatchTimer);
-    if (this.dispatchingIndex >= this.dispatchEventDataList.length) {
-      this.replayStopped();
-    } else {
-      this.replayPaused = true;
-    }
-  }
-
-  resume(): void {
-    this.replayPaused = false;
-    if (this.dispatchingIndex < this.dispatchEventDataList.length) {
-      this.dispatchNextEvent();
-    }
-  }
-
-  private processThreadEvents(_tracingModel: SDK.TracingModel.TracingModel, thread: SDK.TracingModel.Thread): void {
-    for (const event of thread.events()) {
-      if (event.name === 'EventDispatch' && this.isValidInputEvent(event.args.data)) {
-        this.dispatchEventDataList.push(event.args.data);
-      }
-    }
-  }
-
-  private isValidInputEvent(eventData: EventData): boolean {
-    return this.isMouseEvent(eventData as MouseEventData) || this.isKeyboardEvent(eventData as KeyboardEventData);
-  }
-
-  private isMouseEvent(eventData: MouseEventData): boolean {
-    if (!MOUSE_EVENT_TYPE_TO_REQUEST_TYPE.has(eventData.type)) {
-      return false;
-    }
-    if (!('x' in eventData && 'y' in eventData)) {
-      return false;
-    }
-    return true;
-  }
-
-  private isKeyboardEvent(eventData: KeyboardEventData): boolean {
-    if (!KEYBOARD_EVENT_TYPE_TO_REQUEST_TYPE.has(eventData.type)) {
-      return false;
-    }
-    if (!('code' in eventData && 'key' in eventData)) {
-      return false;
-    }
-    return true;
-  }
-
-  private dispatchNextEvent(): void {
-    const eventData = this.dispatchEventDataList[this.dispatchingIndex];
-    this.lastEventTime = eventData.timestamp;
-    if (MOUSE_EVENT_TYPE_TO_REQUEST_TYPE.has(eventData.type)) {
-      void this.dispatchMouseEvent(eventData as MouseEventData);
-    } else if (KEYBOARD_EVENT_TYPE_TO_REQUEST_TYPE.has(eventData.type)) {
-      void this.dispatchKeyEvent(eventData as KeyboardEventData);
-    }
-
-    ++this.dispatchingIndex;
-    if (this.dispatchingIndex < this.dispatchEventDataList.length) {
-      const waitTime = (this.dispatchEventDataList[this.dispatchingIndex].timestamp - this.lastEventTime) / 1000;
-      this.eventDispatchTimer = window.setTimeout(this.dispatchNextEvent.bind(this), waitTime);
-    } else {
-      this.replayStopped();
-    }
-  }
-
-  private async dispatchMouseEvent(eventData: MouseEventData): Promise<void> {
-    const type = MOUSE_EVENT_TYPE_TO_REQUEST_TYPE.get(eventData.type);
-    if (!type) {
-      throw new Error(`Could not find mouse event type for eventData ${eventData.type}`);
-    }
-    const buttonActionName = BUTTONID_TO_ACTION_NAME.get(eventData.button);
-    const params = {
-      type,
-      x: eventData.x,
-      y: eventData.y,
-      modifiers: eventData.modifiers,
-      button: (eventData.type === 'mousedown' || eventData.type === 'mouseup') ? buttonActionName :
-                                                                                 Protocol.Input.MouseButton.None,
-      buttons: eventData.buttons,
-      clickCount: eventData.clickCount,
-      deltaX: eventData.deltaX,
-      deltaY: eventData.deltaY,
-    };
-    await this.inputAgent.invoke_dispatchMouseEvent(params);
-  }
-
-  private async dispatchKeyEvent(eventData: KeyboardEventData): Promise<void> {
-    const type = KEYBOARD_EVENT_TYPE_TO_REQUEST_TYPE.get(eventData.type);
-    if (!type) {
-      throw new Error(`Could not find key event type for eventData ${eventData.type}`);
-    }
-    const text = eventData.type === 'keypress' ? eventData.key[0] : undefined;
-    const params = {
-      type,
-      modifiers: eventData.modifiers,
-      text: text,
-      unmodifiedText: text ? text.toLowerCase() : undefined,
-      code: eventData.code,
-      key: eventData.key,
-    };
-    await this.inputAgent.invoke_dispatchKeyEvent(params);
-  }
-
-  private replayStopped(): void {
-    window.clearTimeout(this.eventDispatchTimer);
-    this.reset();
-    if (this.finishCallback) {
-      this.finishCallback();
-    }
-  }
-}
-
-const MOUSE_EVENT_TYPE_TO_REQUEST_TYPE = new Map<string, Protocol.Input.DispatchMouseEventRequestType>([
-  ['mousedown', Protocol.Input.DispatchMouseEventRequestType.MousePressed],
-  ['mouseup', Protocol.Input.DispatchMouseEventRequestType.MouseReleased],
-  ['mousemove', Protocol.Input.DispatchMouseEventRequestType.MouseMoved],
-  ['wheel', Protocol.Input.DispatchMouseEventRequestType.MouseWheel],
-]);
-
-const KEYBOARD_EVENT_TYPE_TO_REQUEST_TYPE = new Map<string, Protocol.Input.DispatchKeyEventRequestType>([
-  ['keydown', Protocol.Input.DispatchKeyEventRequestType.KeyDown],
-  ['keyup', Protocol.Input.DispatchKeyEventRequestType.KeyUp],
-  ['keypress', Protocol.Input.DispatchKeyEventRequestType.Char],
-]);
-
-const BUTTONID_TO_ACTION_NAME = new Map<number, Protocol.Input.MouseButton>([
-  [0, Protocol.Input.MouseButton.Left],
-  [1, Protocol.Input.MouseButton.Middle],
-  [2, Protocol.Input.MouseButton.Right],
-  [3, Protocol.Input.MouseButton.Back],
-  [4, Protocol.Input.MouseButton.Forward],
-]);
-
-SDK.SDKModel.SDKModel.register(InputModel, {capabilities: SDK.Target.Capability.Input, autostart: false});
-export interface MouseEventData {
-  type: string;
-  modifiers: number;
-  timestamp: number;
-  x: number;
-  y: number;
-  button: number;
-  buttons: number;
-  clickCount: number;
-  deltaX: number;
-  deltaY: number;
-}
-export interface KeyboardEventData {
-  type: string;
-  modifiers: number;
-  timestamp: number;
-  code: string;
-  key: string;
-}
-
-export type EventData = MouseEventData|KeyboardEventData;