Remove remaining OILPAN uses from core/events/

third_party/WebKit/Source/core/events/EventPath.cpp

 /*
  * 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 113 matching lines @@
             if (HTMLSlotElement* slot = current->assignedSlot()) {
                 current = slot;
                 nodesInPath.append(current);
                 continue;
             }
         }
         if (current->isShadowRoot()) {
             if (m_event && shouldStopAtShadowRoot(*m_event, *toShadowRoot(current), *m_node))
                 break;
             current = current->shadowHost();
-#if !ENABLE(OILPAN)
-            // TODO(kochi): crbug.com/507413 This check is necessary when some asynchronous event
-            // is queued while its shadow host is removed and the shadow root gets the event
-            // immediately after it.  When Oilpan is enabled, this situation does not happen.
-            // Except this case, shadow root's host is assumed to be non-null.
-            if (current)
-                nodesInPath.append(current);
-#else
             nodesInPath.append(current);
-#endif
         } else {
             current = current->parentNode();
             if (current)
                 nodesInPath.append(current);
         }
     }
 
     m_nodeEventContexts.reserveCapacity(nodesInPath.size());
     for (Node* nodeInPath : nodesInPath) {
         m_nodeEventContexts.append(NodeEventContext(nodeInPath, eventTargetRespectingTargetRules(*nodeInPath)));
@@ skipping 72 matching lines @@
     m_treeScopeEventContexts.appendRange(treeScopeEventContextMap.values().begin(), treeScopeEventContextMap.values().end());
 }
 
 void EventPath::buildRelatedNodeMap(const Node& relatedNode, RelatedTargetMap& relatedTargetMap)
 {
     EventPath* relatedTargetEventPath = new EventPath(const_cast<Node&>(relatedNode));
     for (size_t i = 0; i < relatedTargetEventPath->m_treeScopeEventContexts.size(); ++i) {
         TreeScopeEventContext* treeScopeEventContext = relatedTargetEventPath->m_treeScopeEventContexts[i].get();
         relatedTargetMap.add(&treeScopeEventContext->treeScope(), treeScopeEventContext->target());
     }
-#if ENABLE(OILPAN)
     // Oilpan: It is important to explicitly clear the vectors to reuse
     // the memory in subsequent event dispatchings.
     relatedTargetEventPath->clear();
-#endif
 }
 
 EventTarget* EventPath::findRelatedNode(TreeScope& scope, RelatedTargetMap& relatedTargetMap)
 {
     HeapVector<Member<TreeScope>, 32> parentTreeScopes;
     EventTarget* relatedNode = nullptr;
     for (TreeScope* current = &scope; current; current = current->olderShadowRootOrParentTreeScope()) {
         parentTreeScopes.append(current);
         RelatedTargetMap::const_iterator iter = relatedTargetMap.find(current);
         if (iter != relatedTargetMap.end() && iter->value) {
@@ skipping 126 matching lines @@
 DEFINE_TRACE(EventPath)
 {
     visitor->trace(m_nodeEventContexts);
     visitor->trace(m_node);
     visitor->trace(m_event);
     visitor->trace(m_treeScopeEventContexts);
     visitor->trace(m_windowEventContext);
 }
 
 } // namespace blink