chrome-devtools-frontend 1.0.1367881 → 1.0.1376716

package/front_end/models/trace/insights/ThirdPartyWeb.ts

@@ -6,7 +6,7 @@ import * as ThirdPartyWeb from '../../../third_party/third-party-web/third-party
 import * as Extras from '../extras/extras.js';
 import type * as Handlers from '../handlers/handlers.js';
 import * as Helpers from '../helpers/helpers.js';
-import * as Types from '../types/types.js';
+import type * as Types from '../types/types.js';
 
 import type {InsightResult, InsightSetContext, RequiredData} from './types.js';
 
@@ -14,177 +14,18 @@ export function deps(): ['Meta', 'NetworkRequests', 'Renderer', 'ImagePainting']
   return ['Meta', 'NetworkRequests', 'Renderer', 'ImagePainting'];
 }
 
-export type Entity = typeof ThirdPartyWeb.ThirdPartyWeb.entities[number];
-
-export interface Summary {
-  transferSize: number;
-  mainThreadTime: Types.Timing.MicroSeconds;
-}
-
 export type ThirdPartyWebInsightResult = InsightResult<{
-  entityByRequest: Map<Types.Events.SyntheticNetworkRequest, Entity>,
-  requestsByEntity: Map<Entity, Types.Events.SyntheticNetworkRequest[]>,
-  summaryByRequest: Map<Types.Events.SyntheticNetworkRequest, Summary>,
-  summaryByEntity: Map<Entity, Summary>,
+  entityByRequest: Map<Types.Events.SyntheticNetworkRequest, Extras.ThirdParties.Entity>,
+  requestsByEntity: Map<Extras.ThirdParties.Entity, Types.Events.SyntheticNetworkRequest[]>,
+  summaryByRequest: Map<Types.Events.SyntheticNetworkRequest, Extras.ThirdParties.Summary>,
+  summaryByEntity: Map<Extras.ThirdParties.Entity, Extras.ThirdParties.Summary>,
   /** The entity for this navigation's URL. Any other entity is from a third party. */
-  firstPartyEntity?: Entity,
+  firstPartyEntity?: Extras.ThirdParties.Entity,
 }>;
 
