SpeculationRules.h

Enable keyboard shortcuts

/* 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 https://mozilla.org/MPL/2.0/. */

#ifndef mozilla_dom_SpeculationRules_h

#define mozilla_dom_SpeculationRules_h

#include "mozilla/UniquePtr.h"

#include "mozilla/dom/speculationrules_ffi_generated.h"

#include "nsCOMPtr.h"

#include "nsClassHashtable.h"

#include "nsCycleCollectionParticipant.h"

#include "nsHashKeys.h"

#include "nsTArrayForwardDeclare.h"

#include "nsTHashSet.h"

class nsIContent;

class nsIScriptElement;

class nsITimer;

class nsIURI;

namespace mozilla::dom {

class Document;

class Element;

class SpeculationRuleSet;

class SpeculationRules final {

 public:

  NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(SpeculationRules)

  NS_DECL_CYCLE_COLLECTION_NATIVE_CLASS(SpeculationRules)

  explicit SpeculationRules(Document* aDocument);

  void RegisterFromScript(nsIScriptElement* aScriptElement,

                          UniquePtr<SpeculationRuleSet> aRuleSet);

  void Unregister(nsIScriptElement* aScriptElement);

  void ConsiderLoads();

  void InnerConsiderLoads();

  void AddLink(Element* aElement);

  void RemoveLink(Element* aElement);

  void FindMatchingLinks(nsTArray<const Element*>& aLinks);

  void HoverContentChanged(nsIContent* aContent);

  void PointerDown(Element* aContent);

 private:

  virtual ~SpeculationRules();

  // The innermost inclusive flat tree ancestor of aContent that is a link this

  // document is tracking, or nullptr if there is none.

  Element* FindInterestedLink(nsIContent* aContent) const;

  // https://html.spec.whatwg.org/#inner-consider-speculative-loads-steps

  // Step 7, for those candidate groups that the user's behaviour has shown to

  // be eager enough. A group is enacted if it is at least as eager as

  // aTriggerLevel and, when aURL is non-null, is for that URL. Only the least

  // eager qualifying group per URL is enacted, as it is the one whose tags were

  // collected from every candidate the user's behaviour justifies.

  void EnactCandidates(nsIURI* aURL, Eagerness aTriggerLevel);

  // Arms the hover timer to enact candidates at least as eager as aLevel for

  // mHoverLink once aDelayMs has passed.

  void ArmHoverTimer(uint32_t aDelayMs, Eagerness aLevel);

  void CancelHoverTimer();

  static void HoverTimerFired(nsITimer* aTimer, void* aClosure);

  RefPtr<Document> mDocument;

  // https://html.spec.whatwg.org/#document-sr-sets

  nsClassHashtable<nsRefPtrHashKey<nsIScriptElement>, SpeculationRuleSet>

      mRuleSetsFromScript;

  // https://html.spec.whatwg.org/#consider-speculative-loads-microtask-queued

  bool mConsiderSpeculativeLoadsMicrotaskQueued{false};

  // The set of HTML <a> and <area> elements with an href attribute that are

  // connected to this document. This is tracked so FindMatchingLinks doesn't

  // have to walk the document tree every time speculative loads are considered.

  // These are non-owning pointers; the elements should remove themselves when

  // they are unbound from the document or lose their href attribute.

  nsTHashSet<Element*> mLinks;

  // https://html.spec.whatwg.org/#speculative-load-candidate-group

  // The representative candidate of each group produced by the last run of

  // InnerConsiderLoads. Immediate groups have already been enacted; the rest

  // are kept so a later signal of user interest can enact them.

  nsTArray<PrefetchCandidate> mCandidateGroups;

  // The link the hover timer is waiting on. Owning, as nothing else keeps the

  // element alive for the duration of the timer.

  RefPtr<Element> mHoverLink;

  nsCOMPtr<nsITimer> mHoverTimer;

  // The eagerness level the pending hover timer will enact. When the eager

  // delay is the shorter one, the timer first fires for "eager" candidates and

  // then re-arms for "moderate" ones.

  Eagerness mHoverTimerLevel{Eagerness::Eager};

};

}  // namespace mozilla::dom

#endif  // mozilla_dom_SpeculationRules_h