devtools-tracing 1.1.0 → 1.2.0

package/lib/front_end/core/host/GdpClient.ts

@@ -1,316 +0,0 @@
-// Copyright 2025 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 Root from '../root/root.js';
-
-import {InspectorFrontendHostInstance} from './InspectorFrontendHost.js';
-import type {DispatchHttpRequestRequest, DispatchHttpRequestResult} from './InspectorFrontendHostAPI.js';
-
-export enum SubscriptionStatus {
-  ENABLED = 'SUBSCRIPTION_STATE_ENABLED',
-  PENDING = 'SUBSCRIPTION_STATE_PENDING',
-  CANCELED = 'SUBSCRIPTION_STATE_CANCELED',
-  REFUNDED = 'SUBSCRIPTION_STATE_REFUNDED',
-  AWAITING_FIX = 'SUBSCRIPTION_STATE_AWAITING_FIX',
-  ON_HOLD = 'SUBSCRIPTION_STATE_ACCOUNT_ON_HOLD',
-}
-
-export enum SubscriptionTier {
-  PREMIUM_ANNUAL = 'SUBSCRIPTION_TIER_PREMIUM_ANNUAL',
-  PREMIUM_MONTHLY = 'SUBSCRIPTION_TIER_PREMIUM_MONTHLY',
-  PRO_ANNUAL = 'SUBSCRIPTION_TIER_PRO_ANNUAL',
-  PRO_MONTHLY = 'SUBSCRIPTION_TIER_PRO_MONTHLY',
-}
-
-export enum EligibilityStatus {
-  ELIGIBLE = 'ELIGIBLE',
-  NOT_ELIGIBLE = 'NOT_ELIGIBLE',
-}
-
-export enum EmailPreference {
-  ENABLED = 'ENABLED',
-  DISABLED = 'DISABLED',
-}
-
-interface CheckElibigilityResponse {
-  createProfile: EligibilityStatus;
-}
-
-interface BatchGetAwardsResponse {
-  awards?: Award[];
-}
-
-export interface Award {
-  name: string;
-  badge: {
-    title: string,
-    description: string,
-    imageUri: string,
-    deletableByUser: boolean,
-  };
-  title: string;
-  description: string;
-  imageUri: string;
-  createTime: string;
-  awardingUri: string;
-}
-
-export interface Profile {
-  // Resource name of the profile.
-  // Format: profiles/{obfuscated_profile_id}
-  name: string;
-  activeSubscription?: {
-    subscriptionStatus: SubscriptionStatus,
-    // To ensure forward compatibility, we accept any string, allowing the server to
-    // introduce new subscription tiers without breaking older clients.
-    subscriptionTier: SubscriptionTier|string,
-  };
-}
-
-export interface GetProfileResponse {
-  profile: Profile|null;
-  isEligible: boolean;
-}
-
-export enum GdpErrorType {
-  HTTP_RESPONSE_UNAVAILABLE = 'HTTP_RESPONSE_UNAVAILABLE',
-  NOT_FOUND = 'NOT_FOUND',
-}
-
-class GdpError extends Error {
-  constructor(readonly type: GdpErrorType, options?: ErrorOptions) {
-    super(undefined, options);
-  }
-}
-
-/**
- * The `batchGet` awards endpoint returns badge names with an
- * obfuscated user ID (e.g., `profiles/12345/awards/badge-name`).
- * This function normalizes them to use `me` instead of the ID
- * (e.g., `profiles/me/awards/badge-path`) to match the format
- * used for client-side requests.
- **/
-function normalizeBadgeName(name: string): string {
-  return name.replace(/profiles\/[^/]+\/awards\//, 'profiles/me/awards/');
-}
-
-export const GOOGLE_DEVELOPER_PROGRAM_PROFILE_LINK = 'https://developers.google.com/profile/u/me';
-
-async function makeHttpRequest<R>(request: DispatchHttpRequestRequest): Promise<R> {
-  if (!isGdpProfilesAvailable()) {
-    throw new GdpError(GdpErrorType.HTTP_RESPONSE_UNAVAILABLE);
-  }
-
-  const response = await new Promise<DispatchHttpRequestResult>(resolve => {
-    InspectorFrontendHostInstance.dispatchHttpRequest(request, resolve);
-  });
-
-  debugLog({request, response});
-  if (response.statusCode === 404) {
-    throw new GdpError(GdpErrorType.NOT_FOUND);
-  }
-
-  if ('response' in response && response.statusCode === 200) {
-    try {
-      return JSON.parse(response.response) as R;
-    } catch (err) {
-      throw new GdpError(GdpErrorType.HTTP_RESPONSE_UNAVAILABLE, {cause: err});
-    }
-  }
-
-  throw new GdpError(GdpErrorType.HTTP_RESPONSE_UNAVAILABLE);
-}
-
-const SERVICE_NAME = 'gdpService';
-let gdpClientInstance: GdpClient|null = null;
-export class GdpClient {
-  #cachedProfilePromise?: Promise<Profile>;
-  #cachedEligibilityPromise?: Promise<CheckElibigilityResponse>;
-
-  private constructor() {
-  }
-
-  static instance({forceNew}: {
-    forceNew: boolean,
-  } = {forceNew: false}): GdpClient {
-    if (!gdpClientInstance || forceNew) {
-      gdpClientInstance = new GdpClient();
-    }
-    return gdpClientInstance;
-  }
-
-  /**
-   * Fetches the user's GDP profile and eligibility status.
-   *
-   * It first attempts to fetch the profile. If the profile is not found
-   * (a `NOT_FOUND` error), this is handled gracefully by treating the profile
-   * as `null` and then proceeding to check for eligibility.
-   *
-   * @returns A promise that resolves with an object containing the `profile`
-   * and `isEligible` status, or `null` if an unexpected error occurs.
-   */
-  async getProfile(): Promise<GetProfileResponse|null> {
-    try {
-      const profile = await this.#getProfile();
-      return {
-        profile,
-        isEligible: true,
-      };
-    } catch (err: unknown) {
-      if (err instanceof GdpError && err.type === GdpErrorType.HTTP_RESPONSE_UNAVAILABLE) {
-        return null;
-      }
-    }
-
-    try {
-      const checkEligibilityResponse = await this.#checkEligibility();
-      return {
-        profile: null,
-        isEligible: checkEligibilityResponse.createProfile === EligibilityStatus.ELIGIBLE,
-      };
-    } catch {
-      return null;
-    }
-  }
-
-  async #getProfile(): Promise<Profile> {
-    if (this.#cachedProfilePromise) {
-      return await this.#cachedProfilePromise;
-    }
-
-    this.#cachedProfilePromise = makeHttpRequest<Profile>({
-                                   service: SERVICE_NAME,
-                                   path: '/v1beta1/profile:get',
-                                   method: 'GET',
-                                 }).then(profile => {
-      this.#cachedEligibilityPromise = Promise.resolve({createProfile: EligibilityStatus.ELIGIBLE});
-      return profile;
-    });
-
-    return await this.#cachedProfilePromise;
-  }
-
-  async #checkEligibility(): Promise<CheckElibigilityResponse> {
-    if (this.#cachedEligibilityPromise) {
-      return await this.#cachedEligibilityPromise;
-    }
-
-    this.#cachedEligibilityPromise =
-        makeHttpRequest({service: SERVICE_NAME, path: '/v1beta1/eligibility:check', method: 'GET'});
-
-    return await this.#cachedEligibilityPromise;
-  }
-
-  /**
-   * @returns null if the request fails, the awarded badge names otherwise.
-   */
-  async getAwardedBadgeNames({names}: {names: string[]}): Promise<Set<string>|null> {
-    try {
-      const response = await makeHttpRequest<BatchGetAwardsResponse>({
-        service: SERVICE_NAME,
-        path: '/v1beta1/profiles/me/awards:batchGet',
-        method: 'GET',
-        queryParams: {
-          allowMissing: 'true',
-          names,
-        }
-      });
-
-      return new Set(response.awards?.map(award => normalizeBadgeName(award.name)) ?? []);
-    } catch {
-      return null;
-    }
-  }
-
-  async createProfile({user, emailPreference}: {user: string, emailPreference: EmailPreference}):
-      Promise<Profile|null> {
-    try {
-      const response = await makeHttpRequest<Profile>({
-        service: SERVICE_NAME,
-        path: '/v1beta1/profiles',
-        method: 'POST',
-        body: JSON.stringify({
-          user,
-          newsletter_email: emailPreference,
-        }),
-      });
-      this.#clearCache();
-      return response;
-    } catch {
-      return null;
-    }
-  }
-
-  #clearCache(): void {
-    this.#cachedProfilePromise = undefined;
-    this.#cachedEligibilityPromise = undefined;
-  }
-
-  async createAward({name}: {name: string}): Promise<Award|null> {
-    try {
-      const response = await makeHttpRequest<Award>({
-        service: SERVICE_NAME,
-        path: '/v1beta1/profiles/me/awards',
-        method: 'POST',
-        body: JSON.stringify({
-          awardingUri: 'devtools://devtools',
-          name,
-        })
-      });
-      return response;
-    } catch {
-      return null;
-    }
-  }
-}
-
-function isDebugMode(): boolean {
-  return Boolean(localStorage.getItem('debugGdpIntegrationEnabled'));
-}
-
-function debugLog(...log: unknown[]): void {
-  if (!isDebugMode()) {
-    return;
-  }
-
-  // eslint-disable-next-line no-console
-  console.log('debugLog', ...log);
-}
-
-function setDebugGdpIntegrationEnabled(enabled: boolean): void {
-  if (enabled) {
-    localStorage.setItem('debugGdpIntegrationEnabled', 'true');
-  } else {
-    localStorage.removeItem('debugGdpIntegrationEnabled');
-  }
-}
-
-export function isGdpProfilesAvailable(): boolean {
-  const isBaseFeatureEnabled = Boolean(Root.Runtime.hostConfig.devToolsGdpProfiles?.enabled);
-  const isBrandedBuild = Boolean(Root.Runtime.hostConfig.devToolsGdpProfilesAvailability?.enabled);
-  const isOffTheRecordProfile = Root.Runtime.hostConfig.isOffTheRecord;
-  const isDisabledByEnterprisePolicy =
-      getGdpProfilesEnterprisePolicy() === Root.Runtime.GdpProfilesEnterprisePolicyValue.DISABLED;
-  return isBaseFeatureEnabled && isBrandedBuild && !isOffTheRecordProfile && !isDisabledByEnterprisePolicy;
-}
-
-export function getGdpProfilesEnterprisePolicy(): Root.Runtime.GdpProfilesEnterprisePolicyValue {
-  return (
-      Root.Runtime.hostConfig.devToolsGdpProfilesAvailability?.enterprisePolicyValue ??
-      Root.Runtime.GdpProfilesEnterprisePolicyValue.DISABLED);
-}
-
-export function isBadgesEnabled(): boolean {
-  const isBadgesEnabledByEnterprisePolicy =
-      getGdpProfilesEnterprisePolicy() === Root.Runtime.GdpProfilesEnterprisePolicyValue.ENABLED;
-  const isBadgesEnabledByFeatureFlag = Boolean(Root.Runtime.hostConfig.devToolsGdpProfiles?.badgesEnabled);
-  return isBadgesEnabledByEnterprisePolicy && isBadgesEnabledByFeatureFlag;
-}
-
-export function isStarterBadgeEnabled(): boolean {
-  return Boolean(Root.Runtime.hostConfig.devToolsGdpProfiles?.starterBadgeEnabled);
-}
-
-// @ts-expect-error
-globalThis.setDebugGdpIntegrationEnabled = setDebugGdpIntegrationEnabled;