devtools-tracing 1.0.0

package/lib/front_end/core/sdk/ConsoleModelTypes.ts

@@ -0,0 +1,15 @@
+// Copyright 2020 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// We need these enums here as enum values of enums defined in closure land
+// are typed as string, and hence provide for weaker type-checking.
+
+export enum FrontendMessageType {
+  /* eslint-disable @typescript-eslint/naming-convention -- Used by web_tests. */
+  Result = 'result',
+  Command = 'command',
+  System = 'system',
+  QueryObjectResult = 'queryObjectResult',
+  /* eslint-enable @typescript-eslint/naming-convention */
+}

package/lib/front_end/core/sdk/Cookie.ts

@@ -0,0 +1,319 @@
+// Copyright 2019 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import type * as Protocol from '../../generated/protocol.js';
+import type * as Platform from '../platform/platform.js';
+
+const OPAQUE_PARTITION_KEY = '<opaque>';
+
+export class Cookie {
+  readonly #name: string;
+  readonly #value: string;
+  readonly #type: Type|null|undefined;
+  #attributes = new Map<Attribute, string|number|boolean|undefined>();
+  #size = 0;
+  #priority: Protocol.Network.CookiePriority;
+  #cookieLine: string|null = null;
+  #partitionKey: Protocol.Network.CookiePartitionKey|undefined;
+
+  constructor(
+      name: string, value: string, type?: Type|null, priority?: Protocol.Network.CookiePriority,
+      partitionKey?: Protocol.Network.CookiePartitionKey) {
+    this.#name = name;
+    this.#value = value;
+    this.#type = type;
+    this.#priority = (priority || 'Medium' as Protocol.Network.CookiePriority);
+    this.#partitionKey = partitionKey;
+  }
+
+  static fromProtocolCookie(protocolCookie: Protocol.Network.Cookie): Cookie {
+    const cookie = new Cookie(protocolCookie.name, protocolCookie.value, null, protocolCookie.priority);
+    cookie.addAttribute(Attribute.DOMAIN, protocolCookie['domain']);
+    cookie.addAttribute(Attribute.PATH, protocolCookie['path']);
+    if (protocolCookie['expires']) {
+      cookie.addAttribute(Attribute.EXPIRES, protocolCookie['expires'] * 1000);
+    }
+    if (protocolCookie['httpOnly']) {
+      cookie.addAttribute(Attribute.HTTP_ONLY);
+    }
+    if (protocolCookie['secure']) {
+      cookie.addAttribute(Attribute.SECURE);
+    }
+    if (protocolCookie['sameSite']) {
+      cookie.addAttribute(Attribute.SAME_SITE, protocolCookie['sameSite']);
+    }
+    if ('sourcePort' in protocolCookie) {
+      cookie.addAttribute(Attribute.SOURCE_PORT, protocolCookie.sourcePort);
+    }
+    if ('sourceScheme' in protocolCookie) {
+      cookie.addAttribute(Attribute.SOURCE_SCHEME, protocolCookie.sourceScheme);
+    }
+    if ('partitionKey' in protocolCookie) {
+      if (protocolCookie.partitionKey) {
+        cookie.setPartitionKey(
+            protocolCookie.partitionKey.topLevelSite, protocolCookie.partitionKey.hasCrossSiteAncestor);
+      }
+    }
+    if ('partitionKeyOpaque' in protocolCookie && protocolCookie.partitionKeyOpaque) {
+      cookie.addAttribute(Attribute.PARTITION_KEY, OPAQUE_PARTITION_KEY);
+    }
+    cookie.setSize(protocolCookie['size']);
+    return cookie;
+  }
+
+  key(): string {
+    return (this.domain() || '-') + ' ' + this.name() + ' ' + (this.path() || '-') + ' ' +
+        (this.partitionKey() ?
+             (this.topLevelSite() + ' ' + (this.hasCrossSiteAncestor() ? 'cross_site' : 'same_site')) :
+             '-');
+  }
+
+  name(): string {
+    return this.#name;
+  }
+
+  value(): string {
+    return this.#value;
+  }
+
+  type(): Type|null|undefined {
+    return this.#type;
+  }
+
+  httpOnly(): boolean {
+    return this.#attributes.has(Attribute.HTTP_ONLY);
+  }
+
+  secure(): boolean {
+    return this.#attributes.has(Attribute.SECURE);
+  }
+
+  partitioned(): boolean {
+    return this.#attributes.has(Attribute.PARTITIONED) || Boolean(this.partitionKey()) || this.partitionKeyOpaque();
+  }
+
+  sameSite(): Protocol.Network.CookieSameSite {
+    // TODO(allada) This should not rely on #attributes and instead store them individually.
+    // when #attributes get added via addAttribute() they are lowercased, hence the lowercasing of samesite here
+    return this.#attributes.get(Attribute.SAME_SITE) as Protocol.Network.CookieSameSite;
+  }
+
+  partitionKey(): Protocol.Network.CookiePartitionKey {
+    return this.#partitionKey as Protocol.Network.CookiePartitionKey;
+  }
+
+  setPartitionKey(topLevelSite: string, hasCrossSiteAncestor: boolean): void {
+    this.#partitionKey = {topLevelSite, hasCrossSiteAncestor};
+    if (!this.#attributes.has(Attribute.PARTITIONED)) {
+      this.addAttribute(Attribute.PARTITIONED);
+    }
+  }
+
+  topLevelSite(): string {
+    if (!this.#partitionKey) {
+      return '';
+    }
+    return this.#partitionKey?.topLevelSite;
+  }
+
+  setTopLevelSite(topLevelSite: string, hasCrossSiteAncestor: boolean): void {
+    this.setPartitionKey(topLevelSite, hasCrossSiteAncestor);
+  }
+
+  hasCrossSiteAncestor(): boolean {
+    if (!this.#partitionKey) {
+      return false;
+    }
+    return this.#partitionKey?.hasCrossSiteAncestor;
+  }
+
+  setHasCrossSiteAncestor(hasCrossSiteAncestor: boolean): void {
+    if (!this.partitionKey() || !Boolean(this.topLevelSite())) {
+      return;
+    }
+    this.setPartitionKey(this.topLevelSite(), hasCrossSiteAncestor);
+  }
+
+  partitionKeyOpaque(): boolean {
+    if (!this.#partitionKey) {
+      return false;
+    }
+    return (this.topLevelSite() === OPAQUE_PARTITION_KEY);
+  }
+
+  setPartitionKeyOpaque(): void {
+    this.addAttribute(Attribute.PARTITION_KEY, OPAQUE_PARTITION_KEY);
+    this.setPartitionKey(OPAQUE_PARTITION_KEY, false);
+  }
+
+  priority(): Protocol.Network.CookiePriority {
+    return this.#priority;
+  }
+
+  session(): boolean {
+    // RFC 2965 suggests using Discard attribute to mark session cookies, but this does not seem to be widely used.
+    // Check for absence of explicitly max-age or expiry date instead.
+    return !(this.#attributes.has(Attribute.EXPIRES) || this.#attributes.has(Attribute.MAX_AGE));
+  }
+
+  path(): string {
+    return this.#attributes.get(Attribute.PATH) as string;
+  }
+
+  domain(): string {
+    return this.#attributes.get(Attribute.DOMAIN) as string;
+  }
+
+  expires(): number {
+    return this.#attributes.get(Attribute.EXPIRES) as number;
+  }
+
+  maxAge(): number {
+    return this.#attributes.get(Attribute.MAX_AGE) as number;
+  }
+
+  sourcePort(): number {
+    return this.#attributes.get(Attribute.SOURCE_PORT) as number;
+  }
+
+  sourceScheme(): Protocol.Network.CookieSourceScheme {
+    return this.#attributes.get(Attribute.SOURCE_SCHEME) as Protocol.Network.CookieSourceScheme;
+  }
+
+  size(): number {
+    return this.#size;
+  }
+
+  /**
+   * @deprecated
+   */
+  url(): Platform.DevToolsPath.UrlString|null {
+    if (!this.domain() || !this.path()) {
+      return null;
+    }
+    let port = '';
+    const sourcePort = this.sourcePort();
+    // Do not include standard ports to ensure the back-end will change standard ports according to the scheme.
+    if (sourcePort && sourcePort !== 80 && sourcePort !== 443) {
+      port = `:${this.sourcePort()}`;
+    }
+    // We must not consider the this.sourceScheme() here, otherwise it will be impossible to set a cookie without
+    // the Secure attribute from a secure origin.
+    return (this.secure() ? 'https://' : 'http://') + this.domain() + port + this.path() as
+        Platform.DevToolsPath.UrlString;
+  }
+
+  setSize(size: number): void {
+    this.#size = size;
+  }
+
+  expiresDate(requestDate: Date): Date|null {
+    // RFC 6265 indicates that the max-age attribute takes precedence over the expires attribute
+    if (this.maxAge()) {
+      return new Date(requestDate.getTime() + 1000 * this.maxAge());
+    }
+
+    if (this.expires()) {
+      return new Date(this.expires());
+    }
+
+    return null;
+  }
+
+  addAttribute(key: Attribute|null, value?: string|number|boolean): void {
+    if (!key) {
+      return;
+    }
+    switch (key) {
+      case Attribute.PRIORITY:
+        this.#priority = (value as Protocol.Network.CookiePriority);
+        break;
+      default:
+        this.#attributes.set(key, value);
+    }
+  }
+
+  hasAttribute(key: Attribute): boolean {
+    return this.#attributes.has(key);
+  }
+
+  getAttribute(key: Attribute): string|number|boolean|undefined {
+    return this.#attributes.get(key);
+  }
+
+  setCookieLine(cookieLine: string): void {
+    this.#cookieLine = cookieLine;
+  }
+
+  getCookieLine(): string|null {
+    return this.#cookieLine;
+  }
+
+  matchesSecurityOrigin(securityOrigin: string): boolean {
+    const hostname = new URL(securityOrigin).hostname;
+    return Cookie.isDomainMatch(this.domain(), hostname);
+  }
+
+  static isDomainMatch(domain: string, hostname: string): boolean {
+    // This implementation mirrors
+    // https://source.chromium.org/search?q=net::cookie_util::IsDomainMatch()
+    //
+    // Can domain match in two ways; as a domain cookie (where the cookie
+    // domain begins with ".") or as a host cookie (where it doesn't).
+
+    // Some consumers of the CookieMonster expect to set cookies on
+    // URLs like http://.strange.url.  To retrieve cookies in this instance,
+    // we allow matching as a host cookie even when the domain_ starts with
+    // a period.
+    if (hostname === domain) {
+      return true;
+    }
+
+    // Domain cookie must have an initial ".".  To match, it must be
+    // equal to url's host with initial period removed, or a suffix of
+    // it.
+
+    // Arguably this should only apply to "http" or "https" cookies, but
+    // extension cookie tests currently use the funtionality, and if we
+    // ever decide to implement that it should be done by preventing
+    // such cookies from being set.
+    if (!domain || domain[0] !== '.') {
+      return false;
+    }
+
+    // The host with a "." prefixed.
+    if (domain.substr(1) === hostname) {
+      return true;
+    }
+
+    // A pure suffix of the host (ok since we know the domain already
+    // starts with a ".")
+    return hostname.length > domain.length && hostname.endsWith(domain);
+  }
+}
+
+export const enum Type {
+  REQUEST = 0,
+  RESPONSE = 1,
+}
+
+export const enum Attribute {
+  NAME = 'name',
+  VALUE = 'value',
+  SIZE = 'size',
+  DOMAIN = 'domain',
+  PATH = 'path',
+  EXPIRES = 'expires',
+  MAX_AGE = 'max-age',
+  HTTP_ONLY = 'http-only',
+  SECURE = 'secure',
+  SAME_SITE = 'same-site',
+  SOURCE_SCHEME = 'source-scheme',
+  SOURCE_PORT = 'source-port',
+  PRIORITY = 'priority',
+  PARTITIONED = 'partitioned',
+  PARTITION_KEY = 'partition-key',
+  PARTITION_KEY_SITE = 'partition-key-site',
+  HAS_CROSS_SITE_ANCESTOR = 'has-cross-site-ancestor',
+}

package/lib/front_end/core/sdk/CookieModel.ts

@@ -0,0 +1,239 @@
+// Copyright 2017 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import * as Protocol from '../../generated/protocol.js';
+import * as Common from '../common/common.js';
+import * as Platform from '../platform/platform.js';
+import * as Root from '../root/root.js';
+
+import {type Attribute, Cookie} from './Cookie.js';
+import {Events as NetworkManagerEvents, NetworkManager} from './NetworkManager.js';
+import type {Resource} from './Resource.js';
+import {Events as ResourceTreeModelEvents, ResourceTreeModel} from './ResourceTreeModel.js';
+import {SDKModel} from './SDKModel.js';
+import {Capability, type Target} from './Target.js';
+
+export class CookieModel extends SDKModel<EventTypes> {
+  readonly #blockedCookies = new Map<string, Cookie>();
+  readonly #cookieToBlockedReasons = new Map<Cookie, BlockedReason[]>();
+  readonly #refreshThrottler = new Common.Throttler.Throttler(300);
+  #cookies = new Map<string, Cookie[]>();
+
+  constructor(target: Target) {
+    super(target);
+
+    target.model(ResourceTreeModel)
+        ?.addEventListener(ResourceTreeModelEvents.PrimaryPageChanged, this.#onPrimaryPageChanged, this);
+    target.model(NetworkManager)
+        ?.addEventListener(NetworkManagerEvents.ResponseReceived, this.#onResponseReceived, this);
+    target.model(NetworkManager)?.addEventListener(NetworkManagerEvents.LoadingFinished, this.#onLoadingFinished, this);
+  }
+
+  addBlockedCookie(cookie: Cookie, blockedReasons: BlockedReason[]|null): void {
+    const key = cookie.key();
+    const previousCookie = this.#blockedCookies.get(key);
+    this.#blockedCookies.set(key, cookie);
+    if (blockedReasons) {
+      this.#cookieToBlockedReasons.set(cookie, blockedReasons);
+    } else {
+      this.#cookieToBlockedReasons.delete(cookie);
+    }
+    if (previousCookie) {
+      this.#cookieToBlockedReasons.delete(previousCookie);
+    }
+  }
+
+  removeBlockedCookie(cookie: Cookie): void {
+    this.#blockedCookies.delete(cookie.key());
+  }
+
+  async #onPrimaryPageChanged(): Promise<void> {
+    this.#blockedCookies.clear();
+    this.#cookieToBlockedReasons.clear();
+    await this.#refresh();
+  }
+
+  getCookieToBlockedReasonsMap(): ReadonlyMap<Cookie, BlockedReason[]> {
+    return this.#cookieToBlockedReasons;
+  }
+
+  async #getCookies(urls: Platform.MapUtilities.Multimap<string, string>): Promise<void> {
+    const networkAgent = this.target().networkAgent();
+    const newCookies = new Map<string, Cookie[]>(await Promise.all(urls.keysArray().map(
+        domain => networkAgent.invoke_getCookies({urls: [...urls.get(domain).values()]})
+                      .then(({cookies}) => [domain, cookies.map(Cookie.fromProtocolCookie)] as const))));
+    const updated = this.#isUpdated(newCookies);
+    this.#cookies = newCookies;
+    if (updated) {
+      this.dispatchEventToListeners(Events.COOKIE_LIST_UPDATED);
+    }
+  }
+
+  async deleteCookie(cookie: Cookie): Promise<void> {
+    await this.deleteCookies([cookie]);
+  }
+
+  async clear(domain?: string, securityOrigin?: string): Promise<void> {
+    if (!this.#isRefreshing()) {
+      await this.#refreshThrottled();
+    }
+    const cookies = domain ? (this.#cookies.get(domain) || []) : [...this.#cookies.values()].flat();
+    cookies.push(...this.#blockedCookies.values());
+    if (securityOrigin) {
+      const cookiesToDelete = cookies.filter(cookie => {
+        return cookie.matchesSecurityOrigin(securityOrigin);
+      });
+      await this.deleteCookies(cookiesToDelete);
+    } else {
+      await this.deleteCookies(cookies);
+    }
+  }
+
+  async saveCookie(cookie: Cookie): Promise<boolean> {
+    let domain = cookie.domain();
+    if (!domain.startsWith('.')) {
+      domain = '';
+    }
+    let expires: number|undefined = undefined;
+    if (cookie.expires()) {
+      expires = Math.floor(Date.parse(`${cookie.expires()}`) / 1000);
+    }
+    const enabled = Root.Runtime.experiments.isEnabled('experimental-cookie-features');
+    const preserveUnset = (scheme: Protocol.Network.CookieSourceScheme): Protocol.Network.CookieSourceScheme.Unset|
+                          undefined => scheme === Protocol.Network.CookieSourceScheme.Unset ? scheme : undefined;
+    const protocolCookie = {
+      name: cookie.name(),
+      value: cookie.value(),
+      url: cookie.url() || undefined,
+      domain,
+      path: cookie.path(),
+      secure: cookie.secure(),
+      httpOnly: cookie.httpOnly(),
+      sameSite: cookie.sameSite(),
+      expires,
+      priority: cookie.priority(),
+      partitionKey: cookie.partitionKey(),
+      sourceScheme: enabled ? cookie.sourceScheme() : preserveUnset(cookie.sourceScheme()),
+      sourcePort: enabled ? cookie.sourcePort() : undefined,
+    };
+    const response = await this.target().networkAgent().invoke_setCookie(protocolCookie);
+    const error = response.getError();
+    if (error || !response.success) {
+      return false;
+    }
+    await this.#refreshThrottled();
+    return response.success;
+  }
+
+  /**
+   * Returns cookies needed by current page's frames whose security origins are |domain|.
+   */
+  async getCookiesForDomain(domain: string, forceUpdate?: boolean): Promise<Cookie[]> {
+    if (!this.#isRefreshing() || forceUpdate) {
+      await this.#refreshThrottled();
+    }
+    const normalCookies = this.#cookies.get(domain) || [];
+    return normalCookies.concat(Array.from(this.#blockedCookies.values()));
+  }
+
+  async deleteCookies(cookies: Cookie[]): Promise<void> {
+    const networkAgent = this.target().networkAgent();
+    this.#blockedCookies.clear();
+    this.#cookieToBlockedReasons.clear();
+    await Promise.all(cookies.map(cookie => networkAgent.invoke_deleteCookies({
+      name: cookie.name(),
+      url: undefined,
+      domain: cookie.domain(),
+      path: cookie.path(),
+      partitionKey: cookie.partitionKey(),
+    })));
+    await this.#refreshThrottled();
+  }
+
+  #isRefreshing(): boolean {
+    return Boolean(this.listeners?.size);
+  }
+
+  #isUpdated(newCookies: Map<string, Cookie[]>): boolean {
+    if (newCookies.size !== this.#cookies.size) {
+      return true;
+    }
+    for (const [domain, newDomainCookies] of newCookies) {
+      if (!this.#cookies.has(domain)) {
+        return true;
+      }
+      const oldDomainCookies = this.#cookies.get(domain) || [];
+      if (newDomainCookies.length !== oldDomainCookies.length) {
+        return true;
+      }
+      const comparisonKey = (c: Cookie): string => c.key() + ' ' + c.value();
+      const oldDomainCookieKeys = new Set(oldDomainCookies.map(comparisonKey));
+      for (const newCookie of newDomainCookies) {
+        if (!oldDomainCookieKeys.has(comparisonKey(newCookie))) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  #refreshThrottled(): Promise<void> {
+    return this.#refreshThrottler.schedule(() => this.#refresh());
+  }
+
+  #refresh(): Promise<void> {
+    const resourceURLs = new Platform.MapUtilities.Multimap<string, string>();
+    function populateResourceURLs(resource: Resource): boolean {
+      const documentURL = Common.ParsedURL.ParsedURL.fromString(resource.documentURL);
+      if (documentURL) {
+        resourceURLs.set(documentURL.securityOrigin(), resource.url);
+      }
+      return false;
+    }
+    const resourceTreeModel = this.target().model(ResourceTreeModel);
+    if (resourceTreeModel) {
+      // In case the current frame was unreachable, add its cookies
+      // because they might help to debug why the frame was unreachable.
+      const unreachableUrl = resourceTreeModel.mainFrame?.unreachableUrl();
+      if (unreachableUrl) {
+        const documentURL = Common.ParsedURL.ParsedURL.fromString(unreachableUrl);
+        if (documentURL) {
+          resourceURLs.set(documentURL.securityOrigin(), unreachableUrl);
+        }
+      }
+
+      resourceTreeModel.forAllResources(populateResourceURLs);
+    }
+    return this.#getCookies(resourceURLs);
+  }
+
+  #onResponseReceived(): void {
+    if (this.#isRefreshing()) {
+      void this.#refreshThrottled();
+    }
+  }
+
+  #onLoadingFinished(): void {
+    if (this.#isRefreshing()) {
+      void this.#refreshThrottled();
+    }
+  }
+}
+
+SDKModel.register(CookieModel, {capabilities: Capability.NETWORK, autostart: false});
+export interface BlockedReason {
+  uiString: string;
+  attribute: Attribute|null;
+}
+export interface ExemptionReason {
+  uiString: string;
+}
+
+export const enum Events {
+  COOKIE_LIST_UPDATED = 'CookieListUpdated',
+}
+
+export interface EventTypes {
+  [Events.COOKIE_LIST_UPDATED]: void;
+}