Rename (updateLayout/updateStyle).*.() to updateStyleAndLayout.*.()

third_party/WebKit/Source/core/editing/commands/ApplyStyleCommand.cpp

 /*
  * Copyright (C) 2005, 2006, 2008, 2009 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 217 matching lines @@
 EditAction ApplyStyleCommand::editingAction() const
 {
     return m_editingAction;
 }
 
 void ApplyStyleCommand::applyBlockStyle(EditingStyle *style, EditingState* editingState)
 {
     // update document layout once before removing styles
     // so that we avoid the expense of updating before each and every call
     // to check a computed style
-    document().updateLayoutIgnorePendingStylesheets();
+    document().updateStyleAndLayoutIgnorePendingStylesheets();
 
     // get positions we want to use for applying style
     Position start = startPosition();
     Position end = endPosition();
     if (comparePositions(end, start) < 0) {
         Position swap = start;
         start = end;
         end = swap;
     }
 
@@ skipping 326 matching lines @@
 }
 
 void ApplyStyleCommand::applyInlineStyle(EditingStyle* style, EditingState* editingState)
 {
     ContainerNode* startDummySpanAncestor = nullptr;
     ContainerNode* endDummySpanAncestor = nullptr;
 
     // update document layout once before removing styles
     // so that we avoid the expense of updating before each and every call
     // to check a computed style
-    document().updateLayoutIgnorePendingStylesheets();
+    document().updateStyleAndLayoutIgnorePendingStylesheets();
 
     // adjust to the positions we want to use for applying style
     Position start = startPosition();
     Position end = endPosition();
 
     if (start.isNull() || end.isNull())
         return;
 
     if (comparePositions(end, start) < 0) {
         Position swap = start;
@@ skipping 93 matching lines @@
         mergeEndWithNextIfIdentical(start, end, editingState);
         if (editingState->isAborted())
             return;
         start = startPosition();
         end = endPosition();
     }
 
     // update document layout once before running the rest of the function
     // so that we avoid the expense of updating before each and every call
     // to check a computed style
-    document().updateLayoutIgnorePendingStylesheets();
+    document().updateStyleAndLayoutIgnorePendingStylesheets();
 
     EditingStyle* styleToApply = style;
     if (hasTextDirection) {
         // Avoid applying the unicode-bidi and direction properties beneath ancestors that already have them.
         HTMLElement* embeddingStartElement = highestEmbeddingAncestor(start.anchorNode(), enclosingBlock(start.anchorNode()));
         HTMLElement* embeddingEndElement = highestEmbeddingAncestor(end.anchorNode(), enclosingBlock(end.anchorNode()));
 
         if (embeddingStartElement || embeddingEndElement) {
             Position embeddingApplyStart = embeddingStartElement ? positionInParentAfterNode(*embeddingStartElement) : start;
             Position embeddingApplyEnd = embeddingEndElement ? positionInParentBeforeNode(*embeddingEndElement) : end;
@@ skipping 108 matching lines @@
 
 WTF_ALLOW_INIT_WITH_MEM_FUNCTIONS(blink::InlineRunToApplyStyle);
 
 namespace blink {
 
 void ApplyStyleCommand::applyInlineStyleToNodeRange(EditingStyle* style, Node* startNode, Node* pastEndNode, EditingState* editingState)
 {
     if (m_removeOnly)
         return;
 
-    document().updateLayoutIgnorePendingStylesheets();
+    document().updateStyleAndLayoutIgnorePendingStylesheets();
 
     HeapVector<InlineRunToApplyStyle> runs;
     Node* node = startNode;
     for (Node* next; node && node != pastEndNode; node = next) {
         next = NodeTraversal::next(*node);
 
         if (!node->layoutObject() || !node->hasEditableStyle())
             continue;
 
         if (!node->layoutObjectIsRichlyEditable() && node->isHTMLElement()) {
@@ skipping 48 matching lines @@
         removeConflictingInlineStyleFromRun(style, run.start, run.end, run.pastEndNode, editingState);
         if (editingState->isAborted())
             return;
         if (run.startAndEndAreStillInDocument()) {
             run.positionForStyleComputation = positionToComputeInlineStyleChange(run.start, run.dummyElement, editingState);
             if (editingState->isAborted())
                 return;
         }
     }
 
-    document().updateLayoutIgnorePendingStylesheets();
+    document().updateStyleAndLayoutIgnorePendingStylesheets();
 
     for (auto& run : runs) {
         if (run.positionForStyleComputation.isNotNull())
             run.change = StyleChange(style, run.positionForStyleComputation);
     }
 
     for (auto& run : runs) {
         if (run.dummyElement) {
             removeNode(run.dummyElement, editingState);
             if (editingState->isAborted())
@@ skipping 178 matching lines @@
             break;
     }
 
     return result;
 }
 
 void ApplyStyleCommand::applyInlineStyleToPushDown(Node* node, EditingStyle* style, EditingState* editingState)
 {
     DCHECK(node);
 
-    node->document().updateLayoutTree();
+    node->document().updateStyleAndLayoutTree();
 
     if (!style || style->isEmpty() || !node->layoutObject() || isHTMLIFrameElement(*node))
         return;
 
     EditingStyle* newInlineStyle = style;
     if (node->isHTMLElement() && toHTMLElement(node)->inlineStyle()) {
         newInlineStyle = style->copy();
         newInlineStyle->mergeInlineStyleOfElement(toHTMLElement(node), EditingStyle::OverrideValues);
     }
 
@@ skipping 172 matching lines @@
             break;
         node = next;
     }
 
     updateStartEnd(s, e);
 }
 
 bool ApplyStyleCommand::elementFullySelected(HTMLElement& element, const Position& start, const Position& end) const
 {
     // The tree may have changed and Position::upstream() relies on an up-to-date layout.
-    element.document().updateLayoutIgnorePendingStylesheets();
+    element.document().updateStyleAndLayoutIgnorePendingStylesheets();
 
     return comparePositions(firstPositionInOrBeforeNode(&element), start) >= 0
         && comparePositions(mostBackwardCaretPosition(lastPositionInOrAfterNode(&element)), end) <= 0;
 }
 
 void ApplyStyleCommand::splitTextAtStart(const Position& start, const Position& end)
 {
     DCHECK(start.computeContainerNode()->isTextNode()) << start;
 
     Position newEnd;
@@ skipping 421 matching lines @@
 DEFINE_TRACE(ApplyStyleCommand)
 {
     visitor->trace(m_style);
     visitor->trace(m_start);
     visitor->trace(m_end);
     visitor->trace(m_styledInlineElement);
     CompositeEditCommand::trace(visitor);
 }
 
 } // namespace blink