ASSERT -> DCHECK in core/editing.

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

 /*
  * Copyright (C) 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  *
  * 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 85 matching lines @@
 using namespace Unicode;
 
 Editor::RevealSelectionScope::RevealSelectionScope(Editor* editor)
     : m_editor(editor)
 {
     ++m_editor->m_preventRevealSelection;
 }
 
 Editor::RevealSelectionScope::~RevealSelectionScope()
 {
-    ASSERT(m_editor->m_preventRevealSelection);
+    DCHECK(m_editor->m_preventRevealSelection);
     --m_editor->m_preventRevealSelection;
     if (!m_editor->m_preventRevealSelection)
         m_editor->frame().selection().revealSelection(ScrollAlignment::alignToEdgeIfNeeded, RevealExtent);
 }
 
 // When an event handler has moved the selection outside of a text control
 // we should use the target control's selection for this editing operation.
 VisibleSelection Editor::selectionForCommand(Event* event)
 {
     frame().selection().updateIfNeeded();
@@ skipping 171 matching lines @@
 }
 
 bool Editor::deleteWithDirection(SelectionDirection direction, TextGranularity granularity, bool killRing, bool isTypingAction)
 {
     if (!canEdit())
         return false;
 
     EditingState editingState;
     if (frame().selection().isRange()) {
         if (isTypingAction) {
-            ASSERT(frame().document());
+            DCHECK(frame().document());
             TypingCommand::deleteKeyPressed(*frame().document(), canSmartCopyOrDelete() ? TypingCommand::SmartDelete : 0, granularity);
             revealSelectionAfterEditingOperation();
         } else {
             if (killRing)
                 addToKillRing(selectedRange());
             deleteSelectionWithSmartDelete(canSmartCopyOrDelete());
             // Implicitly calls revealSelectionAfterEditingOperation().
         }
     } else {
         TypingCommand::Options options = 0;
         if (canSmartCopyOrDelete())
             options |= TypingCommand::SmartDelete;
         if (killRing)
             options |= TypingCommand::KillRing;
         switch (direction) {
         case DirectionForward:
         case DirectionRight:
-            ASSERT(frame().document());
+            DCHECK(frame().document());
             TypingCommand::forwardDeleteKeyPressed(*frame().document(), &editingState, options, granularity);
             if (editingState.isAborted())
                 return false;
             break;
         case DirectionBackward:
         case DirectionLeft:
-            ASSERT(frame().document());
+            DCHECK(frame().document());
             TypingCommand::deleteKeyPressed(*frame().document(), options, granularity);
             break;
         }
         revealSelectionAfterEditingOperation();
     }
 
     // FIXME: We should to move this down into deleteKeyPressed.
     // clear the "start new kill ring sequence" setting, because it was set to true
     // when the selection was updated by deleting the range
     if (killRing)
         setStartNewKillRingSequence(false);
 
     return true;
 }
 
 void Editor::deleteSelectionWithSmartDelete(bool smartDelete)
 {
     if (frame().selection().isNone())
         return;
 
-    ASSERT(frame().document());
+    DCHECK(frame().document());
     DeleteSelectionCommand::create(*frame().document(), smartDelete)->apply();
 }
 
 void Editor::pasteAsPlainText(const String& pastingText, bool smartReplace)
 {
     Element* target = findEventTargetFromSelection();
     if (!target)
         return;
     target->dispatchEvent(TextEvent::createForPlainTextPaste(frame().domWindow(), pastingText, smartReplace));
 }
@@ skipping 37 matching lines @@
 {
     DocumentFragment* fragment = nullptr;
     bool chosePlainText = false;
 
     if (pasteboard->isHTMLAvailable()) {
         unsigned fragmentStart = 0;
         unsigned fragmentEnd = 0;
         KURL url;
         String markup = pasteboard->readHTML(url, fragmentStart, fragmentEnd);
         if (!markup.isEmpty()) {
-            ASSERT(frame().document());
+            DCHECK(frame().document());
             fragment = createFragmentFromMarkupWithContext(*frame().document(), markup, fragmentStart, fragmentEnd, url, DisallowScriptingAndPluginContent);
         }
     }
 
     if (!fragment) {
         String text = pasteboard->plainText();
         if (!text.isEmpty()) {
             chosePlainText = true;
             fragment = createFragmentFromText(selectedRange(), text);
         }
@@ skipping 30 matching lines @@
         if (!cachedImage || cachedImage->errorOccurred())
             return nullptr;
         return cachedImage->getImage();
     }
 
     return nullptr;
 }
 
 static void writeImageNodeToPasteboard(Pasteboard* pasteboard, Node* node, const String& title)
 {
-    ASSERT(pasteboard);
-    ASSERT(node);
+    DCHECK(pasteboard);
+    DCHECK(node);
 
     RefPtr<Image> image = imageFromNode(*node);
     if (!image.get())
         return;
 
     // FIXME: This should probably be reconciled with HitTestResult::absoluteImageURL.
     AtomicString urlString;
     if (isHTMLImageElement(*node) || isHTMLInputElement(*node))
         urlString = toHTMLElement(node)->getAttribute(srcAttr);
     else if (isSVGImageElement(*node))
@@ skipping 42 matching lines @@
     if (frame().selection().isNone() || !frame().selection().isContentEditable() || !fragment)
         return;
 
     ReplaceSelectionCommand::CommandOptions options = ReplaceSelectionCommand::PreventNesting | ReplaceSelectionCommand::SanitizeFragment;
     if (selectReplacement)
         options |= ReplaceSelectionCommand::SelectReplacement;
     if (smartReplace)
         options |= ReplaceSelectionCommand::SmartReplace;
     if (matchStyle)
         options |= ReplaceSelectionCommand::MatchStyle;
-    ASSERT(frame().document());
+    DCHECK(frame().document());
     ReplaceSelectionCommand::create(*frame().document(), fragment, options, EditActionPaste)->apply();
     revealSelectionAfterEditingOperation();
 }
 
 void Editor::replaceSelectionWithText(const String& text, bool selectReplacement, bool smartReplace)
 {
     replaceSelectionWithFragment(createFragmentFromText(selectedRange(), text), selectReplacement, smartReplace, true);
 }
 
 // TODO(xiaochengh): Merge it with |replaceSelectionWithFragment()|.
 void Editor::replaceSelectionAfterDragging(DocumentFragment* fragment, bool smartReplace, bool plainText)
 {
     ReplaceSelectionCommand::CommandOptions options = ReplaceSelectionCommand::SelectReplacement | ReplaceSelectionCommand::PreventNesting;
     if (smartReplace)
         options |= ReplaceSelectionCommand::SmartReplace;
     if (plainText)
         options |= ReplaceSelectionCommand::MatchStyle;
-    ASSERT(frame().document());
+    DCHECK(frame().document());
     ReplaceSelectionCommand::create(*frame().document(), fragment, options, EditActionDrag)->apply();
 }
 
 void Editor::moveSelectionAfterDragging(DocumentFragment* fragment, const Position& pos, bool smartInsert, bool smartDelete)
 {
     MoveSelectionCommand::create(fragment, pos, smartInsert, smartDelete)->apply();
 }
 
 EphemeralRange Editor::selectedRange()
 {
@@ skipping 21 matching lines @@
         if (AXObjectCache* cache = frame().document()->existingAXObjectCache())
             cache->handleEditableTextContentChanged(node);
     }
 
     spellChecker().updateMarkersForWordsAffectedByEditing(true);
     client().respondToChangedContents();
 }
 
 void Editor::removeFormattingAndStyle()
 {
-    ASSERT(frame().document());
+    DCHECK(frame().document());
     RemoveFormatCommand::create(*frame().document())->apply();
 }
 
 void Editor::clearLastEditCommand()
 {
     m_lastEditCommand.clear();
 }
 
 Element* Editor::findEventTargetFrom(const VisibleSelection& selection) const
 {
@@ skipping 13 matching lines @@
 {
     switch (frame().selection().getSelectionType()) {
     case NoSelection:
         // do nothing
         break;
     case CaretSelection:
         computeAndSetTypingStyle(style, editingAction);
         break;
     case RangeSelection:
         if (style) {
-            ASSERT(frame().document());
+            DCHECK(frame().document());
             ApplyStyleCommand::create(*frame().document(), EditingStyle::create(style), editingAction)->apply();
         }
         break;
     }
 }
 
 void Editor::applyParagraphStyle(StylePropertySet* style, EditAction editingAction)
 {
     if (frame().selection().isNone() || !style)
         return;
-    ASSERT(frame().document());
+    DCHECK(frame().document());
     ApplyStyleCommand::create(*frame().document(), EditingStyle::create(style), editingAction, ApplyStyleCommand::ForceBlockProperties)->apply();
 }
 
 void Editor::applyStyleToSelection(StylePropertySet* style, EditAction editingAction)
 {
     if (!style || style->isEmpty() || !canEditRichly())
         return;
 
     applyStyle(style, editingAction);
 }
@@ skipping 41 matching lines @@
 {
     // Note: Request spell checking for and only for |ReplaceSelectionCommand|s
     // created in |Editor::replaceSelectionWithFragment()|.
     // TODO(xiaochengh): May also need to do this after dragging crbug.com/298046.
     if (cmd->editingAction() != EditActionPaste)
         return;
     if (!spellChecker().isContinuousSpellCheckingEnabled())
         return;
     if (!SpellChecker::isSpellCheckingEnabledFor(cmd->endingSelection()))
         return;
-    ASSERT(cmd->isReplaceSelectionCommand());
+    DCHECK(cmd->isReplaceSelectionCommand());
     const EphemeralRange& insertedRange = toReplaceSelectionCommand(cmd)->insertedRange();
     if (insertedRange.isNull())
         return;
     spellChecker().chunkAndMarkAllMisspellingsAndBadGrammar(cmd->endingSelection().rootEditableElement(), insertedRange);
 }
 
 void Editor::appliedEditing(CompositeEditCommand* cmd)
 {
     EventQueueScope scope;
     frame().document()->updateLayout();
 
     // Request spell checking after pasting before any further DOM change.
     requestSpellcheckingAfterApplyingCommand(cmd);
 
     EditCommandComposition* composition = cmd->composition();
-    ASSERT(composition);
+    DCHECK(composition);
     dispatchEditableContentChangedEvents(composition->startingRootEditableElement(), composition->endingRootEditableElement());
     VisibleSelection newSelection(cmd->endingSelection());
 
     // Don't clear the typing style with this selection change. We do those things elsewhere if necessary.
     changeSelectionAfterCommand(newSelection, 0);
 
     if (!cmd->preservesTypingStyle())
         frame().selection().clearTypingStyle();
 
     // Command will be equal to last edit command only in the case of typing
     if (m_lastEditCommand.get() == cmd) {
-        ASSERT(cmd->isTypingCommand());
+        DCHECK(cmd->isTypingCommand());
     } else {
         // Only register a new undo command if the command passed in is
         // different from the last command
         m_lastEditCommand = cmd;
         if (UndoStack* undoStack = this->undoStack())
             undoStack->registerUndoStep(m_lastEditCommand->ensureComposition());
     }
 
     respondToChangedContents(newSelection);
 }
@@ skipping 91 matching lines @@
     return true;
 }
 
 bool Editor::insertLineBreak()
 {
     if (!canEdit())
         return false;
 
     VisiblePosition caret = frame().selection().selection().visibleStart();
     bool alignToEdge = isEndOfEditableOrNonEditableContent(caret);
-    ASSERT(frame().document());
+    DCHECK(frame().document());
     if (!TypingCommand::insertLineBreak(*frame().document()))
         return false;
     revealSelectionAfterEditingOperation(alignToEdge ? ScrollAlignment::alignToEdgeIfNeeded : ScrollAlignment::alignCenterIfNeeded);
 
     return true;
 }
 
 bool Editor::insertParagraphSeparator()
 {
     if (!canEdit())
         return false;
 
     if (!canEditRichly())
         return insertLineBreak();
 
     VisiblePosition caret = frame().selection().selection().visibleStart();
     bool alignToEdge = isEndOfEditableOrNonEditableContent(caret);
-    ASSERT(frame().document());
+    DCHECK(frame().document());
     EditingState editingState;
     if (!TypingCommand::insertParagraphSeparator(*frame().document()))
         return false;
     revealSelectionAfterEditingOperation(alignToEdge ? ScrollAlignment::alignToEdgeIfNeeded : ScrollAlignment::alignCenterIfNeeded);
 
     return true;
 }
 
 void Editor::cut()
 {
@@ skipping 28 matching lines @@
         Document* document = frame().document();
         if (HTMLImageElement* imageElement = imageElementFromImageDocument(document))
             writeImageNodeToPasteboard(Pasteboard::generalPasteboard(), imageElement, document->title());
         else
             writeSelectionToPasteboard();
     }
 }
 
 void Editor::paste()
 {
-    ASSERT(frame().document());
+    DCHECK(frame().document());
     if (tryDHTMLPaste(AllMimeTypes))
         return; // DHTML did the whole operation
     if (!canPaste())
         return;
     spellChecker().updateMarkersForWordsAffectedByEditing(false);
     ResourceFetcher* loader = frame().document()->fetcher();
     ResourceCacheValidationSuppressor validationSuppressor(loader);
     if (frame().selection().isContentRichlyEditable())
         pasteWithPasteboard(Pasteboard::generalPasteboard());
     else
@@ skipping 207 matching lines @@
     // change the caret's DOM position (["hello", 0]). In these situations the above FrameSelection::setSelection call
     // does not call EditorClient::respondToChangedSelection(), which, on the Mac, sends selection change notifications and
     // starts a new kill ring sequence, but we want to do these things (matches AppKit).
     if (selectionDidNotChangeDOMPosition)
         client().respondToChangedSelection(m_frame, frame().selection().getSelectionType());
 }
 
 IntRect Editor::firstRectForRange(const EphemeralRange& range) const
 {
     LayoutUnit extraWidthToEndOfLine;
-    ASSERT(range.isNotNull());
+    DCHECK(range.isNotNull());
 
     IntRect startCaretRect = RenderedPosition(createVisiblePosition(range.startPosition()).deepEquivalent(), TextAffinity::Downstream).absoluteRect(&extraWidthToEndOfLine);
     if (startCaretRect.isEmpty())
         return IntRect();
 
     IntRect endCaretRect = RenderedPosition(createVisiblePosition(range.endPosition()).deepEquivalent(), TextAffinity::Upstream).absoluteRect();
     if (endCaretRect.isEmpty())
         return IntRect();
 
     if (startCaretRect.y() == endCaretRect.y()) {
         // start and end are on the same line
         return IntRect(std::min(startCaretRect.x(), endCaretRect.x()),
             startCaretRect.y(),
             abs(endCaretRect.x() - startCaretRect.x()),
             std::max(startCaretRect.height(), endCaretRect.height()));
     }
 
     // start and end aren't on the same line, so go from start to the end of its line
     return IntRect(startCaretRect.x(),
         startCaretRect.y(),
         startCaretRect.width() + extraWidthToEndOfLine,
         startCaretRect.height());
 }
 
 IntRect Editor::firstRectForRange(const Range* range) const
 {
-    ASSERT(range);
+    DCHECK(range);
     return firstRectForRange(EphemeralRange(range));
 }
 
 void Editor::computeAndSetTypingStyle(StylePropertySet* style, EditAction editingAction)
 {
     if (!style || style->isEmpty()) {
         frame().selection().clearTypingStyle();
         return;
     }
 
     // Calculate the current typing style.
     EditingStyle* typingStyle = nullptr;
     if (frame().selection().typingStyle()) {
         typingStyle = frame().selection().typingStyle()->copy();
         typingStyle->overrideWithStyle(style);
     } else {
         typingStyle = EditingStyle::create(style);
     }
 
     typingStyle->prepareToApplyAt(frame().selection().selection().visibleStart().deepEquivalent(), EditingStyle::PreserveWritingDirection);
 
     // Handle block styles, substracting these from the typing style.
     EditingStyle* blockStyle = typingStyle->extractAndRemoveBlockProperties();
     if (!blockStyle->isEmpty()) {
-        ASSERT(frame().document());
+        DCHECK(frame().document());
         ApplyStyleCommand::create(*frame().document(), blockStyle, editingAction)->apply();
     }
 
     // Set the remaining style as the typing style.
     frame().selection().setTypingStyle(typingStyle);
 }
 
 bool Editor::findString(const String& target, FindOptions options)
 {
     VisibleSelection selection = frame().selection().selection();
@@ skipping 171 matching lines @@
     if (existingHead)
         root->appendChild(existingHead);
     Element* body = nullptr;
     if (existingBody)
         body = existingBody;
     else
         body = HTMLBodyElement::create(document);
     if (document.documentElement() && body != document.documentElement())
         body->appendChild(document.documentElement());
     root->appendChild(body);
-    ASSERT(!document.documentElement());
+    DCHECK(!document.documentElement());
     document.appendChild(root);
 
     // TODO(tkent): Should we check and move Text node children of <html>?
 }
 
 DEFINE_TRACE(Editor)
 {
     visitor->trace(m_frame);
     visitor->trace(m_lastEditCommand);
     visitor->trace(m_mark);
 }
 
 } // namespace blink