Rename isBlock() to isEnclosingBlock() in EditingUtilities

Source/core/editing/serializers/StyledMarkupSerializer.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2008, 2009, 2010, 2011 Google Inc. All rights reserved.
  * Copyright (C) 2011 Igalia S.L.
  * Copyright (C) 2011 Motorola Mobility. 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
@@ skipping 274 matching lines @@
     Node* next;
     Node* lastClosed = nullptr;
     for (Node* n = startNode; n && n != pastEnd; n = next) {
         // If |n| is a selection boundary such as <input>, traverse the child
         // nodes in the DOM tree instead of the composed tree.
         if (handleSelectionBoundary<Strategy>(*n)) {
             lastClosed = StyledMarkupTraverser<EditingStrategy>(m_accumulator, m_lastClosed.get()).traverse(n, EditingStrategy::nextSkippingChildren(*n));
             next = EditingInComposedTreeStrategy::nextSkippingChildren(*n);
         } else {
             next = Strategy::next(*n);
-            if (isBlock(n) && canHaveChildrenForEditing(n) && next == pastEnd) {
+            if (isEnclosingBlock(n) && canHaveChildrenForEditing(n) && next == pastEnd) {
                 // Don't write out empty block containers that aren't fully selected.
                 continue;
             }
 
             if (!n->layoutObject() && !enclosingElementWithTag(firstPositionInOrBeforeNode(n), selectTag)) {
                 next = Strategy::nextSkippingChildren(*n);
                 // Don't skip over pastEnd.
                 if (pastEnd && Strategy::isDescendantOf(*pastEnd, *n))
                     next = pastEnd;
             } else {
@@ skipping 50 matching lines @@
     return lastClosed;
 }
 
 template<typename Strategy>
 bool StyledMarkupTraverser<Strategy>::needsInlineStyle(const Element& element)
 {
     if (!element.isHTMLElement())
         return false;
     if (shouldAnnotate())
         return true;
-    return convertBlocksToInlines() && isBlock(&element);
+    return convertBlocksToInlines() && isEnclosingBlock(&element);
 }
 
 template<typename Strategy>
 void StyledMarkupTraverser<Strategy>::wrapWithNode(ContainerNode& node, PassRefPtrWillBeRawPtr<EditingStyle> style)
 {
     if (!m_accumulator)
         return;
     StringBuilder markup;
     if (node.isDocumentNode()) {
         MarkupFormatter::appendXMLDeclaration(markup, toDocument(node));
@@ skipping 12 matching lines @@
 }
 
 template<typename Strategy>
 RefPtrWillBeRawPtr<EditingStyle> StyledMarkupTraverser<Strategy>::createInlineStyleIfNeeded(Node& node)
 {
     if (!m_accumulator)
         return nullptr;
     if (!node.isElementNode())
         return nullptr;
     RefPtrWillBeRawPtr<EditingStyle> inlineStyle = createInlineStyle(toElement(node));
-    if (convertBlocksToInlines() && isBlock(&node))
+    if (convertBlocksToInlines() && isEnclosingBlock(&node))
         inlineStyle->forceInline();
     return inlineStyle;
 }
 
 template<typename Strategy>
 void StyledMarkupTraverser<Strategy>::appendStartMarkup(Node& node)
 {
     if (!m_accumulator)
         return;
     switch (node.nodeType()) {
@@ skipping 65 matching lines @@
     if (element.isHTMLElement() && shouldAnnotate())
         inlineStyle->mergeStyleFromRulesForSerialization(&toHTMLElement(element));
 
     return inlineStyle;
 }
 
 template class StyledMarkupSerializer<EditingStrategy>;
 template class StyledMarkupSerializer<EditingInComposedTreeStrategy>;
 
 } // namespace blink