Revert removal of events

Source/core/dom/EventRetargeter.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * 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
@@ skipping 62 matching lines @@
         return StayInsideShadowDOM;
 
     return RetargetEvent;
 }
 
 void EventRetargeter::calculateEventPath(Node* node, Event* event, EventPath& eventPath)
 {
     bool inDocument = node->inDocument();
     bool isSVGElement = node->isSVGElement();
     bool isMouseOrFocusEvent = event->isMouseEvent() || event->isFocusEvent();
+#if ENABLE(TOUCH_EVENTS)
     bool isTouchEvent = event->isTouchEvent();
+#endif
     Vector<EventTarget*, 32> targetStack;
     for (EventPathWalker walker(node); walker.node(); walker.moveToParent()) {
         Node* node = walker.node();
         if (targetStack.isEmpty())
             targetStack.append(eventTargetRespectingTargetRules(node));
         else if (walker.isVisitingInsertionPointInReprojection())
             targetStack.append(targetStack.last());
         if (isMouseOrFocusEvent)
             eventPath.append(adoptPtr(new MouseOrFocusEventContext(node, eventTargetRespectingTargetRules(node), targetStack.last())));
+#if ENABLE(TOUCH_EVENTS)
         else if (isTouchEvent)
             eventPath.append(adoptPtr(new TouchEventContext(node, eventTargetRespectingTargetRules(node), targetStack.last())));
+#endif
         else
             eventPath.append(adoptPtr(new EventContext(node, eventTargetRespectingTargetRules(node), targetStack.last())));
         if (!inDocument)
             return;
         if (!node->isShadowRoot())
             continue;
         if (determineDispatchBehavior(event, toShadowRoot(node), targetStack.last()) == StayInsideShadowDOM)
             return;
         if (!isSVGElement) {
             ASSERT(!targetStack.isEmpty());
             targetStack.removeLast();
         }
     }
 }
 
 void EventRetargeter::adjustForMouseEvent(Node* node, const MouseEvent& mouseEvent, EventPath& eventPath)
 {
     adjustForRelatedTarget(node, mouseEvent.relatedTarget(), eventPath);
 }
 
 void EventRetargeter::adjustForFocusEvent(Node* node, const FocusEvent& focusEvent, EventPath& eventPath)
 {
     adjustForRelatedTarget(node, focusEvent.relatedTarget(), eventPath);
 }
 
+#if ENABLE(TOUCH_EVENTS)
 void EventRetargeter::adjustForTouchEvent(Node* node, const TouchEvent& touchEvent, EventPath& eventPath)
 {
     size_t eventPathSize = eventPath.size();
 
     EventPathTouchLists eventPathTouches(eventPathSize);
     EventPathTouchLists eventPathTargetTouches(eventPathSize);
     EventPathTouchLists eventPathChangedTouches(eventPathSize);
 
     for (size_t i = 0; i < eventPathSize; ++i) {
         ASSERT(eventPath[i]->isTouchEventContext());
@@ skipping 16 matching lines @@
     ASSERT(eventPathTouchLists.size() == eventPathSize);
     for (size_t i = 0; i < touchList->length(); ++i) {
         const Touch& touch = *touchList->item(i);
         AdjustedNodes adjustedNodes;
         calculateAdjustedNodes(node, touch.target()->toNode(), DoesNotStopAtBoundary, const_cast<EventPath&>(eventPath), adjustedNodes);
         ASSERT(adjustedNodes.size() == eventPathSize);
         for (size_t j = 0; j < eventPathSize; ++j)
             eventPathTouchLists[j]->append(touch.cloneWithNewTarget(adjustedNodes[j].get()));
     }
 }
+#endif
 
 void EventRetargeter::adjustForRelatedTarget(const Node* node, EventTarget* relatedTarget, EventPath& eventPath)
 {
     if (!node)
         return;
     if (!relatedTarget)
         return;
     Node* relatedNode = relatedTarget->toNode();
     if (!relatedNode)
         return;
@@ skipping 77 matching lines @@
             break;
         }
         scope = scope->parentTreeScope();
     }
     for (Vector<TreeScope*, 32>::iterator iter = parentTreeScopes.begin(); iter < parentTreeScopes.end(); ++iter)
         relatedNodeMap.add(*iter, relatedNode);
     return relatedNode;
 }
 
 }