DevTools: migrate inspector-protocol/dom tests to a new test runner

third_party/WebKit/LayoutTests/inspector-protocol/resources/inspector-protocol-test.js

 // Copyright 2017 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.
 
 var TestRunner = class {
   constructor(baseURL, log, completeTest, fetch) {
     this._dumpInspectorProtocolMessages = false;
     this._baseURL = baseURL;
     this._log = log;
     this._completeTest = completeTest;
     this._fetch = fetch;
   }
 
   startDumpingProtocolMessages() {
     this._dumpInspectorProtocolMessages = true;
   };
 
   completeTest() {
     this._completeTest.call(null);
   }
 
   log(text) {
     this._log.call(null, text);
   }
 
-  logMessage(originalMessage) {
+  logMessage(originalMessage, title) {
     var message = JSON.parse(JSON.stringify(originalMessage));
     if (message.id)
       message.id = '<messageId>';
-    const nonStableFields = new Set(['nodeId', 'objectId', 'scriptId', 'timestamp']);
+    const nonStableFields = new Set(['nodeId', 'objectId', 'scriptId', 'timestamp', 'backendNodeId', 'parentId', 'frameId', 'baseURL', 'documentURL']);
     var objects = [message];
     while (objects.length) {
       var object = objects.shift();
       for (var key in object) {
         if (nonStableFields.has(key))
           object[key] = `<${key}>`;
         else if (typeof object[key] === 'string' && object[key].match(/\d+:\d+:\d+:debug/))
           object[key] = object[key].replace(/\d+/, '<scriptId>');
         else if (typeof object[key] === 'object')
           objects.push(object[key]);
       }
     }
-    this.logObject(message);
+    this.logObject(message, title);
     return originalMessage;
   }
 
   logObject(object, title) {
     var lines = [];
 
     function dumpValue(value, prefix, prefixWithName) {
       if (typeof value === 'object' && value !== null) {
         if (value instanceof Array)
           dumpItems(value, prefix, prefixWithName);
@@ skipping 130 matching lines @@
     var session = await this.createSession();
     session.protocol.Page.enable();
     session.protocol.Page.navigate({url: url});
 
     var callback;
     var promise = new Promise(f => callback = f);
     session.protocol.Page.onFrameNavigated(message => {
       if (!message.params.frame.parentId)
         callback();
     });
-    await promise;
+    await Promise.all([
+      promise,
+      session.protocol.Page.onceLoadEventFired()
+    ]);
 
     await session.disconnect();
   }
 
   async loadHTML(html) {
     if (DevToolsAPI._sessions.get(this._targetId))
       this._testRunner.die('Cannot loadHTML with active session', new Error());
 
     html = html.replace(/'/g, "\\'").replace(/\n/g, '\\n');
     var session = await this.createSession();
-    await session.protocol.Runtime.evaluate({expression: `document.body.innerHTML='${html}'`});
+    await session.protocol.Runtime.evaluate({expression: `document.write('${html}');document.close();`});
     await session.disconnect();
   }
 };
 
 TestRunner.Session = class {
   constructor(page) {
     this._testRunner = page._testRunner;
     this._page = page;
     this._requestId = 0;
     this._dispatchTable = new Map();
@@ skipping 13 matching lines @@
 
   sendCommand(method, params) {
     var requestId = ++this._requestId;
     var messageObject = {'id': requestId, 'method': method, 'params': params};
     if (this._testRunner._dumpInspectorProtocolMessages)
       this._testRunner.log(`frontend => backend: ${JSON.stringify(messageObject)}`);
     return this.sendRawCommand(requestId, JSON.stringify(messageObject));
   }
 
   async evaluate(code) {
+    if (typeof code === 'function')
+      code = `(${code.toString()})()`;
     var response = await this.protocol.Runtime.evaluate({expression: code, returnByValue: true});
     if (response.error) {
       this._testRunner.log(`Error while evaluating '${code}': ${response.error}`);
       this._testRunner.completeTest();
     } else {
       return response.result.result.value;
     }
   }
 
   async evaluateAsync(code) {
+    if (typeof code === 'function')
+      code = `(${code.toString()})()`;
     var response = await this.protocol.Runtime.evaluate({expression: code, returnByValue: true, awaitPromise: true});
     if (response.error) {
       this._testRunner.log(`Error while evaluating async '${code}': ${response.error}`);
       this._testRunner.completeTest();
     } else {
       return response.result.result.value;
     }
   }
 
   _dispatchMessage(message) {
@@ skipping 184 matching lines @@
 
 window['onerror'] = (message, source, lineno, colno, error) => {
   DevToolsAPI._log(`${error}\n${error.stack}`);
   DevToolsAPI._completeTest();
 };
 
 window.addEventListener('unhandledrejection', e => {
   DevToolsAPI._log(`Promise rejection: ${e.reason}\n${e.reason ? e.reason.stack : ''}`);
   DevToolsAPI._completeTest();
 }, false);