CONTINUED Make FrameSelection to hold non-canonicalized positions

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 36 matching lines @@
                        const SelectionEditor& selectionEditor)
     : m_selectionEditor(&selectionEditor),
       m_frame(frame),
       m_caretBase(new CaretDisplayItemClient()),
       m_caretVisibility(CaretVisibility::Hidden),
       m_caretBlinkTimer(TaskRunnerHelper::get(TaskType::UnspecedTimer, &frame),
                         this,
                         &FrameCaret::caretBlinkTimerFired),
       m_shouldPaintCaret(true),
       m_isCaretBlinkingSuspended(false),
-      m_shouldShowBlockCursor(false) {}
+      m_shouldShowBlockCursor(false),
+      m_shouldUpdateLayoutAndStyle(false) {}
 
 FrameCaret::~FrameCaret() = default;
 
 DEFINE_TRACE(FrameCaret) {
   visitor->trace(m_selectionEditor);
   visitor->trace(m_frame);
 }
 
 const DisplayItemClient& FrameCaret::displayItemClient() const {
   return *m_caretBase;
 }
 
 const PositionWithAffinity FrameCaret::caretPosition() const {
   const VisibleSelection& selection =
       m_selectionEditor->visibleSelection<EditingStrategy>();
   if (!selection.isCaret())
     return PositionWithAffinity();
   return PositionWithAffinity(selection.start(), selection.affinity());
 }
 
 inline static bool shouldStopBlinkingDueToTypingCommand(LocalFrame* frame) {
   return frame->editor().lastEditCommand() &&
          frame->editor().lastEditCommand()->shouldStopCaretBlinking();
 }
 
 void FrameCaret::updateAppearance() {
+  DCHECK_GE(m_frame->document()->lifecycle().state(),
+            DocumentLifecycle::LayoutClean);
   // Paint a block cursor instead of a caret in overtype mode unless the caret
   // is at the end of a line (in this case the FrameSelection will paint a
   // blinking caret as usual).
-  bool paintBlockCursor = m_shouldShowBlockCursor && isActive();
-  if (paintBlockCursor) {
-    // TODO(editing-dev): Use of updateStyleAndLayoutIgnorePendingStylesheets
-    // needs to be audited.  see http://crbug.com/590369 for more details.
-    // In the long term, we should defer the update of the caret's appearance
-    // to prevent synchronous layout.
-    m_frame->document()->updateStyleAndLayoutIgnorePendingStylesheets();
-
-    if (isLogicalEndOfLine(createVisiblePosition(caretPosition())))
-      paintBlockCursor = false;
-  }
+  const bool paintBlockCursor =
+      m_shouldShowBlockCursor && isActive() &&
+      !isLogicalEndOfLine(createVisiblePosition(caretPosition()));
 
   bool shouldBlink = !paintBlockCursor && shouldBlinkCaret();
 
   // If the caret moved, stop the blink timer so we can restart with a
   // black caret in the new location.
   if (!shouldBlink || shouldStopBlinkingDueToTypingCommand(m_frame))
     stopCaretBlinkTimer();
 
   // Start blinking with a black caret. Be sure not to restart if we're
   // already blinking in the right location.
@@ skipping 20 matching lines @@
   m_shouldPaintCaret = true;
   scheduleVisualUpdateForPaintInvalidationIfNeeded();
 }
 
 void FrameCaret::setCaretVisibility(CaretVisibility visibility) {
   if (m_caretVisibility == visibility)
     return;
 
   m_caretVisibility = visibility;
 
-  updateAppearance();
+  if (visibility == CaretVisibility::Hidden)
+    stopCaretBlinkTimer();
   scheduleVisualUpdateForPaintInvalidationIfNeeded();
 }
 
 void FrameCaret::clearPreviousVisualRect(const LayoutBlock& block) {
   m_caretBase->clearPreviousVisualRect(block);
 }
 
 void FrameCaret::layoutBlockWillBeDestroyed(const LayoutBlock& block) {
   m_caretBase->layoutBlockWillBeDestroyed(block);
 }
 
 void FrameCaret::updateStyleAndLayoutIfNeeded() {
+  DCHECK_GE(m_frame->document()->lifecycle().state(),
+            DocumentLifecycle::LayoutClean);
+  updateAppearance();
   bool shouldPaintCaret =
       m_shouldPaintCaret && isActive() &&
       m_caretVisibility == CaretVisibility::Visible &&
       m_selectionEditor->visibleSelection<EditingStrategy>().hasEditableStyle();
 
   m_caretBase->updateStyleAndLayoutIfNeeded(
       shouldPaintCaret ? caretPosition() : PositionWithAffinity());
 }
 
 void FrameCaret::invalidatePaintIfNeeded(const LayoutBlock& block,
@@ skipping 38 matching lines @@
         caretNode, CaretDisplayItemClient::computeCaretRect(caretPosition()));
   }
   return absoluteBoundsForLocalRect(
       caretNode,
       CaretDisplayItemClient::computeCaretRect(
           createVisiblePosition(caretPosition()).toPositionWithAffinity()));
 }
 
 void FrameCaret::setShouldShowBlockCursor(bool shouldShowBlockCursor) {
   m_shouldShowBlockCursor = shouldShowBlockCursor;
-
-  m_frame->document()->updateStyleAndLayoutIgnorePendingStylesheets();
-
-  updateAppearance();
+  scheduleVisualUpdateForPaintInvalidationIfNeeded();
 }
 
 bool FrameCaret::shouldPaintCaret(const LayoutBlock& block) const {
   return m_caretBase->shouldPaintCaret(block);
 }
 
 void FrameCaret::paintCaret(GraphicsContext& context,
                             const LayoutPoint& paintOffset) const {
   m_caretBase->paintCaret(context, paintOffset, DisplayItem::kCaret);
 }
@@ skipping 21 matching lines @@
   m_shouldPaintCaret = !m_shouldPaintCaret;
   scheduleVisualUpdateForPaintInvalidationIfNeeded();
 }
 
 void FrameCaret::scheduleVisualUpdateForPaintInvalidationIfNeeded() {
   if (FrameView* frameView = m_frame->view())
     frameView->scheduleVisualUpdateForPaintInvalidationIfNeeded();
 }
 
 }  // namespace blink