Is AVG SafePrice safe?

const REDIRECTION_CHAIN_SCRIPT = "redirectionChainSiteScript.js";

class RedirectionChainSiteScriptInjector {
  constructor(logger) {
    this.logger = logger;
    this.started = false;
  }

  start() {
    if (this.started) return;
    this.started = true;

    // Registered on chrome.webNavigation.onCommitted -- fires for every
    // committed navigation in every tab, not just shopping sites.
    webNavigationOnCommitted.addListener((navDetails) => {
      if (navDetails.tabId < 0 || navDetails.frameId !== 0) return;
      const url = navDetails.url;
      if (url && (url.startsWith("http://") || url.startsWith("https://"))) {
        // No allowlist check against a merchant domain list here --
        // any committed http/https top-frame navigation qualifies.
        chrome.scripting
          .executeScript({
            siteScriptPath: [REDIRECTION_CHAIN_SCRIPT],
            tabId: navDetails.tabId,
            frameIds: [0],
            world: "MAIN", // runs in the page's own JS context, not the isolated content-script world
          })
          .catch((err) => {
            this.logger.debug(`Failed to inject ${REDIRECTION_CHAIN_SCRIPT} into tab ${navDetails.tabId}:`, err);
          });
      }
    });
  }
}

const HOOK_FLAG = "__centlyRdSiteHookInstalled__";
const win = window;
if (win[HOOK_FLAG]) return; // only patch once per page

function reportHop(payload) {
  const message = { source: "cently-rd-site", payload };
  try {
    window.postMessage(message, "*");
  } catch (e) {
    try {
      window.postMessage(JSON.parse(JSON.stringify(message)), "*");
    } catch (e2) {}
  }
}

function captureStack() {
  const { stack } = new Error();
  if (stack) return stack.split("\n").slice(2, 8).join("\n");
}

function resolveUrl(value) {
  if (value == null) return;
  try {
    return new URL(value.toString(), location.href).href;
  } catch (e) {
    return value.toString();
  }
}

win[HOOK_FLAG] = true;
const locationProto = Location.prototype;

// Patch location.assign / .replace / .reload
function patchLocationMethod(methodName, label) {
  const original = locationProto[methodName];
  if (typeof original !== "function") return;
  const patched = function (...args) {
    const targetUrl = methodName === "reload" ? location.href : (resolveUrl(args[0]) ?? location.href);
    reportHop({ kind: "js_location_change", url: location.href, targetUrl, method: label, stack: captureStack() });
    return original.apply(this, args);
  };
  Object.defineProperty(locationProto, methodName, { value: patched, writable: true, configurable: true });
}
patchLocationMethod("assign", "assign");
patchLocationMethod("replace", "replace");
patchLocationMethod("reload", "reload");

// Patch location.href / pathname / hash / search / host / hostname / port / protocol setters
const locationProps = ["href", "pathname", "hash", "search", "host", "hostname", "port", "protocol"];
for (const prop of locationProps) {
  const descriptor = Object.getOwnPropertyDescriptor(locationProto, prop);
  if (!descriptor || typeof descriptor.set !== "function") continue;
  const originalGet = descriptor.get;
  const originalSet = descriptor.set;
  Object.defineProperty(locationProto, prop, {
    configurable: true,
    enumerable: descriptor.enumerable,
    get: originalGet,
    set(value) {
      const targetUrl = prop === "href" ? (resolveUrl(value) ?? value) : (() => {
        try {
          const u = new URL(location.href);
          u[prop] = value;
          return u.href;
        } catch (e) {
          return value;
        }
      })();
      reportHop({ kind: "js_location_change", url: location.href, targetUrl, method: prop, stack: captureStack() });
      return originalSet.call(this, value);
    },
  });
}

// Patch window.location assignment itself
try {
  const proto = Object.getPrototypeOf(window);
  const descriptor = (proto && Object.getOwnPropertyDescriptor(proto, "location")) || Object.getOwnPropertyDescriptor(window, "location");
  if (descriptor && typeof descriptor.set === "function") {
    const originalSet = descriptor.set;
    Object.defineProperty(window, "location", {
      configurable: true,
      enumerable: descriptor.enumerable ?? true,
      get: descriptor.get,
      set(value) {
        reportHop({ kind: "js_location_change", url: location.href, targetUrl: resolveUrl(value) ?? value, method: "window_location_setter", stack: captureStack() });
        return originalSet.call(window, value);
      },
    });
  }
} catch (e) {}

// Patch window.open, history.pushState, history.replaceState
const originalOpen = window.open;
function patchHistoryMethod(methodName) {
  const original = history[methodName];
  history[methodName] = function (state, title, url) {
    reportHop({ kind: "history_state_change", url: location.href, method: methodName, targetUrl: resolveUrl(url ?? undefined), stack: captureStack() });
    return original.call(this, state, title, url);
  };
}
if (typeof originalOpen === "function") {
  window.open = function (url, target, features) {
    reportHop({ kind: "js_window_open", url: location.href, targetUrl: resolveUrl(url), target, features, stack: captureStack() });
    return originalOpen.call(window, url, target, features);
  };
}
patchHistoryMethod("pushState");
patchHistoryMethod("replaceState");