Make FrameSelection to hold non-canonicalized positions

third_party/WebKit/Source/core/editing/SelectionEditor.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
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/editing/SelectionEditor.h"
 
+#include "core/dom/NodeWithIndex.h"
+#include "core/dom/Text.h"
 #include "core/editing/EditingUtilities.h"
 #include "core/editing/Editor.h"
 #include "core/editing/SelectionAdjuster.h"
 #include "core/frame/LocalFrame.h"
 
 namespace blink {
 
-SelectionEditor::SelectionEditor(LocalFrame& frame)
-    : m_frame(frame), m_observingVisibleSelection(false) {
+SelectionEditor::SelectionEditor(LocalFrame& frame) : m_frame(frame) {
   clearVisibleSelection();
 }
 
 SelectionEditor::~SelectionEditor() {}
 
+void SelectionEditor::assertSelectionValid() const {
+#if DCHECK_IS_ON()
+  // Since We don't track dom tree version during attribute changes, we can't
+  // use it for validity of |m_selection|.
+  const_cast<SelectionEditor*>(this)->m_selection.m_domTreeVersion =
+      document().domTreeVersion();
+#endif
+  m_selection.assertValidFor(document());
+}
+
 void SelectionEditor::clearVisibleSelection() {
-  m_selection = VisibleSelection();
-  m_selectionInFlatTree = VisibleSelectionInFlatTree();
+  m_selection = SelectionInDOMTree();
+  m_cachedVisibleSelectionInDOMTree = VisibleSelection();
+  m_cachedVisibleSelectionInFlatTree = VisibleSelectionInFlatTree();
+  m_cacheIsDirty = false;
   if (!shouldAlwaysUseDirectionalSelection())
     return;
-  m_selection.setIsDirectional(true);
-  m_selectionInFlatTree.setIsDirectional(true);
+  m_selection.m_isDirectional = true;
 }
 
 void SelectionEditor::dispose() {
   resetLogicalRange();
   clearDocumentCachedRange();
   clearVisibleSelection();
 }
 
-const Document& SelectionEditor::document() const {
-  DCHECK(m_document);
-  return *m_document;
+Document& SelectionEditor::document() const {
+  DCHECK(lifecycleContext());
+  return *lifecycleContext();
 }
 
 template <>
 const VisibleSelection& SelectionEditor::visibleSelection<EditingStrategy>()
     const {
-  DCHECK_EQ(frame()->document(), document());
-  DCHECK_EQ(frame(), document().frame());
-  if (m_selection.isNone())
-    return m_selection;
-  DCHECK_EQ(m_selection.base().document(), document());
-  return m_selection;
+  return computeVisibleSelectionInDOMTree();
 }
 
 template <>
 const VisibleSelectionInFlatTree&
 SelectionEditor::visibleSelection<EditingInFlatTreeStrategy>() const {
+  return computeVisibleSelectionInFlatTree();
+}
+
+const VisibleSelection& SelectionEditor::computeVisibleSelectionInDOMTree()
+    const {
   DCHECK_EQ(frame()->document(), document());
   DCHECK_EQ(frame(), document().frame());
-  if (m_selectionInFlatTree.isNone())
-    return m_selectionInFlatTree;
-  DCHECK_EQ(m_selectionInFlatTree.base().document(), document());
-  return m_selectionInFlatTree;
+  updateCachedVisibleSelectionIfNeeded();
+  if (m_cachedVisibleSelectionInDOMTree.isNone())
+    return m_cachedVisibleSelectionInDOMTree;
+  DCHECK_EQ(m_cachedVisibleSelectionInDOMTree.base().document(), document());
+  return m_cachedVisibleSelectionInDOMTree;
 }
 
-void SelectionEditor::setVisibleSelection(
-    const VisibleSelection& newSelection,
-    FrameSelection::SetSelectionOptions options) {
-  DCHECK(newSelection.isValidFor(document())) << newSelection;
+const VisibleSelectionInFlatTree&
+SelectionEditor::computeVisibleSelectionInFlatTree() const {

[yoichio, 2017/02/13 06:37:42]

Remove const declaration.

[yosin_UTC9, 2017/02/13 07:28:40]

I would like to keep "const" since term "computeXXX()" doesn't
imply causing side effect into object. Cache is considered as
implementation details and callers doesn't care about cache.

[yoichio, 2017/02/13 08:18:03]

Then I prefer changing its name. Caller side developers may believe object state
doesn't change over const method calling and its 
important to understand and debug.

[tkent, 2017/02/13 08:33:27]

Maybe updateCachedVisibleSelectionIfNeeded should be a const function if it
touch only mutable data members.

[yosin_UTC9, 2017/02/13 09:24:14]

No. I don't want to call this function to
computeVisibleSelectionWithUpdatingCache().
This is kind of exposing too much implementation details.

|computeVS()| is "logical const". 
I think [1] is an good article for "mutable" and "const".
[1]
http://stackoverflow.com/questions/105014/does-the-mutable-keyword-have-any-p...

+  DCHECK_EQ(frame()->document(), document());
+  DCHECK_EQ(frame(), document().frame());
+  const_cast<SelectionEditor*>(this)->updateCachedVisibleSelectionIfNeeded();
+  if (m_cachedVisibleSelectionInFlatTree.isNone())
+    return m_cachedVisibleSelectionInFlatTree;
+  DCHECK_EQ(m_cachedVisibleSelectionInFlatTree.base().document(), document());
+  return m_cachedVisibleSelectionInFlatTree;
+}
+
+const SelectionInDOMTree& SelectionEditor::selectionInDOMTree() const {
+  assertSelectionValid();
+  return m_selection;
+}
+
+bool SelectionEditor::hasEditableStyle() const {
+  return computeVisibleSelectionInDOMTree().hasEditableStyle();
+}
+
+bool SelectionEditor::isContentEditable() const {
+  return computeVisibleSelectionInDOMTree().isContentEditable();
+}
+
+bool SelectionEditor::isContentRichlyEditable() const {
+  return computeVisibleSelectionInDOMTree().isContentRichlyEditable();
+}
+
+void SelectionEditor::markCacheDirty() {
+  m_cachedVisibleSelectionInFlatTree = VisibleSelectionInFlatTree();
+  m_cachedVisibleSelectionInDOMTree = VisibleSelection();
+  m_cacheIsDirty = true;
+}
+
+void SelectionEditor::setSelection(const SelectionInDOMTree& newSelection) {
+  newSelection.assertValidFor(document());
+  if (m_selection == newSelection)
+    return;
   resetLogicalRange();
   clearDocumentCachedRange();
+  markCacheDirty();
+  m_selection = newSelection;
+}
 
-  m_selection = newSelection;
-  if (options & FrameSelection::DoNotAdjustInFlatTree) {
-    m_selectionInFlatTree.setWithoutValidation(
-        toPositionInFlatTree(m_selection.base()),
-        toPositionInFlatTree(m_selection.extent()));
+void SelectionEditor::didChangeChildren(const ContainerNode&) {
+  markCacheDirty();
+  didFinishDOMMutation();
+}
+
+static Position positionAfterPreviousSiblingOf(const Node& node) {
+  Node* const previousSibling = NodeTraversal::previousSibling(node);
+  if (!previousSibling) {
+    // Returns |BeforeChildren| of a parent of |node| since |node| is the
+    // first child.
+    return Position::firstPositionInNode(NodeTraversal::parent(node));
+  }
+  if (previousSibling->isCharacterDataNode()) {
+    return Position(previousSibling,
+                    toCharacterData(previousSibling)->length());
+  }
+  return Position::afterNode(previousSibling);
+}
+
+static Position computePositionForNodeRemoval(const Position& position,
+                                              Node& nodeToBeRemoved) {

[yoichio, 2017/02/13 06:37:42]

Why don't you use uodatePositionForNodeRemoval 
 as FrameSelection::nodeWillBeRemoved originally uses it?

[yosin_UTC9, 2017/02/13 07:28:40]

Good catch. I implemented by myself when I need to change
it. But, original updatePositionForNodeRemoval() works
fine. I switch to it.

+  Node* const anchorNode = position.anchorNode();
+  if (anchorNode == nodeToBeRemoved)
+    return positionAfterPreviousSiblingOf(nodeToBeRemoved);
+  if (position.isOffsetInAnchor() &&
+      anchorNode == nodeToBeRemoved.parentNode()) {
+    const int positionOffset = position.offsetInContainerNode();
+    if (positionOffset == 0)
+      return position;
+    // |nodeToBeRemoved| is sibling or itself of |position|.
+    int offset = 0;
+    for (Node& child :
+         NodeTraversal::childrenOf(*nodeToBeRemoved.parentNode())) {
+      if (nodeToBeRemoved == child) {
+        // |position| is after |nodeToBeRemoved|.
+        return Position(anchorNode, positionOffset - 1);
+      }
+      if (positionOffset == offset) {
+        // |position| is before |nodeToBeRemoved|.
+        return position;
+      }
+      ++offset;
+    }
+    NOTREACHED() << position << " should be handled.";
+  }
+  if (!nodeToBeRemoved.isContainerNode())
+    return position;
+  if (toContainerNode(nodeToBeRemoved)
+          .containsIncludingHostElements(*anchorNode))
+    return positionAfterPreviousSiblingOf(nodeToBeRemoved);
+  return position;
+}
+
+void SelectionEditor::didFinishTextChange(const Position& newBase,
+                                          const Position& newExtent) {
+  if (newBase == m_selection.m_base && newExtent == m_selection.m_extent) {
+    didFinishDOMMutation();
     return;
   }
-
-  SelectionAdjuster::adjustSelectionInFlatTree(&m_selectionInFlatTree,
-                                               m_selection);
+  m_selection.m_base = newBase;
+  m_selection.m_extent = newExtent;
+  markCacheDirty();
+  didFinishDOMMutation();
 }
 
-void SelectionEditor::setVisibleSelection(
-    const VisibleSelectionInFlatTree& newSelection,
-    FrameSelection::SetSelectionOptions options) {
-  DCHECK(newSelection.isValidFor(document())) << newSelection;
-  DCHECK(!(options & FrameSelection::DoNotAdjustInFlatTree));
-  resetLogicalRange();
-  clearDocumentCachedRange();
-
-  m_selectionInFlatTree = newSelection;
-  SelectionAdjuster::adjustSelectionInDOMTree(&m_selection,
-                                              m_selectionInFlatTree);
+void SelectionEditor::didFinishDOMMutation() {
+  assertSelectionValid();
 }
 
-void SelectionEditor::setWithoutValidation(const Position& base,
-                                           const Position& extent) {
-  resetLogicalRange();
-  if (base.isNotNull())
-    DCHECK_EQ(base.document(), document());
-  if (extent.isNotNull())
-    DCHECK_EQ(extent.document(), document());
-  clearDocumentCachedRange();
-
-  m_selection.setWithoutValidation(base, extent);
-  m_selectionInFlatTree.setWithoutValidation(toPositionInFlatTree(base),
-                                             toPositionInFlatTree(extent));
+void SelectionEditor::nodeWillBeRemoved(Node& nodeToBeRemoved) {

[yoichio, 2017/02/13 08:18:04]

I prefer setting this function after |FrameSelection::nodeWillBeRemoved|
 to emphasize this replaces |FrameSelection::respondToNodeModification|
 like |nodeChildrenWillBeRemoved|.

[yosin_UTC9, 2017/02/13 09:24:14]

Done. Move to "FrameSelection.cpp"

+  if (m_selection.isNone())
+    return;
+  const Position oldBase = m_selection.m_base;
+  const Position oldExtent = m_selection.m_extent;
+  const Position& newBase =
+      computePositionForNodeRemoval(oldBase, nodeToBeRemoved);
+  const Position& newExtent =
+      computePositionForNodeRemoval(oldExtent, nodeToBeRemoved);
+  if (newBase == oldBase && newExtent == oldExtent)
+    return;
+  m_selection = SelectionInDOMTree::Builder()
+                    .setBaseAndExtent(newBase, newExtent)
+                    .build();
+  markCacheDirty();
 }
 
 void SelectionEditor::documentAttached(Document* document) {
   DCHECK(document);
-  DCHECK(!m_document) << m_document;
-  m_document = document;
+  DCHECK(!lifecycleContext()) << lifecycleContext();
+  m_styleVersion = static_cast<uint64_t>(-1);
+  clearVisibleSelection();
+  setContext(document);
 }
 
-void SelectionEditor::documentDetached(const Document& document) {
-  DCHECK_EQ(m_document, &document);
+void SelectionEditor::contextDestroyed(Document*) {
   dispose();
-  m_document = nullptr;
+  m_styleVersion = static_cast<uint64_t>(-1);
+  m_selection = SelectionInDOMTree();
+  m_cachedVisibleSelectionInDOMTree = VisibleSelection();
+  m_cachedVisibleSelectionInFlatTree = VisibleSelectionInFlatTree();
+  m_cacheIsDirty = false;
 }
 
 void SelectionEditor::resetLogicalRange() {
   // Non-collapsed ranges are not allowed to start at the end of a line that
   // is wrapped, they start at the beginning of the next line instead
   if (!m_logicalRange)
     return;
   m_logicalRange->dispose();
   m_logicalRange = nullptr;
 }
 
 void SelectionEditor::setLogicalRange(Range* range) {
   DCHECK_EQ(range->ownerDocument(), document());
   DCHECK(!m_logicalRange) << "A logical range should be one.";
   m_logicalRange = range;
 }
 
 Range* SelectionEditor::firstRange() const {
   if (m_logicalRange)
     return m_logicalRange->cloneRange();
-  return firstRangeOf(m_selection);
+  return firstRangeOf(computeVisibleSelectionInDOMTree());
 }
 
 bool SelectionEditor::shouldAlwaysUseDirectionalSelection() const {
   return frame()->editor().behavior().shouldConsiderSelectionAsDirectional();
 }
 
 void SelectionEditor::updateIfNeeded() {
-  DCHECK(m_selection.isValidFor(document())) << m_selection;
-  DCHECK(m_selectionInFlatTree.isValidFor(document())) << m_selection;
-  m_selection.updateIfNeeded();
-  m_selectionInFlatTree.updateIfNeeded();
+  // TODO(yosin): We should unify |SelectionEditor::updateIfNeeded()| and
+  // |updateCachedVisibleSelectionIfNeeded()|
+  updateCachedVisibleSelectionIfNeeded();
+}
+
+bool SelectionEditor::needsUpdateVisibleSelection() const {
+  return m_cacheIsDirty || m_styleVersion != document().styleVersion();
+}
+
+void SelectionEditor::updateCachedVisibleSelectionIfNeeded() const {
+  // Note: Since we |FrameCaret::updateApperance()| is called from
+  // |FrameView::performPostLayoutTasks()|, we check lifecycle against
+  // |AfterPerformLayout| instead of |LayoutClean|.
+  DCHECK_GE(document().lifecycle().state(),
+            DocumentLifecycle::AfterPerformLayout);
+  assertSelectionValid();
+  if (!needsUpdateVisibleSelection())
+    return;
+
+  m_cachedVisibleSelectionInDOMTree = createVisibleSelection(m_selection);
+  m_cachedVisibleSelectionInFlatTree = createVisibleSelection(
+      SelectionInFlatTree::Builder()
+          .setBaseAndExtent(toPositionInFlatTree(m_selection.base()),
+                            toPositionInFlatTree(m_selection.extent()))
+          .setAffinity(m_selection.affinity())
+          .setHasTrailingWhitespace(m_selection.hasTrailingWhitespace())
+          .setGranularity(m_selection.granularity())
+          .setIsDirectional(m_selection.isDirectional())
+          .build());
+  m_styleVersion = document().styleVersion();
+  m_cacheIsDirty = false;
 }
 
 void SelectionEditor::cacheRangeOfDocument(Range* range) {
   m_cachedRange = range;
 }
 
 Range* SelectionEditor::documentCachedRange() const {
   return m_cachedRange;
 }
 
 void SelectionEditor::clearDocumentCachedRange() {
   m_cachedRange = nullptr;
 }
 
 DEFINE_TRACE(SelectionEditor) {
-  visitor->trace(m_document);
   visitor->trace(m_frame);
   visitor->trace(m_selection);
-  visitor->trace(m_selectionInFlatTree);
+  visitor->trace(m_cachedVisibleSelectionInDOMTree);
+  visitor->trace(m_cachedVisibleSelectionInFlatTree);
   visitor->trace(m_logicalRange);
   visitor->trace(m_cachedRange);
+  SynchronousMutationObserver::trace(visitor);
 }
 
 }  // namespace blink