Wrap provided objectClient function calls in try/catch blocks.

Since we don't know what the ObjectClient we get looks like, it might happens that it doesn't have
the method we try to call (e.g. connecting to an older server, you will miss the enumSymbols function).
Wrapping everything in try/catch blocks mitigate the risk of crashing the ObjectInspector (in the beforementioned
case, everything will be fine except we wouldn't get symbol properties, which seems acceptable).

Author: nchevobbe

packages/devtools-reps/src/object-inspector/tests/component/create-object-client.js

@@ -81,4 +81,16 @@ describe("createObjectClient", () => {
     }));
     expect(createObjectClient.mock.calls[0][0]).toBe(grip);
   });
+
+  it("does not fail if the ObjectClient does not have the expected functions", () => {
+    const stub = gripRepStubs.get("testMoreThanMaxProps");
+    const root = createNode(null, "root", "/", {value: stub});
+
+    const createObjectClient = x => ({});
+    mount(ObjectInspector({
+      autoExpandDepth: 1,
+      roots: [root],
+      createObjectClient,
+    }));
+  });
 });

packages/devtools-reps/src/object-inspector/utils/client.js

@@ -13,47 +13,70 @@ async function enumIndexedProperties(
   objectClient: ObjectClient,
   start: ?number,
   end: ?number
-) : Promise<{ownProperties: Object}> {
-  const {iterator} = await objectClient
-    .enumProperties({ignoreNonIndexedProperties: true});
-  const response = await iteratorSlice(iterator, start, end);
-  return response;
+) : Promise<{ownProperties?: Object}> {
+  try {
+    const {iterator} = await objectClient
+      .enumProperties({ignoreNonIndexedProperties: true});
+    const response = await iteratorSlice(iterator, start, end);
+    return response;
+  } catch (e) {
+    console.warn("Error in enumIndexedProperties", e);
+    return {};
+  }
 }
 
 async function enumNonIndexedProperties(
   objectClient: ObjectClient,
   start: ?number,
   end: ?number
-) : Promise<{ownProperties: Object}> {
-  const {iterator} = await objectClient.enumProperties({ignoreIndexedProperties: true});
-
-  const response = await iteratorSlice(iterator, start, end);
-  return response;
+) : Promise<{ownProperties?: Object}> {
+  try {
+    const {iterator} = await objectClient.enumProperties({ignoreIndexedProperties: true});
+    const response = await iteratorSlice(iterator, start, end);
+    return response;
+  } catch (e) {
+    console.warn("Error in enumNonIndexedProperties", e);
+    return {};
+  }
 }
 
 async function enumEntries(
   objectClient: ObjectClient,
   start: ?number,
   end: ?number
-) : Promise<{ownProperties: Object}> {
-  const {iterator} = await objectClient.enumEntries();
-  const response = await iteratorSlice(iterator, start, end);
-  return response;
+) : Promise<{ownProperties?: Object}> {
+  try {
+    const {iterator} = await objectClient.enumEntries();
+    const response = await iteratorSlice(iterator, start, end);
+    return response;
+  } catch (e) {
+    console.warn("Error in enumEntries", e);
+    return {};
+  }
 }
 
 async function enumSymbols(
   objectClient: ObjectClient,
   start: ?number,
   end: ?number
-) : Promise<{ownSymbols: Array<Object>}> {
-  const {iterator} = await objectClient.enumSymbols();
-  const response = await iteratorSlice(iterator, start, end);
-  return response;
+) : Promise<{ownSymbols?: Array<Object>}> {
+  try {
+    const {iterator} = await objectClient.enumSymbols();
+    const response = await iteratorSlice(iterator, start, end);
+    return response;
+  } catch (e) {
+    console.warn("Error in enumSymbols", e);
+    return {};
+  }
 }
 
-function getPrototype(
+async function getPrototype(
   objectClient: ObjectClient
-) : ?Promise<{prototype: Object}> {
+) : ?Promise<{prototype?: Object}> {
+  if (typeof objectClient.getPrototype !== "function") {
+    console.warn("objectClient.getPrototype is not a function");
+    return Promise.resolve({});
+  }
   return objectClient.getPrototype();
 }