Trigger preconnect for link anchor tags on pre-click {mouse,gesture} events.

Source/core/html/HTMLAnchorElement.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Simon Hausmann <hausmann@kde.org>
  * Copyright (C) 2003, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  *           (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "config.h"
 #include "core/html/HTMLAnchorElement.h"
 
+#include <public/Platform.h>
+#include <public/WebPrescientNetworking.h>
+#include <public/WebURL.h>
 #include <wtf/text/StringBuilder.h>
 #include "HTMLNames.h"
 #include "core/dom/Attribute.h"
 #include "core/dom/EventNames.h"
 #include "core/dom/KeyboardEvent.h"
 #include "core/dom/MouseEvent.h"
 #include "core/editing/FrameSelection.h"
 #include "core/html/HTMLImageElement.h"
 #include "core/html/parser/HTMLParserIdioms.h"
 #include "core/loader/FrameLoader.h"
 #include "core/loader/FrameLoaderClient.h"
 #include "core/loader/FrameLoaderTypes.h"
 #include "core/loader/PingLoader.h"
 #include "core/page/Chrome.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/Frame.h"
 #include "core/page/Page.h"
 #include "core/page/Settings.h"
 #include "core/platform/HistogramSupport.h"
 #include "core/platform/PlatformMouseEvent.h"
 #include "core/platform/network/DNS.h"
 #include "core/platform/network/ResourceRequest.h"
 #include "core/rendering/RenderImage.h"
 #include "weborigin/KnownPorts.h"
 #include "weborigin/SecurityOrigin.h"
 #include "weborigin/SecurityPolicy.h"
 
 namespace WebCore {
 
+namespace {
+
+void preconnectToURL(const KURL& url, WebKit::WebPreconnectMotivation motivation)
+{
+    WebKit::WebPrescientNetworking* prescientNetworking = WebKit::Platform::current()->prescientNetworking();
+    if (!prescientNetworking)
+        return;
+
+    prescientNetworking->preconnect(url, motivation);
+}
+
+}
+
 class HTMLAnchorElement::PrefetchEventHandler {
 public:
-    static PassOwnPtr<PrefetchEventHandler> create()
+    static PassOwnPtr<PrefetchEventHandler> create(HTMLAnchorElement* anchorElement)
     {
-        return adoptPtr(new HTMLAnchorElement::PrefetchEventHandler());
+        return adoptPtr(new HTMLAnchorElement::PrefetchEventHandler(anchorElement));
     }
 
     void handleEvent(Event* e);
 
 private:
-    PrefetchEventHandler();
+    explicit PrefetchEventHandler(HTMLAnchorElement*);
 
     void reset();
 
     void handleMouseOver(Event* event);
     void handleMouseOut(Event* event);
     void handleLeftMouseDown(Event* event);
     void handleGestureTapUnconfirmed(Event*);
     void handleGestureTapDown(Event*);
     void handleClick(Event* event);
 
+    bool shouldPrefetch(const KURL&);
+    void prefetch(WebKit::WebPreconnectMotivation);
+
+    HTMLAnchorElement* m_anchorElement;
     double m_mouseOverTimestamp;
     double m_mouseDownTimestamp;
     double m_tapDownTimestamp;
     bool m_hadTapUnconfirmed;
+    bool m_hasIssuedPreconnect;
 };
 
 using namespace HTMLNames;
 
 HTMLAnchorElement::HTMLAnchorElement(const QualifiedName& tagName, Document* document)
     : HTMLElement(tagName, document)
     , m_hasRootEditableElementForSelectionOnMouseDown(false)
     , m_wasShiftKeyDownOnMouseDown(false)
     , m_linkRelations(0)
     , m_cachedVisitedLinkHash(0)
@@ skipping 550 matching lines @@
         return;
     }
 
     rootEditableElementMap().set(this, element);
     m_hasRootEditableElementForSelectionOnMouseDown = true;
 }
 
 HTMLAnchorElement::PrefetchEventHandler* HTMLAnchorElement::prefetchEventHandler()
 {
     if (!m_prefetchEventHandler)
-        m_prefetchEventHandler = PrefetchEventHandler::create();
+        m_prefetchEventHandler = PrefetchEventHandler::create(this);
 
     return m_prefetchEventHandler.get();
 }
 
