third_party/WebKit/Source/core/html/HTMLAnchorElement.cpp

   1 /*
   2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
   4  *           (C) 2000 Simon Hausmann <hausmann@kde.org>
   5  * Copyright (C) 2003, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
   6  *           (C) 2006 Graham Dennis (graham.dennis@gmail.com)
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Library General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public License
  19  * along with this library; see the file COPYING.LIB.  If not, write to
  20  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  21  * Boston, MA 02110-1301, USA.
  22  */
  23
  24 #include "config.h"
  25 #include "core/html/HTMLAnchorElement.h"
  26
  27 #include "bindings/core/v8/V8DOMActivityLogger.h"
  28 #include "core/events/KeyboardEvent.h"
  29 #include "core/events/MouseEvent.h"
  30 #include "core/frame/FrameHost.h"
  31 #include "core/frame/Settings.h"
  32 #include "core/frame/UseCounter.h"
  33 #include "core/html/HTMLImageElement.h"
  34 #include "core/html/parser/HTMLParserIdioms.h"
  35 #include "core/layout/LayoutImage.h"
  36 #include "core/loader/FrameLoadRequest.h"
  37 #include "core/loader/FrameLoaderClient.h"
  38 #include "core/loader/PingLoader.h"
  39 #include "core/page/ChromeClient.h"
  40 #include "platform/RuntimeEnabledFeatures.h"
  41 #include "platform/network/NetworkHints.h"
  42 #include "platform/weborigin/SecurityPolicy.h"
  43
  44 namespace blink {
  45
  46 using namespace HTMLNames;
  47
  48 HTMLAnchorElement::HTMLAnchorElement(const QualifiedName& tagName, Document& document)
  49     : HTMLElement(tagName, document)
  50     , m_linkRelations(0)
  51     , m_cachedVisitedLinkHash(0)
  52     , m_wasFocusedByMouse(false)
  53 {
  54 }
  55
  56 PassRefPtrWillBeRawPtr<HTMLAnchorElement> HTMLAnchorElement::create(Document& document)
  57 {
  58     return adoptRefWillBeNoop(new HTMLAnchorElement(aTag, document));
  59 }
  60
  61 HTMLAnchorElement::~HTMLAnchorElement()
  62 {
  63 }
  64
  65 bool HTMLAnchorElement::supportsFocus() const
  66 {
  67     if (hasEditableStyle())
  68         return HTMLElement::supportsFocus();
  69     // If not a link we should still be able to focus the element if it has tabIndex.
  70     return isLink() || HTMLElement::supportsFocus();
  71 }
  72
  73 bool HTMLAnchorElement::shouldHaveFocusAppearance() const
  74 {
  75     return !m_wasFocusedByMouse || HTMLElement::supportsFocus();
  76 }
  77
  78 void HTMLAnchorElement::dispatchFocusEvent(Element* oldFocusedElement, WebFocusType type, InputDeviceCapabilities* sourceCapabilities)
  79 {
  80     if (type != WebFocusTypePage)
  81         m_wasFocusedByMouse = type == WebFocusTypeMouse;
  82     HTMLElement::dispatchFocusEvent(oldFocusedElement, type, sourceCapabilities);
  83 }
  84
  85 void HTMLAnchorElement::dispatchBlurEvent(Element* newFocusedElement, WebFocusType type, InputDeviceCapabilities* sourceCapabilities)
  86 {
  87     if (type != WebFocusTypePage)
  88         m_wasFocusedByMouse = false;
  89     HTMLElement::dispatchBlurEvent(newFocusedElement, type, sourceCapabilities);
  90 }
  91
  92 bool HTMLAnchorElement::isMouseFocusable() const
  93 {
  94     if (isLink())
  95         return supportsFocus();
  96
  97     return HTMLElement::isMouseFocusable();
  98 }
  99
 100 bool HTMLAnchorElement::isKeyboardFocusable() const
 101 {
 102     ASSERT(document().isActive());
 103
 104     if (isFocusable() && Element::supportsFocus())
 105         return HTMLElement::isKeyboardFocusable();
 106
 107     if (isLink() && !document().frameHost()->chromeClient().tabsToLinks())
 108         return false;
 109     return HTMLElement::isKeyboardFocusable();
 110 }
 111
 112 static void appendServerMapMousePosition(StringBuilder& url, Event* event)
 113 {
 114     if (!event->isMouseEvent())
 115         return;
 116
 117     ASSERT(event->target());
 118     Node* target = event->target()->toNode();
 119     ASSERT(target);
 120     if (!isHTMLImageElement(*target))
 121         return;
 122
 123     HTMLImageElement& imageElement = toHTMLImageElement(*target);
 124     if (!imageElement.isServerMap())
 125         return;
 126
 127     LayoutObject* layoutObject = imageElement.layoutObject();
 128     if (!layoutObject || !layoutObject->isBox())
 129         return;
 130
 131     // The coordinates sent in the query string are relative to the height and
 132     // width of the image element, ignoring CSS transform/zoom.
 133     LayoutPoint mapPoint(layoutObject->absoluteToLocal(FloatPoint(toMouseEvent(event)->absoluteLocation()), UseTransforms));
 134
 135     // The origin (0,0) is at the upper left of the content area, inside the
 136     // padding and border.
 137     mapPoint -= toLayoutBox(layoutObject)->contentBoxOffset();
 138
 139     // CSS zoom is not reflected in the map coordinates.
 140     float scaleFactor = 1 / layoutObject->style()->effectiveZoom();
 141     mapPoint.scale(scaleFactor, scaleFactor);
 142
 143     // Negative coordinates are clamped to 0 such that clicks in the left and
 144     // top padding/border areas receive an X or Y coordinate of 0.
 145     IntPoint clampedPoint(roundedIntPoint(mapPoint));
 146     clampedPoint.clampNegativeToZero();
 147
 148     url.append('?');
 149     url.appendNumber(clampedPoint.x());
 150     url.append(',');
 151     url.appendNumber(clampedPoint.y());
 152 }
 153
 154 void HTMLAnchorElement::defaultEventHandler(Event* event)
 155 {
 156     if (isLink()) {
 157         if (focused() && isEnterKeyKeydownEvent(event) && isLiveLink()) {
 158             event->setDefaultHandled();
 159             dispatchSimulatedClick(event);
 160             return;
 161         }
 162
 163         if (isLinkClick(event) && isLiveLink()) {
 164             handleClick(event);
 165             return;
 166         }
 167     }
 168
 169     HTMLElement::defaultEventHandler(event);
 170 }
 171
 172 void HTMLAnchorElement::setActive(bool down)
 173 {
 174     if (hasEditableStyle())
 175         return;
 176
 177     ContainerNode::setActive(down);
 178 }
 179
 180 void HTMLAnchorElement::attributeWillChange(const QualifiedName& name, const AtomicString& oldValue, const AtomicString& newValue)
 181 {
 182     if (name == hrefAttr && inDocument()) {
 183         V8DOMActivityLogger* activityLogger = V8DOMActivityLogger::currentActivityLoggerIfIsolatedWorld();
 184         if (activityLogger) {
 185             Vector<String> argv;
 186             argv.append("a");
 187             argv.append(hrefAttr.toString());
 188             argv.append(oldValue);
 189             argv.append(newValue);
 190             activityLogger->logEvent("blinkSetAttribute", argv.size(), argv.data());
 191         }
 192     }
 193     HTMLElement::attributeWillChange(name, oldValue, newValue);
 194 }
 195
 196 void HTMLAnchorElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
 197 {
 198     if (name == hrefAttr) {
 199         bool wasLink = isLink();
 200         setIsLink(!value.isNull());
 201         if (wasLink || isLink()) {
 202             pseudoStateChanged(CSSSelector::PseudoLink);
 203             pseudoStateChanged(CSSSelector::PseudoVisited);
 204             pseudoStateChanged(CSSSelector::PseudoAnyLink);
 205         }
 206         if (wasLink && !isLink() && treeScope().adjustedFocusedElement() == this) {
 207             // We might want to call blur(), but it's dangerous to dispatch
 208             // events here.
 209             document().setNeedsFocusedElementCheck();
 210         }
 211         if (isLink()) {
 212             String parsedURL = stripLeadingAndTrailingHTMLSpaces(value);
 213             if (document().isDNSPrefetchEnabled()) {
 214                 if (protocolIs(parsedURL, "http") || protocolIs(parsedURL, "https") || parsedURL.startsWith("//"))
 215                     prefetchDNS(document().completeURL(parsedURL).host());
 216             }
 217         }
 218         invalidateCachedVisitedLinkHash();
 219     } else if (name == nameAttr || name == titleAttr) {
 220         // Do nothing.
 221     } else if (name == relAttr) {
 222         setRel(value);
 223     } else {
 224         HTMLElement::parseAttribute(name, value);
 225     }
 226 }
 227
 228 void HTMLAnchorElement::accessKeyAction(bool sendMouseEvents)
 229 {
 230     dispatchSimulatedClick(0, sendMouseEvents ? SendMouseUpDownEvents : SendNoEvents);
 231 }
 232
 233 bool HTMLAnchorElement::isURLAttribute(const Attribute& attribute) const
 234 {
 235     return attribute.name().localName() == hrefAttr || HTMLElement::isURLAttribute(attribute);
 236 }
 237
 238 bool HTMLAnchorElement::hasLegalLinkAttribute(const QualifiedName& name) const
 239 {
 240     return name == hrefAttr || HTMLElement::hasLegalLinkAttribute(name);
 241 }
 242
 243 bool HTMLAnchorElement::canStartSelection() const
 244 {
 245     if (!isLink())
 246         return HTMLElement::canStartSelection();
 247     return hasEditableStyle();
 248 }
 249
 250 bool HTMLAnchorElement::draggable() const
 251 {
 252     // Should be draggable if we have an href attribute.
 253     const AtomicString& value = getAttribute(draggableAttr);
 254     if (equalIgnoringCase(value, "true"))
 255         return true;
 256     if (equalIgnoringCase(value, "false"))
 257         return false;
 258     return hasAttribute(hrefAttr);
 259 }
 260
 261 KURL HTMLAnchorElement::href() const
 262 {
 263     return document().completeURL(stripLeadingAndTrailingHTMLSpaces(getAttribute(hrefAttr)));
 264 }
 265
 266 void HTMLAnchorElement::setHref(const AtomicString& value)
 267 {
 268     setAttribute(hrefAttr, value);
 269 }
 270
 271 KURL HTMLAnchorElement::url() const
 272 {
 273     return href();
 274 }
 275
 276 void HTMLAnchorElement::setURL(const KURL& url)
 277 {
 278     setHref(AtomicString(url.string()));
 279 }
 280
 281 String HTMLAnchorElement::input() const
 282 {
 283     return getAttribute(hrefAttr);
 284 }
 285
 286 void HTMLAnchorElement::setInput(const String& value)
 287 {
 288     setHref(AtomicString(value));
 289 }
 290
 291 bool HTMLAnchorElement::hasRel(uint32_t relation) const
 292 {
 293     return m_linkRelations & relation;
 294 }
 295
 296 void HTMLAnchorElement::setRel(const AtomicString& value)
 297 {
 298     m_linkRelations = 0;
 299     SpaceSplitString newLinkRelations(value, SpaceSplitString::ShouldFoldCase);
 300     // FIXME: Add link relations as they are implemented
 301     if (newLinkRelations.contains("noreferrer"))
 302         m_linkRelations |= RelationNoReferrer;
 303 }
 304
 305 const AtomicString& HTMLAnchorElement::name() const
 306 {
 307     return getNameAttribute();
 308 }
 309
 310 short HTMLAnchorElement::tabIndex() const
 311 {
 312     // Skip the supportsFocus check in HTMLElement.
 313     return Element::tabIndex();
 314 }
 315
 316 bool HTMLAnchorElement::isLiveLink() const
 317 {
 318     return isLink() && !hasEditableStyle();
 319 }
 320
 321 void HTMLAnchorElement::sendPings(const KURL& destinationURL) const
 322 {
 323     const AtomicString& pingValue = getAttribute(pingAttr);
 324     if (pingValue.isNull() || !document().settings() || !document().settings()->hyperlinkAuditingEnabled())
 325         return;
 326
 327     UseCounter::count(document(), UseCounter::HTMLAnchorElementPingAttribute);
 328
 329     SpaceSplitString pingURLs(pingValue, SpaceSplitString::ShouldNotFoldCase);
 330     for (unsigned i = 0; i < pingURLs.size(); i++)
 331         PingLoader::sendLinkAuditPing(document().frame(), document().completeURL(pingURLs[i]), destinationURL);
 332 }
 333
 334 void HTMLAnchorElement::handleClick(Event* event)
 335 {
 336     event->setDefaultHandled();
 337
 338     LocalFrame* frame = document().frame();
 339     if (!frame)
 340         return;
 341
 342     StringBuilder url;
 343     url.append(stripLeadingAndTrailingHTMLSpaces(fastGetAttribute(hrefAttr)));
 344     appendServerMapMousePosition(url, event);
 345     KURL completedURL = document().completeURL(url.toString());
 346
 347     // Schedule the ping before the frame load. Prerender in Chrome may kill the renderer as soon as the navigation is
 348     // sent out.
 349     sendPings(completedURL);
 350
 351     ResourceRequest request(completedURL);
 352     request.setUIStartTime(event->uiCreateTime());
 353     request.setInputPerfMetricReportPolicy(InputToLoadPerfMetricReportPolicy::ReportLink);
 354
 355     ReferrerPolicy policy;
 356     if (RuntimeEnabledFeatures::referrerPolicyAttributeEnabled() && hasAttribute(referrerpolicyAttr) && SecurityPolicy::referrerPolicyFromString(fastGetAttribute(referrerpolicyAttr), &policy) && !hasRel(RelationNoReferrer)) {
 357         request.setHTTPReferrer(SecurityPolicy::generateReferrer(policy, completedURL, document().outgoingReferrer()));
 358     }
 359
 360     if (hasAttribute(downloadAttr)) {
 361         request.setRequestContext(WebURLRequest::RequestContextDownload);
 362         bool isSameOrigin = completedURL.protocolIsData() || document().securityOrigin()->canRequest(completedURL);
 363         const AtomicString& suggestedName = (isSameOrigin ? fastGetAttribute(downloadAttr) : nullAtom);
 364
 365         frame->loader().client()->loadURLExternally(request, NavigationPolicyDownload, suggestedName);
 366     } else {
 367         request.setRequestContext(WebURLRequest::RequestContextHyperlink);
 368         FrameLoadRequest frameRequest(&document(), request, getAttribute(targetAttr));
 369         frameRequest.setTriggeringEvent(event);
 370         if (hasRel(RelationNoReferrer))
 371             frameRequest.setShouldSendReferrer(NeverSendReferrer);
 372         frame->loader().load(frameRequest);
 373     }
 374 }
 375
 376 bool isEnterKeyKeydownEvent(Event* event)
 377 {
 378     return event->type() == EventTypeNames::keydown && event->isKeyboardEvent() && toKeyboardEvent(event)->keyIdentifier() == "Enter";
 379 }
 380
 381 bool isLinkClick(Event* event)
 382 {
 383     return event->type() == EventTypeNames::click && (!event->isMouseEvent() || toMouseEvent(event)->button() != RightButton);
 384 }
 385
 386 bool HTMLAnchorElement::willRespondToMouseClickEvents()
 387 {
 388     return isLink() || HTMLElement::willRespondToMouseClickEvents();
 389 }
 390
 391 bool HTMLAnchorElement::isInteractiveContent() const
 392 {
 393     return isLink();
 394 }
 395
 396 Node::InsertionNotificationRequest HTMLAnchorElement::insertedInto(ContainerNode* insertionPoint)
 397 {
 398     if (insertionPoint->inDocument()) {
 399         V8DOMActivityLogger* activityLogger = V8DOMActivityLogger::currentActivityLoggerIfIsolatedWorld();
 400         if (activityLogger) {
 401             Vector<String> argv;
 402             argv.append("a");
 403             argv.append(fastGetAttribute(hrefAttr));
 404             activityLogger->logEvent("blinkAddElement", argv.size(), argv.data());
 405         }
 406     }
 407     return HTMLElement::insertedInto(insertionPoint);
 408 }
 409
 410 } // namespace blink