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

third_party/WebKit/LayoutTests/editing/assert_selection.js

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 'use strict';
 
 // This file provides |assert_selection(sample, tester, expectedText, options)|
 // assertion to W3C test harness to write editing test cases easier.
 //
 // |sample| is an HTML fragment text which is inserted as |innerHTML|. It should
 // have at least one focus boundary point marker "|" and at most one anchor
 // boundary point marker "^".
 //
 // |tester| is either name with parameter of execCommand or function taking
 // one parameter |Selection|.
 //
 // |expectedText| is an HTML fragment text containing at most one focus marker
 // and anchor marker. If resulting selection is none, you don't need to have
 // anchor and focus markers.
 //
 // |options| is a string as description, undefined, or a dictionary containing:
 //  description: A description
 //  dumpAs: 'domtree' or 'flattree'. Default is 'domtree'.
 //  removeSampleIfSucceeded: A boolean. Default is true.
+//  dumpFromRoot: A boolean. Default is false.

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

Could you move "assert_selection.js" change to another patch with a test in
"assert_selection.html"?

 //
 // Example:
 //  test(() => {
 //    assert_selection(
 //      '|foo',
 //      (selection) => selection.modify('extent', 'forward, 'character'),
 //      '<a href="http://bar">^f|oo</a>'
 //  });
 //
 //  test(() => {
@@ skipping 577 matching lines @@
       }
       this.emit(endMarker);
       this.emit(value.substr(end));
     }
     this.emit('</textarea>');
   }
 
   /**
    * @public
    * @param {!HTMLDocument} document
+   * @param {boolean} dumpFromRoot
    */
-  serialize(document) {
-    if (document.body)
+  serialize(document, dumpFromRoot) {
+    if (document.body && !dumpFromRoot)
         this.serializeChildren(document.body);
     else
         this.serializeInternal(document.documentElement);
     return this.strings_.join('');
   }
 
   /**
    * @private
    * @param {!HTMLElement} element
    */
@@ skipping 146 matching lines @@
   }
 
   /**
    * @public
    */
   remove() { this.iframe_.remove(); }
 
   /**
    * @public
    * @param {!Traversal} traversal
+   * @param {boolean} dumpFromRoot
    * @return {string}
    */
-  serialize(traversal) {
+  serialize(traversal, dumpFromRoot) {
     /** @type {!SampleSelection} */
     const selection = traversal.fromDOMSelection(this.selection_);
     /** @type {!Serializer} */
     const serializer = new Serializer(selection, traversal);
-    return serializer.serialize(this.document_);
+    return serializer.serialize(this.document_, dumpFromRoot);
   }
 }
 
 function assembleDescription() {
   function getStack() {
     let stack;
     try {
       throw new Error('get line number');
     } catch (error) {
       stack = error.stack.split('\n').slice(1);
@@ skipping 57 matching lines @@
  * @param {function(!Selection)|string}
  * @param {string} expectedText
  * @param {Object=} opt_options
  * @return {!Sample}
  */
 function assertSelection(
     inputText, tester, expectedText, opt_options = {}) {
   const kDescription = 'description';
   const kDumpAs = 'dumpAs';
   const kRemoveSampleIfSucceeded = 'removeSampleIfSucceeded';
+  const kDumpFromRoot = 'dumpFromRoot';
   /** @type {!Object} */
   const options = typeof(opt_options) === 'string'
       ? {description: opt_options} : opt_options;
   /** @type {string} */
   const description = kDescription in options
       ? options[kDescription] : assembleDescription();
   /** @type {boolean} */
   const removeSampleIfSucceeded = kRemoveSampleIfSucceeded in options
       ? !!options[kRemoveSampleIfSucceeded] : true;
   /** @type {DumpAs} */
   const dumpAs = options[kDumpAs] || DumpAs.DOM_TREE;
+  /** @type {boolean} */
+  const dumpFromRoot = options[kDumpFromRoot] || false;
 
   checkExpectedText(expectedText);
   const sample = new Sample(inputText);
   if (typeof(tester) === 'function') {
     tester.call(window, sample.selection);
   } else if (typeof(tester) === 'string') {
     const strings = tester.split(/ (.+)/);
     sample.document.execCommand(strings[0], false, strings[1]);
   } else {
     throw new Error(`Invalid tester: ${tester}`);
   }
 
   /** @type {!Traversal} */
   const traversal = (() => {
     switch (dumpAs) {
       case DumpAs.DOM_TREE:
         return new DOMTreeTraversal();
       case DumpAs.FLAT_TREE:
         if (!window.internals)
           throw new Error('This test requires window.internals.');
         return new FlatTreeTraversal();
       default:
         throw `${kDumpAs} must be one of ` +
               `{${Object.values(DumpAs).join(', ')}}` +
               ` instead of '${dumpAs}'`;
     }
   })();
 
   /** @type {string} */
-  const actualText = sample.serialize(traversal);
+  const actualText = sample.serialize(traversal, dumpFromRoot);
   // We keep sample HTML when assertion is false for ease of debugging test
   // case.
   if (actualText === expectedText) {
     if (removeSampleIfSucceeded)
         sample.remove();
     return sample;
   }
   throw new Error(`${description}\n` +
     `\t expected ${expectedText},\n` +
     `\t but got  ${actualText},\n` +
     `\t sameupto ${commonPrefixOf(expectedText, actualText)}`);
 }
 
 // Export symbols
 window.Sample = Sample;
 window.assert_selection = assertSelection;
 })();