CONTINUED Make FrameSelection to hold non-canonicalized positions

third_party/WebKit/Source/core/editing/FrameSelection.h

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 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
@@ skipping 11 matching lines @@
  * 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.
  */
 
 #ifndef FrameSelection_h
 #define FrameSelection_h
 
 #include "core/CoreExport.h"
 #include "core/dom/Range.h"
+#include "core/dom/SynchronousMutationObserver.h"
 #include "core/editing/EditingStyle.h"
 #include "core/editing/EphemeralRange.h"
+#include "core/editing/SelectionTemplate.h"
 #include "core/editing/VisiblePosition.h"
 #include "core/editing/VisibleSelection.h"
 #include "core/editing/iterators/TextIteratorFlags.h"
 #include "core/layout/ScrollAlignment.h"
 #include "platform/Timer.h"
 #include "platform/geometry/IntRect.h"
 #include "platform/geometry/LayoutRect.h"
 #include "platform/heap/Handle.h"
 #include "wtf/Noncopyable.h"
 #include <memory>
 
 namespace blink {
 
-class CharacterData;
 class DisplayItemClient;
 class LayoutBlock;
 class LocalFrame;
 class FrameCaret;
 class GranularityStrategy;
 class GraphicsContext;
 class HTMLFormElement;
 class SelectionEditor;
 class PendingSelection;
-class Text;
 
 enum class CursorAlignOnScroll { IfNeeded, Always };
 
 enum EUserTriggered { NotUserTriggered = 0, UserTriggered = 1 };
 
 enum RevealExtentOption { RevealExtent, DoNotRevealExtent };
 
 enum class SelectionDirectionalMode { NonDirectional, Directional };
 
 enum class CaretVisibility;
 
 class CORE_EXPORT FrameSelection final
-    : public GarbageCollectedFinalized<FrameSelection> {
+    : public GarbageCollectedFinalized<FrameSelection>,
+      public SynchronousMutationObserver {
   WTF_MAKE_NONCOPYABLE(FrameSelection);
+  USING_GARBAGE_COLLECTED_MIXIN(FrameSelection);
 
  public:
-  static FrameSelection* create(LocalFrame& frame) {
-    return new FrameSelection(frame);
-  }
+  static FrameSelection* create(LocalFrame&);
   ~FrameSelection();
 
   enum EAlteration { AlterationMove, AlterationExtend };
   enum SetSelectionOption {
     // 1 << 0 is reserved for EUserTriggered
     CloseTyping = 1 << 1,
     ClearTypingStyle = 1 << 2,
     DoNotSetFocus = 1 << 3,
     DoNotUpdateAppearance = 1 << 4,
     DoNotClearStrategy = 1 << 5,
+    // TODO(yosin): We should get rid of |DoNotAdjustInFlatTree|.
     DoNotAdjustInFlatTree = 1 << 6,
   };
   // Union of values in SetSelectionOption and EUserTriggered
   typedef unsigned SetSelectionOptions;
   static inline EUserTriggered selectionOptionsToUserTriggered(
       SetSelectionOptions options) {
     return static_cast<EUserTriggered>(options & UserTriggered);
   }
 
-  bool isAvailable() const { return m_document; }
-  // You should not call |document()| when |!isAvailable()|.
-  const Document& document() const;
-  Document& document();
+  bool isAvailable() const { return lifecycleContext(); }
+  Document& document() const;
   LocalFrame* frame() const { return m_frame; }
   Element* rootEditableElement() const {
     return selection().rootEditableElement();
   }
   Element* rootEditableElementOrDocumentElement() const;
   ContainerNode* rootEditableElementOrTreeScopeRootNode() const;
 
   bool hasEditableStyle() const { return selection().hasEditableStyle(); }
   bool isContentEditable() const { return selection().isContentEditable(); }
   bool isContentRichlyEditable() const {
     return selection().isContentRichlyEditable();
   }
 
   // An implementation of |WebFrame::moveCaretSelection()|
   void moveCaretSelection(const IntPoint&);
 
-  template <typename Strategy>
-  const VisibleSelectionTemplate<Strategy>& visibleSelection() const;
+  const VisibleSelection& computeVisibleSelectionInDOMTree() const;
+  const VisibleSelectionInFlatTree& computeVisibleSelectionInFlatTree() const;
 
   const VisibleSelection& selection() const;
 
   void setSelection(const SelectionInDOMTree&,
                     SetSelectionOptions = CloseTyping | ClearTypingStyle,
                     CursorAlignOnScroll = CursorAlignOnScroll::IfNeeded,
                     TextGranularity = CharacterGranularity);
 
   void setSelection(const SelectionInFlatTree&,
                     SetSelectionOptions = CloseTyping | ClearTypingStyle,
                     CursorAlignOnScroll = CursorAlignOnScroll::IfNeeded,
                     TextGranularity = CharacterGranularity);
 
-  // TODO(yosin): We should use |SelectionInDOMTree| version instead of
-  // |VisibleSelection| version.
+  // TODO(yosin): Get rid of |granularity| parameter from |setSelection()|.
   void setSelection(const VisibleSelection&,
                     SetSelectionOptions = CloseTyping | ClearTypingStyle,
                     CursorAlignOnScroll = CursorAlignOnScroll::IfNeeded,
                     TextGranularity = CharacterGranularity);
-  // TODO(yosin): We should use |SelectionInFlatTree| version instead of
-  // |VisibleSelectionInFlatTree| version.
   void setSelection(const VisibleSelectionInFlatTree&,
                     SetSelectionOptions = CloseTyping | ClearTypingStyle,
                     CursorAlignOnScroll = CursorAlignOnScroll::IfNeeded,
                     TextGranularity = CharacterGranularity);
+  // TODO(yosin) We should get rid of |Range| version of |setSelectedRagne()|
+  // for Oilpan.
+  bool setSelectedRange(
+      Range*,
+      TextAffinity,
+      SelectionDirectionalMode = SelectionDirectionalMode::NonDirectional,
+      SetSelectionOptions = CloseTyping | ClearTypingStyle);
   bool setSelectedRange(
       const EphemeralRange&,
       TextAffinity,
       SelectionDirectionalMode = SelectionDirectionalMode::NonDirectional,
       FrameSelection::SetSelectionOptions = CloseTyping | ClearTypingStyle);
   void selectAll();
   void clear();
 
   // Call this after doing user-triggered selections to make it easy to delete
   // the frame you entirely selected.
@@ skipping 16 matching lines @@
 
   // Moves the selection extent based on the selection granularity strategy.
   // This function does not allow the selection to collapse. If the new
   // extent is resolved to the same position as the current base, this
   // function will do nothing.
   void moveRangeSelectionExtent(const IntPoint&);
   void moveRangeSelection(const VisiblePosition& base,
                           const VisiblePosition& extent,
                           TextGranularity);
 
+  // TODO(yosin): We should use |selection().granularity()|.
   TextGranularity granularity() const { return m_granularity; }
 
   Position base() const { return selection().base(); }
   Position extent() const { return selection().extent(); }
   Position start() const { return selection().start(); }
   Position end() const { return selection().end(); }
 
   // Return the layoutObject that is responsible for painting the caret (in the
   // selection start node)
   LayoutBlock* caretLayoutObject() const;
 
   // Bounds of (possibly transformed) caret in absolute coords
   IntRect absoluteCaretBounds();
 
   void didChangeFocus();
 
+  const SelectionInDOMTree& selectionInDOMTree() const;
+  // TODO(yosin): We should rename |isNone()| to |isVisibleNone()|.
   bool isNone() const { return selection().isNone(); }
   bool isCaret() const { return selection().isCaret(); }
   bool isRange() const { return selection().isRange(); }
   bool isInPasswordField() const;
-  bool isDirectional() const { return selection().isDirectional(); }
+  bool isDirectional() const { return selectionInDOMTree().isDirectional(); }
 
   // If this FrameSelection has a logical range which is still valid, this
   // function return its clone. Otherwise, the return value from underlying
   // VisibleSelection's firstRange() is returned.
   Range* firstRange() const;
 
+  // Called after layout finished.
+  void didLayout();
+
   void documentAttached(Document*);
-  void documentDetached(const Document&);
-  void nodeChildrenWillBeRemoved(ContainerNode&);
-  void nodeWillBeRemoved(Node&);
-  void dataWillChange(const CharacterData& node);
-  void didUpdateCharacterData(CharacterData*,
-                              unsigned offset,
-                              unsigned oldLength,
-                              unsigned newLength);
-  void didMergeTextNodes(const Text& oldNode, unsigned offset);
-  void didSplitTextNode(const Text& oldNode);
 
   bool isAppearanceDirty() const;
   void commitAppearanceIfNeeded(LayoutView&);
   void updateAppearance();
   void setCaretVisible(bool caretIsVisible);
   bool isCaretBoundsDirty() const;
   void setCaretRectNeedsUpdate();
   void scheduleVisualUpdate() const;
   void invalidateCaretRect(bool forceInvalidation = false);
   void paintCaret(GraphicsContext&, const LayoutPoint&);
@@ skipping 49 matching lines @@
   // |FrameSelection::selection()| to make sure we use updated selection,
   // rather than having |updateIfNeeded()|. Once, we update all layout tests
   // to use updated selection, we should make |updateIfNeeded()| private.
   void updateIfNeeded();
 
   DECLARE_TRACE();
 
  private:
   friend class FrameSelectionTest;
   friend class PaintControllerPaintTestForSlimmingPaintV1AndV2;
-  friend class SelectionControllerTest;
   FRIEND_TEST_ALL_PREFIXES(PaintControllerPaintTestForSlimmingPaintV1AndV2,
                            FullDocumentPaintingWithCaret);
 
   explicit FrameSelection(LocalFrame&);
 
   // For |PaintControllerPaintTestForSlimmingPaintV1AndV2|.
   const DisplayItemClient& caretDisplayItemClientForTesting() const;
 
-  // Note: We have |selectionInFlatTree()| for unit tests, we should
-  // use |visibleSelection<EditingInFlatTreeStrategy>()|.
-  const VisibleSelectionInFlatTree& selectionInFlatTree() const;
-
-  template <typename Strategy>
-  void setSelectionAlgorithm(const VisibleSelectionTemplate<Strategy>&,
-                             SetSelectionOptions,
-                             CursorAlignOnScroll,
-                             TextGranularity);
-
   void respondToNodeModification(Node&,
                                  bool baseRemoved,
                                  bool extentRemoved,
                                  bool startRemoved,
                                  bool endRemoved);
 
   void notifyAccessibilityForSelectionChange();
   void notifyCompositorForSelectionChange();
   void notifyEventHandlerForSelectionChange();
 
   void focusedOrActiveStateChanged();
 
   void setUseSecureKeyboardEntry(bool);
 
   void updateSelectionIfNeeded(const Position& base,
                                const Position& extent,
                                const Position& start,
                                const Position& end);
 
+  template <typename Strategy>
+  VisibleSelectionTemplate<Strategy> validateSelection(
+      const VisibleSelectionTemplate<Strategy>&);
+
   GranularityStrategy* granularityStrategy();
 
+  // Implementation of |SynchronousMutationObserver| member functions.
+  void contextDestroyed(Document*) final;
+  void nodeChildrenWillBeRemoved(ContainerNode&) final;
+  void nodeWillBeRemoved(Node&) final;
+
   // For unittests
   bool shouldPaintCaretForTesting() const;
   bool isPreviousCaretDirtyForTesting() const;
 
-  Member<Document> m_document;
   Member<LocalFrame> m_frame;
   const Member<PendingSelection> m_pendingSelection;
   const Member<SelectionEditor> m_selectionEditor;
 
   TextGranularity m_granularity;
   LayoutUnit m_xPosForVerticalArrowNavigation;
 
   Member<EditingStyle> m_typingStyle;
 
   bool m_focused : 1;
@@ skipping 19 matching lines @@
 }
 }  // namespace blink
 
 #ifndef NDEBUG
 // Outside the WebCore namespace for ease of invocation from gdb.
 void showTree(const blink::FrameSelection&);
 void showTree(const blink::FrameSelection*);
 #endif
 
 #endif  // FrameSelection_h