Speculatively launch Service Workers on mouse/touch events. [1/5]

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

Index: third_party/WebKit/Source/core/html/HTMLAnchorElement.cpp
diff --git a/third_party/WebKit/Source/core/html/HTMLAnchorElement.cpp b/third_party/WebKit/Source/core/html/HTMLAnchorElement.cpp
index eccde4647c675b1b06ae3b1f500fc036e4c5ac65..c483edee14a228b26ca2c5018a989c4ca8d28215 100644
--- a/third_party/WebKit/Source/core/html/HTMLAnchorElement.cpp
+++ b/third_party/WebKit/Source/core/html/HTMLAnchorElement.cpp
@@ -35,13 +35,85 @@
 #include "core/loader/FrameLoaderClient.h"
 #include "core/loader/PingLoader.h"
 #include "core/page/ChromeClient.h"
+#include "platform/RuntimeEnabledFeatures.h"
 #include "platform/network/NetworkHints.h"
+#include "platform/weborigin/SchemeRegistry.h"
 #include "platform/weborigin/SecurityPolicy.h"
+#include "public/platform/WebNavigationHintType.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
+class HTMLAnchorElement::NavigationHintSender : public GarbageCollected<HTMLAnchorElement::NavigationHintSender> {
+public:
+    static NavigationHintSender* create(HTMLAnchorElement* anchorElement)
+    {
+        return new NavigationHintSender(anchorElement);
+    }
+    void handleEvent(Event*);
+
+    DECLARE_VIRTUAL_TRACE();
+
+private:
+    explicit NavigationHintSender(HTMLAnchorElement*);
+    bool shouldSendNavigationHintForServiceWorker() const;
+    void maybeSendNavigationHintForServiceWorker(WebNavigationHintType);
+
+    Member<HTMLAnchorElement> m_anchorElement;
+};
+
+void HTMLAnchorElement::NavigationHintSender::handleEvent(Event* event)
+{
+    if (event->type() == EventTypeNames::mousedown && event->isMouseEvent() && toMouseEvent(event)->button() == LeftButton)
+        maybeSendNavigationHintForServiceWorker(WebNavigationHintType::LinkMouseDown);
+    else if (event->type() == EventTypeNames::gesturetapunconfirmed)
+        maybeSendNavigationHintForServiceWorker(WebNavigationHintType::LinkTapUnconfirmed);
+    else if (event->type() == EventTypeNames::gestureshowpress)
+        maybeSendNavigationHintForServiceWorker(WebNavigationHintType::LinkTapDown);
+}
+
+DEFINE_TRACE(HTMLAnchorElement::NavigationHintSender)
+{
+    visitor->trace(m_anchorElement);
+}
+
+HTMLAnchorElement::NavigationHintSender::NavigationHintSender(HTMLAnchorElement* anchorElement)
+    : m_anchorElement(anchorElement)
+{
+}
+
+bool HTMLAnchorElement::NavigationHintSender::shouldSendNavigationHintForServiceWorker() const
+{
+    const KURL& url = m_anchorElement->href();
+    if (!SchemeRegistry::shouldTreatURLSchemeAsAllowingServiceWorkers(url.protocol()))
+        return false;
+    Document& document = m_anchorElement->document();
+    if (!document.frame())
+        return false;
+    if (!document.getSecurityOrigin()->canDisplay(url))
+        return false;

[falken, 2016/06/15 13:48:19]

I'm probably just clueless about DOM stuff but why do we need to check frame()
and security origin here? If there is a link to a some URL, I'd assume that a
navigation to that isn't restricted by this document's origin, since we'd get a
new document. However if I were to come across this code I'd be afraid to change
it in and cause a security issue.

I'd prefer explanatory comments here for better maintainability, unless it's
obvious to Blink people.

[horo, 2016/06/16 06:02:44]

Added comment about checking frame().
Ah we don't need to check canDisplay(). Removed.
(It was originally from kouhei@'s patch.
https://chromiumcodereview.appspot.com/15352003)

+    if (url.hasFragmentIdentifier() && equalIgnoringFragmentIdentifier(document.url(), url))
+        return false;

[falken, 2016/06/15 13:48:19]

Thanks for the explanation of this one, that makes sense to me now.

+
+    // If the opener is to be suppressed and the target frame name is set,
+    // WebContentsImpl::CreateNewWindow() will create a new process when the
+    // user click the anchor element. In such case we shouldn't start the

[falken, 2016/06/15 13:48:19]

s/click/clicks

+    // Service Worker not to keep the current process running.

[falken, 2016/06/15 13:48:19]

The first sentence makes sense to me, but the second sentence does not... both
the grammar and the meaning. Is it saying you don't want to create the SW in
this  current process, because the navigation will go to a new process? I
thought our SW implementation is supposed to handle the case of SW in one
process and page in another.

[horo, 2016/06/16 06:02:44]

I thought that we should not run the SW in the current process if the new
navigation creates another new process.
But there is no apparent reason.

Removed.

+    const bool openerSuppressed = m_anchorElement->hasRel(RelationNoReferrer) || m_anchorElement->hasRel(RelationNoOpener);
+    if (openerSuppressed && !m_anchorElement->getAttribute(targetAttr).isEmpty())
+        return false;
+    return true;
+}
+
+void HTMLAnchorElement::NavigationHintSender::maybeSendNavigationHintForServiceWorker(WebNavigationHintType type)
+{
+    if (!shouldSendNavigationHintForServiceWorker())
+        return;
+
+    // TODO(horo): Send the navigation hint message to the browser process.
+}
+
 HTMLAnchorElement::HTMLAnchorElement(const QualifiedName& tagName, Document& document)
     : HTMLElement(tagName, document)
     , m_linkRelations(0)
@@ -59,6 +131,12 @@ HTMLAnchorElement::~HTMLAnchorElement()
 {
 }
 
+DEFINE_TRACE(HTMLAnchorElement)
+{
+    visitor->trace(m_navigationHintsender);
+    HTMLElement::trace(visitor);
+}
+
 bool HTMLAnchorElement::supportsFocus() const
 {
     if (hasEditableStyle())
@@ -162,6 +240,10 @@ void HTMLAnchorElement::defaultEventHandler(Event* event)
             return;
         }
 
+        // TODO(horo): Call NavigationHintSender::handleEvent() when
+        // SpeculativeLaunchServiceWorker feature is enabled.
+        // ensureNavigationHintSender()->handleEvent(event);
+
         if (isLinkClick(event) && isLiveLink()) {
             handleClick(event);
             return;
@@ -396,4 +478,11 @@ Node::InsertionNotificationRequest HTMLAnchorElement::insertedInto(ContainerNode
     return request;
 }
 
+HTMLAnchorElement::NavigationHintSender* HTMLAnchorElement::ensureNavigationHintSender()
+{
+    if (!m_navigationHintsender)
+        m_navigationHintsender = NavigationHintSender::create(this);
+    return m_navigationHintsender;
+}
+
 } // namespace blink