WIP (Introduce WTF::NonNullPtr<T>.)

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 22 matching lines @@
 #include "core/dom/TreeScope.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/RefPtr.h"
 #include "wtf/Vector.h"
 
 namespace WebCore {
 
 static inline bool inTheSameScope(ShadowRoot* shadowRoot, EventTarget* target)
 {
-    return target->toNode() && target->toNode()->treeScope().rootNode() == shadowRoot;
+    return target->toNode() && target->toNode()->treeScope()->rootNode() == shadowRoot;
 }
 
 static inline EventDispatchBehavior determineDispatchBehavior(Event* event, ShadowRoot* shadowRoot, EventTarget* target)
 {
     // Video-only full screen is a mode where we use the shadow DOM as an implementation
     // detail that should not be detectable by the web content.
     if (Element* element = FullscreenElementStack::currentFullScreenElementFrom(&target->toNode()->document())) {
         // FIXME: We assume that if the full screen element is a media element that it's
         // the video-only full screen. Both here and elsewhere. But that is probably wrong.
         if (element->isMediaElement() && shadowRoot && shadowRoot->host() == element)
@@ skipping 59 matching lines @@
     }
 }
 
 void EventRetargeter::calculateAdjustedEventPathForEachNode(EventPath& eventPath)
 {
     if (!RuntimeEnabledFeatures::shadowDOMEnabled())
         return;
     TreeScope* lastScope = 0;
     size_t eventPathSize = eventPath.size();
     for (size_t i = 0; i < eventPathSize; ++i) {
-        TreeScope* currentScope = &eventPath[i]->node()->treeScope();
+        NonNullPtr<TreeScope> currentScope = eventPath[i]->node()->treeScope();
         if (currentScope == lastScope) {
             // Fast path.
             eventPath[i]->setEventPath(eventPath[i - 1]->eventPath());
             continue;
         }
-        lastScope = currentScope;
+        lastScope = currentScope.get();
         Vector<RefPtr<Node> > nodes;
         for (size_t j = 0; j < eventPathSize; ++j) {
             Node* node = eventPath[j]->node();
-            if (node->treeScope().isInclusiveAncestorOf(*currentScope))
+            if (node->treeScope()->isInclusiveAncestorOf(currentScope))
                 nodes.append(node);
         }
         eventPath[i]->adoptEventPath(nodes);
     }
 }
 
 void EventRetargeter::adjustForMouseEvent(Node* node, MouseEvent& mouseEvent)
 {
     adjustForRelatedTarget(node, mouseEvent.relatedTarget(), mouseEvent.eventPath());
 }
@@ skipping 64 matching lines @@
 {
     RelatedNodeMap relatedNodeMap;
     buildRelatedNodeMap(relatedNode, relatedNodeMap);
 
     // Synthetic mouse events can have a relatedTarget which is identical to the target.
     bool targetIsIdenticalToToRelatedTarget = (node == relatedNode);
 
     TreeScope* lastTreeScope = 0;
     Node* adjustedNode = 0;
     for (EventPath::const_iterator iter = eventPath.begin(); iter < eventPath.end(); ++iter) {
-        TreeScope* scope = &(*iter)->node()->treeScope();
+        NonNullPtr<TreeScope> scope = (*iter)->node()->treeScope();
         if (scope == lastTreeScope) {
             // Re-use the previous adjustedRelatedTarget if treeScope does not change. Just for the performance optimization.
             adjustedNodes.append(adjustedNode);
         } else {
-            adjustedNode = findRelatedNode(scope, relatedNodeMap);
+            adjustedNode = findRelatedNode(scope.get(), relatedNodeMap);
             adjustedNodes.append(adjustedNode);
         }
-        lastTreeScope = scope;
+        lastTreeScope = scope.get();
         if (eventWithRelatedTargetDispatchBehavior == DoesNotStopAtBoundary)
             continue;
         if (targetIsIdenticalToToRelatedTarget) {
-            if (node->treeScope().rootNode() == (*iter)->node()) {
+            if (node->treeScope()->rootNode() == (*iter)->node()) {
                 eventPath.shrink(iter + 1 - eventPath.begin());
                 break;
             }
         } else if ((*iter)->target() == adjustedNode) {
             // Event dispatching should be stopped here.
             eventPath.shrink(iter - eventPath.begin());
             adjustedNodes.shrink(adjustedNodes.size() - 1);
             break;
         }
     }
 }
 
 void EventRetargeter::buildRelatedNodeMap(const Node* relatedNode, RelatedNodeMap& relatedNodeMap)
 {
     Vector<Node*, 32> relatedNodeStack;
     TreeScope* lastTreeScope = 0;
     for (EventPathWalker walker(relatedNode); walker.node(); walker.moveToParent()) {
         Node* node = walker.node();
         if (relatedNodeStack.isEmpty())
             relatedNodeStack.append(node);
         else if (walker.isVisitingInsertionPointInReprojection())
             relatedNodeStack.append(relatedNodeStack.last());
-        TreeScope* scope = &node->treeScope();
+        NonNullPtr<TreeScope> scope = node->treeScope();
         // Skips adding a node to the map if treeScope does not change. Just for the performance optimization.
         if (scope != lastTreeScope)
-            relatedNodeMap.add(scope, relatedNodeStack.last());
-        lastTreeScope = scope;
+            relatedNodeMap.add(scope.get(), relatedNodeStack.last());
+        lastTreeScope = scope.get();
         if (node->isShadowRoot()) {
             ASSERT(!relatedNodeStack.isEmpty());
             relatedNodeStack.removeLast();
         }
     }
 }
 
 Node* EventRetargeter::findRelatedNode(TreeScope* scope, RelatedNodeMap& relatedNodeMap)
 {
     Vector<TreeScope*, 32> parentTreeScopes;
     Node* relatedNode = 0;
     while (scope) {
         parentTreeScopes.append(scope);
         RelatedNodeMap::const_iterator found = relatedNodeMap.find(scope);
         if (found != relatedNodeMap.end()) {
             relatedNode = found->value;
             break;
         }
         scope = scope->parentTreeScope();
     }
     for (Vector<TreeScope*, 32>::iterator iter = parentTreeScopes.begin(); iter < parentTreeScopes.end(); ++iter)
         relatedNodeMap.add(*iter, relatedNode);
     return relatedNode;
 }
 
 }