-/**
- * Returns the origin portion of a Chrome extension URL.
- */
-function getChromeExtensionOrigin(url: URL): string {
-  return url.protocol + '//' + url.host;
-}
-
-function makeUpChromeExtensionEntity(entityCache: Map<string, Entity>, url: string, extensionName?: string): Entity {
-  const parsedUrl = new URL(url);
-  const origin = getChromeExtensionOrigin(parsedUrl);
-  const host = new URL(origin).host;
-  const name = extensionName || host;
-
-  const cachedEntity = entityCache.get(origin);
-  if (cachedEntity) {
-    return cachedEntity;
-  }
-
-  const chromeExtensionEntity = {
-    name,
-    company: name,
-    category: 'Chrome Extension',
-    homepage: 'https://chromewebstore.google.com/detail/' + host,
-    categories: [],
-    domains: [],
-    averageExecutionTime: 0,
-    totalExecutionTime: 0,
-    totalOccurrences: 0,
-  };
-
-  entityCache.set(origin, chromeExtensionEntity);
-  return chromeExtensionEntity;
-}
-
-function makeUpEntity(entityCache: Map<string, Entity>, url: string): Entity|undefined {
-  if (url.startsWith('chrome-extension:')) {
-    return makeUpChromeExtensionEntity(entityCache, url);
-  }
-
-  // Make up an entity only for valid http/https URLs.
-  if (!url.startsWith('http')) {
-    return;
-  }
-
-  // NOTE: Lighthouse uses a tld database to determine the root domain, but here
-  // we are using third party web's database. Doesn't really work for the case of classifying
-  // domains 3pweb doesn't know about, so it will just give us a guess.
-  const rootDomain = ThirdPartyWeb.ThirdPartyWeb.getRootDomain(url);
-  if (!rootDomain) {
-    return;
-  }
-
-  if (entityCache.has(rootDomain)) {
-    return entityCache.get(rootDomain);
-  }
-
-  const unrecognizedEntity = {
-    name: rootDomain,
-    company: rootDomain,
-    category: '',
-    categories: [],
-    domains: [rootDomain],
-    averageExecutionTime: 0,
-    totalExecutionTime: 0,
-    totalOccurrences: 0,
-    isUnrecognized: true,
-  };
-  entityCache.set(rootDomain, unrecognizedEntity);
-  return unrecognizedEntity;
-}
-
-interface SummaryMaps {
-  byEntity: Map<Entity, Summary>;
-  byRequest: Map<Types.Events.SyntheticNetworkRequest, Summary>;
-  requestsByEntity: Map<Entity, Types.Events.SyntheticNetworkRequest[]>;
-}
-
-function getSelfTimeByUrl(parsedTrace: RequiredData<typeof deps>, context: InsightSetContext): Map<string, number> {
-  const selfTimeByUrl = new Map<string, number>();
-
-  for (const process of parsedTrace.Renderer.processes.values()) {
-    if (!process.isOnMainFrame) {
-      continue;
-    }
-
-    for (const thread of process.threads.values()) {
-      if (thread.name === 'CrRendererMain') {
-        if (!thread.tree) {
-          break;
-        }
-
-        for (const event of thread.entries) {
-          if (!Helpers.Timing.eventIsInBounds(event, context.bounds)) {
-            continue;
-          }
-
-          const node = parsedTrace.Renderer.entryToNode.get(event);
-          if (!node || !node.selfTime) {
-            continue;
-          }
-
-          const url = Extras.URLForEntry.getNonResolved(parsedTrace as Handlers.Types.ParsedTrace, event);
-          if (!url) {
-            continue;
-          }
-
-          selfTimeByUrl.set(url, node.selfTime + (selfTimeByUrl.get(url) ?? 0));
-        }
-      }
-    }
-  }
-
-  return selfTimeByUrl;
-}
-
-function getSummaries(
-    requests: Types.Events.SyntheticNetworkRequest[],
-    entityByRequest: Map<Types.Events.SyntheticNetworkRequest, Entity>,
-    selfTimeByUrl: Map<string, number>): SummaryMaps {
-  const byRequest = new Map<Types.Events.SyntheticNetworkRequest, Summary>();
-  const byEntity = new Map<Entity, Summary>();
-  const defaultSummary: Summary = {transferSize: 0, mainThreadTime: Types.Timing.MicroSeconds(0)};
-
-  for (const request of requests) {
-    const urlSummary = byRequest.get(request) || {...defaultSummary};
-    urlSummary.transferSize += request.args.data.encodedDataLength;
-    urlSummary.mainThreadTime =
-        Types.Timing.MicroSeconds(urlSummary.mainThreadTime + (selfTimeByUrl.get(request.args.data.url) ?? 0));
-    byRequest.set(request, urlSummary);
-  }
-
-  // Map each request's stat to a particular entity.
-  const requestsByEntity = new Map<Entity, Types.Events.SyntheticNetworkRequest[]>();
-  for (const [request, requestSummary] of byRequest.entries()) {
-    const entity = entityByRequest.get(request);
-    if (!entity) {
-      byRequest.delete(request);
-      continue;
-    }
-
-    const entitySummary = byEntity.get(entity) || {...defaultSummary};
-    entitySummary.transferSize += requestSummary.transferSize;
-    entitySummary.mainThreadTime =
-        Types.Timing.MicroSeconds(entitySummary.mainThreadTime + requestSummary.mainThreadTime);
-    byEntity.set(entity, entitySummary);
-
-    const entityRequests = requestsByEntity.get(entity) || [];
-    entityRequests.push(request);
-    requestsByEntity.set(entity, entityRequests);
-  }
-
-  return {byEntity, byRequest, requestsByEntity};
-}
-
-function getRelatedEvents(summaries: SummaryMaps, firstPartyEntity: Entity|undefined): Types.Events.Event[] {
+function getRelatedEvents(
+    summaries: Extras.ThirdParties.SummaryMaps,
+    firstPartyEntity: Extras.ThirdParties.Entity|undefined): Types.Events.Event[] {
   const events = [];
 
   for (const [entity, requests] of summaries.requestsByEntity.entries()) {
@@ -210,23 +51,12 @@ export function generateInsight(
     return Helpers.Timing.eventIsInBounds(event, context.bounds);
   });
 
-  const entityByRequest = new Map<Types.Events.SyntheticNetworkRequest, Entity>();
-  const madeUpEntityCache = new Map<string, Entity>();
-  for (const request of networkRequests) {
-    const url = request.args.data.url;
-    const entity = ThirdPartyWeb.ThirdPartyWeb.getEntity(url) ?? makeUpEntity(madeUpEntityCache, url);
-    if (entity) {
-      entityByRequest.set(request, entity);
-    }
-  }
-
-  const selfTimeByUrl = getSelfTimeByUrl(parsedTrace, context);
-  // TODO(crbug.com/352244718): re-work to still collect main thread activity if no request is present
-  const summaries = getSummaries(networkRequests, entityByRequest, selfTimeByUrl);
+  const {entityByRequest, madeUpEntityCache, summaries} = Extras.ThirdParties.getSummariesAndEntitiesForTraceBounds(
+      parsedTrace as Handlers.Types.ParsedTrace, context.bounds, networkRequests);
 
   const firstPartyUrl = context.navigation?.args.data?.documentLoaderURL ?? parsedTrace.Meta.mainFrameURL;
-  const firstPartyEntity =
-      ThirdPartyWeb.ThirdPartyWeb.getEntity(firstPartyUrl) || makeUpEntity(madeUpEntityCache, firstPartyUrl);
+  const firstPartyEntity = ThirdPartyWeb.ThirdPartyWeb.getEntity(firstPartyUrl) ||
+      Extras.ThirdParties.makeUpEntity(madeUpEntityCache, firstPartyUrl);
 
   return {
     relatedEvents: getRelatedEvents(summaries, firstPartyEntity),

package/front_end/models/trace/lantern/core/NetworkAnalyzer.test.ts

@@ -42,7 +42,7 @@ describe('NetworkAnalyzer', () => {
           connectionReused: false,
           networkRequestTime: 10,
           networkEndTime: 10,
-          transferSize: 0,
+          transferSize: 10000,
           protocol: opts.protocol || 'http/1.1',
           parsedURL: {scheme: url.match(/https?/)[0], securityOrigin: url.match(/.*\.com/)[0]},
           timing: opts.timing || null,
@@ -339,9 +339,9 @@ describe('NetworkAnalyzer', () => {
       );
     }
 
-    it('should return Infinity for no/missing records', () => {
-      assert.strictEqual(estimateThroughput([]), Infinity);
-      assert.strictEqual(estimateThroughput([createThroughputRecord(0, 0, {finished: false})]), Infinity);
+    it('should return null for no/missing records', () => {
+      assert.strictEqual(estimateThroughput([]), null);
+      assert.strictEqual(estimateThroughput([createThroughputRecord(0, 0, {finished: false})]), null);
     });
 
     it('should compute correctly for a basic waterfall', () => {

package/front_end/models/trace/lantern/core/NetworkAnalyzer.ts

@@ -412,7 +412,7 @@ class NetworkAnalyzer {
       function collectEstimates(estimator: (e: RequestInfo) => number[] | number | undefined, multiplier = 1): void {
         for (const request of originRequests) {
           const timing = request.timing;
-          if (!timing) {
+          if (!timing || !request.transferSize) {
             continue;
           }
 
@@ -489,9 +489,9 @@ class NetworkAnalyzer {
   /**
    * Computes the average throughput for the given requests in bits/second.
    * Excludes data URI, failed or otherwise incomplete, and cached requests.
-   * Returns Infinity if there were no analyzable network requests.
+   * Returns null if there were no analyzable network requests.
    */
-  static estimateThroughput(records: Lantern.NetworkRequest[]): number {
+  static estimateThroughput(records: Lantern.NetworkRequest[]): number|null {
     let totalBytes = 0;
 
     // We will measure throughput by summing the total bytes downloaded by the total time spent
@@ -518,7 +518,7 @@ class NetworkAnalyzer {
                                .sort((a, b) => a.time - b.time);
 
     if (!timeBoundaries.length) {
-      return Infinity;
+      return null;
     }
 
     let inflight = 0;
@@ -576,8 +576,12 @@ class NetworkAnalyzer {
     };
   }
 
-  static analyze(records: Lantern.NetworkRequest[]): Lantern.Simulation.Settings['networkAnalysis'] {
+  static analyze(records: Lantern.NetworkRequest[]): Lantern.Simulation.Settings['networkAnalysis']|null {
     const throughput = NetworkAnalyzer.estimateThroughput(records);
+    if (throughput === null) {
+      return null;
+    }
+
     return {
       throughput,
       ...NetworkAnalyzer.computeRTTAndServerResponseTime(records),

package/front_end/models/trace/lantern/simulation/Simulator.ts

@@ -143,7 +143,7 @@ class Simulator<T = Lantern.AnyNetworkObject> {
       throw new Core.LanternError(`Invalid rtt ${this._rtt}`);
     }
     if (!Number.isFinite(this.throughput)) {
-      throw new Core.LanternError(`Invalid rtt ${this.throughput}`);
+      throw new Core.LanternError(`Invalid throughput ${this.throughput}`);
     }
   }
 

package/front_end/models/trace/lantern/testing/MetricTestUtils.ts

@@ -32,6 +32,10 @@ async function getComputationDataFromFixture({trace, settings, url}: {
   const parsedTrace = await runTrace(trace);
   const requests = Trace.LanternComputationData.createNetworkRequests(trace, parsedTrace);
   const networkAnalysis = Lantern.Core.NetworkAnalyzer.analyze(requests);
+  if (!networkAnalysis) {
+    throw new Error('no networkAnalysis');
+  }
+
   const frameId = parsedTrace.Meta.mainFrameId;
   const navigationId = parsedTrace.Meta.mainFrameNavigations[0].args.data?.navigationId;
   if (!navigationId) {

package/front_end/models/trace/types/TraceEvents.ts

@@ -951,8 +951,10 @@ export interface ResourceSendRequest extends Instant {
       requestId: string,
       url: string,
       priority: Protocol.Network.ResourcePriority,
-      resourceType: Protocol.Network.ResourceType,
-      fetchPriorityHint: FetchPriorityHint,
+      /** Added Feb 2024. https://crrev.com/c/5277583 */
+      resourceType?: Protocol.Network.ResourceType,
+      /** Added Feb 2024. https://crrev.com/c/5297615 */
+      fetchPriorityHint?: FetchPriorityHint,
       // TODO(crbug.com/1457985): change requestMethod to enum when confirm in the backend code.
       requestMethod?: string,
       renderBlocking?: RenderBlocking,
@@ -1191,10 +1193,25 @@ export interface RenderFrameImplCreateChildFrame extends Event {
     frame_token: string,
   };
 }
+
 export function isRenderFrameImplCreateChildFrame(event: Event): event is RenderFrameImplCreateChildFrame {
   return event.name === Name.RENDER_FRAME_IMPL_CREATE_CHILD_FRAME;
 }
 
+export interface LayoutImageUnsized extends Event {
+  name: Name.LAYOUT_IMAGE_UNSIZED;
+  args: Args&{
+    data: {
+      nodeId: Protocol.DOM.BackendNodeId,
+      frameId: string,
+    },
+  };
+}
+
+export function isLayoutImageUnsized(event: Event): event is LayoutImageUnsized {
+  return event.name === Name.LAYOUT_IMAGE_UNSIZED;
+}
+
 export interface PrePaint extends Complete {
   name: 'PrePaint';
 }
@@ -2535,6 +2552,51 @@ export function isSyntheticServerTiming(event: Event): event is SyntheticServerT
   return event.cat === 'devtools.server-timing';
 }
 
+export interface SchedulePostTaskCallback extends Instant {
+  name: Name.SCHEDULE_POST_TASK_CALLBACK;
+  args: Args&{
+    data: {
+      taskId: number,
+      priority: 'user-blocking'|'user-visible'|'background',
+      delay: MilliSeconds,
+      frame?: string,
+      stackTrace?: CallFrame,
+    },
+  };
+}
+export function isSchedulePostTaskCallback(event: Event): event is SchedulePostTaskCallback {
+  return event.name === Name.SCHEDULE_POST_TASK_CALLBACK;
+}
+
+export interface RunPostTaskCallback extends Complete {
+  name: Name.RUN_POST_TASK_CALLBACK;
+  args: Args&{
+    data: {
+      taskId: number,
+      priority: 'user-blocking'|'user-visible'|'background',
+      delay: MilliSeconds,
+      frame?: string,
+    },
+  };
+}
+export function isRunPostTaskCallback(event: Event): event is RunPostTaskCallback {
+  return event.name === Name.RUN_POST_TASK_CALLBACK;
+}
+
+export interface AbortPostTaskCallback extends Complete {
+  name: Name.ABORT_POST_TASK_CALLBACK;
+  args: Args&{
+    data: {
+      taskId: number,
+      frame?: string,
+      stackTrace?: CallFrame,
+    },
+  };
+}
+export function isAbortPostTaskCallback(event: Event): event is RunPostTaskCallback {
+  return event.name === Name.ABORT_POST_TASK_CALLBACK;
+}
+
 /**
  * Generally, before JS is executed, a trace event is dispatched that
  * parents the JS calls. These we call "invocation" events. This
@@ -2628,6 +2690,9 @@ export const enum Name {
   CRYPTO_DO_VERIFY = 'DoVerify',
   CRYPTO_DO_VERIFY_REPLY = 'DoVerifyReply',
   V8_EXECUTE = 'V8.Execute',
+  SCHEDULE_POST_TASK_CALLBACK = 'SchedulePostTaskCallback',
+  RUN_POST_TASK_CALLBACK = 'RunPostTaskCallback',
+  ABORT_POST_TASK_CALLBACK = 'AbortPostTaskCallback',
 
   /* Gc */
   GC = 'GCEvent',
@@ -2756,6 +2821,7 @@ export const enum Name {
   HANDLE_POST_MESSAGE = 'HandlePostMessage',
 
   RENDER_FRAME_IMPL_CREATE_CHILD_FRAME = 'RenderFrameImpl::createChildFrame',
+  LAYOUT_IMAGE_UNSIZED = 'LayoutImageUnsized',
 
   DOM_LOADING = 'domLoading',
   BEGIN_REMOTE_FONT_LOAD = 'BeginRemoteFontLoad',

package/front_end/panels/accessibility/AccessibilitySidebarView.ts

@@ -24,7 +24,7 @@ export class AccessibilitySidebarView extends UI.ThrottledWidget.ThrottledWidget
   private readonly axNodeSubPane: AXNodeSubPane;
   private readonly sourceOrderSubPane: SourceOrderPane;
   private constructor(throttlingTimeout?: number) {
-    super(false /* isWebComponent */, throttlingTimeout);
+    super(false /* useShadowDom */, throttlingTimeout);
     this.nodeInternal = null;
     this.axNodeInternal = null;
     this.skipNextPullNode = false;

package/front_end/panels/animation/AnimationGroupPreviewUI.ts

@@ -2,22 +2,22 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+import type * as SDK from '../../core/sdk/sdk.js';
 import * as IconButton from '../../ui/components/icon_button/icon_button.js';
 import * as UI from '../../ui/legacy/legacy.js';
 import * as VisualLogging from '../../ui/visual_logging/visual_logging.js';
 
-import type {AnimationGroup} from './AnimationModel.js';
 import {AnimationUI} from './AnimationUI.js';
 
 export class AnimationGroupPreviewUI {
-  #model: AnimationGroup;
+  #model: SDK.AnimationModel.AnimationGroup;
   element: HTMLButtonElement;
   readonly #removeButtonInternal: HTMLElement;
   readonly #replayOverlayElement: HTMLElement;
   readonly #svg: Element;
   readonly #viewBoxHeight: number;
 
-  constructor(model: AnimationGroup) {
+  constructor(model: SDK.AnimationModel.AnimationGroup) {
     this.#model = model;
     this.element = document.createElement('button');
     this.element.setAttribute(

package/front_end/panels/animation/AnimationTimeline.test.ts

@@ -92,21 +92,21 @@ const cancelAllPendingRaf = () => {
 };
 
 const stubAnimationGroup = () => {
-  sinon.stub(Animation.AnimationModel.AnimationGroup.prototype, 'scrollNode')
-      .resolves(new Animation.AnimationDOMNode.AnimationDOMNode(null as unknown as SDK.DOMModel.DOMNode));
+  sinon.stub(SDK.AnimationModel.AnimationGroup.prototype, 'scrollNode')
+      .resolves(new SDK.AnimationModel.AnimationDOMNode(null as unknown as SDK.DOMModel.DOMNode));
 };
 
 const stubAnimationDOMNode = (): AnimationDOMNodeStubs => {
   const verticalScrollRange =
-      sinon.stub(Animation.AnimationDOMNode.AnimationDOMNode.prototype, 'verticalScrollRange').resolves(100);
+      sinon.stub(SDK.AnimationModel.AnimationDOMNode.prototype, 'verticalScrollRange').resolves(100);
   const horizontalScrollRange =
-      sinon.stub(Animation.AnimationDOMNode.AnimationDOMNode.prototype, 'horizontalScrollRange').resolves(100);
-  const scrollLeft = sinon.stub(Animation.AnimationDOMNode.AnimationDOMNode.prototype, 'scrollLeft').resolves(10);
-  const scrollTop = sinon.stub(Animation.AnimationDOMNode.AnimationDOMNode.prototype, 'scrollTop').resolves(10);
+      sinon.stub(SDK.AnimationModel.AnimationDOMNode.prototype, 'horizontalScrollRange').resolves(100);
+  const scrollLeft = sinon.stub(SDK.AnimationModel.AnimationDOMNode.prototype, 'scrollLeft').resolves(10);
+  const scrollTop = sinon.stub(SDK.AnimationModel.AnimationDOMNode.prototype, 'scrollTop').resolves(10);
   const addScrollEventListener =
-      sinon.stub(Animation.AnimationDOMNode.AnimationDOMNode.prototype, 'addScrollEventListener').resolves();
+      sinon.stub(SDK.AnimationModel.AnimationDOMNode.prototype, 'addScrollEventListener').resolves();
   const removeScrollEventListener =
-      sinon.stub(Animation.AnimationDOMNode.AnimationDOMNode.prototype, 'removeScrollEventListener').resolves();
+      sinon.stub(SDK.AnimationModel.AnimationDOMNode.prototype, 'removeScrollEventListener').resolves();
   return {
     verticalScrollRange,
     horizontalScrollRange,
@@ -159,7 +159,7 @@ describeWithMockConnection('AnimationTimeline', () => {
 
   const updatesUiOnEvent = (inScope: boolean) => async () => {
     SDK.TargetManager.TargetManager.instance().setScopeTarget(inScope ? target : null);
-    const model = target.model(Animation.AnimationModel.AnimationModel);
+    const model = target.model(SDK.AnimationModel.AnimationModel);
     assert.exists(model);
 
     view = Animation.AnimationTimeline.AnimationTimeline.instance({forceNew: true});
@@ -239,7 +239,7 @@ describeWithMockConnection('AnimationTimeline', () => {
     const waitForAnimationGroupSelectedPromise = new ManualPromise();
 
     let domModel: SDK.DOMModel.DOMModel;
-    let animationModel: Animation.AnimationModel.AnimationModel;
+    let animationModel: SDK.AnimationModel.AnimationModel;
     let contentDocument: SDK.DOMModel.DOMDocument;
     beforeEach(async () => {
       view = Animation.AnimationTimeline.AnimationTimeline.instance({forceNew: true});
@@ -253,7 +253,7 @@ describeWithMockConnection('AnimationTimeline', () => {
         waitForPreviewsManualPromise.resolve();
       });
 
-      const model = target.model(Animation.AnimationModel.AnimationModel);
+      const model = target.model(SDK.AnimationModel.AnimationModel);
       assert.exists(model);
       animationModel = model;
 
@@ -389,7 +389,7 @@ describeWithMockConnection('AnimationTimeline', () => {
     const waitForScheduleRedrawAfterAnimationGroupUpdated = new ManualPromise();
 
     let domModel: SDK.DOMModel.DOMModel;
-    let animationModel: Animation.AnimationModel.AnimationModel;
+    let animationModel: SDK.AnimationModel.AnimationModel;
     let contentDocument: SDK.DOMModel.DOMDocument;
     beforeEach(async () => {
       view = Animation.AnimationTimeline.AnimationTimeline.instance({forceNew: true});
@@ -406,7 +406,7 @@ describeWithMockConnection('AnimationTimeline', () => {
         waitForScheduleRedrawAfterAnimationGroupUpdated.resolve();
       });
 
-      const model = target.model(Animation.AnimationModel.AnimationModel);
+      const model = target.model(SDK.AnimationModel.AnimationModel);
       assert.isNotNull(model);
       animationModel = model;
 
@@ -481,7 +481,7 @@ describeWithMockConnection('AnimationTimeline', () => {
     const waitForScheduleRedrawAfterAnimationGroupUpdated = new ManualPromise();
 
     let domModel: SDK.DOMModel.DOMModel;
-    let animationModel: Animation.AnimationModel.AnimationModel;
+    let animationModel: SDK.AnimationModel.AnimationModel;
     let contentDocument: SDK.DOMModel.DOMDocument;
     beforeEach(async () => {
       stubbedAnimationDOMNode = stubAnimationDOMNode();
@@ -501,7 +501,7 @@ describeWithMockConnection('AnimationTimeline', () => {
         waitForScheduleRedrawAfterAnimationGroupUpdated.resolve();
       });
 
-      const model = target.model(Animation.AnimationModel.AnimationModel);
+      const model = target.model(SDK.AnimationModel.AnimationModel);
       assert.exists(model);
       animationModel = model;