fix(evaluate): consistently serialize json values (#2377)

Author: pavelfeldman

src/chromium/crAccessibility.ts

@@ -95,8 +95,8 @@ class CRAXNode implements accessibility.AXNode {
   }
 
   async _findElement(element: dom.ElementHandle): Promise<CRAXNode | null> {
-    const remoteObject = element._remoteObject as Protocol.Runtime.RemoteObject;
-    const {node: {backendNodeId}} = await this._client.send('DOM.describeNode', {objectId: remoteObject.objectId});
+    const objectId = element._objectId!;
+    const {node: {backendNodeId}} = await this._client.send('DOM.describeNode', { objectId });
     const needle = this.find(node => node._payload.backendDOMNodeId === backendNodeId);
     return needle || null;
   }

src/chromium/crExecutionContext.ts

@@ -17,10 +17,11 @@
 
 import { CRSession } from './crConnection';
 import { helper } from '../helper';
-import { valueFromRemoteObject, getExceptionMessage, releaseObject } from './crProtocolHelper';
+import { getExceptionMessage, releaseObject } from './crProtocolHelper';
 import { Protocol } from './protocol';
 import * as js from '../javascript';
 import * as debugSupport from '../debug/debugSupport';
+import { RemoteObject, parseEvaluationResultValue } from '../remoteObject';
 
 export class CRExecutionContext implements js.ExecutionContextDelegate {
   _client: CRSession;
@@ -31,7 +32,7 @@ export class CRExecutionContext implements js.ExecutionContextDelegate {
     this._contextId = contextPayload.id;
   }
 
-  async rawEvaluate(expression: string): Promise<js.RemoteObject> {
+  async rawEvaluate(expression: string): Promise<RemoteObject> {
     const { exceptionDetails, result: remoteObject } = await this._client.send('Runtime.evaluate', {
       expression: debugSupport.ensureSourceUrl(expression),
       contextId: this._contextId,
@@ -51,29 +52,7 @@ export class CRExecutionContext implements js.ExecutionContextDelegate {
 
     if (typeof pageFunction !== 'function')
       throw new Error(`Expected to get |string| or |function| as the first argument, but got "${pageFunction}" instead.`);
-
-    const { functionText, values, handles, dispose } = await js.prepareFunctionCall<Protocol.Runtime.CallArgument>(pageFunction, context, args, (value: any) => {
-      if (typeof value === 'bigint') // eslint-disable-line valid-typeof
-        return { handle: { unserializableValue: `${value.toString()}n` } };
-      if (Object.is(value, -0))
-        return { handle: { unserializableValue: '-0' } };
-      if (Object.is(value, Infinity))
-        return { handle: { unserializableValue: 'Infinity' } };
-      if (Object.is(value, -Infinity))
-        return { handle: { unserializableValue: '-Infinity' } };
-      if (Object.is(value, NaN))
-        return { handle: { unserializableValue: 'NaN' } };
-      if (value && (value instanceof js.JSHandle)) {
-        const remoteObject = toRemoteObject(value);
-        if (remoteObject.unserializableValue)
-          return { handle: { unserializableValue: remoteObject.unserializableValue } };
-        if (!remoteObject.objectId)
-          return { handle: { value: remoteObject.value } };
-        return { handle: { objectId: remoteObject.objectId } };
-      }
-      return { value };
-    });
-
+    const { functionText, values, handles, dispose } = await js.prepareFunctionCall(pageFunction, context, args);
     return this._callOnUtilityScript(context,
         'callFunction', [
           { value: functionText },
@@ -87,7 +66,7 @@ export class CRExecutionContext implements js.ExecutionContextDelegate {
       const utilityScript = await context.utilityScript();
       const { exceptionDetails, result: remoteObject } = await this._client.send('Runtime.callFunctionOn', {
         functionDeclaration: `function (...args) { return this.${method}(...args) }` + debugSupport.generateSourceUrl(),
-        objectId: utilityScript._remoteObject.objectId,
+        objectId: utilityScript._objectId,
         arguments: [
           { value: returnByValue },
           ...args
@@ -98,14 +77,14 @@ export class CRExecutionContext implements js.ExecutionContextDelegate {
       }).catch(rewriteError);
       if (exceptionDetails)
         throw new Error('Evaluation failed: ' + getExceptionMessage(exceptionDetails));
-      return returnByValue ? valueFromRemoteObject(remoteObject) : context.createHandle(remoteObject);
+      return returnByValue ? parseEvaluationResultValue(remoteObject.value) : context.createHandle(remoteObject);
     } finally {
       dispose();
     }
   }
 
   async getProperties(handle: js.JSHandle): Promise<Map<string, js.JSHandle>> {
-    const objectId = toRemoteObject(handle).objectId;
+    const objectId = handle._objectId;
     if (!objectId)
       return new Map();
     const response = await this._client.send('Runtime.getProperties', {
@@ -114,43 +93,28 @@ export class CRExecutionContext implements js.ExecutionContextDelegate {
     });
     const result = new Map();
     for (const property of response.result) {
-      if (!property.enumerable)
+      if (!property.enumerable || !property.value)
         continue;
       result.set(property.name, handle._context.createHandle(property.value));
     }
     return result;
   }
 
   async releaseHandle(handle: js.JSHandle): Promise<void> {
-    await releaseObject(this._client, toRemoteObject(handle));
+    if (!handle._objectId)
+      return;
+    await releaseObject(this._client, handle._objectId);
   }
 
   async handleJSONValue<T>(handle: js.JSHandle<T>): Promise<T> {
-    const remoteObject = toRemoteObject(handle);
-    if (remoteObject.objectId) {
-      const response = await this._client.send('Runtime.callFunctionOn', {
-        functionDeclaration: 'function() { return this; }' + debugSupport.generateSourceUrl(),
-        objectId: remoteObject.objectId,
-        returnByValue: true,
-        awaitPromise: true,
-      });
-      return valueFromRemoteObject(response.result);
+    if (handle._objectId) {
+      return this._callOnUtilityScript(handle._context,
+          `jsonValue`, [
+            { objectId: handle._objectId },
+          ], true, () => {});
     }
-    return valueFromRemoteObject(remoteObject);
+    return handle._value;
   }
-
-  handleToString(handle: js.JSHandle, includeType: boolean): string {
-    const object = toRemoteObject(handle);
-    if (object.objectId) {
-      const type =  object.subtype || object.type;
-      return 'JSHandle@' + type;
-    }
-    return (includeType ? 'JSHandle:' : '') + valueFromRemoteObject(object);
-  }
-}
-
-function toRemoteObject(handle: js.JSHandle): Protocol.Runtime.RemoteObject {
-  return handle._remoteObject as Protocol.Runtime.RemoteObject;
 }
 
 function rewriteError(error: Error): Protocol.Runtime.evaluateReturnValue {

src/chromium/crPage.ts

@@ -665,7 +665,7 @@ class FrameSession {
   _onLogEntryAdded(event: Protocol.Log.entryAddedPayload) {
     const {level, text, args, source, url, lineNumber} = event.entry;
     if (args)
-      args.map(arg => releaseObject(this._client, arg));
+      args.map(arg => releaseObject(this._client, arg.objectId!));
     if (source !== 'worker')
       this._page.emit(Events.Page.Console, new ConsoleMessage(level, text, [], {url, lineNumber}));
   }
@@ -778,7 +778,7 @@ class FrameSession {
 
   async _getContentFrame(handle: dom.ElementHandle): Promise<frames.Frame | null> {
     const nodeInfo = await this._client.send('DOM.describeNode', {
-      objectId: handle._remoteObject.objectId
+      objectId: handle._objectId
     });
     if (!nodeInfo || typeof nodeInfo.node.frameId !== 'string')
       return null;
@@ -795,11 +795,10 @@ class FrameSession {
     });
     if (!documentElement)
       return null;
-    const remoteObject = documentElement._remoteObject;
-    if (!remoteObject.objectId)
+    if (!documentElement._objectId)
       return null;
     const nodeInfo = await this._client.send('DOM.describeNode', {
-      objectId: remoteObject.objectId
+      objectId: documentElement._objectId
     });
     const frameId = nodeInfo && typeof nodeInfo.node.frameId === 'string' ?
       nodeInfo.node.frameId : null;
@@ -809,7 +808,7 @@ class FrameSession {
 
   async _getBoundingBox(handle: dom.ElementHandle): Promise<types.Rect | null> {
     const result = await this._client.send('DOM.getBoxModel', {
-      objectId: handle._remoteObject.objectId
+      objectId: handle._objectId
     }).catch(logError(this._page));
     if (!result)
       return null;
@@ -823,7 +822,7 @@ class FrameSession {
 
   async _scrollRectIntoViewIfNeeded(handle: dom.ElementHandle, rect?: types.Rect): Promise<'success' | 'invisible'> {
     return await this._client.send('DOM.scrollIntoViewIfNeeded', {
-      objectId: handle._remoteObject.objectId,
+      objectId: handle._objectId,
       rect,
     }).then(() => 'success' as const).catch(e => {
       if (e instanceof Error && e.message.includes('Node does not have a layout object'))
@@ -839,7 +838,7 @@ class FrameSession {
 
   async _getContentQuads(handle: dom.ElementHandle): Promise<types.Quad[] | null> {
     const result = await this._client.send('DOM.getContentQuads', {
-      objectId: handle._remoteObject.objectId
+      objectId: handle._objectId
     }).catch(logError(this._page));
     if (!result)
       return null;
@@ -853,7 +852,7 @@ class FrameSession {
 
   async _adoptElementHandle<T extends Node>(handle: dom.ElementHandle<T>, to: dom.FrameExecutionContext): Promise<dom.ElementHandle<T>> {
     const nodeInfo = await this._client.send('DOM.describeNode', {
-      objectId: handle._remoteObject.objectId,
+      objectId: handle._objectId,
     });
     return this._adoptBackendNodeId(nodeInfo.node.backendNodeId, to) as Promise<dom.ElementHandle<T>>;
   }

src/chromium/crProtocolHelper.ts

@@ -15,7 +15,6 @@
  * limitations under the License.
  */
 
-import { assert } from '../helper';
 import { CRSession } from './crConnection';
 import { Protocol } from './protocol';
 import * as fs from 'fs';
@@ -35,31 +34,8 @@ export function getExceptionMessage(exceptionDetails: Protocol.Runtime.Exception
   return message;
 }
 
-export function valueFromRemoteObject(remoteObject: Protocol.Runtime.RemoteObject): any {
-  assert(!remoteObject.objectId, 'Cannot extract value when objectId is given');
-  if (remoteObject.unserializableValue) {
-    if (remoteObject.type === 'bigint' && typeof BigInt !== 'undefined')
-      return BigInt(remoteObject.unserializableValue.replace('n', ''));
-    switch (remoteObject.unserializableValue) {
-      case '-0':
-        return -0;
-      case 'NaN':
-        return NaN;
-      case 'Infinity':
-        return Infinity;
-      case '-Infinity':
-        return -Infinity;
-      default:
-        throw new Error('Unsupported unserializable value: ' + remoteObject.unserializableValue);
-    }
-  }
-  return remoteObject.value;
-}
-
-export async function releaseObject(client: CRSession, remoteObject: Protocol.Runtime.RemoteObject) {
-  if (!remoteObject.objectId)
-    return;
-  await client.send('Runtime.releaseObject', {objectId: remoteObject.objectId}).catch(error => {});
+export async function releaseObject(client: CRSession, objectId: string) {
+  await client.send('Runtime.releaseObject', { objectId }).catch(error => {});
 }
 
 export async function readProtocolStream(client: CRSession, handle: string, path: string | null): Promise<Buffer> {

src/console.ts

@@ -42,7 +42,7 @@ export class ConsoleMessage {
 
   text(): string {
     if (this._text === undefined)
-      this._text = this._args.map(arg => arg._context._delegate.handleToString(arg, false /* includeType */)).join(' ');
+      this._text = this._args.map(arg => arg._handleToString(false /* includeType */)).join(' ');
     return this._text;
   }
 

src/firefox/ffAccessibility.ts

@@ -21,7 +21,7 @@ import { Protocol } from './protocol';
 import * as dom from '../dom';
 
 export async function getAccessibilityTree(session: FFSession, needle?: dom.ElementHandle): Promise<{tree: accessibility.AXNode, needle: accessibility.AXNode | null}> {
-  const objectId = needle ? needle._remoteObject.objectId : undefined;
+  const objectId = needle ? needle._objectId : undefined;
   const { tree } = await session.send('Accessibility.getFullAXTree', { objectId });
   const axNode = new FFAXNode(tree);
   return {