Update tests for snapshot allowfullscreen behavior

content/test/data/tree_parser_util.js

 // Copyright 2015 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.
 
 /**
  * Parser for a simple grammar that describes a tree structure using a function-
  * like "a(b(c,d))" syntax. Original intended usage: to have browsertests
  * specify an arbitrary tree of iframes, loaded from various sites, without
  * having to write a .html page for each level or do crazy feats of data: url
  * escaping. But there's nothing really iframe-specific here. See below for some
@@ skipping 18 matching lines @@
  * //             { value: 'g', children: [
  * //               { value: 'h', children: [] },
  * //               { value: 'i', children: [
  * //                 { value: 'j', children: [] }
  * //               ]},
  * //             ]}
  * //           ]}
  * //         ]}
  * TreeParserUtil.parse('e(f(g(h(),i(j))))';
  *
+ * @example <caption>Tree nodes can also have attributes, which are a comma-
+ * separated list of identifiers, surrounded by braces, after the node name.
+ * </caption>
+ * // returns { value: 'b', attributes: [red,blue], children: [
+ * //           { value: 'c', children: [] },
+ * //           { value: 'd', attributes: [green], children: [] }
+ * //         ]}
+ * TreeParserUtil.parse('b{red,blue}(c,d{green})';

[ncarter (slow), 2017/05/05 22:34:05]

So it turns out that I did write unittests for this, but couldn't figure out how
to hook them up to actually run. :(

If you want to play with them, there's a file in ps4 of the original code review
here:

https://codereview.chromium.org/1264923002/#ps50001

[iclelland, 2017/05/06 03:03:10]

Thanks! I will definitely take a look.

+ *
  * @example <caption>flatten() converts a [sub]tree back to a string.</caption>
  * var tree = TreeParserUtil.parse('b.com (c.com(e.com), d.com)');
  * TreeParserUtil.flatten(tree.children[0]);  // returns 'c.com(e.com())'
  */
 var TreeParserUtil = (function() {
   'use strict';
 
   /**
    * Parses an input string into a tree. See class comment for examples.
    * @returns A tree of the form {value: <string>, children: <Array.<tree>>}.
    */
   function parse(input) {
     var tokenStream = lex(input);
 
     var result = takeIdAndChild(tokenStream);
     if (tokenStream.length != 0)
       throw new Error('Expected end of stream, but found "' +
                       tokenStream[0] + '".')
     return result;
   }
 
   /**
    * Inverse of |parse|. Converts a parsed tree object into a string. Can be
    * used to forward a subtree as an argument to a nested document.
    */
   function flatten(tree) {
-    return tree.value + '(' + tree.children.map(flatten).join(',') + ')';
+    var result = tree.value;
+    if (tree.attributes && tree.attributes.length)
+      result += '{' + tree.attributes.join(",") + "}";
+    return result + '(' + tree.children.map(flatten).join(',') + ')';
   }
 
   /**
    * Lexer function to convert an input string into a token stream.  Splits the
    * input along whitespace, parens and commas. Whitespace is removed, while
    * parens and commas are preserved as standalone tokens.
    *
    * @param {string} input The input string.
    * @return {Array.<string>} The resulting token stream.
    */
   function lex(input) {
-    return input.split(/(\s+|\(|\)|,)/).reduce(
+    return input.split(/(\s+|\(|\)|{|}|,)/).reduce(
       function (resultArray, token) {
         var trimmed = token.trim();
         if (trimmed) {
           resultArray.push(trimmed);
         }
         return resultArray;
       }, []);
   }
 
-
   /**
    * Consumes from the stream an identifier and optional child list, returning
    * its parsed representation.
    */
   function takeIdAndChild(tokenStream) {
     return { value: takeIdentifier(tokenStream),
+             attributes: takeAttributeList(tokenStream),

[ncarter (slow), 2017/05/05 22:34:05]

The jsdoc suggests that attributes here will be omitted if the result of
takeAttributeList() is empty.

An empty attribute list is more caller-friendly, but omitting the attributes
property is definitely more documentation-friendly.

I guess we should just go ahead and update the jsdoc?

[iclelland, 2017/05/06 03:03:10]

Updated.

              children: takeChildList(tokenStream) };
   }
 
   /**
    * Consumes from the stream an identifier, returning its value (as a string).
    */
   function takeIdentifier(tokenStream) {
     if (tokenStream.length == 0)
       throw new Error('Expected an identifier, but found end-of-stream.');
     var token = tokenStream.shift();
-    if (!token.match(/[a-zA-Z0-9.-]+/))
+    if (!token.match(/^[a-zA-Z0-9.-]+$/))
       throw new Error('Expected an identifier, but found "' + token + '".');
     return token;
   }
 
   /**
+   * Consumes an optional attribute list from the token stream, returning a list
+   * of the parsed attribute identifiers.
+   */
+  function takeAttributeList(tokenStream) {
+    // Remove the next token from the stream if it matches |token|.
+    function tryToEatA(token) {
+      if (tokenStream[0] == token) {
+        tokenStream.shift();
+        return true;
+      }
+      return false;
+    }
+
+    // Bare identifier case, as in 'b' in the input '(a (b, c))'
+    if (!tryToEatA('{'))
+      return [];
+
+    // Empty list case, as in 'b' in the input 'a (b {}, c)'.
+    if (tryToEatA('}')) {
+      return [];
+    }
+
+    // List with at least one entry.
+    var result = [ takeIdentifier(tokenStream) ];
+
+    // Additional entries allowed with comman.

[ncarter (slow), 2017/05/05 22:34:05]

comman -> comma

[iclelland, 2017/05/06 03:03:10]

Thanks, done

+    while (tryToEatA(',')) {
+      result.push(takeIdentifier(tokenStream));
+    }
+
+    // End of list.
+    if (tryToEatA('}')) {
+      return result;
+    }
+    if (tokenStream.length == 0)
+      throw new Error('Expected "}" or ",", but found end-of-stream.');
+    throw new Error('Expected "}" or ",", but found "' + tokenStream[0] + '".');
+  }
+
+  /**
    * Consumes an optional child list from the token stream, returning a list of
    * the parsed children.
    */
   function takeChildList(tokenStream) {
     // Remove the next token from the stream if it matches |token|.
     function tryToEatA(token) {
       if (tokenStream[0] == token) {
         tokenStream.shift();
         return true;
       }
@@ skipping 24 matching lines @@
     if (tokenStream.length == 0)
       throw new Error('Expected ")" or ",", but found end-of-stream.');
     throw new Error('Expected ")" or ",", but found "' + tokenStream[0] + '".');
   }
 
   return {
     parse:   parse,
     flatten: flatten
   };
 })();