[LayoutTests] add Symbols to webexposed global-interface-listing

third_party/WebKit/LayoutTests/webexposed/resources/global-interface-listing.js

 // Run all the code in a local scope.
 (function(globalObject) {
 
 // Save the list of property names of the global object before loading other scripts.
 var propertyNamesInGlobal = globalObject.propertyNamesInGlobal || Object.getOwnPropertyNames(globalObject);
 
 if (self.importScripts) {
     importScripts('../../resources/js-test.js');
 
     if (!self.postMessage) {
@@ skipping 79 matching lines @@
 
 function isWebIDLConstructor(propertyName) {
     if (jsBuiltins.has(propertyName))
         return false;
     var descriptor = Object.getOwnPropertyDescriptor(this, propertyName);
     if (descriptor.value == undefined || descriptor.value.prototype == undefined)
         return false;
     return descriptor.writable && !descriptor.enumerable && descriptor.configurable;
 }
 
+var wellKnownSymbols = new Map([
+    [Symbol.hasInstance, "@@hasInstance"],
+    [Symbol.isConcatSpreadable, "@@isConcatSpreadable"],
+    [Symbol.iterator, "@@iterator"],
+    [Symbol.match, "@@match"],
+    [Symbol.replace, "@@replace"],
+    [Symbol.search, "@@search"],
+    [Symbol.species, "@@species"],
+    [Symbol.split, "@@split"],
+    [Symbol.toPrimitive, "@@toPrimitive"],
+    [Symbol.toStringTag, "@@toStringTag"],
+    [Symbol.unscopables, "@@unscopables"]
+]);
+
 function collectPropertyInfo(object, propertyName, output) {

[jsbell, 2016/03/11 20:23:46]

Can we s/propertyName/propertyKey/ while we're here?

[caitp (gmail), 2016/03/11 20:29:01]

Acknowledged.

-    var keywords = ('prototype' in object) ? 'static ' : '';
+    var propertyString = wellKnownSymbols.get(propertyName) || propertyName.toString();

[jsbell, 2016/03/11 20:23:46]

Is this map necessary? Seems annoying to maintain. I'd be fine with
"Symbol(Symbol.iterator)" appearing in the output.

Or .replace(/^Symbol\(Symbol\.(.*)\)$/, '@@$1') if we want to be clever.

[caitp (gmail), 2016/03/11 20:29:01]

hmm, it doesn't seem that hard --- I just wanted to distuingish between
ECMAScript-defined Symbols, and arbitrary ones introduced elsewhere --- which
would be harder and more expensive to do with a regexp. This seems like it would
make it easier to identify mistakenly added Symbols, but yeah, can avoid that.

I'm not really expecting the list of well known symbols to be expanded very
often, but if it does happen and does impact bindings in blink, having the map
provides an easy way to update the list.

+    var keywords = Object.prototype.hasOwnProperty.call(object, 'prototype') ? 'static ' : '';
     var descriptor = Object.getOwnPropertyDescriptor(object, propertyName);
     if ('value' in descriptor) {
         var type = typeof descriptor.value === 'function' ? 'method' : 'attribute';
-        output.push('    ' + keywords + type + ' ' + propertyName);
+        output.push('    ' + keywords + type + ' ' + propertyString);
     } else {
         if (descriptor.get)
-            output.push('    ' + keywords + 'getter ' + propertyName);
+            output.push('    ' + keywords + 'getter ' + propertyString);
         if (descriptor.set)
-            output.push('    ' + keywords + 'setter ' + propertyName);
+            output.push('    ' + keywords + 'setter ' + propertyString);
     }
 }
 
+function ownEnumerableSymbols(object) {
+    return Object.getOwnPropertySymbols(object).
+        filter(function(name) {
+            return Object.getOwnPropertyDescriptor(name).enumerable;
+        });
+}
+
+function collectPropertyNames(object) {
+   if (Object.prototype.hasOwnProperty.call(object, 'prototype')) {
+       // Skip properties that aren't static (e.g. consts), or are inherited.
+       var protoProperties = new Set(Object.keys(object.prototype).concat(

[caitp (gmail), 2016/03/11 20:10:49]

I'm not sure if it's intentional to use Object.keys(), which omits
non-enumerable properties or not --- since "not-a-constructor" branch doesn't
only look at enumerable properties.

[jsbell, 2016/03/11 20:23:46]

I'm okay with leaving this as-is for now, maybe with a TODO to improve it.

+                                     Object.keys(object.__proto__),
+                                     ownEnumerableSymbols(object.prototype),
+                                     ownEnumerableSymbols(object.__proto__)));
+       return propertyNames = Object.keys(object).
+           concat(ownEnumerableSymbols(object)).
+           filter(function(name) {
+                // TODO(johnme): Stop filtering out 'toString' once
+                //               https://crbug.com/547773 is fixed.
+               return !protoProperties.has(name) && name !== 'toString';
+           });
+   }
+   return Object.getOwnPropertyNames(object).concat(Object.getOwnPropertySymbols(object));
+}
+
 // FIXME: List interfaces with NoInterfaceObject specified in their IDL file.
 debug('[INTERFACES]');
 var interfaceNames = Object.getOwnPropertyNames(this).filter(isWebIDLConstructor);
 interfaceNames.sort();
 interfaceNames.forEach(function(interfaceName) {
     var inheritsFrom = this[interfaceName].__proto__.name;
     if (inheritsFrom)
         debug('interface ' + interfaceName + ' : ' + inheritsFrom);
     else
         debug('interface ' + interfaceName);
     // List static properties then prototype properties.
     [this[interfaceName], this[interfaceName].prototype].forEach(function(object) {
-        if ('prototype' in object) {
-            // Skip properties that aren't static (e.g. consts), or are inherited.
-            var protoProperties = new Set(Object.keys(object.prototype).concat(
-                                          Object.keys(object.__proto__)));
-            var propertyNames = Object.keys(object).filter(function(name) {
-                // TODO(johnme): Stop filtering out 'toString' once
-                //               https://crbug.com/547773 is fixed.
-                return !protoProperties.has(name) && name !== 'toString';
-            });
-        } else {
-            var propertyNames = Object.getOwnPropertyNames(object);
-        }
+        var propertyNames = collectPropertyNames(object);
         var propertyStrings = [];
         propertyNames.forEach(function(propertyName) {
             collectPropertyInfo(object, propertyName, propertyStrings);
         });
         propertyStrings.sort().forEach(debug);
     });
 });
 
 debug('[GLOBAL OBJECT]');
 var propertyStrings = [];
 var memberNames = propertyNamesInGlobal.filter(function(propertyName) {
     return !jsBuiltins.has(propertyName) && !isWebIDLConstructor(propertyName);
 });
 memberNames.forEach(function(propertyName) {
     collectPropertyInfo(globalObject, propertyName, propertyStrings);
 });
 propertyStrings.sort().forEach(debug);
 
 if (isWorker())
     finishJSTest();
 
 })(this); // Run all the code in a local scope.