Rename EventContext to NodeEventContext.

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 34 matching lines @@
     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]; }
+    NodeEventContext& operator[](size_t index) { return m_nodeEventContexts[index]; }
+    const NodeEventContext& operator[](size_t index) const { return m_nodeEventContexts[index]; }
+    const NodeEventContext& last() const { return m_nodeEventContexts[size() - 1]; }
 
-    bool isEmpty() const { return m_eventContexts.isEmpty(); }
-    size_t size() const { return m_eventContexts.size(); }
+    bool isEmpty() const { return m_nodeEventContexts.isEmpty(); }
+    size_t size() const { return m_nodeEventContexts.size(); }
 
     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]; }
+    NodeEventContext& at(size_t index) { return m_nodeEventContexts[index]; }
 
-    void addEventContext(Node*);
+    void addNodeEventContext(Node*);
 
     void calculatePath();
     void calculateAdjustedTargets();
     void calculateAdjustedEventPath();
 
-    void shrink(size_t newSize) { m_eventContexts.shrink(newSize); }
+    void shrink(size_t newSize) { m_nodeEventContexts.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;
+    Vector<NodeEventContext, 64> m_nodeEventContexts;
     Node* m_node;
     Event* m_event;
     Vector<RefPtr<TreeScopeEventContext> > m_treeScopeEventContexts;
 };
 
 } // namespace
 
 #endif