Introduce TreeScopeEventContext

Source/core/events/EventPath.h

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Neither the name of Google Inc. nor the names of its
@@ skipping 11 matching lines @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef EventPath_h
 #define EventPath_h
 
 #include "core/events/EventContext.h"
 
-#include "wtf/OwnPtr.h"
+#include "wtf/HashMap.h"
 #include "wtf/Vector.h"
 
 namespace WebCore {
 
 class Event;
 class EventTarget;
 class Node;
+class TouchEvent;
+class TouchList;
+class TreeScope;
 
 enum EventDispatchBehavior {
     RetargetEvent,
     StayInsideShadowDOM
 };
 
 class EventPath {
 public:
     explicit EventPath(Event*);
     explicit EventPath(Node*);
     void resetWith(Node*);
 
     EventContext& operator[](size_t index) { return m_eventContexts[index]; }
     const EventContext& operator[](size_t index) const { return m_eventContexts[index]; }
     const EventContext& last() const { return m_eventContexts[size() - 1]; }
 
     bool isEmpty() const { return m_eventContexts.isEmpty(); }
     size_t size() const { return m_eventContexts.size(); }
 
-    void shrink(size_t newSize) { m_eventContexts.shrink(newSize); }
+    void adjustForRelatedTarget(Node*, EventTarget* relatedTarget);
+    void adjustForTouchEvent(Node*, TouchEvent&);
 
     static Node* parent(Node*);
     static EventTarget* eventTargetRespectingTargetRules(Node*);
 
 private:
     EventPath();
 
     EventContext& at(size_t index) { return m_eventContexts[index]; }
 
     void addEventContext(Node*);
 
     void calculatePath();
     void calculateAdjustedTargets();
-    void calculateAdjustedEventPathForEachNode();
+    void calculateAdjustedEventPath();
+
+    void shrink(size_t newSize) { m_eventContexts.shrink(newSize); }
+    void shrinkIfNeeded(const Node* target, const EventTarget* relatedTarget);
+
+    void adjustTouchList(const Node*, const TouchList*, Vector<TouchList*> adjustedTouchList, const Vector<TreeScope*>& treeScopes);
+
+    typedef HashMap<TreeScope*, EventTarget*> RelatedTargetMap;
+
+    static void buildRelatedNodeMap(const Node*, RelatedTargetMap&);
+    static EventTarget* findRelatedNode(TreeScope*, RelatedTargetMap&);
+
+#ifndef NDEBUG
+    static void checkReachability(TreeScope&, TouchList&);
+#endif
 
     Vector<EventContext, 64> m_eventContexts;
     Node* m_node;
     Event* m_event;
+    Vector<RefPtr<TreeScopeEventContext> > m_sharedEventContexts;
 };
 
 } // namespace
 
 #endif