[oilpan] Handlify Nodes in htmlediting

Source/core/dom/Node.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 1125 matching lines @@
 #ifndef NDEBUG
     detachingNode = 0;
 #endif
 }
 
 // FIXME: This code is used by editing.  Seems like it could move over there and not pollute Node.
 Node* Node::previousNodeConsideringAtomicNodes() const
 {
     if (previousSibling()) {
         Handle<Node> n = previousSibling();
-        while (!isAtomicNode(n.raw()) && n->lastChild()) {
+        while (!isAtomicNode(n) && n->lastChild()) {
             HandleScope scope;
             n = n->lastChild();
         }
         return n.raw();
     }
     else if (parentNode()) {
         return parentNode().handle().raw();
     }
     else {
         return 0;
     }
 }
 
 Node* Node::nextNodeConsideringAtomicNodes() const
 {
-    if (!isAtomicNode(this) && firstChild())
+    if (!isAtomicNode(selfHandle()) && firstChild())
         return firstChild().handle().raw();
     if (nextSibling())
         return nextSibling().handle().raw();
     Handle<const Node> n = selfHandle();
     while (n && !n->nextSibling()) {
         HandleScope scope;
         n = n->parentNode();
     }
     if (n)
         return n->nextSibling().handle().raw();
     return 0;
 }
 
 Result<Node> Node::previousLeafNode() const
 {
     Handle<Node> node = adoptRawResult(previousNodeConsideringAtomicNodes());
     while (node) {
         HandleScope scope;
-        if (isAtomicNode(node.raw()))
+        if (isAtomicNode(node))
             return node;
         node = adoptRawResult(node->previousNodeConsideringAtomicNodes());
     }
     return nullptr;
 }
 
 Result<Node> Node::nextLeafNode() const
 {
     Handle<Node> node = adoptRawResult(nextNodeConsideringAtomicNodes());
     while (node) {
         HandleScope scope;
-        if (isAtomicNode(node.raw()))
+        if (isAtomicNode(node))
             return node;
         node = adoptRawResult(node->nextNodeConsideringAtomicNodes());
     }
     return nullptr;
 }
 
 Result<ContainerNode> Node::parentNodeForRenderingAndStyle()
 {
     return NodeRenderingContext(selfHandle()).parentNodeForRenderingAndStyle();
 }
@@ skipping 1564 matching lines @@
         node->showTreeForThis();
 }
 
 void showNodePath(const WebCore::Node* node)
 {
     if (node)
         node->showNodePathForThis();
 }
 
 #endif