--- a/editor/libeditor/HTMLEditRules.cpp
+++ b/editor/libeditor/HTMLEditRules.cpp
@@ -7103,57 +7103,68 @@ HTMLEditRules::GetParagraphFormatNodes(
       outArrayOfNodes.RemoveElementAt(i);
       GetInnerContent(testNode, outArrayOfNodes, &j);
     }
   }
   return NS_OK;
 }
 
 nsresult
-HTMLEditRules::BustUpInlinesAtRangeEndpoints(RangeItem& item)
+HTMLEditRules::BustUpInlinesAtRangeEndpoints(RangeItem& aRangeItem)
 {
   MOZ_ASSERT(IsEditorDataAvailable());
 
-  bool isCollapsed = item.mStartContainer == item.mEndContainer &&
-                     item.mStartOffset == item.mEndOffset;
-
-  nsCOMPtr<nsIContent> endInline = GetHighestInlineParent(*item.mEndContainer);
+  bool isCollapsed = aRangeItem.mStartContainer == aRangeItem.mEndContainer &&
+                     aRangeItem.mStartOffset == aRangeItem.mEndOffset;
+
+  nsCOMPtr<nsIContent> endInline =
+    GetHighestInlineParent(*aRangeItem.mEndContainer);
 
   // XXX Oh, then, if the range is collapsed, we don't need to call
   //     GetHighestInlineParent(), isn't it?
   if (endInline && !isCollapsed) {
     SplitNodeResult splitEndInlineResult =
       HTMLEditorRef().SplitNodeDeepWithTransaction(
                         *endInline,
-                        EditorRawDOMPoint(item.mEndContainer, item.mEndOffset),
+                        EditorRawDOMPoint(aRangeItem.mEndContainer,
+                                          aRangeItem.mEndOffset),
                         SplitAtEdges::eDoNotCreateEmptyContainer);
+    if (NS_WARN_IF(!CanHandleEditAction())) {
+      return NS_ERROR_EDITOR_DESTROYED;
+    }
     if (NS_WARN_IF(splitEndInlineResult.Failed())) {
       return splitEndInlineResult.Rv();
     }
     EditorRawDOMPoint splitPointAtEnd(splitEndInlineResult.SplitPoint());
-    item.mEndContainer = splitPointAtEnd.GetContainer();
-    item.mEndOffset = splitPointAtEnd.Offset();
+    aRangeItem.mEndContainer = splitPointAtEnd.GetContainer();
+    aRangeItem.mEndOffset = splitPointAtEnd.Offset();
   }
 
   nsCOMPtr<nsIContent> startInline =
-    GetHighestInlineParent(*item.mStartContainer);
+    GetHighestInlineParent(*aRangeItem.mStartContainer);
 
   if (startInline) {
     SplitNodeResult splitStartInlineResult =
       HTMLEditorRef().SplitNodeDeepWithTransaction(
                         *startInline,
-                        EditorRawDOMPoint(item.mStartContainer,
-                                          item.mStartOffset),
+                        EditorRawDOMPoint(aRangeItem.mStartContainer,
+                                          aRangeItem.mStartOffset),
                         SplitAtEdges::eDoNotCreateEmptyContainer);
+    if (NS_WARN_IF(!CanHandleEditAction())) {
+      return NS_ERROR_EDITOR_DESTROYED;
+    }
     if (NS_WARN_IF(splitStartInlineResult.Failed())) {
       return splitStartInlineResult.Rv();
     }
+    // XXX If we split only here because of collapsed range, we're modifying
+    //     only start point of aRangeItem.  Shouldn't we modify end point here
+    //     if it's collapsed?
     EditorRawDOMPoint splitPointAtStart(splitStartInlineResult.SplitPoint());
-    item.mStartContainer = splitPointAtStart.GetContainer();
-    item.mStartOffset = splitPointAtStart.Offset();
+    aRangeItem.mStartContainer = splitPointAtStart.GetContainer();
+    aRangeItem.mStartOffset = splitPointAtStart.Offset();
   }
 
   return NS_OK;
 }
 
 nsresult
 HTMLEditRules::BustUpInlinesAtBRs(
                  nsIContent& aNode,

--- a/editor/libeditor/HTMLEditRules.h
+++ b/editor/libeditor/HTMLEditRules.h
@@ -498,17 +498,28 @@ protected:
              nsTArray<OwningNonNull<nsINode>>& aOutArrayOfNodes,
              EntireList aEntireList,
              TouchContent aTouchContent = TouchContent::yes);
   void GetDefinitionListItemTypes(Element* aElement, bool* aDT, bool* aDD);
   nsresult GetParagraphFormatNodes(
              nsTArray<OwningNonNull<nsINode>>& outArrayOfNodes,
              TouchContent aTouchContent = TouchContent::yes);
   void LookInsideDivBQandList(nsTArray<OwningNonNull<nsINode>>& aNodeArray);
-  nsresult BustUpInlinesAtRangeEndpoints(RangeItem& inRange);
+
+  /**
+   * BustUpInlinesAtRangeEndpoints() splits nodes at both start and end of
+   * aRangeItem.  If this splits at every point, this modifies aRangeItem
+   * to point each split point (typically, right node).  Note that this splits
+   * nodes only in highest inline element at every point.
+   *
+   * @param aRangeItem          One or two DOM points where should be split.
+   *                            Will be modified to split point if they're
+   *                            split.
+   */
+  MOZ_MUST_USE nsresult BustUpInlinesAtRangeEndpoints(RangeItem& aRangeItem);
 
   /**
    * BustUpInlinesAtBRs() splits before all <br> elements in aNode.  All <br>
    * nodes will be moved before right node at splitting its parent.  Finally,
    * this returns all <br> elements, every left node and aNode with
    * aOutArrayNodes.
    *
    * @param aNode               An inline container element.