gecko-dev/browser/components/extensions/parent/ext-history.js

/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */
/* vim: set sts=2 sw=2 et tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this file,
 * You can obtain one at http://mozilla.org/MPL/2.0/. */

"use strict";

ChromeUtils.defineESModuleGetters(this, {
  PlacesUtils: "resource://gre/modules/PlacesUtils.sys.mjs",
});

var { normalizeTime } = ExtensionCommon;

let nsINavHistoryService = Ci.nsINavHistoryService;
const TRANSITION_TO_TRANSITION_TYPES_MAP = new Map([
  ["link", nsINavHistoryService.TRANSITION_LINK],
  ["typed", nsINavHistoryService.TRANSITION_TYPED],
  ["auto_bookmark", nsINavHistoryService.TRANSITION_BOOKMARK],
  ["auto_subframe", nsINavHistoryService.TRANSITION_EMBED],
  ["manual_subframe", nsINavHistoryService.TRANSITION_FRAMED_LINK],
  ["reload", nsINavHistoryService.TRANSITION_RELOAD],
]);

let TRANSITION_TYPE_TO_TRANSITIONS_MAP = new Map();
for (let [transition, transitionType] of TRANSITION_TO_TRANSITION_TYPES_MAP) {
  TRANSITION_TYPE_TO_TRANSITIONS_MAP.set(transitionType, transition);
}

const getTransitionType = transition => {
  // cannot set a default value for the transition argument as the framework sets it to null
  transition = transition || "link";
  let transitionType = TRANSITION_TO_TRANSITION_TYPES_MAP.get(transition);
  if (!transitionType) {
    throw new Error(
      `|${transition}| is not a supported transition for history`
    );
  }
  return transitionType;
};

const getTransition = transitionType => {
  return TRANSITION_TYPE_TO_TRANSITIONS_MAP.get(transitionType) || "link";
};

/*
 * Converts a mozIStorageRow into a HistoryItem
 */
const convertRowToHistoryItem = row => {
  return {
    id: row.getResultByName("guid"),
    url: row.getResultByName("url"),
    title: row.getResultByName("page_title"),
    lastVisitTime: PlacesUtils.toDate(
      row.getResultByName("last_visit_date")
    ).getTime(),
    visitCount: row.getResultByName("visit_count"),
  };
};

/*
 * Converts a mozIStorageRow into a VisitItem
 */
const convertRowToVisitItem = row => {
  return {
    id: row.getResultByName("guid"),
    visitId: String(row.getResultByName("id")),
    visitTime: PlacesUtils.toDate(row.getResultByName("visit_date")).getTime(),
    referringVisitId: String(row.getResultByName("from_visit")),
    transition: getTransition(row.getResultByName("visit_type")),
  };
};

/*
 * Converts a mozIStorageResultSet into an array of objects
 */
const accumulateNavHistoryResults = (resultSet, converter, results) => {
  let row;
  while ((row = resultSet.getNextRow())) {
    results.push(converter(row));
  }
};

function executeAsyncQuery(historyQuery, options, resultConverter) {
  let results = [];
  return new Promise((resolve, reject) => {
    PlacesUtils.history.asyncExecuteLegacyQuery(historyQuery, options, {
      handleResult(resultSet) {
        accumulateNavHistoryResults(resultSet, resultConverter, results);
      },
      handleError(error) {
        reject(
          new Error(
            "Async execution error (" + error.result + "): " + error.message
          )
        );
      },
      handleCompletion() {
        resolve(results);
      },
    });
  });
}

