Refactor unreliable Proxy tests

While working on crrev.com/c/1141045 I caused 3 assertThrows() tests
under the 'Deeply nested target' tests to fail. The tests for
defineProperty, isExtensible, and preventExtensions began to fail under
a couple build configurations because my change modified the stack check
code such that it no longer inhibited tail call optimization. Under some
build configurations the methods responsible for causing a stack oveflow
for those 3 methods were tail call optimized and the tests no longer
threw an exception.

Other built-in implementations of proxy handler methods could also fail
in the future due to refactors moving variables off the stack. Change
the test to ensure v8 doesn't crash but don't rely on stack overflow
exceptions being thrown for the 'deeply nested target' test.

BUG=chromium:864705

Change-Id: Iefeaa1d5402986c1831d0f259f83025452756387
Reviewed-on: https://chromium-review.googlesource.com/1159356Reviewed-by: Georg Neis <neis@chromium.org>
Commit-Queue: Georg Neis <neis@chromium.org>
Cr-Commit-Position: refs/heads/master@{#54878}

test/mjsunit/regress/regress-7716.js

@@ -10,22 +10,22 @@ for (let i = 0; i < 100000; i++) {
   proxy = new Proxy(proxy, {});
 }
 
-// We get a stack overflow in all cases except for Reflect.apply, which here
-// happens to run in constant space: Call jumps into CallProxy and CallProxy
-// jumps into the next Call.
-assertDoesNotThrow(() => Reflect.apply(proxy, {}, []));
-assertThrows(() => Reflect.construct(proxy, []), RangeError);
-assertThrows(() => Reflect.defineProperty(proxy, "x", {}), RangeError);
-assertThrows(() => Reflect.deleteProperty(proxy, "x"), RangeError);
-assertThrows(() => Reflect.get(proxy, "x"), RangeError);
-assertThrows(() => Reflect.getOwnPropertyDescriptor(proxy, "x"), RangeError);
-assertThrows(() => Reflect.getPrototypeOf(proxy), RangeError);
-assertThrows(() => Reflect.has(proxy, "x"), RangeError);
-assertThrows(() => Reflect.isExtensible(proxy), RangeError);
-assertThrows(() => Reflect.ownKeys(proxy), RangeError);
-assertThrows(() => Reflect.preventExtensions(proxy), RangeError);
-assertThrows(() => Reflect.setPrototypeOf(proxy, {}), RangeError);
-assertThrows(() => Reflect.set(proxy, "x", {}), RangeError);
+// Ensure these nested calls don't segfault. They may not all throw exceptions
+// depending on whether the compiler is able to perform tail call optimization
+// on the affected routines.
+try { Reflect.apply(proxy, {}, []) } catch(_) {}
+try { Reflect.construct(proxy, []) } catch(_) {}
+try { Reflect.defineProperty(proxy, "x", {}) } catch(_) {}
+try { Reflect.deleteProperty(proxy, "x") } catch(_) {}
+try { Reflect.get(proxy, "x") } catch(_) {}
+try { Reflect.getOwnPropertyDescriptor(proxy, "x") } catch(_) {}
+try { Reflect.getPrototypeOf(proxy) } catch(_) {}
+try { Reflect.has(proxy, "x") } catch(_) {}
+try { Reflect.isExtensible(proxy) } catch(_) {}
+try { Reflect.ownKeys(proxy) } catch(_) {}
+try { Reflect.preventExtensions(proxy) } catch(_) {}
+try { Reflect.setPrototypeOf(proxy, {}) } catch(_) {}
+try { Reflect.set(proxy, "x", {}) } catch(_) {}
 
 
 // Recursive handler.