Import wpt@c5a14f553cba5f197743b9af605a84eddd8692a2

third_party/WebKit/LayoutTests/imported/wpt/uievents/resources/eventrecorder.js

 // interface EventRecorder {
 //    static void start();
 //    static void stop();
 //    static void clearRecords();
 //    static sequence<EventRecord> getRecords();
 //    static void configure(EventRecorderOptions options);
 // };
 // * getRecords
 //   * returns an array of EventRecord objects; the array represents the sequence of events captured at anytime after the last clear()
 //             call, between when the recorder was started and stopped (including multiple start/stop pairs)
@@ skipping 122 matching lines @@
          },
          clearRecords: {
             enumerable: true, configurable: true, writable: true, value: function clearRecords() {
                rawOrder = 1;
                allRecords = [];
             }
          },
          getRecords: {
             enumerable: true, configurable: true, writable: true, value: function getRecords() { return allRecords; }
          },
+         checkRecords: {
+            enumerable: true, configurable: true, writable: true, value: function checkRecords(expected) {
+               if (expected.length < allRecords.length) {
+                  return false;
+               }
+               var j = 0;
+               for (var i = 0; i < expected.length; ++i) {
+                  if (j >= allRecords.length) {
+                     if (expected[i].optional) {
+                        continue;
+                     }
+                     return false;
+                  }
+                  if (expected[i].type == allRecords[j].event.type && expected[i].target == allRecords[j].event.currentTarget) {
+                     ++j;
+                     continue;
+                  }
+                  if (expected[i].optional) {
+                     continue;
+                  }
+                  return false;
+               }
+               return true;
+            }
+         },
          configure: {
             enumerable: true, configurable: true, writable: true, value: function configure(options) {
                if (allRecords.length > 0)
                   throw new Error("Wrong time to call me: EventRecorder.configure must only be called when no recorded events are present. Try 'clearRecords' first.");
 
                // Un-configure existing options by calling again with no options set...
                mergeTypesTruthMap = {};
                knownObjectsMap = eventConstructorsNameMap;
 
                if (!(options instanceof Object))
                   return;
                // Sanitize the passed object (tease-out getter functions)
                var sanitizedOptions = {};
                for (var x in options) {
                   sanitizedOptions[x] = options[x];
                }
                if (sanitizedOptions.mergeEventTypes && Array.isArray(sanitizedOptions.mergeEventTypes)) {
                   sanitizedOptions.mergeEventTypes.forEach(function (eventType) {
                      if (typeof eventType == "string")
                         mergeTypesTruthMap[eventType] = true;
                   });
                }
                if (sanitizedOptions.objectMap && (sanitizedOptions.objectMap instanceof Object)) {
                   for (var y in sanitizedOptions.objectMap) {
                      knownObjectsMap.set(sanitizedOptions.objectMap[y], y);
                   }
                }
             }
+         },
+         addEventListenersForNodes: {
+            enumerable: true, configurable: true, writable: true, value: function addEventListenersForNodes(events, nodes, handler) {
+               for (var i = 0; i < nodes.length; ++i) {
+                  for (var j = 0; j < events.length; ++j) {
+                     nodes[i].addRecordedEventListener(events[j], handler);
+                  }
+               }
+            }
          }
       })
    });
 
    function EventRecord(rawEvent) {
       this.chronologicalOrder = rawOrder++;
       this.sequentialOccurrences = 1;
       this.nestedEvents = null; // potentially a []
       this.interfaceType = knownObjectsMap.get(rawEvent.constructor);
       if (!this.interfaceType) // In case (somehow) this event's constructor is not named something with an 'Event' suffix...
@@ skipping 93 matching lines @@
       removeRecordedEventListener: {
          enumerable: true, writable: true, configurable: true,
          value: function addRecordedEventListener(type, handler, capture) {
             var alternateHandlerUsed = handlerMap.get(handler);
             this.removeEventListenter(type, alternateHandlerUsed ? alternateHandlerUsed : recordedEventHandler, capture);
          }
       }
    });
 
 })(window);