Revert of "Speculatively launch Service Workers on mouse/touch events."

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
@@ skipping 21 matching lines @@
 #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/PingLoader.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/Page.h"
 #include "platform/network/NetworkHints.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_TRACE();
-
- private:
-  explicit NavigationHintSender(HTMLAnchorElement*);
-  bool shouldSendNavigationHint() const;
-  void maybeSendNavigationHint(WebNavigationHintType);
-
-  Member<HTMLAnchorElement> m_anchorElement;
-};
-
-void HTMLAnchorElement::NavigationHintSender::handleEvent(Event* event) {
-  if (event->type() == EventTypeNames::mousedown && event->isMouseEvent() &&
-      toMouseEvent(event)->button() ==
-          static_cast<short>(WebPointerProperties::Button::Left))
-    maybeSendNavigationHint(WebNavigationHintType::LinkMouseDown);
-  else if (event->type() == EventTypeNames::gesturetapunconfirmed)
-    maybeSendNavigationHint(WebNavigationHintType::LinkTapUnconfirmed);
-  else if (event->type() == EventTypeNames::gestureshowpress)
-    maybeSendNavigationHint(WebNavigationHintType::LinkTapDown);
-}
-
-DEFINE_TRACE(HTMLAnchorElement::NavigationHintSender) {
-  visitor->trace(m_anchorElement);
-}
-
-HTMLAnchorElement::NavigationHintSender::NavigationHintSender(
-    HTMLAnchorElement* anchorElement)
-    : m_anchorElement(anchorElement) {}
-
-bool HTMLAnchorElement::NavigationHintSender::shouldSendNavigationHint() const {
-  const KURL& url = m_anchorElement->href();
-  // Currently the navigation hint only supports HTTP and HTTPS.
-  if (!url.protocolIsInHTTPFamily())
-    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 send the navigation hint
-  // to the browser process.
-  if (url.hasFragmentIdentifier() &&
-      equalIgnoringFragmentIdentifier(document.url(), url))
-    return false;
-
-  return true;
-}
-
-void HTMLAnchorElement::NavigationHintSender::maybeSendNavigationHint(
-    WebNavigationHintType type) {
-  if (!shouldSendNavigationHint())
-    return;
-
-  sendNavigationHint(m_anchorElement->href(), type);
-}
-
 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(*this))
     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 {
   return isLink();
@@ skipping 82 matching lines @@
 }
 
 void HTMLAnchorElement::defaultEventHandler(Event* event) {
   if (isLink()) {
     if (isFocused() && isEnterKeyKeydownEvent(event) && isLiveLink()) {
       event->setDefaultHandled();
       dispatchSimulatedClick(event);
       return;
     }
 
-    if (RuntimeEnabledFeatures::speculativeLaunchServiceWorkerEnabled())
-      ensureNavigationHintSender()->handleEvent(event);
-
     if (isLinkClick(event) && isLiveLink()) {
       handleClick(event);
       return;
     }
   }
 
   HTMLElement::defaultEventHandler(event);
 }
 
 void HTMLAnchorElement::setActive(bool down) {
@@ skipping 226 matching lines @@
 }
 
 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