this.history = class extends ExtensionAPIPersistent {
  PERSISTENT_EVENTS = {
    onVisited({ fire }) {
      const listener = events => {
        for (const event of events) {
          const visit = {
            id: event.pageGuid,
            url: event.url,
            title: event.lastKnownTitle || "",
            lastVisitTime: event.visitTime,
            visitCount: event.visitCount,
            typedCount: event.typedCount,
          };
          fire.sync(visit);
        }
      };

      PlacesUtils.observers.addListener(["page-visited"], listener);
      return {
        unregister() {
          PlacesUtils.observers.removeListener(["page-visited"], listener);
        },
        convert(_fire) {
          fire = _fire;
        },
      };
    },
    onVisitRemoved({ fire }) {
      const listener = events => {
        const removedURLs = [];

        for (const event of events) {
          switch (event.type) {
            case "history-cleared": {
              fire.sync({ allHistory: true, urls: [] });
              break;
            }
            case "page-removed": {
              if (!event.isPartialVisistsRemoval) {
                removedURLs.push(event.url);
              }
              break;
            }
          }
        }

        if (removedURLs.length) {
          fire.sync({ allHistory: false, urls: removedURLs });
        }
      };

      PlacesUtils.observers.addListener(
        ["history-cleared", "page-removed"],
        listener
      );
      return {
        unregister() {
          PlacesUtils.observers.removeListener(
            ["history-cleared", "page-removed"],
            listener
          );
        },
        convert(_fire) {
          fire = _fire;
        },
      };
    },
    onTitleChanged({ fire }) {
      const listener = events => {
        for (const event of events) {
          const titleChanged = {
            id: event.pageGuid,
            url: event.url,
            title: event.title,
          };
          fire.sync(titleChanged);
        }
      };

      PlacesUtils.observers.addListener(["page-title-changed"], listener);
      return {
        unregister() {
          PlacesUtils.observers.removeListener(
            ["page-title-changed"],
            listener
          );
        },
        convert(_fire) {
          fire = _fire;
        },
      };
    },
  };

  getAPI(context) {
    return {
      history: {
        addUrl: function (details) {
          let transition, date;
          try {
            transition = getTransitionType(details.transition);
          } catch (error) {
            return Promise.reject({ message: error.message });
          }
          if (details.visitTime) {
            date = normalizeTime(details.visitTime);
          }
          let pageInfo = {
            title: details.title,
            url: details.url,
            visits: [
              {
                transition,
                date,
              },
            ],
          };
          try {
            return PlacesUtils.history.insert(pageInfo).then(() => undefined);
          } catch (error) {
            return Promise.reject({ message: error.message });
          }
        },

        deleteAll: function () {
          return PlacesUtils.history.clear();
        },

        deleteRange: function (filter) {
          let newFilter = {
            beginDate: normalizeTime(filter.startTime),
            endDate: normalizeTime(filter.endTime),
          };
          // History.removeVisitsByFilter returns a boolean, but our API should return nothing
          return PlacesUtils.history
            .removeVisitsByFilter(newFilter)
            .then(() => undefined);
        },

        deleteUrl: function (details) {
          let url = details.url;
          // History.remove returns a boolean, but our API should return nothing
          return PlacesUtils.history.remove(url).then(() => undefined);
        },

        search: function (query) {
          let beginTime =
            query.startTime == null
              ? PlacesUtils.toPRTime(Date.now() - 24 * 60 * 60 * 1000)
              : PlacesUtils.toPRTime(normalizeTime(query.startTime));
          let endTime =
            query.endTime == null
              ? Number.MAX_VALUE
              : PlacesUtils.toPRTime(normalizeTime(query.endTime));
          if (beginTime > endTime) {
            return Promise.reject({
              message: "The startTime cannot be after the endTime",
            });
          }

          let options = PlacesUtils.history.getNewQueryOptions();
          options.includeHidden = true;
          options.sortingMode = options.SORT_BY_DATE_DESCENDING;
          options.maxResults = query.maxResults || 100;

          let historyQuery = PlacesUtils.history.getNewQuery();
          historyQuery.searchTerms = query.text;
          historyQuery.beginTime = beginTime;
          historyQuery.endTime = endTime;
          return executeAsyncQuery(
            historyQuery,
            options,
            convertRowToHistoryItem
          );
        },

        getVisits: function (details) {
          let url = details.url;
          if (!url) {
            return Promise.reject({
              message: "A URL must be provided for getVisits",
            });
          }

          let options = PlacesUtils.history.getNewQueryOptions();
          options.includeHidden = true;
          options.sortingMode = options.SORT_BY_DATE_DESCENDING;
          options.resultType = options.RESULTS_AS_VISIT;

          let historyQuery = PlacesUtils.history.getNewQuery();
          historyQuery.uri = Services.io.newURI(url);
          return executeAsyncQuery(
            historyQuery,
            options,
            convertRowToVisitItem
          );
        },

        onVisited: new EventManager({
          context,
          module: "history",
          event: "onVisited",
          extensionApi: this,
        }).api(),

        onVisitRemoved: new EventManager({
          context,
          module: "history",
          event: "onVisitRemoved",
          extensionApi: this,
        }).api(),

        onTitleChanged: new EventManager({
          context,
          module: "history",
          event: "onTitleChanged",
          extensionApi: this,
        }).api(),
      },
    };
  }
};