dom/html/HTMLAnchorElement.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "mozilla/dom/HTMLAnchorElement.h"
   8
   9 #include "mozilla/dom/HTMLAnchorElementBinding.h"
  10 #include "mozilla/EventDispatcher.h"
  11 #include "mozilla/EventStates.h"
  12 #include "mozilla/MemoryReporting.h"
  13 #include "nsCOMPtr.h"
  14 #include "nsContentUtils.h"
  15 #include "nsGkAtoms.h"
  16 #include "nsHTMLDNSPrefetch.h"
  17 #include "nsAttrValueOrString.h"
  18 #include "nsIDocument.h"
  19 #include "nsIPresShell.h"
  20 #include "nsPresContext.h"
  21 #include "nsIURI.h"
  22 #include "nsWindowSizes.h"
  23
  24 NS_IMPL_NS_NEW_HTML_ELEMENT(Anchor)
  25
  26 namespace mozilla {
  27 namespace dom {
  28
  29 #define ANCHOR_ELEMENT_FLAG_BIT(n_) NODE_FLAG_BIT(ELEMENT_TYPE_SPECIFIC_BITS_OFFSET + (n_))
  30
  31 // Anchor element specific bits
  32 enum {
  33   // Indicates that a DNS Prefetch has been requested from this Anchor elem
  34   HTML_ANCHOR_DNS_PREFETCH_REQUESTED =    ANCHOR_ELEMENT_FLAG_BIT(0),
  35
  36   // Indicates that a DNS Prefetch was added to the deferral queue
  37   HTML_ANCHOR_DNS_PREFETCH_DEFERRED =     ANCHOR_ELEMENT_FLAG_BIT(1)
  38 };
  39
  40 ASSERT_NODE_FLAGS_SPACE(ELEMENT_TYPE_SPECIFIC_BITS_OFFSET + 2);
  41
  42 #undef ANCHOR_ELEMENT_FLAG_BIT
  43
  44 // static
  45 const DOMTokenListSupportedToken HTMLAnchorElement::sSupportedRelValues[] = {
  46   "noreferrer",
  47   "noopener",
  48   nullptr
  49 };
  50
  51 HTMLAnchorElement::~HTMLAnchorElement()
  52 {
  53 }
  54
  55 bool
  56 HTMLAnchorElement::IsInteractiveHTMLContent(bool aIgnoreTabindex) const
  57 {
  58   return HasAttr(kNameSpaceID_None, nsGkAtoms::href) ||
  59          nsGenericHTMLElement::IsInteractiveHTMLContent(aIgnoreTabindex);
  60 }
  61
  62 NS_IMPL_ISUPPORTS_CYCLE_COLLECTION_INHERITED(HTMLAnchorElement,
  63                                              nsGenericHTMLElement,
  64                                              Link)
  65
  66 NS_IMPL_CYCLE_COLLECTION_INHERITED(HTMLAnchorElement,
  67                                    nsGenericHTMLElement,
  68                                    mRelList)
  69
  70 NS_IMPL_ELEMENT_CLONE(HTMLAnchorElement)
  71
  72 JSObject*
  73 HTMLAnchorElement::WrapNode(JSContext *aCx, JS::Handle<JSObject*> aGivenProto)
  74 {
  75   return HTMLAnchorElement_Binding::Wrap(aCx, this, aGivenProto);
  76 }
  77
  78 int32_t
  79 HTMLAnchorElement::TabIndexDefault()
  80 {
  81   return 0;
  82 }
  83
  84 bool
  85 HTMLAnchorElement::Draggable() const
  86 {
  87   // links can be dragged as long as there is an href and the
  88   // draggable attribute isn't false
  89   if (!HasAttr(kNameSpaceID_None, nsGkAtoms::href)) {
  90     // no href, so just use the same behavior as other elements
  91     return nsGenericHTMLElement::Draggable();
  92   }
  93
  94   return !AttrValueIs(kNameSpaceID_None, nsGkAtoms::draggable,
  95                       nsGkAtoms::_false, eIgnoreCase);
  96 }
  97
  98 void
  99 HTMLAnchorElement::OnDNSPrefetchRequested()
 100 {
 101   UnsetFlags(HTML_ANCHOR_DNS_PREFETCH_DEFERRED);
 102   SetFlags(HTML_ANCHOR_DNS_PREFETCH_REQUESTED);
 103 }
 104
 105 void
 106 HTMLAnchorElement::OnDNSPrefetchDeferred()
 107 {
 108   UnsetFlags(HTML_ANCHOR_DNS_PREFETCH_REQUESTED);
 109   SetFlags(HTML_ANCHOR_DNS_PREFETCH_DEFERRED);
 110 }
 111
 112 bool
 113 HTMLAnchorElement::HasDeferredDNSPrefetchRequest()
 114 {
 115   return HasFlag(HTML_ANCHOR_DNS_PREFETCH_DEFERRED);
 116 }
 117
 118 nsresult
 119 HTMLAnchorElement::BindToTree(nsIDocument* aDocument, nsIContent* aParent,
 120                               nsIContent* aBindingParent)
 121 {
 122   Link::ResetLinkState(false, Link::ElementHasHref());
 123
 124   nsresult rv = nsGenericHTMLElement::BindToTree(aDocument, aParent,
 125                                                  aBindingParent);
 126   NS_ENSURE_SUCCESS(rv, rv);
 127
 128   // Prefetch links
 129   nsIDocument* doc = GetComposedDoc();
 130   if (doc) {
 131     doc->RegisterPendingLinkUpdate(this);
 132     TryDNSPrefetch();
 133   }
 134
 135   return rv;
 136 }
 137
 138 void
 139 HTMLAnchorElement::UnbindFromTree(bool aDeep, bool aNullParent)
 140 {
 141   // Cancel any DNS prefetches
 142   // Note: Must come before ResetLinkState.  If called after, it will recreate
 143   // mCachedURI based on data that is invalid - due to a call to GetHostname.
 144   CancelDNSPrefetch(HTML_ANCHOR_DNS_PREFETCH_DEFERRED,
 145                     HTML_ANCHOR_DNS_PREFETCH_REQUESTED);
 146
 147   // If this link is ever reinserted into a document, it might
 148   // be under a different xml:base, so forget the cached state now.
 149   Link::ResetLinkState(false, Link::ElementHasHref());
 150
 151   nsGenericHTMLElement::UnbindFromTree(aDeep, aNullParent);
 152 }
 153
 154 static bool
 155 IsNodeInEditableRegion(nsINode* aNode)
 156 {
 157   while (aNode) {
 158     if (aNode->IsEditable()) {
 159       return true;
 160     }
 161     aNode = aNode->GetParent();
 162   }
 163   return false;
 164 }
 165
 166 bool
 167 HTMLAnchorElement::IsHTMLFocusable(bool aWithMouse,
 168                                    bool *aIsFocusable, int32_t *aTabIndex)
 169 {
 170   if (nsGenericHTMLElement::IsHTMLFocusable(aWithMouse, aIsFocusable, aTabIndex)) {
 171     return true;
 172   }
 173
 174   // cannot focus links if there is no link handler
 175   nsIDocument* doc = GetComposedDoc();
 176   if (doc) {
 177     nsPresContext* presContext = doc->GetPresContext();
 178     if (presContext && !presContext->GetLinkHandler()) {
 179       *aIsFocusable = false;
 180       return false;
 181     }
 182   }
 183
 184   // Links that are in an editable region should never be focusable, even if
 185   // they are in a contenteditable="false" region.
 186   if (IsNodeInEditableRegion(this)) {
 187     if (aTabIndex) {
 188       *aTabIndex = -1;
 189     }
 190
 191     *aIsFocusable = false;
 192
 193     return true;
 194   }
 195
 196   if (!HasAttr(kNameSpaceID_None, nsGkAtoms::tabindex)) {
 197     // check whether we're actually a link
 198     if (!Link::HasURI()) {
 199       // Not tabbable or focusable without href (bug 17605), unless
 200       // forced to be via presence of nonnegative tabindex attribute
 201       if (aTabIndex) {
 202         *aTabIndex = -1;
 203       }
 204
 205       *aIsFocusable = false;
 206
 207       return false;
 208     }
 209   }
 210
 211   if (aTabIndex && (sTabFocusModel & eTabFocus_linksMask) == 0) {
 212     *aTabIndex = -1;
 213   }
 214
 215   *aIsFocusable = true;
 216
 217   return false;
 218 }
 219
 220 void
 221 HTMLAnchorElement::GetEventTargetParent(EventChainPreVisitor& aVisitor)
 222 {
 223   GetEventTargetParentForAnchors(aVisitor);
 224 }
 225
 226 nsresult
 227 HTMLAnchorElement::PostHandleEvent(EventChainPostVisitor& aVisitor)
 228 {
 229   return PostHandleEventForAnchors(aVisitor);
 230 }
 231
 232 bool
 233 HTMLAnchorElement::IsLink(nsIURI** aURI) const
 234 {
 235   return IsHTMLLink(aURI);
 236 }
 237
 238 void
 239 HTMLAnchorElement::GetLinkTarget(nsAString& aTarget)
 240 {
 241   GetAttr(kNameSpaceID_None, nsGkAtoms::target, aTarget);
 242   if (aTarget.IsEmpty()) {
 243     GetBaseTarget(aTarget);
 244   }
 245 }
 246
 247 void
 248 HTMLAnchorElement::GetTarget(nsAString& aValue)
 249 {
 250   if (!GetAttr(kNameSpaceID_None, nsGkAtoms::target, aValue)) {
 251     GetBaseTarget(aValue);
 252   }
 253 }
 254
 255 nsDOMTokenList*
 256 HTMLAnchorElement::RelList()
 257 {
 258   if (!mRelList) {
 259     mRelList = new nsDOMTokenList(this, nsGkAtoms::rel, sSupportedRelValues);
 260   }
 261   return mRelList;
 262 }
 263
 264 void
 265 HTMLAnchorElement::GetText(nsAString& aText, mozilla::ErrorResult& aRv)
 266 {
 267   if (NS_WARN_IF(!nsContentUtils::GetNodeTextContent(this, true, aText, fallible))) {
 268     aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
 269   }
 270 }
 271
 272 void
 273 HTMLAnchorElement::SetText(const nsAString& aText, ErrorResult& aRv)
 274 {
 275   aRv = nsContentUtils::SetNodeTextContent(this, aText, false);
 276 }
 277
 278 void
 279 HTMLAnchorElement::ToString(nsAString& aSource)
 280 {
 281   return GetHref(aSource);
 282 }
 283
 284 already_AddRefed<nsIURI>
 285 HTMLAnchorElement::GetHrefURI() const
 286 {
 287   nsCOMPtr<nsIURI> uri = Link::GetCachedURI();
 288   if (uri) {
 289     return uri.forget();
 290   }
 291
 292   return GetHrefURIForAnchors();
 293 }
 294
 295 nsresult
 296 HTMLAnchorElement::BeforeSetAttr(int32_t aNamespaceID, nsAtom* aName,
 297                                  const nsAttrValueOrString* aValue,
 298                                  bool aNotify)
 299 {
 300   if (aNamespaceID == kNameSpaceID_None) {
 301     if (aName == nsGkAtoms::href) {
 302       CancelDNSPrefetch(HTML_ANCHOR_DNS_PREFETCH_DEFERRED,
 303                         HTML_ANCHOR_DNS_PREFETCH_REQUESTED);
 304     }
 305   }
 306
 307   return nsGenericHTMLElement::BeforeSetAttr(aNamespaceID, aName, aValue,
 308                                              aNotify);
 309 }
 310
 311 nsresult
 312 HTMLAnchorElement::AfterSetAttr(int32_t aNamespaceID, nsAtom* aName,
 313                                 const nsAttrValue* aValue,
 314                                 const nsAttrValue* aOldValue,
 315                                 nsIPrincipal* aSubjectPrincipal,
 316                                 bool aNotify)
 317 {
 318   if (aNamespaceID == kNameSpaceID_None) {
 319     if (aName == nsGkAtoms::href) {
 320       Link::ResetLinkState(aNotify, !!aValue);
 321       if (aValue && IsInComposedDoc()) {
 322         TryDNSPrefetch();
 323       }
 324     }
 325   }
 326
 327   return nsGenericHTMLElement::AfterSetAttr(aNamespaceID, aName,
 328                                             aValue, aOldValue, aSubjectPrincipal, aNotify);
 329 }
 330
 331 EventStates
 332 HTMLAnchorElement::IntrinsicState() const
 333 {
 334   return Link::LinkState() | nsGenericHTMLElement::IntrinsicState();
 335 }
 336
 337 void
 338 HTMLAnchorElement::AddSizeOfExcludingThis(nsWindowSizes& aSizes,
 339                                           size_t* aNodeSize) const
 340 {
 341   nsGenericHTMLElement::AddSizeOfExcludingThis(aSizes, aNodeSize);
 342   *aNodeSize += Link::SizeOfExcludingThis(aSizes.mState);
 343 }
 344
 345 } // namespace dom
 346 } // namespace mozilla