Make contenteditable="false" element as atomic node for selection motion

Source/core/editing/htmlediting.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007 Apple 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 48 matching lines @@
 using namespace std;
 
 namespace WebCore {
 
 using namespace HTMLNames;
 
 // Atomic means that the node has no children, or has children which are ignored for the
 // purposes of editing.
 bool isAtomicNode(const Node *node)
 {
-    return node && (!node->hasChildNodes() || editingIgnoresContent(node));
+    if (!node)
+        return false;
+    if (!node->hasChildNodes() || editingIgnoresContent(node))
+        return true;
+    RenderObject* renderer = node->renderer();
+    if (!renderer)
+        return false;
+    // For compatibility with IE, we allow to move caret into table cell event
+    // if TABLE and TR are uneditable.
+    if (renderer->isTable() || renderer->isTableRow())

[ojan, 2013/05/27 06:51:54]

I don't think this bit is right. Even if we were to special-case tables, this
leaves out table sections. What does IE do if you make the tbody uneditable?

Still, I don't think we want to special-case tables unless we have some evidence
(other than layout tests) that web content depends on this. Browser
compatibility is important, but we should try to get browsers to converge on a
behavior that we think is good.

[yosin_UTC9, 2013/05/27 09:10:13]

I don't think there are web contents depend on this. Because, all browsers do
different.
Anyway, I'm reverting this patch: https://codereview.chromium.org/15732019/

+        return false;
+    return renderer->style()->userModify() == READ_ONLY && lowestEditableAncestor(node);
 }
 
 // Compare two positions, taking into account the possibility that one or both
 // could be inside a shadow tree. Only works for non-null values.
 int comparePositions(const Position& a, const Position& b)
 {
     TreeScope* commonScope = commonTreeScope(a.containerNode(), b.containerNode());
 
     ASSERT(commonScope);
     if (!commonScope)
@@ skipping 41 matching lines @@
         if (node->rendererIsEditable(editableType))
             highestRoot = node;
         if (node->hasTagName(bodyTag))
             break;
         node = node->parentNode();
     }
     
     return highestRoot;
 }
 
-Node* lowestEditableAncestor(Node* node)
+Node* lowestEditableAncestor(const Node* node)
 {
     if (!node)
         return 0;
     
     Node* lowestRoot = 0;
     while (node) {
         if (node->rendererIsEditable())
             return node->rootEditableElement();
         if (node->hasTagName(bodyTag))
             break;
@@ skipping 1059 matching lines @@
     // if the selection starts just before a paragraph break, skip over it
     if (isEndOfParagraph(visiblePosition))
         return visiblePosition.next().deepEquivalent().downstream();
 
     // otherwise, make sure to be at the start of the first selected node,
     // instead of possibly at the end of the last node before the selection
     return visiblePosition.deepEquivalent().downstream();
 }
 
 } // namespace WebCore