summaryrefslogtreecommitdiffstats
path: root/dom/base/Link.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'dom/base/Link.cpp')
-rw-r--r--dom/base/Link.cpp497
1 files changed, 497 insertions, 0 deletions
diff --git a/dom/base/Link.cpp b/dom/base/Link.cpp
new file mode 100644
index 0000000000..296a584ed1
--- /dev/null
+++ b/dom/base/Link.cpp
@@ -0,0 +1,497 @@
+/* -*- 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 "Link.h"
+
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/BindContext.h"
+#include "mozilla/dom/SVGAElement.h"
+#include "mozilla/dom/HTMLDNSPrefetch.h"
+#include "mozilla/IHistory.h"
+#include "mozilla/StaticPrefs_layout.h"
+#include "nsLayoutUtils.h"
+#include "nsIURL.h"
+#include "nsIURIMutator.h"
+#include "nsISizeOf.h"
+
+#include "nsEscape.h"
+#include "nsGkAtoms.h"
+#include "nsString.h"
+#include "mozAutoDocUpdate.h"
+
+#include "mozilla/Components.h"
+#include "nsAttrValueInlines.h"
+#include "HTMLLinkElement.h"
+
+namespace mozilla::dom {
+
+Link::Link(Element* aElement)
+ : mElement(aElement),
+ mNeedsRegistration(false),
+ mRegistered(false),
+ mHasPendingLinkUpdate(false),
+ mHistory(true) {
+ MOZ_ASSERT(mElement, "Must have an element");
+}
+
+Link::Link()
+ : mElement(nullptr),
+ mNeedsRegistration(false),
+ mRegistered(false),
+ mHasPendingLinkUpdate(false),
+ mHistory(false) {}
+
+Link::~Link() {
+ // !mElement is for mock_Link.
+ MOZ_ASSERT(!mElement || !mElement->IsInComposedDoc());
+ Unregister();
+}
+
+bool Link::ElementHasHref() const {
+ if (mElement->HasAttr(nsGkAtoms::href)) {
+ return true;
+ }
+ if (const auto* svg = SVGAElement::FromNode(*mElement)) {
+ // This can be a HasAttr(kNameSpaceID_XLink, nsGkAtoms::href) check once
+ // SMIL is fixed to actually mutate DOM attributes rather than faking it.
+ return svg->HasHref();
+ }
+ MOZ_ASSERT(!mElement->IsSVGElement(),
+ "What other SVG element inherits from Link?");
+ return false;
+}
+
+void Link::SetLinkState(State aState, bool aNotify) {
+ Element::AutoStateChangeNotifier notifier(*mElement, aNotify);
+ switch (aState) {
+ case State::Visited:
+ mElement->AddStatesSilently(ElementState::VISITED);
+ mElement->RemoveStatesSilently(ElementState::UNVISITED);
+ break;
+ case State::Unvisited:
+ mElement->AddStatesSilently(ElementState::UNVISITED);
+ mElement->RemoveStatesSilently(ElementState::VISITED);
+ break;
+ case State::NotLink:
+ mElement->RemoveStatesSilently(ElementState::VISITED_OR_UNVISITED);
+ break;
+ }
+}
+
+void Link::TriggerLinkUpdate(bool aNotify) {
+ if (mRegistered || !mNeedsRegistration || mHasPendingLinkUpdate ||
+ !mElement->IsInComposedDoc()) {
+ return;
+ }
+
+ // Only try and register once.
+ mNeedsRegistration = false;
+
+ nsCOMPtr<nsIURI> hrefURI = GetURI();
+
+ // Assume that we are not visited until we are told otherwise.
+ SetLinkState(State::Unvisited, aNotify);
+
+ // Make sure the href attribute has a valid link (bug 23209).
+ // If we have a good href, register with History if available.
+ if (mHistory && hrefURI) {
+ if (nsCOMPtr<IHistory> history = components::History::Service()) {
+ mRegistered = true;
+ history->RegisterVisitedCallback(hrefURI, this);
+ // And make sure we are in the document's link map.
+ mElement->GetComposedDoc()->AddStyleRelevantLink(this);
+ }
+ }
+}
+
+void Link::VisitedQueryFinished(bool aVisited) {
+ MOZ_ASSERT(mRegistered, "Setting the link state of an unregistered Link!");
+
+ SetLinkState(aVisited ? State::Visited : State::Unvisited,
+ /* aNotify = */ true);
+ // Even if the state didn't actually change, we need to repaint in order for
+ // the visited state not to be observable.
+ nsLayoutUtils::PostRestyleEvent(GetElement(), RestyleHint::RestyleSubtree(),
+ nsChangeHint_RepaintFrame);
+}
+
+nsIURI* Link::GetURI() const {
+ // If we have this URI cached, use it.
+ if (mCachedURI) {
+ return mCachedURI;
+ }
+
+ // Otherwise obtain it.
+ Link* self = const_cast<Link*>(this);
+ Element* element = self->mElement;
+ mCachedURI = element->GetHrefURI();
+
+ return mCachedURI;
+}
+
+void Link::SetProtocol(const nsAString& aProtocol) {
+ nsCOMPtr<nsIURI> uri(GetURI());
+ if (!uri) {
+ // Ignore failures to be compatible with NS4.
+ return;
+ }
+ uri = net::TryChangeProtocol(uri, aProtocol);
+ if (!uri) {
+ return;
+ }
+ SetHrefAttribute(uri);
+}
+
+void Link::SetPassword(const nsAString& aPassword) {
+ nsCOMPtr<nsIURI> uri(GetURI());
+ if (!uri) {
+ // Ignore failures to be compatible with NS4.
+ return;
+ }
+
+ nsresult rv = NS_MutateURI(uri)
+ .SetPassword(NS_ConvertUTF16toUTF8(aPassword))
+ .Finalize(uri);
+ if (NS_SUCCEEDED(rv)) {
+ SetHrefAttribute(uri);
+ }
+}
+
+void Link::SetUsername(const nsAString& aUsername) {
+ nsCOMPtr<nsIURI> uri(GetURI());
+ if (!uri) {
+ // Ignore failures to be compatible with NS4.
+ return;
+ }
+
+ nsresult rv = NS_MutateURI(uri)
+ .SetUsername(NS_ConvertUTF16toUTF8(aUsername))
+ .Finalize(uri);
+ if (NS_SUCCEEDED(rv)) {
+ SetHrefAttribute(uri);
+ }
+}
+
+void Link::SetHost(const nsAString& aHost) {
+ nsCOMPtr<nsIURI> uri(GetURI());
+ if (!uri) {
+ // Ignore failures to be compatible with NS4.
+ return;
+ }
+
+ nsresult rv =
+ NS_MutateURI(uri).SetHostPort(NS_ConvertUTF16toUTF8(aHost)).Finalize(uri);
+ if (NS_FAILED(rv)) {
+ return;
+ }
+ SetHrefAttribute(uri);
+}
+
+void Link::SetHostname(const nsAString& aHostname) {
+ nsCOMPtr<nsIURI> uri(GetURI());
+ if (!uri) {
+ // Ignore failures to be compatible with NS4.
+ return;
+ }
+
+ nsresult rv =
+ NS_MutateURI(uri).SetHost(NS_ConvertUTF16toUTF8(aHostname)).Finalize(uri);
+ if (NS_FAILED(rv)) {
+ return;
+ }
+ SetHrefAttribute(uri);
+}
+
+void Link::SetPathname(const nsAString& aPathname) {
+ nsCOMPtr<nsIURI> uri(GetURI());
+ if (!uri) {
+ // Ignore failures to be compatible with NS4.
+ return;
+ }
+
+ nsresult rv = NS_MutateURI(uri)
+ .SetFilePath(NS_ConvertUTF16toUTF8(aPathname))
+ .Finalize(uri);
+ if (NS_FAILED(rv)) {
+ return;
+ }
+ SetHrefAttribute(uri);
+}
+
+void Link::SetSearch(const nsAString& aSearch) {
+ nsCOMPtr<nsIURI> uri(GetURI());
+ if (!uri) {
+ // Ignore failures to be compatible with NS4.
+ return;
+ }
+
+ nsresult rv =
+ NS_MutateURI(uri).SetQuery(NS_ConvertUTF16toUTF8(aSearch)).Finalize(uri);
+ if (NS_FAILED(rv)) {
+ return;
+ }
+ SetHrefAttribute(uri);
+}
+
+void Link::SetPort(const nsAString& aPort) {
+ nsCOMPtr<nsIURI> uri(GetURI());
+ if (!uri) {
+ // Ignore failures to be compatible with NS4.
+ return;
+ }
+
+ nsresult rv;
+ nsAutoString portStr(aPort);
+
+ // nsIURI uses -1 as default value.
+ int32_t port = -1;
+ if (!aPort.IsEmpty()) {
+ port = portStr.ToInteger(&rv);
+ if (NS_FAILED(rv)) {
+ return;
+ }
+ }
+
+ rv = NS_MutateURI(uri).SetPort(port).Finalize(uri);
+ if (NS_FAILED(rv)) {
+ return;
+ }
+ SetHrefAttribute(uri);
+}
+
+void Link::SetHash(const nsAString& aHash) {
+ nsCOMPtr<nsIURI> uri(GetURI());
+ if (!uri) {
+ // Ignore failures to be compatible with NS4.
+ return;
+ }
+
+ nsresult rv =
+ NS_MutateURI(uri).SetRef(NS_ConvertUTF16toUTF8(aHash)).Finalize(uri);
+ if (NS_FAILED(rv)) {
+ return;
+ }
+
+ SetHrefAttribute(uri);
+}
+
+void Link::GetOrigin(nsAString& aOrigin) {
+ aOrigin.Truncate();
+
+ nsCOMPtr<nsIURI> uri(GetURI());
+ if (!uri) {
+ return;
+ }
+
+ nsString origin;
+ nsContentUtils::GetWebExposedOriginSerialization(uri, origin);
+ aOrigin.Assign(origin);
+}
+
+void Link::GetProtocol(nsAString& _protocol) {
+ nsCOMPtr<nsIURI> uri(GetURI());
+ if (uri) {
+ nsAutoCString scheme;
+ (void)uri->GetScheme(scheme);
+ CopyASCIItoUTF16(scheme, _protocol);
+ }
+ _protocol.Append(char16_t(':'));
+}
+
+void Link::GetUsername(nsAString& aUsername) {
+ aUsername.Truncate();
+
+ nsCOMPtr<nsIURI> uri(GetURI());
+ if (!uri) {
+ return;
+ }
+
+ nsAutoCString username;
+ uri->GetUsername(username);
+ CopyASCIItoUTF16(username, aUsername);
+}
+
+void Link::GetPassword(nsAString& aPassword) {
+ aPassword.Truncate();
+
+ nsCOMPtr<nsIURI> uri(GetURI());
+ if (!uri) {
+ return;
+ }
+
+ nsAutoCString password;
+ uri->GetPassword(password);
+ CopyASCIItoUTF16(password, aPassword);
+}
+
+void Link::GetHost(nsAString& _host) {
+ _host.Truncate();
+
+ nsCOMPtr<nsIURI> uri(GetURI());
+ if (!uri) {
+ // Do not throw! Not having a valid URI should result in an empty string.
+ return;
+ }
+
+ nsAutoCString hostport;
+ nsresult rv = uri->GetHostPort(hostport);
+ if (NS_SUCCEEDED(rv)) {
+ CopyUTF8toUTF16(hostport, _host);
+ }
+}
+
+void Link::GetHostname(nsAString& _hostname) {
+ _hostname.Truncate();
+
+ nsCOMPtr<nsIURI> uri(GetURI());
+ if (!uri) {
+ // Do not throw! Not having a valid URI should result in an empty string.
+ return;
+ }
+
+ nsContentUtils::GetHostOrIPv6WithBrackets(uri, _hostname);
+}
+
+void Link::GetPathname(nsAString& _pathname) {
+ _pathname.Truncate();
+
+ nsCOMPtr<nsIURI> uri(GetURI());
+ if (!uri) {
+ // Do not throw! Not having a valid URI should result in an empty string.
+ return;
+ }
+
+ nsAutoCString file;
+ nsresult rv = uri->GetFilePath(file);
+ if (NS_SUCCEEDED(rv)) {
+ CopyUTF8toUTF16(file, _pathname);
+ }
+}
+
+void Link::GetSearch(nsAString& _search) {
+ _search.Truncate();
+
+ nsCOMPtr<nsIURI> uri(GetURI());
+ if (!uri) {
+ // Do not throw! Not having a valid URI or URL should result in an empty
+ // string.
+ return;
+ }
+
+ nsAutoCString search;
+ nsresult rv = uri->GetQuery(search);
+ if (NS_SUCCEEDED(rv) && !search.IsEmpty()) {
+ _search.Assign(u'?');
+ AppendUTF8toUTF16(search, _search);
+ }
+}
+
+void Link::GetPort(nsAString& _port) {
+ _port.Truncate();
+
+ nsCOMPtr<nsIURI> uri(GetURI());
+ if (!uri) {
+ // Do not throw! Not having a valid URI should result in an empty string.
+ return;
+ }
+
+ int32_t port;
+ nsresult rv = uri->GetPort(&port);
+ // Note that failure to get the port from the URI is not necessarily a bad
+ // thing. Some URIs do not have a port.
+ if (NS_SUCCEEDED(rv) && port != -1) {
+ nsAutoString portStr;
+ portStr.AppendInt(port, 10);
+ _port.Assign(portStr);
+ }
+}
+
+void Link::GetHash(nsAString& _hash) {
+ _hash.Truncate();
+
+ nsCOMPtr<nsIURI> uri(GetURI());
+ if (!uri) {
+ // Do not throw! Not having a valid URI should result in an empty
+ // string.
+ return;
+ }
+
+ nsAutoCString ref;
+ nsresult rv = uri->GetRef(ref);
+ if (NS_SUCCEEDED(rv) && !ref.IsEmpty()) {
+ _hash.Assign(char16_t('#'));
+ AppendUTF8toUTF16(ref, _hash);
+ }
+}
+
+void Link::BindToTree(const BindContext& aContext) {
+ if (aContext.InComposedDoc()) {
+ aContext.OwnerDoc().RegisterPendingLinkUpdate(this);
+ }
+ ResetLinkState(false);
+}
+
+void Link::ResetLinkState(bool aNotify, bool aHasHref) {
+ // If we have an href, we should register with the history.
+ //
+ // FIXME(emilio): Do we really want to allow all MathML elements to be
+ // :visited? That seems not great.
+ mNeedsRegistration = aHasHref;
+
+ // If we've cached the URI, reset always invalidates it.
+ Unregister();
+ mCachedURI = nullptr;
+
+ // Update our state back to the default; the default state for links with an
+ // href is unvisited.
+ SetLinkState(aHasHref ? State::Unvisited : State::NotLink, aNotify);
+ TriggerLinkUpdate(aNotify);
+}
+
+void Link::Unregister() {
+ // If we are not registered, we have nothing to do.
+ if (!mRegistered) {
+ return;
+ }
+
+ MOZ_ASSERT(mHistory);
+ MOZ_ASSERT(mCachedURI, "Should unregister before invalidating the URI");
+
+ // And tell History to stop tracking us.
+ if (nsCOMPtr<IHistory> history = components::History::Service()) {
+ history->UnregisterVisitedCallback(mCachedURI, this);
+ }
+ mElement->OwnerDoc()->ForgetLink(this);
+ mRegistered = false;
+}
+
+void Link::SetHrefAttribute(nsIURI* aURI) {
+ NS_ASSERTION(aURI, "Null URI is illegal!");
+
+ // if we change this code to not reserialize we need to do something smarter
+ // in SetProtocol because changing the protocol of an URI can change the
+ // "nature" of the nsIURL/nsIURI implementation.
+ nsAutoCString href;
+ (void)aURI->GetSpec(href);
+ (void)mElement->SetAttr(kNameSpaceID_None, nsGkAtoms::href,
+ NS_ConvertUTF8toUTF16(href), true);
+}
+
+size_t Link::SizeOfExcludingThis(mozilla::SizeOfState& aState) const {
+ size_t n = 0;
+
+ if (nsCOMPtr<nsISizeOf> iface = do_QueryInterface(mCachedURI)) {
+ n += iface->SizeOfIncludingThis(aState.mMallocSizeOf);
+ }
+
+ // The following members don't need to be measured:
+ // - mElement, because it is a pointer-to-self used to avoid QIs
+
+ return n;
+}
+
+} // namespace mozilla::dom