background.js

(function () {
  "use strict";

  const FE = FireEfficient;
  const SWEEP_ALARM = "fireefficient-sweep-tabs";
  const MAX_DISCARDS_PER_SWEEP = 5;
  const REQUEST_PERMISSION_NAMES = Object.freeze(["webRequest", "webRequestBlocking"]);
  const REQUEST_PERMISSIONS = Object.freeze({
    permissions: REQUEST_PERMISSION_NAMES
  });
  const MANAGED_URL_PATTERNS = Object.freeze(["http://*/*", "https://*/*"]);
  const TRUSTED_EXTENSION_PAGE_PATHS = new Set([
    "options/options.html",
    "popup/popup.html"
  ]);
  const REQUEST_FILTER = Object.freeze({
    urls: MANAGED_URL_PATTERNS,
    types: [
      "beacon",
      "font",
      "main_frame",
      "media",
      "object",
      "object_subrequest",
      "ping",
      "websocket"
    ]
  });
  const REQUEST_OPTIONS = Object.freeze(["blocking"]);
  const BLOCKED_TRACKER_FLAGS = new Set([
    "any_basic_tracking",
    "any_strict_tracking",
    "any_social_tracking",
    "cryptomining",
    "emailtracking",
    "fingerprinting",
    "tracking",
    "tracking_ad",
    "tracking_analytics",
    "tracking_social"
  ]);

  let settings = FE.normalizeSettings();
  const tabState = new Map();
  const blockedByTab = new Map();
  const blockedByType = new Map();
  const protectedTabs = new Set();
  let blockedTotal = 0;
  let offloadedTotal = 0;

  function now() {
    return Date.now();
  }

  function getTabState(tabId) {
    return tabState.get(tabId) || {
      host: "",
      lastActive: now(),
      performance: false,
      unsavedForm: false,
      url: ""
    };
  }

  function classifyTab(tab) {
    const host = FE.hostFromUrl(tab.url || "");
    const existing = getTabState(tab.id);
    return {
      host,
      lastActive: tab.active ? now() : existing.lastActive,
      performance: FE.isPerformanceHost(host, settings.performanceHosts),
      unsavedForm: existing.unsavedForm,
      url: tab.url || ""
    };
  }

  async function updateTabProtection(tabId, isPerformanceTab, wasPerformanceTab) {
    if (!isPerformanceTab && !wasPerformanceTab && !protectedTabs.has(tabId)) {
      return;
    }

    try {
      await browser.tabs.update(tabId, {
        autoDiscardable: !isPerformanceTab
      });

      if (isPerformanceTab) {
        protectedTabs.add(tabId);
      } else {
        protectedTabs.delete(tabId);
      }
    } catch (error) {
      // Tab properties can change while events are in flight.
    }
  }

  async function updateBadge(tabId, state) {
    const text = state.host ? (state.performance ? "MAX" : "ECO") : "";
    const color = state.performance ? "#0f766e" : "#b45309";
    const title = state.performance
      ? "FireEfficient: max performance"
      : "FireEfficient: efficiency profile";

    try {
      await browser.browserAction.setBadgeText({ tabId, text });
      await browser.browserAction.setBadgeBackgroundColor({ tabId, color });
      await browser.browserAction.setTitle({ tabId, title });
    } catch (error) {
      // Browser action updates are best-effort for disappearing tabs.
    }
  }

  async function trackTab(tab) {
    if (!tab || typeof tab.id !== "number") {
      return;
    }

    const previousState = tabState.get(tab.id);
    const state = classifyTab(tab);
    tabState.set(tab.id, state);
    await updateTabProtection(tab.id, state.performance, Boolean(previousState && previousState.performance));
    await updateBadge(tab.id, state);
  }

  async function refreshAllTabs() {
    const tabs = await browser.tabs.query({});
    await Promise.allSettled(tabs.map(trackTab));
  }

  function runQuietly(operation) {
    Promise.resolve()
      .then(operation)
      .catch(() => {
        // Event listeners should not leave unhandled promise rejections behind.
      });
  }

  function hasAnyRequestSavingsRule() {
    return Boolean(
      settings.blockBeacons ||
      settings.blockEmbeddedObjects ||
      settings.blockFirefoxClassifiedTrackers ||
      settings.blockThirdPartyFonts ||
      settings.blockThirdPartyMedia ||
      settings.blockThirdPartyWebSockets
    );
  }

  function shouldListenForRequests() {
    const policy = FE.getEffectivePolicy(settings);
    return Boolean(
      policy.blockRequests &&
      hasAnyRequestSavingsRule()
    );
  }

  function requestApiIsAvailable() {
    return Boolean(
      browser.webRequest &&
      browser.webRequest.onBeforeRequest &&
      typeof browser.webRequest.onBeforeRequest.addListener === "function"
    );
  }

  async function requestPermissionsGranted() {
    if (!browser.permissions || typeof browser.permissions.contains !== "function") {
      return true;
    }

    try {
      return Boolean(await browser.permissions.contains(REQUEST_PERMISSIONS));
    } catch (error) {
      return false;
    }
  }

  function permissionChangeTouchesRequestSavings(permissions) {
    const names = permissions && Array.isArray(permissions.permissions)
      ? permissions.permissions
      : [];

    return REQUEST_PERMISSION_NAMES.some((name) => names.includes(name));
  }

  async function syncRequestListener() {
    if (!requestApiIsAvailable()) {
      return;
    }

    const isListening = browser.webRequest.onBeforeRequest.hasListener(handleBeforeRequest);
    const shouldListen = shouldListenForRequests() && await requestPermissionsGranted();

    if (shouldListen && !isListening) {
      browser.webRequest.onBeforeRequest.addListener(
        handleBeforeRequest,
        REQUEST_FILTER,
        REQUEST_OPTIONS
      );
      return;
    }

    if (!shouldListen && isListening) {
      browser.webRequest.onBeforeRequest.removeListener(handleBeforeRequest);
    }
  }

  async function withFreshSettings(mutator) {
    const current = await FE.readSettings();
    const updated = mutator(FE.normalizeSettings(current));
    settings = await FE.writeSettings(updated || current);
    await refreshAllTabs();
    return settings;
  }

  function recordBlocked(tabId, type) {
    blockedTotal += 1;

    if (typeof tabId === "number" && tabId >= 0) {
      blockedByTab.set(tabId, (blockedByTab.get(tabId) || 0) + 1);
    }

    blockedByType.set(type, (blockedByType.get(type) || 0) + 1);
  }

  function hasBlockedTrackingClassification(details) {
    const classification = details.urlClassification;
    if (!classification) {
      return false;
    }

    const flags = [
      ...(classification.firstParty || []),
      ...(classification.thirdParty || [])
    ];

    return flags.some((flag) => BLOCKED_TRACKER_FLAGS.has(flag));
  }

  function isConservedRequest(details) {
    const policy = FE.getEffectivePolicy(settings);
    if (!policy.blockRequests || details.tabId < 0) {
      return false;
    }

    const state = getTabState(details.tabId);
    if (state.performance) {
      return false;
    }

    const requestHost = FE.hostFromUrl(details.url);
    if (!state.host && requestHost) {
      return !FE.isPerformanceHost(requestHost, settings.performanceHosts);
    }

    return Boolean(state.host);
  }

  function shouldBlockRequest(details) {
    if (details.type === "main_frame") {
      return false;
    }

    if (!isConservedRequest(details)) {
      return false;
    }

    if (settings.blockBeacons && (details.type === "beacon" || details.type === "ping")) {
      return true;
    }

    if (settings.blockFirefoxClassifiedTrackers && hasBlockedTrackingClassification(details)) {
      return true;
    }

    if (details.thirdParty && settings.blockThirdPartyMedia && details.type === "media") {
      return true;
    }

    if (details.thirdParty && settings.blockThirdPartyFonts && details.type === "font") {
      return true;
    }

    if (details.thirdParty && settings.blockThirdPartyWebSockets && details.type === "websocket") {
      return true;
    }

    return settings.blockEmbeddedObjects && (details.type === "object" || details.type === "object_subrequest");
  }

  function countLoadedEcoTabs(tabs) {
    return tabs.filter((tab) => (
      tab &&
      typeof tab.id === "number" &&
      !tab.discarded &&
      FE.hostFromUrl(tab.url || "") &&
      !getTabState(tab.id).performance
    )).length;
  }

  function getIntensityDiscardMultiplier() {
    if (settings.ecoIntensity === "strict") {
      return 0.5;
    }

    if (settings.ecoIntensity === "light") {
      return 1.25;
    }

    return 1;
  }

  function getPressureDiscardMultiplier(loadedEcoTabs) {
    if (loadedEcoTabs >= 40) {
      return 0.25;
    }

    if (loadedEcoTabs >= 25) {
      return 0.4;
    }

    if (loadedEcoTabs >= 15) {
      return 0.6;
    }

    if (loadedEcoTabs >= 8) {
      return 0.8;
    }

    return 1;
  }

  function getEffectiveDiscardAfterMinutes(tabs) {
    if (settings.discardAfterMinutes <= 0) {
      return 0;
    }

    const policy = FE.getEffectivePolicy(settings);
    if (!policy.adaptiveDiscardEnabled) {
      return settings.discardAfterMinutes;
    }

    const multiplier = getIntensityDiscardMultiplier() *
      getPressureDiscardMultiplier(countLoadedEcoTabs(tabs));

    return Math.max(1, Math.ceil(settings.discardAfterMinutes * multiplier));
  }

  function handleBeforeRequest(details) {
    if (details.type === "main_frame" && details.tabId >= 0) {
      const existing = getTabState(details.tabId);
      const previousState = tabState.get(details.tabId);
      const host = FE.hostFromUrl(details.url);
      const state = {
        host,
        lastActive: existing.lastActive,
        performance: FE.isPerformanceHost(host, settings.performanceHosts),
        unsavedForm: existing.unsavedForm,
        url: details.url
      };

      tabState.set(details.tabId, state);
      runQuietly(() => updateTabProtection(
        details.tabId,
        state.performance,
        Boolean(previousState && previousState.performance)
      ));
      runQuietly(() => updateBadge(details.tabId, state));
      return {};
    }

    if (!shouldBlockRequest(details)) {
      return {};
    }

    recordBlocked(details.tabId, details.type);
    return { cancel: true };
  }

  function isDiscardCandidate(tab) {
    if (!settings.efficiencyEnabled || settings.discardAfterMinutes <= 0) {
      return false;
    }

    if (!tab || typeof tab.id !== "number" || tab.active || tab.discarded || tab.status === "loading") {
      return false;
    }

    if (!FE.hostFromUrl(tab.url || "")) {
      return false;
    }

    if (tab.pinned && !settings.discardPinnedTabs) {
      return false;
    }

    if (tab.audible && !settings.discardAudibleTabs) {
      return false;
    }

    const state = getTabState(tab.id);
    const policy = FE.getEffectivePolicy(settings);
    if (policy.protectUnsavedForms && state.unsavedForm) {
      return false;
    }

    return !state.performance;
  }

  async function sweepTabs() {
    const tabs = await browser.tabs.query({});
    const effectiveDiscardAfterMinutes = getEffectiveDiscardAfterMinutes(tabs);
    if (effectiveDiscardAfterMinutes <= 0) {
      return;
    }

    const cutoff = now() - effectiveDiscardAfterMinutes * 60 * 1000;
    let discardedThisSweep = 0;

    for (const tab of tabs) {
      if (discardedThisSweep >= MAX_DISCARDS_PER_SWEEP) {
        return;
      }

      if (!isDiscardCandidate(tab)) {
        continue;
      }

      const state = getTabState(tab.id);
      if (state.lastActive > cutoff) {
        continue;
      }

      try {
        await browser.tabs.discard(tab.id);
        discardedThisSweep += 1;
        offloadedTotal += 1;
      } catch (error) {
        // Firefox can reject active tabs or pages with beforeunload handlers.
      }
    }
  }

  async function getActiveStatus() {
    const [allTabs, activeTabs] = await Promise.all([
      browser.tabs.query({}),
      browser.tabs.query({
        active: true,
        currentWindow: true
      })
    ]);
    const tab = activeTabs[0];

    if (tab) {
      await trackTab(tab);
    }

    const state = tab ? getTabState(tab.id) : null;
    return {
      tabId: tab ? tab.id : null,
      host: state ? state.host : "",
      isPerformance: state ? state.performance : false,
      settings,
      blockedInTab: tab ? (blockedByTab.get(tab.id) || 0) : 0,
      blockedTotal,
      blockedByType: Object.fromEntries(blockedByType),
      offloadedTabs: allTabs.filter((candidate) => candidate.discarded).length,
      offloadedTotal,
      totalTabs: allTabs.length,
      effectiveDiscardAfterMinutes: getEffectiveDiscardAfterMinutes(allTabs),
      unsavedForm: state ? state.unsavedForm : false
    };
  }

  function extensionRootUrl() {
    return typeof browser.runtime.getURL === "function"
      ? browser.runtime.getURL("")
      : "";
  }

  function senderIsOwnExtension(sender) {
    return Boolean(sender && sender.id === browser.runtime.id);
  }

  function senderExtensionPagePath(sender) {
    if (!senderIsOwnExtension(sender) || typeof sender.url !== "string") {
      return "";
    }

    try {
      const rootUrl = new URL(extensionRootUrl());
      const senderUrl = new URL(sender.url);
      if (senderUrl.origin !== rootUrl.origin) {
        return "";
      }

      return senderUrl.pathname.replace(/^\//, "");
    } catch (error) {
      return "";
    }
  }

  function senderIsExtensionPage(sender) {
    return TRUSTED_EXTENSION_PAGE_PATHS.has(senderExtensionPagePath(sender));
  }

  function senderIsManagedContentScript(sender) {
    return Boolean(
      senderIsOwnExtension(sender) &&
      sender.tab &&
      typeof sender.tab.id === "number" &&
      typeof sender.url === "string" &&
      FE.hostFromUrl(sender.url)
    );
  }

  function requireExtensionPageSender(sender) {
    if (!senderIsExtensionPage(sender)) {
      throw new Error("Unauthorized extension message sender.");
    }
  }

  function requireManagedContentSender(sender) {
    if (!senderIsManagedContentScript(sender)) {
      throw new Error("Unauthorized content message sender.");
    }
  }

  function requireMessageKeys(message, allowedKeys) {
    const allowed = new Set(allowedKeys);
    if (!Object.keys(message).every((key) => allowed.has(key))) {
      throw new Error("Invalid message shape.");
    }
  }

  async function handleMessage(message, sender) {
    if (!message || typeof message.type !== "string") {
      return undefined;
    }

    if (message.type === "fireefficient-get-active-status") {
      requireExtensionPageSender(sender);
      requireMessageKeys(message, ["type"]);
      return getActiveStatus();
    }

    if (message.type === "fireefficient-unsaved-form-state") {
      requireManagedContentSender(sender);
      requireMessageKeys(message, ["type", "unsavedForm"]);
      if (typeof message.unsavedForm !== "boolean") {
        throw new Error("Invalid unsaved-form state.");
      }

      const tabId = sender.tab.id;
      const state = getTabState(tabId);
      tabState.set(tabId, {
        ...state,
        unsavedForm: message.unsavedForm
      });

      return undefined;
    }

    if (message.type === "fireefficient-add-performance-host") {
      requireExtensionPageSender(sender);
      requireMessageKeys(message, ["type", "host"]);
      const host = FE.normalizeHostInput(message.host);
      if (!host) {
        throw new Error("Enter a valid domain or host.");
      }

      return withFreshSettings((draft) => {
        draft.performanceHosts = Array.from(new Set([...draft.performanceHosts, host]));
        return draft;
      });
    }

    if (message.type === "fireefficient-remove-performance-host") {
      requireExtensionPageSender(sender);
      requireMessageKeys(message, ["type", "host"]);
      const host = FE.normalizeHostInput(message.host);
      return withFreshSettings((draft) => {
        draft.performanceHosts = draft.performanceHosts.filter((entry) => entry !== host);
        return draft;
      });
    }

    return undefined;
  }

  browser.runtime.onMessage.addListener((message, sender) => handleMessage(message, sender));

  browser.storage.onChanged.addListener((changes, areaName) => {
    if (areaName !== "local" || !changes[FE.STORAGE_KEY]) {
      return;
    }

    settings = FE.normalizeSettings(changes[FE.STORAGE_KEY].newValue);
    runQuietly(syncRequestListener);
    runQuietly(refreshAllTabs);
  });

  if (browser.permissions && browser.permissions.onAdded && browser.permissions.onRemoved) {
    browser.permissions.onAdded.addListener((permissions) => {
      if (permissionChangeTouchesRequestSavings(permissions)) {
        runQuietly(syncRequestListener);
      }
    });

    browser.permissions.onRemoved.addListener((permissions) => {
      if (permissionChangeTouchesRequestSavings(permissions)) {
        runQuietly(syncRequestListener);
      }
    });
  }

  browser.tabs.onActivated.addListener(async ({ tabId }) => {
    try {
      const tab = await browser.tabs.get(tabId);
      await trackTab(tab);
    } catch (error) {
      // The tab may have closed immediately after activation.
    }
  });

  browser.tabs.onCreated.addListener((tab) => {
    runQuietly(() => trackTab(tab));
  });

  browser.tabs.onRemoved.addListener((tabId) => {
    tabState.delete(tabId);
    blockedByTab.delete(tabId);
    protectedTabs.delete(tabId);
  });

  browser.tabs.onUpdated.addListener((tabId, changeInfo, tab) => {
    if (changeInfo.url || changeInfo.status === "complete" || typeof changeInfo.audible === "boolean") {
      runQuietly(() => trackTab(tab));
    }
  });

  browser.alarms.onAlarm.addListener((alarm) => {
    if (alarm.name === SWEEP_ALARM) {
      runQuietly(sweepTabs);
    }
  });

  async function start() {
    settings = await FE.readSettings();
    await syncRequestListener();
    browser.alarms.create(SWEEP_ALARM, {
      periodInMinutes: 1
    });
    await refreshAllTabs();
  }

  runQuietly(start);
})();