[bindings] Create SymbolizedError from string RemoteObjects with details

We support parsing not only for RemoteObjects of subtype 'error' but
also RemoteObjects of type 'string'. This is because it is very
common to `console.log(e.stack)` and we want to source-map and
stringify that.

Moreover, for uncaught errors, we already have the exception details
so we can pass those in as well instead of re-fetching them from the
backend.

R=kimanh@chromium.org

Bug: 485140575
Change-Id: Ie001d20cba01026b0741ddcb621159361836d17e
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/7784557
Reviewed-by: Kim-Anh Tran <kimanh@chromium.org>
Commit-Queue: Simon Zünd <szuend@chromium.org>

Author: szuend

front_end/models/bindings/DebuggerWorkspaceBinding.ts

@@ -215,28 +215,41 @@ export class DebuggerWorkspaceBinding implements SDK.TargetManager.SDKModelObser
     return await stackTracePromise;
   }
 
-  async createSymbolizedError(remoteObject: SDK.RemoteObject.RemoteObject): Promise<SymbolizedError|null> {
-    if (remoteObject.subtype !== 'error') {
+  async createSymbolizedError(
+      remoteObject: SDK.RemoteObject.RemoteObject,
+      exceptionDetails?: Protocol.Runtime.ExceptionDetails): Promise<SymbolizedError|null> {
+    let errorStack = '';
+    let causeRemoteObject: SDK.RemoteObject.RemoteObject|undefined;
+    let fetchedExceptionDetails = exceptionDetails;
+
+    if (remoteObject.subtype === 'error') {
+      const remoteError = SDK.RemoteObject.RemoteError.objectAsError(remoteObject);
+      errorStack = remoteError.errorStack;
+
+      const [details, causeRemote] = await Promise.all([
+        exceptionDetails ? Promise.resolve(exceptionDetails) : remoteError.exceptionDetails(),
+        remoteError.cause(),
+      ]);
+      fetchedExceptionDetails = details;
+      causeRemoteObject = causeRemote;
+
+    } else if (remoteObject.type === 'string') {
+      errorStack = remoteObject.description || '';
+    } else {
       return null;
     }
 
-    const remoteError = SDK.RemoteObject.RemoteError.objectAsError(remoteObject);
-    const [exceptionDetails, causeRemoteObject] = await Promise.all([
-      remoteError.exceptionDetails(),
-      remoteError.cause(),
-    ]);
-
     const [stackTrace, cause] = await Promise.all([
       this.createStackTraceFromErrorStackLikeString(
-          remoteObject.runtimeModel().target(), remoteError.errorStack, exceptionDetails),
+          remoteObject.runtimeModel().target(), errorStack, fetchedExceptionDetails),
       causeRemoteObject ? this.createSymbolizedError(causeRemoteObject) : Promise.resolve(null),
     ]);
 
     if (!stackTrace) {
       return null;
     }
 
-    const message = StackTraceImpl.DetailedErrorStackParser.parseMessage(remoteError.errorStack);
+    const message = StackTraceImpl.DetailedErrorStackParser.parseMessage(errorStack);
     return new SymbolizedError(message, stackTrace, cause);
   }
 

front_end/models/bindings/SymbolizedError.test.ts

@@ -98,6 +98,70 @@ describe('SymbolizedError', () => {
     assert.isNull(result);
   });
 
+  it('can create a SymbolizedError from a string RemoteObject', async () => {
+    const target = universe.createTarget({});
+    const runtimeModel = target.model(SDK.RuntimeModel.RuntimeModel);
+    assert.exists(runtimeModel);
+
+    const stringRemoteObject = {
+      type: 'string',
+      description: 'Error: string error\n    at http://example.com/script.js:1:1',
+      runtimeModel: () => runtimeModel,
+    } as unknown as SDK.RemoteObject.RemoteObject;
+
+    const symbolizedError = await universe.debuggerWorkspaceBinding.createSymbolizedError(stringRemoteObject);
+
+    assert.exists(symbolizedError);
+    assert.strictEqual(symbolizedError.message, 'Error: string error');
+    assert.strictEqual(symbolizedError.stackTrace.syncFragment.frames[0].url, 'http://example.com/script.js');
+    assert.isNull(symbolizedError.cause);
+  });
+
+  it('returns null for a string RemoteObject if the stack trace cannot be parsed', async () => {
+    const target = universe.createTarget({});
+    const runtimeModel = target.model(SDK.RuntimeModel.RuntimeModel);
+    assert.exists(runtimeModel);
+
+    const stringRemoteObject = {
+      type: 'string',
+      description: 'Error: string error\n    at http://example.com/script.js:1:1\ninvalid line',
+      runtimeModel: () => runtimeModel,
+    } as unknown as SDK.RemoteObject.RemoteObject;
+
+    const result = await universe.debuggerWorkspaceBinding.createSymbolizedError(stringRemoteObject);
+    assert.isNull(result);
+  });
+
+  it('uses the provided exceptionDetails preferentially', async () => {
+    const target = universe.createTarget({});
+    const runtimeModel = target.model(SDK.RuntimeModel.RuntimeModel);
+    assert.exists(runtimeModel);
+
+    const errorRemoteObject = {
+      subtype: 'error',
+      description: 'Error: error\n    at http://example.com/script.js:1:1',
+      runtimeModel: () => runtimeModel,
+      objectId: '1' as Protocol.Runtime.RemoteObjectId,
+      getAllProperties: async () => ({properties: [], internalProperties: []}),
+    } as unknown as SDK.RemoteObject.RemoteObject;
+
+    const exceptionDetails = {
+      exceptionId: 1,
+      text: 'Uncaught',
+      lineNumber: 0,
+      columnNumber: 0,
+    } as Protocol.Runtime.ExceptionDetails;
+
+    const invokeGetExceptionDetailsSpy = sinon.spy(target.runtimeAgent(), 'invoke_getExceptionDetails');
+
+    const symbolizedError =
+        await universe.debuggerWorkspaceBinding.createSymbolizedError(errorRemoteObject, exceptionDetails);
+
+    assert.exists(symbolizedError);
+    assert.strictEqual(symbolizedError.message, 'Error: error');
+    sinon.assert.notCalled(invokeGetExceptionDetailsSpy);
+  });
+
   it('emits UPDATED when stackTrace or cause updates', async () => {
     const symbolizedError = await createSymbolizedErrorWithCause();
     assert.exists(symbolizedError);