mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-23 02:05:42 +00:00
57c26c9834
This patch moves measurement of ComputedValues objects from Rust to C++. Measurement now happens (a) via DOM elements and (b) remaining elements via the frame tree. Likewise for the style structs hanging off ComputedValues objects. Here is an example of the output. > ├──27,600,448 B (26.49%) -- active/window(https://en.wikipedia.org/wiki/Barack_Obama) > │ ├──12,772,544 B (12.26%) -- layout > │ │ ├───4,483,744 B (04.30%) -- frames > │ │ │ ├──1,653,552 B (01.59%) ── nsInlineFrame > │ │ │ ├──1,415,760 B (01.36%) ── nsTextFrame > │ │ │ ├────431,376 B (00.41%) ── nsBlockFrame > │ │ │ ├────340,560 B (00.33%) ── nsHTMLScrollFrame > │ │ │ ├────302,544 B (00.29%) ── nsContinuingTextFrame > │ │ │ ├────156,408 B (00.15%) ── nsBulletFrame > │ │ │ ├─────73,024 B (00.07%) ── nsPlaceholderFrame > │ │ │ ├─────27,656 B (00.03%) ── sundries > │ │ │ ├─────23,520 B (00.02%) ── nsTableCellFrame > │ │ │ ├─────16,704 B (00.02%) ── nsImageFrame > │ │ │ ├─────15,488 B (00.01%) ── nsTableRowFrame > │ │ │ ├─────13,776 B (00.01%) ── nsTableColFrame > │ │ │ └─────13,376 B (00.01%) ── nsTableFrame > │ │ ├───3,412,192 B (03.28%) -- servo-style-structs > │ │ │ ├──1,288,224 B (01.24%) ── Display > │ │ │ ├────742,400 B (00.71%) ── Position > │ │ │ ├────308,736 B (00.30%) ── Font > │ │ │ ├────226,512 B (00.22%) ── Background > │ │ │ ├────218,304 B (00.21%) ── TextReset > │ │ │ ├────214,896 B (00.21%) ── Text > │ │ │ ├────130,560 B (00.13%) ── Border > │ │ │ ├─────81,408 B (00.08%) ── UIReset > │ │ │ ├─────61,440 B (00.06%) ── Padding > │ │ │ ├─────38,176 B (00.04%) ── UserInterface > │ │ │ ├─────29,232 B (00.03%) ── Margin > │ │ │ ├─────21,824 B (00.02%) ── sundries > │ │ │ ├─────20,080 B (00.02%) ── Color > │ │ │ ├─────20,080 B (00.02%) ── Column > │ │ │ └─────10,320 B (00.01%) ── Effects > │ │ ├───2,227,680 B (02.14%) -- computed-values > │ │ │ ├──1,182,928 B (01.14%) ── non-dom > │ │ │ └──1,044,752 B (01.00%) ── dom > │ │ ├───1,500,016 B (01.44%) ── text-runs > │ │ ├─────492,640 B (00.47%) ── line-boxes > │ │ ├─────326,688 B (00.31%) ── frame-properties > │ │ ├─────301,760 B (00.29%) ── pres-shell > │ │ ├──────27,648 B (00.03%) ── pres-contexts > │ │ └─────────176 B (00.00%) ── style-sets The 'servo-style-structs' and 'computed-values' sub-trees are new. (Prior to this patch, ComputedValues under DOM elements were tallied under the the 'dom/element-nodes' sub-tree, and ComputedValues not under DOM element were ignored.) 'servo-style-structs/sundries' aggregates all the style structs that are smaller than 8 KiB. Other notable things done by the patch are as follows. - It significantly changes the signatures of the methods measuring nsINode and its subclasses, in order to handle the tallying of style structs separately from element-nodes. Likewise for nsIFrame. - It renames the 'layout/style-structs' sub-tree as 'layout/gecko-style-structs', to clearly distinguish it from the new 'layout/servo-style-structs' sub-tree. - It adds some FFI functions to access various Rust-side data structures from C++ code. - There is a nasty hack used twice to measure Arcs, by stepping backwards from an interior pointer to a base pointer. It works, but I want to replace it with something better eventually. The "XXX WARNING" comments have details. - It makes DMD print a line to the console if it sees a pointer it doesn't recognise. This is useful for detecting when we are measuring an interior pointer instead of a base pointer, which is bad but easy to do when Arcs are involved. - It removes the Rust code for measuring CVs, because it's now all done on the C++ side. MozReview-Commit-ID: BKebACLKtCi --HG-- extra : rebase_source : 4d9a8c6b198a0ff025b811759a6bfa9f33a260ba
419 lines
11 KiB
C++
419 lines
11 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 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/. */
|
|
|
|
#include "mozilla/dom/HTMLAnchorElement.h"
|
|
|
|
#include "mozilla/dom/HTMLAnchorElementBinding.h"
|
|
#include "mozilla/EventDispatcher.h"
|
|
#include "mozilla/EventStates.h"
|
|
#include "mozilla/MemoryReporting.h"
|
|
#include "nsCOMPtr.h"
|
|
#include "nsContentUtils.h"
|
|
#include "nsGkAtoms.h"
|
|
#include "nsHTMLDNSPrefetch.h"
|
|
#include "nsAttrValueOrString.h"
|
|
#include "nsIDocument.h"
|
|
#include "nsIPresShell.h"
|
|
#include "nsPresContext.h"
|
|
#include "nsIURI.h"
|
|
|
|
NS_IMPL_NS_NEW_HTML_ELEMENT(Anchor)
|
|
|
|
namespace mozilla {
|
|
namespace dom {
|
|
|
|
#define ANCHOR_ELEMENT_FLAG_BIT(n_) NODE_FLAG_BIT(ELEMENT_TYPE_SPECIFIC_BITS_OFFSET + (n_))
|
|
|
|
// Anchor element specific bits
|
|
enum {
|
|
// Indicates that a DNS Prefetch has been requested from this Anchor elem
|
|
HTML_ANCHOR_DNS_PREFETCH_REQUESTED = ANCHOR_ELEMENT_FLAG_BIT(0),
|
|
|
|
// Indicates that a DNS Prefetch was added to the deferral queue
|
|
HTML_ANCHOR_DNS_PREFETCH_DEFERRED = ANCHOR_ELEMENT_FLAG_BIT(1)
|
|
};
|
|
|
|
ASSERT_NODE_FLAGS_SPACE(ELEMENT_TYPE_SPECIFIC_BITS_OFFSET + 2);
|
|
|
|
#undef ANCHOR_ELEMENT_FLAG_BIT
|
|
|
|
// static
|
|
const DOMTokenListSupportedToken HTMLAnchorElement::sSupportedRelValues[] = {
|
|
"noreferrer",
|
|
"noopener",
|
|
nullptr
|
|
};
|
|
|
|
HTMLAnchorElement::~HTMLAnchorElement()
|
|
{
|
|
}
|
|
|
|
bool
|
|
HTMLAnchorElement::IsInteractiveHTMLContent(bool aIgnoreTabindex) const
|
|
{
|
|
return HasAttr(kNameSpaceID_None, nsGkAtoms::href) ||
|
|
nsGenericHTMLElement::IsInteractiveHTMLContent(aIgnoreTabindex);
|
|
}
|
|
|
|
NS_INTERFACE_TABLE_HEAD_CYCLE_COLLECTION_INHERITED(HTMLAnchorElement)
|
|
NS_INTERFACE_TABLE_INHERITED(HTMLAnchorElement,
|
|
nsIDOMHTMLAnchorElement,
|
|
Link)
|
|
NS_INTERFACE_TABLE_TAIL_INHERITING(nsGenericHTMLElement)
|
|
|
|
NS_IMPL_ADDREF_INHERITED(HTMLAnchorElement, Element)
|
|
NS_IMPL_RELEASE_INHERITED(HTMLAnchorElement, Element)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_CLASS(HTMLAnchorElement)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(HTMLAnchorElement,
|
|
nsGenericHTMLElement)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRelList)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(HTMLAnchorElement,
|
|
nsGenericHTMLElement)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mRelList)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
|
|
|
|
NS_IMPL_ELEMENT_CLONE(HTMLAnchorElement)
|
|
|
|
JSObject*
|
|
HTMLAnchorElement::WrapNode(JSContext *aCx, JS::Handle<JSObject*> aGivenProto)
|
|
{
|
|
return HTMLAnchorElementBinding::Wrap(aCx, this, aGivenProto);
|
|
}
|
|
|
|
NS_IMPL_STRING_ATTR(HTMLAnchorElement, Charset, charset)
|
|
NS_IMPL_STRING_ATTR(HTMLAnchorElement, Coords, coords)
|
|
NS_IMPL_URI_ATTR(HTMLAnchorElement, Href, href)
|
|
NS_IMPL_STRING_ATTR(HTMLAnchorElement, Hreflang, hreflang)
|
|
NS_IMPL_STRING_ATTR(HTMLAnchorElement, Name, name)
|
|
NS_IMPL_STRING_ATTR(HTMLAnchorElement, Rel, rel)
|
|
NS_IMPL_STRING_ATTR(HTMLAnchorElement, Rev, rev)
|
|
NS_IMPL_STRING_ATTR(HTMLAnchorElement, Shape, shape)
|
|
NS_IMPL_STRING_ATTR(HTMLAnchorElement, Type, type)
|
|
NS_IMPL_STRING_ATTR(HTMLAnchorElement, Download, download)
|
|
|
|
int32_t
|
|
HTMLAnchorElement::TabIndexDefault()
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
bool
|
|
HTMLAnchorElement::Draggable() const
|
|
{
|
|
// links can be dragged as long as there is an href and the
|
|
// draggable attribute isn't false
|
|
if (!HasAttr(kNameSpaceID_None, nsGkAtoms::href)) {
|
|
// no href, so just use the same behavior as other elements
|
|
return nsGenericHTMLElement::Draggable();
|
|
}
|
|
|
|
return !AttrValueIs(kNameSpaceID_None, nsGkAtoms::draggable,
|
|
nsGkAtoms::_false, eIgnoreCase);
|
|
}
|
|
|
|
void
|
|
HTMLAnchorElement::OnDNSPrefetchRequested()
|
|
{
|
|
UnsetFlags(HTML_ANCHOR_DNS_PREFETCH_DEFERRED);
|
|
SetFlags(HTML_ANCHOR_DNS_PREFETCH_REQUESTED);
|
|
}
|
|
|
|
void
|
|
HTMLAnchorElement::OnDNSPrefetchDeferred()
|
|
{
|
|
UnsetFlags(HTML_ANCHOR_DNS_PREFETCH_REQUESTED);
|
|
SetFlags(HTML_ANCHOR_DNS_PREFETCH_DEFERRED);
|
|
}
|
|
|
|
bool
|
|
HTMLAnchorElement::HasDeferredDNSPrefetchRequest()
|
|
{
|
|
return HasFlag(HTML_ANCHOR_DNS_PREFETCH_DEFERRED);
|
|
}
|
|
|
|
nsresult
|
|
HTMLAnchorElement::BindToTree(nsIDocument* aDocument, nsIContent* aParent,
|
|
nsIContent* aBindingParent,
|
|
bool aCompileEventHandlers)
|
|
{
|
|
Link::ResetLinkState(false, Link::ElementHasHref());
|
|
|
|
nsresult rv = nsGenericHTMLElement::BindToTree(aDocument, aParent,
|
|
aBindingParent,
|
|
aCompileEventHandlers);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
// Prefetch links
|
|
nsIDocument* doc = GetComposedDoc();
|
|
if (doc) {
|
|
doc->RegisterPendingLinkUpdate(this);
|
|
TryDNSPrefetch();
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
void
|
|
HTMLAnchorElement::UnbindFromTree(bool aDeep, bool aNullParent)
|
|
{
|
|
// Cancel any DNS prefetches
|
|
// Note: Must come before ResetLinkState. If called after, it will recreate
|
|
// mCachedURI based on data that is invalid - due to a call to GetHostname.
|
|
CancelDNSPrefetch(HTML_ANCHOR_DNS_PREFETCH_DEFERRED,
|
|
HTML_ANCHOR_DNS_PREFETCH_REQUESTED);
|
|
|
|
// If this link is ever reinserted into a document, it might
|
|
// be under a different xml:base, so forget the cached state now.
|
|
Link::ResetLinkState(false, Link::ElementHasHref());
|
|
|
|
nsGenericHTMLElement::UnbindFromTree(aDeep, aNullParent);
|
|
}
|
|
|
|
static bool
|
|
IsNodeInEditableRegion(nsINode* aNode)
|
|
{
|
|
while (aNode) {
|
|
if (aNode->IsEditable()) {
|
|
return true;
|
|
}
|
|
aNode = aNode->GetParent();
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
HTMLAnchorElement::IsHTMLFocusable(bool aWithMouse,
|
|
bool *aIsFocusable, int32_t *aTabIndex)
|
|
{
|
|
if (nsGenericHTMLElement::IsHTMLFocusable(aWithMouse, aIsFocusable, aTabIndex)) {
|
|
return true;
|
|
}
|
|
|
|
// cannot focus links if there is no link handler
|
|
nsIDocument* doc = GetComposedDoc();
|
|
if (doc) {
|
|
nsIPresShell* presShell = doc->GetShell();
|
|
if (presShell) {
|
|
nsPresContext* presContext = presShell->GetPresContext();
|
|
if (presContext && !presContext->GetLinkHandler()) {
|
|
*aIsFocusable = false;
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Links that are in an editable region should never be focusable, even if
|
|
// they are in a contenteditable="false" region.
|
|
if (IsNodeInEditableRegion(this)) {
|
|
if (aTabIndex) {
|
|
*aTabIndex = -1;
|
|
}
|
|
|
|
*aIsFocusable = false;
|
|
|
|
return true;
|
|
}
|
|
|
|
if (!HasAttr(kNameSpaceID_None, nsGkAtoms::tabindex)) {
|
|
// check whether we're actually a link
|
|
if (!Link::HasURI()) {
|
|
// Not tabbable or focusable without href (bug 17605), unless
|
|
// forced to be via presence of nonnegative tabindex attribute
|
|
if (aTabIndex) {
|
|
*aTabIndex = -1;
|
|
}
|
|
|
|
*aIsFocusable = false;
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (aTabIndex && (sTabFocusModel & eTabFocus_linksMask) == 0) {
|
|
*aTabIndex = -1;
|
|
}
|
|
|
|
*aIsFocusable = true;
|
|
|
|
return false;
|
|
}
|
|
|
|
nsresult
|
|
HTMLAnchorElement::GetEventTargetParent(EventChainPreVisitor& aVisitor)
|
|
{
|
|
return GetEventTargetParentForAnchors(aVisitor);
|
|
}
|
|
|
|
nsresult
|
|
HTMLAnchorElement::PostHandleEvent(EventChainPostVisitor& aVisitor)
|
|
{
|
|
return PostHandleEventForAnchors(aVisitor);
|
|
}
|
|
|
|
bool
|
|
HTMLAnchorElement::IsLink(nsIURI** aURI) const
|
|
{
|
|
return IsHTMLLink(aURI);
|
|
}
|
|
|
|
void
|
|
HTMLAnchorElement::GetLinkTarget(nsAString& aTarget)
|
|
{
|
|
GetAttr(kNameSpaceID_None, nsGkAtoms::target, aTarget);
|
|
if (aTarget.IsEmpty()) {
|
|
GetBaseTarget(aTarget);
|
|
}
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
HTMLAnchorElement::GetTarget(nsAString& aValue)
|
|
{
|
|
if (!GetAttr(kNameSpaceID_None, nsGkAtoms::target, aValue)) {
|
|
GetBaseTarget(aValue);
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
HTMLAnchorElement::SetTarget(const nsAString& aValue)
|
|
{
|
|
return SetAttr(kNameSpaceID_None, nsGkAtoms::target, aValue, true);
|
|
}
|
|
|
|
nsDOMTokenList*
|
|
HTMLAnchorElement::RelList()
|
|
{
|
|
if (!mRelList) {
|
|
mRelList = new nsDOMTokenList(this, nsGkAtoms::rel, sSupportedRelValues);
|
|
}
|
|
return mRelList;
|
|
}
|
|
|
|
#define IMPL_URI_PART(_part) \
|
|
NS_IMETHODIMP \
|
|
HTMLAnchorElement::Get##_part(nsAString& a##_part) \
|
|
{ \
|
|
Link::Get##_part(a##_part); \
|
|
return NS_OK; \
|
|
} \
|
|
NS_IMETHODIMP \
|
|
HTMLAnchorElement::Set##_part(const nsAString& a##_part) \
|
|
{ \
|
|
Link::Set##_part(a##_part); \
|
|
return NS_OK; \
|
|
}
|
|
|
|
IMPL_URI_PART(Protocol)
|
|
IMPL_URI_PART(Host)
|
|
IMPL_URI_PART(Hostname)
|
|
IMPL_URI_PART(Pathname)
|
|
IMPL_URI_PART(Search)
|
|
IMPL_URI_PART(Port)
|
|
IMPL_URI_PART(Hash)
|
|
|
|
#undef IMPL_URI_PART
|
|
|
|
NS_IMETHODIMP
|
|
HTMLAnchorElement::GetText(nsAString& aText)
|
|
{
|
|
if(!nsContentUtils::GetNodeTextContent(this, true, aText, fallible)) {
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
HTMLAnchorElement::SetText(const nsAString& aText)
|
|
{
|
|
return nsContentUtils::SetNodeTextContent(this, aText, false);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
HTMLAnchorElement::ToString(nsAString& aSource)
|
|
{
|
|
return GetHref(aSource);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
HTMLAnchorElement::GetPing(nsAString& aValue)
|
|
{
|
|
GetAttr(kNameSpaceID_None, nsGkAtoms::ping, aValue);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
HTMLAnchorElement::SetPing(const nsAString& aValue)
|
|
{
|
|
return SetAttr(kNameSpaceID_None, nsGkAtoms::ping, aValue, true);
|
|
}
|
|
|
|
already_AddRefed<nsIURI>
|
|
HTMLAnchorElement::GetHrefURI() const
|
|
{
|
|
nsCOMPtr<nsIURI> uri = Link::GetCachedURI();
|
|
if (uri) {
|
|
return uri.forget();
|
|
}
|
|
|
|
return GetHrefURIForAnchors();
|
|
}
|
|
|
|
nsresult
|
|
HTMLAnchorElement::BeforeSetAttr(int32_t aNamespaceID, nsIAtom* aName,
|
|
const nsAttrValueOrString* aValue,
|
|
bool aNotify)
|
|
{
|
|
if (aNamespaceID == kNameSpaceID_None) {
|
|
if (aName == nsGkAtoms::href) {
|
|
CancelDNSPrefetch(HTML_ANCHOR_DNS_PREFETCH_DEFERRED,
|
|
HTML_ANCHOR_DNS_PREFETCH_REQUESTED);
|
|
}
|
|
}
|
|
|
|
return nsGenericHTMLElement::BeforeSetAttr(aNamespaceID, aName, aValue,
|
|
aNotify);
|
|
}
|
|
|
|
nsresult
|
|
HTMLAnchorElement::AfterSetAttr(int32_t aNamespaceID, nsIAtom* aName,
|
|
const nsAttrValue* aValue,
|
|
const nsAttrValue* aOldValue, bool aNotify)
|
|
{
|
|
if (aNamespaceID == kNameSpaceID_None) {
|
|
if (aName == nsGkAtoms::href) {
|
|
Link::ResetLinkState(aNotify, !!aValue);
|
|
if (aValue && IsInComposedDoc()) {
|
|
TryDNSPrefetch();
|
|
}
|
|
}
|
|
}
|
|
|
|
return nsGenericHTMLElement::AfterSetAttr(aNamespaceID, aName,
|
|
aValue, aOldValue, aNotify);
|
|
}
|
|
|
|
EventStates
|
|
HTMLAnchorElement::IntrinsicState() const
|
|
{
|
|
return Link::LinkState() | nsGenericHTMLElement::IntrinsicState();
|
|
}
|
|
|
|
void
|
|
HTMLAnchorElement::AddSizeOfExcludingThis(SizeOfState& aState,
|
|
nsStyleSizes& aSizes,
|
|
size_t* aNodeSize) const
|
|
{
|
|
nsGenericHTMLElement::AddSizeOfExcludingThis(aState, aSizes, aNodeSize);
|
|
*aNodeSize += Link::SizeOfExcludingThis(aState);
|
|
}
|
|
|
|
} // namespace dom
|
|
} // namespace mozilla
|