[oilpan] Handlify Nodes in htmlediting

Source/core/editing/VisibleSelection.cpp

 /*
  * Copyright (C) 2004, 2005, 2006 Apple Computer, 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 78 matching lines @@
     : m_base(range->startPosition())
     , m_extent(range->endPosition())
     , m_affinity(affinity)
     , m_isDirectional(isDirectional)
 {
     validate();
 }
 
 VisibleSelection VisibleSelection::selectionFromContentsOfNode(Node* node)
 {
-    ASSERT(!editingIgnoresContent(node));
+    ASSERT(!editingIgnoresContent(adoptRawResult(node)));
     return VisibleSelection(firstPositionInNode(adoptRawResult(node)), lastPositionInNode(adoptRawResult(node)), DOWNSTREAM);
 }
 
 void VisibleSelection::setBase(const Position& position)
 {
     m_base = position;
     validate();
 }
 
 void VisibleSelection::setBase(const VisiblePosition& visiblePosition)
@@ skipping 187 matching lines @@
             if (isEndOfEditableOrNonEditableContent(start) || (isEndOfLine(start) && !isStartOfLine(start) && !isEndOfParagraph(start)))
                 side = LeftWordIfOnBoundary;
             m_start = startOfWord(start, side).deepEquivalent();
             side = RightWordIfOnBoundary;
             if (isEndOfEditableOrNonEditableContent(originalEnd) || (isEndOfLine(originalEnd) && !isStartOfLine(originalEnd) && !isEndOfParagraph(originalEnd)))
                 side = LeftWordIfOnBoundary;
 
             VisiblePosition wordEnd(endOfWord(originalEnd, side));
             VisiblePosition end(wordEnd);
 
-            if (isEndOfParagraph(originalEnd) && !isEmptyTableCell(m_start.deprecatedNode().handle().raw())) {
+            if (isEndOfParagraph(originalEnd) && !isEmptyTableCell(m_start.deprecatedNode())) {
                 // Select the paragraph break (the space from the end of a paragraph to the start of
                 // the next one) to match TextEdit.
                 end = wordEnd.next();
 
-                if (Node* table = isFirstPositionAfterTable(end)) {
+                if (Handle<Node> table = isFirstPositionAfterTable(end)) {
                     // The paragraph break after the last paragraph in the last cell of a block table ends
                     // at the start of the paragraph after the table.
                     if (isBlock(table))
                         end = end.next(CannotCrossEditingBoundary);
                     else
                         end = wordEnd;
                 }
 
                 if (end.isNull())
                     end = wordEnd;
@@ skipping 29 matching lines @@
             VisiblePosition pos(m_start, m_affinity);
             if (isStartOfLine(pos) && isEndOfEditableOrNonEditableContent(pos))
                 pos = pos.previous();
             m_start = startOfParagraph(pos).deepEquivalent();
             VisiblePosition visibleParagraphEnd = endOfParagraph(VisiblePosition(m_end, m_affinity));
 
             // Include the "paragraph break" (the space from the end of this paragraph to the start
             // of the next one) in the selection.
             VisiblePosition end(visibleParagraphEnd.next());
 
-            if (Node* table = isFirstPositionAfterTable(end)) {
+            if (Handle<Node> table = isFirstPositionAfterTable(end)) {
                 // The paragraph break after the last paragraph in the last cell of a block table ends
                 // at the start of the paragraph after the table, not at the position just after the table.
                 if (isBlock(table))
                     end = end.next(CannotCrossEditingBoundary);
                 // There is no parargraph break after the last paragraph in the last cell of an inline table.
                 else
                     end = visibleParagraphEnd;
             }
 
             if (end.isNull())
@@ skipping 142 matching lines @@
     }
 
     ASSERT(m_start.anchorNode()->treeScope() == m_end.anchorNode()->treeScope());
 }
 
 void VisibleSelection::adjustSelectionToAvoidCrossingEditingBoundaries()
 {
     if (m_base.isNull() || m_start.isNull() || m_end.isNull())
         return;
 
-    Node* baseRoot = highestEditableRoot(m_base);
-    Node* startRoot = highestEditableRoot(m_start);
-    Node* endRoot = highestEditableRoot(m_end);
+    Handle<Node> baseRoot = highestEditableRoot(m_base);
+    Handle<Node> startRoot = highestEditableRoot(m_start);
+    Handle<Node> endRoot = highestEditableRoot(m_end);
 
-    Node* baseEditableAncestor = lowestEditableAncestor(m_base.containerNode().handle().raw());
+    Handle<Node> baseEditableAncestor = lowestEditableAncestor(m_base.containerNode());
 
     // The base, start and end are all in the same region.  No adjustment necessary.
     if (baseRoot == startRoot && baseRoot == endRoot)
         return;
 
     // The selection is based in editable content.
     if (baseRoot) {
         // If the start is outside the base's editable root, cap it at the start of that root.
         // If the start is in non-editable content that is inside the base's editable root, put it
         // at the first editable position after start inside the base's editable root.
@@ skipping 14 matching lines @@
             if (m_end.isNull())
                 m_end = m_start;
         }
     // The selection is based in non-editable content.
     } else {
         // FIXME: Non-editable pieces inside editable content should be atomic, in the same way that editable
         // pieces in non-editable content are atomic.
 
         // The selection ends in editable content or non-editable content inside a different editable ancestor,
         // move backward until non-editable content inside the same lowest editable ancestor is reached.
-        Node* endEditableAncestor = lowestEditableAncestor(m_end.containerNode().handle().raw());
+        Handle<Node> endEditableAncestor = lowestEditableAncestor(m_end.containerNode());
         if (endRoot || endEditableAncestor != baseEditableAncestor) {
 
             Position p = previousVisuallyDistinctCandidate(m_end);
             Handle<Node> shadowAncestor = endRoot ? endRoot->shadowHost() : nullptr;
             if (p.isNull() && shadowAncestor)
                 p = positionAfterNode(shadowAncestor);
-            while (p.isNotNull() && !(lowestEditableAncestor(p.containerNode().handle().raw()) == baseEditableAncestor && !isEditablePosition(p))) {
+            while (p.isNotNull() && !(lowestEditableAncestor(p.containerNode()) == baseEditableAncestor && !isEditablePosition(p))) {
                 HandleScope scope;
                 Handle<Node> root = editableRootForPosition(p);
                 shadowAncestor = root ? root->shadowHost() : nullptr;
-                p = isAtomicNode(p.containerNode().handle().raw()) ? positionInParentBeforeNode(p.containerNode()) : previousVisuallyDistinctCandidate(p);
+                p = isAtomicNode(p.containerNode()) ? positionInParentBeforeNode(p.containerNode()) : previousVisuallyDistinctCandidate(p);
                 if (p.isNull() && shadowAncestor)
                     p = positionAfterNode(shadowAncestor);
             }
             VisiblePosition previous(p);
 
             if (previous.isNull()) {
                 // The selection crosses an Editing boundary.  This is a
                 // programmer error in the editing code.  Happy debugging!
                 ASSERT_NOT_REACHED();
                 m_base = Position();
                 m_extent = Position();
                 validate();
                 return;
             }
             m_end = previous.deepEquivalent();
         }
 
         // The selection starts in editable content or non-editable content inside a different editable ancestor,
         // move forward until non-editable content inside the same lowest editable ancestor is reached.
-        Node* startEditableAncestor = lowestEditableAncestor(m_start.containerNode().handle().raw());
+        Handle<Node> startEditableAncestor = lowestEditableAncestor(m_start.containerNode());
         if (startRoot || startEditableAncestor != baseEditableAncestor) {
             Position p = nextVisuallyDistinctCandidate(m_start);
             Handle<Node> shadowAncestor = startRoot ? startRoot->shadowHost() : nullptr;
             if (p.isNull() && shadowAncestor)
                 p = positionBeforeNode(shadowAncestor);
-            while (p.isNotNull() && !(lowestEditableAncestor(p.containerNode().handle().raw()) == baseEditableAncestor && !isEditablePosition(p))) {
+            while (p.isNotNull() && !(lowestEditableAncestor(p.containerNode()) == baseEditableAncestor && !isEditablePosition(p))) {
                 HandleScope scope;
                 Handle<Node> root = editableRootForPosition(p);
                 shadowAncestor = root ? root->shadowHost() : nullptr;
-                p = isAtomicNode(p.containerNode().handle().raw()) ? positionInParentAfterNode(p.containerNode()) : nextVisuallyDistinctCandidate(p);
+                p = isAtomicNode(p.containerNode()) ? positionInParentAfterNode(p.containerNode()) : nextVisuallyDistinctCandidate(p);
                 if (p.isNull() && shadowAncestor)
                     p = positionBeforeNode(shadowAncestor);
             }
             VisiblePosition next(p);
 
             if (next.isNull()) {
                 // The selection crosses an Editing boundary.  This is a
                 // programmer error in the editing code.  Happy debugging!
                 ASSERT_NOT_REACHED();
                 m_base = Position();
                 m_extent = Position();
                 validate();
                 return;
             }
             m_start = next.deepEquivalent();
         }
     }
 
     // Correct the extent if necessary.
-    if (baseEditableAncestor != lowestEditableAncestor(m_extent.containerNode().handle().raw()))
+    if (baseEditableAncestor != lowestEditableAncestor(m_extent.containerNode()))
         m_extent = m_baseIsFirst ? m_end : m_start;
 }
 
 bool VisibleSelection::isContentEditable() const
 {
     return isEditablePosition(start());
 }
 
 bool VisibleSelection::rendererIsEditable() const
 {
@@ skipping 79 matching lines @@
     sel.showTreeForThis();
 }
 
 void showTree(const WebCore::VisibleSelection* sel)
 {
     if (sel)
         sel->showTreeForThis();
 }
 
 #endif