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

third_party/WebKit/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
@@ skipping 17 matching lines @@
 #include "core/frame/FrameHost.h"
 #include "core/frame/Settings.h"
 #include "core/frame/UseCounter.h"
 #include "core/html/HTMLImageElement.h"
 #include "core/html/parser/HTMLParserIdioms.h"
 #include "core/layout/LayoutBox.h"
 #include "core/loader/FrameLoadRequest.h"
 #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)
     , m_cachedVisitedLinkHash(0)
     , m_wasFocusedByMouse(false)
 {
 }
 
 HTMLAnchorElement* HTMLAnchorElement::create(Document& document)
 {
     return new HTMLAnchorElement(aTag, document);
 }
 
 HTMLAnchorElement::~HTMLAnchorElement()
 {
 }
 
+DEFINE_TRACE(HTMLAnchorElement)
+{
+    visitor->trace(m_navigationHintsender);
+    HTMLElement::trace(visitor);
+}
+
 bool HTMLAnchorElement::supportsFocus() const
 {
     if (hasEditableStyle())
         return HTMLElement::supportsFocus();
     // If not a link we should still be able to focus the element if it has tabIndex.
     return isLink() || HTMLElement::supportsFocus();
 }
 
 bool HTMLAnchorElement::matchesEnabledPseudoClass() const
 {
@@ skipping 83 matching lines @@
 
 void HTMLAnchorElement::defaultEventHandler(Event* event)
 {
     if (isLink()) {
         if (focused() && isEnterKeyKeydownEvent(event) && isLiveLink()) {
             event->setDefaultHandled();
             dispatchSimulatedClick(event);
             return;
         }
 
+        // TODO(horo): Call NavigationHintSender::handleEvent() when
+        // SpeculativeLaunchServiceWorker feature is enabled.
+        // ensureNavigationHintSender()->handleEvent(event);
+
         if (isLinkClick(event) && isLiveLink()) {
             handleClick(event);
             return;
         }
     }
 
     HTMLElement::defaultEventHandler(event);
 }
 
 void HTMLAnchorElement::setActive(bool down)
@@ skipping 214 matching lines @@
     return isLink();
 }
 
 Node::InsertionNotificationRequest HTMLAnchorElement::insertedInto(ContainerNode* insertionPoint)
 {
     InsertionNotificationRequest request = HTMLElement::insertedInto(insertionPoint);
     logAddElementIfIsolatedWorldAndInDocument("a", hrefAttr);
     return request;
 }
 
+HTMLAnchorElement::NavigationHintSender* HTMLAnchorElement::ensureNavigationHintSender()
+{
+    if (!m_navigationHintsender)
+        m_navigationHintsender = NavigationHintSender::create(this);
+    return m_navigationHintsender;
+}
+
 } // namespace blink