-HTMLAnchorElement::PrefetchEventHandler::PrefetchEventHandler()
+HTMLAnchorElement::PrefetchEventHandler::PrefetchEventHandler(HTMLAnchorElement* anchorElement)
+    : m_anchorElement(anchorElement)
 {
+    ASSERT(m_anchorElement);
+
     reset();
 }
 
 void HTMLAnchorElement::PrefetchEventHandler::reset()
 {
     m_mouseOverTimestamp = 0;
     m_mouseDownTimestamp = 0;
     m_hadTapUnconfirmed = false;
     m_tapDownTimestamp = 0;
+    m_hasIssuedPreconnect = false;
 }
 
 void HTMLAnchorElement::PrefetchEventHandler::handleEvent(Event* event)
 {
+    if (!shouldPrefetch(m_anchorElement->href()))
+        return;
+
     if (event->type() == eventNames().mouseoverEvent)
         handleMouseOver(event);
     else if (event->type() == eventNames().mouseoutEvent)
         handleMouseOut(event);
     else if (event->type() == eventNames().mousedownEvent && event->isMouseEvent() && static_cast<MouseEvent*>(event)->button() == LeftButton)
         handleLeftMouseDown(event);
     else if (event->type() == eventNames().gesturetapdownEvent)
         handleGestureTapDown(event);
     else if (event->type() == eventNames().gesturetapunconfirmedEvent)
         handleGestureTapUnconfirmed(event);
     else if (isLinkClick(event))
         handleClick(event);
 }
 
 void HTMLAnchorElement::PrefetchEventHandler::handleMouseOver(Event* event)
 {
     if (m_mouseOverTimestamp == 0.0) {
         m_mouseOverTimestamp = event->timeStamp();
 
         HistogramSupport::histogramEnumeration("MouseEventPrefetch.MouseOvers", 0, 2);
+
+        prefetch(WebKit::WebPreconnectMotivationLinkMouseOver);
     }
 }
 
 void HTMLAnchorElement::PrefetchEventHandler::handleMouseOut(Event* event)
 {
     if (m_mouseOverTimestamp > 0.0) {
         double mouseOverDuration = convertDOMTimeStampToSeconds(event->timeStamp() - m_mouseOverTimestamp);
         HistogramSupport::histogramCustomCounts("MouseEventPrefetch.MouseOverDuration_NoClick", mouseOverDuration * 1000, 0, 10000, 100);
 
         m_mouseOverTimestamp = 0.0;
     }
 }
 
 void HTMLAnchorElement::PrefetchEventHandler::handleLeftMouseDown(Event* event)
 {
     m_mouseDownTimestamp = event->timeStamp();
 
     HistogramSupport::histogramEnumeration("MouseEventPrefetch.MouseDowns", 0, 2);
+
+    prefetch(WebKit::WebPreconnectMotivationLinkMouseDown);
 }
 
 void HTMLAnchorElement::PrefetchEventHandler::handleGestureTapUnconfirmed(Event* event)
 {
     m_hadTapUnconfirmed = true;
 
     HistogramSupport::histogramEnumeration("MouseEventPrefetch.TapUnconfirmeds", 0, 2);
+
+    prefetch(WebKit::WebPreconnectMotivationLinkTapUnconfirmed);
 }
 
 void HTMLAnchorElement::PrefetchEventHandler::handleGestureTapDown(Event* event)
 {
     m_tapDownTimestamp = event->timeStamp();
 
     HistogramSupport::histogramEnumeration("MouseEventPrefetch.TapDowns", 0, 2);
+
+    prefetch(WebKit::WebPreconnectMotivationLinkTapDown);
 }
 
 void HTMLAnchorElement::PrefetchEventHandler::handleClick(Event* event)
 {
     bool capturedMouseOver = (m_mouseOverTimestamp > 0.0);
     if (capturedMouseOver) {
         double mouseOverDuration = convertDOMTimeStampToSeconds(event->timeStamp() - m_mouseOverTimestamp);
 
         HistogramSupport::histogramCustomCounts("MouseEventPrefetch.MouseOverDuration_Click", mouseOverDuration * 1000, 0, 10000, 100);
     }
@@ skipping 13 matching lines @@
 
         HistogramSupport::histogramCustomCounts("MouseEventPrefetch.TapDownDuration_Click", tapDownDuration * 1000, 0, 10000, 100);
     }
 
     int flags = (m_hadTapUnconfirmed ? 2 : 0) | (capturedTapDown ? 1 : 0);
     HistogramSupport::histogramEnumeration("MouseEventPrefetch.PreTapEventsFollowedByClick", flags, 4);
 
     reset();
 }
 
+bool HTMLAnchorElement::PrefetchEventHandler::shouldPrefetch(const KURL& url)
+{
+    Document* document = m_anchorElement->document();
+    if (!document)
+        return false;
+
+    if (!document->securityOrigin()->canDisplay(url))
+        return false;
+
+    if (url.hasFragmentIdentifier() && equalIgnoringFragmentIdentifier(document->url(), url))
+        return false;
+
+    Frame* frame = document->frame();
+    if (!frame)
+        return false;
+
+    // Links which create new window/tab are avoided because they may require user approval interaction.
+    if (!m_anchorElement->target().isEmpty())
+        return false;
+
+    return true;
 }
+
+void HTMLAnchorElement::PrefetchEventHandler::prefetch(WebKit::WebPreconnectMotivation motivation)
+{
+    const KURL& url = m_anchorElement->href();
+
+    if (!shouldPrefetch(url))
+        return;
+
+    preconnectToURL(url, motivation);
+}
+
+}