Editing: Indent command: Do not insert BLOCKQUOTE under the root HTML element.

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

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 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
@@ skipping 1808 matching lines @@
     return PositionTemplate<Strategy>();
 
   if (isRenderedAsNonInlineTableImageOrHR(startNode))
     return PositionTemplate<Strategy>::beforeNode(startNode);
 
   Element* const startBlock = enclosingBlock(
       PositionTemplate<Strategy>::firstPositionInOrBeforeNode(startNode),
       CannotCrossEditingBoundary);
   ContainerNode* const highestRoot = highestEditableRoot(position);
   const bool startNodeIsEditable = hasEditableStyle(*startNode);
+  const HTMLElement* body = startNode->document().body();

[yosin_UTC9, 2017/03/17 10:04:11]

Could you move VisibleUnits.cpp change in another CL with units tests?

+  const bool startNodeIsInBody = body && Strategy::contains(*body, *startNode);
 
   Node* candidateNode = startNode;
   PositionAnchorType candidateType = position.anchorType();
   int candidateOffset = position.computeEditingOffset();
 
   Node* previousNodeIterator = startNode;
   while (previousNodeIterator) {
     if (boundaryCrossingRule == CannotCrossEditingBoundary &&
         !nodeIsUserSelectAll(previousNodeIterator) &&
         hasEditableStyle(*previousNodeIterator) != startNodeIsEditable)
       break;
     if (boundaryCrossingRule == CanSkipOverEditingBoundary) {
       while (previousNodeIterator &&
              hasEditableStyle(*previousNodeIterator) != startNodeIsEditable) {
         previousNodeIterator =
             Strategy::previousPostOrder(*previousNodeIterator, startBlock);
       }
       if (!previousNodeIterator ||
           !previousNodeIterator->isDescendantOf(highestRoot))
         break;
     }
 
+    if (startNodeIsInBody !=

[yosin_UTC9, 2017/03/17 10:04:11]

There are three occurrences of this pattern. Is it worth to introduce local
function for this?

+        (body && Strategy::contains(*body, *previousNodeIterator)))
+      break;
+
     const LayoutItem layoutItem =
         LayoutItem(previousNodeIterator->layoutObject());
     if (layoutItem.isNull()) {
       previousNodeIterator =
           Strategy::previousPostOrder(*previousNodeIterator, startBlock);
       continue;
     }
     const ComputedStyle& style = layoutItem.styleRef();
     if (style.visibility() != EVisibility::kVisible) {
       previousNodeIterator =
@@ skipping 76 matching lines @@
     return PositionTemplate<Strategy>();
 
   if (isRenderedAsNonInlineTableImageOrHR(startNode))
     return PositionTemplate<Strategy>::afterNode(startNode);
 
   Element* const startBlock = enclosingBlock(
       PositionTemplate<Strategy>::firstPositionInOrBeforeNode(startNode),
       CannotCrossEditingBoundary);
   ContainerNode* const highestRoot = highestEditableRoot(position);
   const bool startNodeIsEditable = hasEditableStyle(*startNode);
+  const HTMLElement* body = startNode->document().body();
+  const bool startNodeIsInBody = body && Strategy::contains(*body, *startNode);
 
   Node* candidateNode = startNode;
   PositionAnchorType candidateType = position.anchorType();
   int candidateOffset = position.computeEditingOffset();
 
   Node* nextNodeIterator = startNode;
   while (nextNodeIterator) {
     if (boundaryCrossingRule == CannotCrossEditingBoundary &&
         !nodeIsUserSelectAll(nextNodeIterator) &&
         hasEditableStyle(*nextNodeIterator) != startNodeIsEditable)
       break;
     if (boundaryCrossingRule == CanSkipOverEditingBoundary) {
       while (nextNodeIterator &&
              hasEditableStyle(*nextNodeIterator) != startNodeIsEditable)
         nextNodeIterator = Strategy::next(*nextNodeIterator, startBlock);
       if (!nextNodeIterator || !nextNodeIterator->isDescendantOf(highestRoot))
         break;
     }
 
+    if (startNodeIsInBody !=
+        (body && Strategy::contains(*body, *nextNodeIterator)))
+      break;
+
     LayoutObject* const layoutObject = nextNodeIterator->layoutObject();
     if (!layoutObject) {
       nextNodeIterator = Strategy::next(*nextNodeIterator, startBlock);
       continue;
     }
     const ComputedStyle& style = layoutObject->styleRef();
     if (style.visibility() != EVisibility::kVisible) {
       nextNodeIterator = Strategy::next(*nextNodeIterator, startBlock);
       continue;
     }
@@ skipping 945 matching lines @@
   if (!startNode)
     return PositionTemplate<Strategy>();
 
   // iterate backward from there, looking for a qualified position
   Node* boundary = enclosingVisualBoundary<Strategy>(startNode);
   // FIXME: PositionIterator should respect Before and After positions.
   PositionIteratorAlgorithm<Strategy> lastVisible(
       adjustPositionForBackwardIteration<Strategy>(position));
   PositionIteratorAlgorithm<Strategy> currentPos = lastVisible;
   bool startEditable = hasEditableStyle(*startNode);
+  const HTMLElement* body = startNode->document().body();
+  const bool startNodeIsInBody = body && Strategy::contains(*body, *startNode);
   Node* lastNode = startNode;
   bool boundaryCrossed = false;
   for (; !currentPos.atStart(); currentPos.decrement()) {
     Node* currentNode = currentPos.node();
     // Don't check for an editability change if we haven't moved to a different
     // node, to avoid the expense of computing hasEditableStyle().
     if (currentNode != lastNode) {
       // Don't change editability.
       bool currentEditable = hasEditableStyle(*currentNode);
       if (startEditable != currentEditable) {
         if (rule == CannotCrossEditingBoundary)
           break;
         boundaryCrossed = true;
       }
       lastNode = currentNode;
     }
 
+    if (startNodeIsInBody != (body && Strategy::contains(*body, *currentNode)))
+      break;
+
     // If we've moved to a position that is visually distinct, return the last
     // saved position. There is code below that terminates early if we're
     // *about* to move to a visually distinct position.
     if (endsOfNodeAreVisuallyDistinctPositions(currentNode) &&
         currentNode != boundary)
       return lastVisible.deprecatedComputePosition();
 
     // skip position in non-laid out or invisible node
     LayoutObject* layoutObject =
         associatedLayoutObjectOf(*currentNode, currentPos.offsetInLeafNode());
@@ skipping 158 matching lines @@
         if (rule == CannotCrossEditingBoundary)
           break;
         boundaryCrossed = true;
       }
 
       lastNode = currentNode;
     }
 
     // stop before going above the body, up into the head
     // return the last visible streamer position
-    if (isHTMLBodyElement(*currentNode) && currentPos.atEndOfNode())
+    if (currentNode->document().body() == currentNode &&
+        currentPos.atEndOfNode())
       break;
 
     // Do not move to a visually distinct position.
     if (endsOfNodeAreVisuallyDistinctPositions(currentNode) &&
         currentNode != boundary)
       return lastVisible.deprecatedComputePosition();
     // Do not move past a visually disinct position.
     // Note: The first position after the last in a node whose ends are visually
     // distinct positions will be [boundary->parentNode(),
     // originalBlock->nodeIndex() + 1].
@@ skipping 861 matching lines @@
 
 VisiblePositionInFlatTree previousPositionOf(
     const VisiblePositionInFlatTree& visiblePosition,
     EditingBoundaryCrossingRule rule) {
   DCHECK(visiblePosition.isValid()) << visiblePosition;
   return previousPositionOfAlgorithm<EditingInFlatTreeStrategy>(
       visiblePosition.deepEquivalent(), rule);
 }
 
 }  // namespace blink