Use anchor node, rather than current selected node, to check editability.

third_party/WebKit/Source/core/editing/FrameCaret.cpp

 /*
  * Copyright (C) 2004, 2008, 2009, 2010 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 42 matching lines @@
       m_shouldShowBlockCursor(false) {
   DCHECK(frame);
 }
 
 FrameCaret::~FrameCaret() = default;
 
 DEFINE_TRACE(FrameCaret) {
   visitor->trace(m_selectionEditor);
   visitor->trace(m_frame);
   visitor->trace(m_previousCaretNode);
+  visitor->trace(m_previousCaretAnchorNode);
   CaretBase::trace(visitor);
 }
 
 const PositionWithAffinity FrameCaret::caretPosition() const {
   const VisibleSelection& selection =
       m_selectionEditor->visibleSelection<EditingStrategy>();
   if (!selection.isCaret())
     return PositionWithAffinity();
   return PositionWithAffinity(selection.start(), selection.affinity());
 }
@@ skipping 72 matching lines @@
 }
 
 void FrameCaret::invalidateCaretRect(bool forceInvalidation) {
   if (!m_caretRectDirty)
     return;
   m_caretRectDirty = false;
 
   DCHECK(caretPositionIsValidForDocument(*m_frame->document()));
   LayoutObject* layoutObject = nullptr;
   LayoutRect newRect;
+  PositionWithAffinity currentCaretPosition = caretPosition();
   if (isActive())
-    newRect = localCaretRectOfPosition(caretPosition(), layoutObject);
+    newRect = localCaretRectOfPosition(currentCaretPosition, layoutObject);
   Node* newNode = layoutObject ? layoutObject->node() : nullptr;
-
+  // The current selected node |newNode| could be a child multiple levels below
+  // its associated "anchor node" ancestor, so we reference and keep around the
+  // anchor node for checking editability.
+  // TODO(wkorman): Consider storing previous Position, rather than Node, and
+  // making use of EditingUtilies::isEditablePosition() directly.
+  Node* newAnchorNode =

[yosin_UTC9, 2016/10/13 03:58:47]

I think we should use layout object associated DisplayItem passed to
CaretBase::paintCaret(),
since actual painting will be done that.

Anyway, I'll visit again for http://crrev.com/1958093002

+      currentCaretPosition.position().parentAnchoredEquivalent().anchorNode();
+  if (newNode && newAnchorNode && newNode != newAnchorNode &&
+      newAnchorNode->layoutObject() && newAnchorNode->layoutObject()->isBox()) {
+    newNode->layoutObject()->mapToVisualRectInAncestorSpace(
+        toLayoutBoxModelObject(newAnchorNode->layoutObject()), newRect);
+  }
   // It's possible for the timer to be inactive even though we want to
   // invalidate the caret. For example, when running as a layout test the
   // caret blink interval could be zero and thus |m_caretBlinkTimer| will
   // never be started. We provide |forceInvalidation| for use by paint
   // invalidation internals where we need to invalidate the caret regardless
   // of timer state.
   if (!forceInvalidation && !m_caretBlinkTimer.isActive() &&
       newNode == m_previousCaretNode && newRect == m_previousCaretRect &&
       m_caretVisibility == m_previousCaretVisibility)
     return;
 
-  if (m_previousCaretNode && shouldRepaintCaret(*m_previousCaretNode))
-    invalidateLocalCaretRect(m_previousCaretNode.get(), m_previousCaretRect);
-  if (newNode && shouldRepaintCaret(*newNode))
-    invalidateLocalCaretRect(newNode, newRect);
+  if (m_previousCaretNode && shouldRepaintCaret(*m_previousCaretAnchorNode)) {
+    invalidateLocalCaretRect(m_previousCaretAnchorNode.get(),
+                             m_previousCaretRect);
+  }
+  if (newNode && shouldRepaintCaret(*newAnchorNode))
+    invalidateLocalCaretRect(newAnchorNode, newRect);
   m_previousCaretNode = newNode;
+  m_previousCaretAnchorNode = newAnchorNode;
   m_previousCaretRect = newRect;
   m_previousCaretVisibility = m_caretVisibility;
 }
 
 IntRect FrameCaret::absoluteCaretBounds() {
   DCHECK_NE(m_frame->document()->lifecycle().state(),
             DocumentLifecycle::InPaintInvalidation);
   DCHECK(!m_frame->document()->needsLayoutTreeUpdate());
   DocumentLifecycle::DisallowTransitionScope disallowTransition(
       m_frame->document()->lifecycle());
@@ skipping 32 matching lines @@
 
   updateCaretRect(caretPosition());
   CaretBase::paintCaret(caretPosition().position().anchorNode(), context,
                         paintOffset, DisplayItem::kCaret);
 }
 
 void FrameCaret::dataWillChange(const CharacterData& node) {
   if (node == m_previousCaretNode) {
     // This invalidation is eager, and intentionally uses stale state.
     DisableCompositingQueryAsserts disabler;
-    invalidateLocalCaretRect(m_previousCaretNode.get(), m_previousCaretRect);
+    invalidateLocalCaretRect(m_previousCaretAnchorNode.get(),
+                             m_previousCaretRect);
   }
 }
 
 void FrameCaret::nodeWillBeRemoved(Node& node) {
-  if (node != m_previousCaretNode)
+  if (node != m_previousCaretNode && node != m_previousCaretAnchorNode)
     return;
   // Hits in ManualTests/caret-paint-after-last-text-is-removed.html
   DisableCompositingQueryAsserts disabler;
-  invalidateLocalCaretRect(m_previousCaretNode.get(), m_previousCaretRect);
+  invalidateLocalCaretRect(m_previousCaretAnchorNode.get(),
+                           m_previousCaretRect);
   m_previousCaretNode = nullptr;
+  m_previousCaretAnchorNode = nullptr;
   m_previousCaretRect = LayoutRect();
   m_previousCaretVisibility = CaretVisibility::Hidden;
 }
 
 void FrameCaret::documentDetached() {
   m_caretBlinkTimer.stop();
   m_previousCaretNode.clear();
+  m_previousCaretAnchorNode.clear();
 }
 
 bool FrameCaret::shouldBlinkCaret() const {
   if (m_caretVisibility != CaretVisibility::Visible || !isActive())
     return false;
 
   Element* root = rootEditableElementOf(caretPosition().position());
   if (!root)
     return false;
 
   Element* focusedElement = root->document().focusedElement();
   if (!focusedElement)
     return false;
 
   return focusedElement->isShadowIncludingInclusiveAncestorOf(
       caretPosition().position().anchorNode());
 }
 
 void FrameCaret::caretBlinkTimerFired(TimerBase*) {
   DCHECK_EQ(m_caretVisibility, CaretVisibility::Visible);
   if (isCaretBlinkingSuspended() && m_shouldPaintCaret)
     return;
   m_shouldPaintCaret = !m_shouldPaintCaret;
   setCaretRectNeedsUpdate();
 }
 
-}  // nemaspace blink
+}  // namespace blink