Introduce TreeScopeEventContext

Source/core/events/EventContext.h

 /*
  * Copyright (C) 2010 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 25 matching lines @@
 namespace WebCore {
 
 class Event;
 class TouchList;
 
 class TouchEventContext : public RefCounted<TouchEventContext> {
 public:
     static PassRefPtr<TouchEventContext> create();
     ~TouchEventContext();
     void handleLocalEvents(Event*) const;
-    TouchList* touches() { return m_touches.get(); }
-    TouchList* targetTouches() { return m_targetTouches.get(); }
-    TouchList* changedTouches() { return m_changedTouches.get(); }
+    TouchList& touches() { return *m_touches; }
+    TouchList& targetTouches() { return *m_targetTouches; }
+    TouchList& changedTouches() { return *m_changedTouches; }
 
 private:
     TouchEventContext();
 
     RefPtr<TouchList> m_touches;
     RefPtr<TouchList> m_targetTouches;
     RefPtr<TouchList> m_changedTouches;
 };
 
-class EventContext {
+class SharedEventContext : public RefCounted<SharedEventContext> {

[dglazkov, 2013/12/26 17:30:13]

"Shared" is a bit too vague here. To be fair, "EventContext" is also a bit too
vague, and that is totally my fault.

Maybe TreeEventContext and NodeEventContext?

 public:
-    // FIXME: Use ContainerNode instead of Node.
-    EventContext(PassRefPtr<Node>, PassRefPtr<EventTarget> currentTarget);
-    ~EventContext();
+    static PassRefPtr<SharedEventContext> create(TreeScope&);
+    ~SharedEventContext();
 
-    Node* node() const { return m_node.get(); }
-    EventTarget* currentTarget() const { return m_currentTarget.get(); }
+    TreeScope& treeScope() const { return m_treeScope; }
 
     EventTarget* target() const { return m_target.get(); }
     void setTarget(PassRefPtr<EventTarget>);
 
     EventTarget* relatedTarget() const { return m_relatedTarget.get(); }
     void setRelatedTarget(PassRefPtr<EventTarget>);
 
     TouchEventContext* touchEventContext() const { return m_touchEventContext.get(); }
     TouchEventContext* ensureTouchEventContext();
 
     PassRefPtr<NodeList> eventPath() const { return m_eventPath; }
     void adoptEventPath(Vector<RefPtr<Node> >&);
-    void setEventPath(PassRefPtr<NodeList> nodeList) { m_eventPath = nodeList; }
 
-    bool currentTargetSameAsTarget() const { return m_currentTarget.get() == m_target.get(); }
-    void handleLocalEvents(Event*) const;
+private:
+    SharedEventContext(TreeScope&);
 
-protected:
 #ifndef NDEBUG
     bool isUnreachableNode(EventTarget*);
 #endif
-    RefPtr<Node> m_node;
-    RefPtr<EventTarget> m_currentTarget;
+
+    TreeScope& m_treeScope;
     RefPtr<EventTarget> m_target;
     RefPtr<EventTarget> m_relatedTarget;
     RefPtr<NodeList> m_eventPath;
     RefPtr<TouchEventContext> m_touchEventContext;
 };
 
+class EventContext {
+public:
+    // FIXME: Use ContainerNode instead of Node.
+    EventContext(PassRefPtr<Node>, PassRefPtr<EventTarget> currentTarget);
+    ~EventContext();
+
+    Node* node() const { return m_node.get(); }
+    EventTarget* currentTarget() const { return m_currentTarget.get(); }
+
+    SharedEventContext* sharedEventContext() const { return m_sharedEventContext.get(); }
+    void setSharedEventContext(PassRefPtr<SharedEventContext> sharedEventContext) { m_sharedEventContext = sharedEventContext; }
+
+    EventTarget* target() const { return m_sharedEventContext->target(); }
+    EventTarget* relatedTarget() const { return m_sharedEventContext->relatedTarget(); }
+    TouchEventContext* touchEventContext() const { return m_sharedEventContext->touchEventContext(); }
+    PassRefPtr<NodeList> eventPath() const { return m_sharedEventContext->eventPath(); }
+
+    bool currentTargetSameAsTarget() const { return m_currentTarget.get() == target(); }
+    void handleLocalEvents(Event*) const;
+
+private:
+    RefPtr<Node> m_node;
+    RefPtr<EventTarget> m_currentTarget;
+    RefPtr<SharedEventContext> m_sharedEventContext;
+};
+
 #ifndef NDEBUG
-inline bool EventContext::isUnreachableNode(EventTarget* target)
+inline bool SharedEventContext::isUnreachableNode(EventTarget* target)
 {
     // FIXME: Checks also for SVG elements.
-    return target && target->toNode() && !target->toNode()->isSVGElement() && !target->toNode()->treeScope().isInclusiveAncestorOf(m_node->treeScope());
+    return target && target->toNode() && !target->toNode()->isSVGElement() && !target->toNode()->treeScope().isInclusiveAncestorOf(m_treeScope);
 }
 #endif
 
-inline void EventContext::setTarget(PassRefPtr<EventTarget> target)
+inline void SharedEventContext::setTarget(PassRefPtr<EventTarget> target)
 {
     ASSERT(!isUnreachableNode(target.get()));
     m_target = target;
 }
 
-inline void EventContext::setRelatedTarget(PassRefPtr<EventTarget> relatedTarget)
+inline void SharedEventContext::setRelatedTarget(PassRefPtr<EventTarget> relatedTarget)
 {
     ASSERT(!isUnreachableNode(relatedTarget.get()));
     m_relatedTarget = relatedTarget;
 }
 
 }
 
 #endif // EventContext_h