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> {

[kinuko, 2016/06/16 06:14:31]

Now it looks this class seems to exist primarily for SW, is it intended
layering?  NavigationHintFoo class names / enum names appear to be very generic
on the contrary.

[horo, 2016/06/16 07:02:14]

Added "ForServiceWorkerSender".

+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 the element was detached from the frame, handleClick() doesn't cause
+    // the navigation.
+    if (!document.frame())
+        return false;
+
+    // When the user clicks a link which is to the current document with a hash,
+    // the network request is not fetched. So we don't need to start the Service
+    // Worker.
+    if (url.hasFragmentIdentifier() && equalIgnoringFragmentIdentifier(document.url(), url))
+        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