[runtime] support new Proxy() instead of Proxy.create and install getPrototypeOf trap

test/mjsunit/harmony/proxies-example-membrane.js

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 137 matching lines @@
     function wrapCall2(fun, that, args) {
       if (!enabled) { throw new Error("disabled"); }
       try {
         return wrap(fun.apply(that, Array.prototype.map.call(args, wrap)));
       } catch (e) {
         throw wrap(e);
       }
     }
 
     var baseHandler = createHandler(obj);
-    var handler = Proxy.create(Object.freeze({
+    var handler = new Proxy({}, Object.freeze({
       get: function(receiver, name) {
         return function() {
           var arg = (name === "get" || name == "set") ? arguments[1] : "";
           print("handler enter", name, arg);
           var x = wrapCall(baseHandler[name], baseHandler, arguments);
           print("handler exit", name, arg, "returning", str(x));
           return x;
         }
       }
     }));
@@ skipping 12 matching lines @@
         try {
           function forward(args) { return obj.apply(this, args) }
           return wrap(new forward(Array.prototype.map.call(arguments, wrap)));
         } catch (e) {
           throw wrap(e);
         }
       }
       return Proxy.createFunction(handler, callTrap, constructTrap);
     } else {
       var prototype = wrap(Object.getPrototypeOf(obj));
-      return Proxy.create(handler, prototype);
+      return new Proxy(prototype, handler);
     }
   }
 
   var gate = Object.freeze({
     enable: function() { enabled = true; },
     disable: function() { enabled = false; }
   });
 
   return Object.freeze({
     wrapper: wrap(target),
@@ skipping 102 matching lines @@
   function asDry2(wet) {
     if (wet !== Object(wet)) {
       // primitives provide only irrevocable knowledge, so don't
       // bother wrapping it.
       return wet;
     }
     var dryResult = wet2dry.get(wet);
     if (dryResult) { return dryResult; }
 
     var wetHandler = createHandler(wet);
-    var dryRevokeHandler = Proxy.create(Object.freeze({
+    var dryRevokeHandler = new Proxy({}, Object.freeze({
       get: function(receiver, name) {
         return function() {
           var arg = (name === "get" || name == "set") ? arguments[1] : "";
           print("dry handler enter", name, arg);
           var optWetHandler = dry2wet.get(dryRevokeHandler);
           try {
             var x = asDry(optWetHandler[name].apply(
               optWetHandler, Array.prototype.map.call(arguments, asWet)));
             print("dry handler exit", name, arg, "returning", str(x));
             return x;
@@ skipping 16 matching lines @@
         return x;
       }
       function constructTrap() {
         function forward(args) { return wet.apply(this, args) }
         return asDry(new forward(Array.prototype.map.call(arguments, asWet)));
       }
       dryResult =
         Proxy.createFunction(dryRevokeHandler, callTrap, constructTrap);
     } else {
       dryResult =
-        Proxy.create(dryRevokeHandler, asDry(Object.getPrototypeOf(wet)));
+        new Proxy(asDry(Object.getPrototypeOf(wet)), dryRevokeHandler);
     }
     wet2dry.set(wet, dryResult);
     dry2wet.set(dryResult, wet);
     return dryResult;
   }
 
   function asWet(obj) {
     registerObject(obj)
     print("asWet enter", str(obj))
     try {
       var x = asWet2(obj)
       registerObject(x, "wet")
       print("asWet exit", str(obj), "as", str(x))
       return x
     } catch(e) {
       print("asWet exception", str(e))
       throw e
     }
   }
   function asWet2(dry) {
     if (dry !== Object(dry)) {
       // primitives provide only irrevocable knowledge, so don't
       // bother wrapping it.
       return dry;
     }
     var wetResult = dry2wet.get(dry);
     if (wetResult) { return wetResult; }
 
     var dryHandler = createHandler(dry);
-    var wetRevokeHandler = Proxy.create(Object.freeze({
+    var wetRevokeHandler = new Proxy({}, Object.freeze({
       get: function(receiver, name) {
         return function() {
           var arg = (name === "get" || name == "set") ? arguments[1] : "";
           print("wet handler enter", name, arg);
           var optDryHandler = wet2dry.get(wetRevokeHandler);
           try {
             var x = asWet(optDryHandler[name].apply(
               optDryHandler, Array.prototype.map.call(arguments, asDry)));
             print("wet handler exit", name, arg, "returning", str(x));
             return x;
@@ skipping 16 matching lines @@
         return x;
       }
       function constructTrap() {
         function forward(args) { return dry.apply(this, args) }
         return asWet(new forward(Array.prototype.map.call(arguments, asDry)));
       }
       wetResult =
         Proxy.createFunction(wetRevokeHandler, callTrap, constructTrap);
     } else {
       wetResult =
-        Proxy.create(wetRevokeHandler, asWet(Object.getPrototypeOf(dry)));
+        new Proxy(asWet(Object.getPrototypeOf(dry)), wetRevokeHandler);
     }
     dry2wet.set(dry, wetResult);
     wet2dry.set(wetResult, dry);
     return wetResult;
   }
 
   var gate = Object.freeze({
     revoke: function() {
       dry2wet = wet2dry = Object.freeze({
         get: function(key) { throw new Error("revoked"); },
@@ skipping 74 matching lines @@
 assertThrows(function() { w[1] }, Error)
 assertThrows(function() { w.c }, Error)
 assertThrows(function() { wb.bb }, Error)
 assertEquals(3, wr.a)
 assertThrows(function() { wf(4) }, Error)
 assertEquals(6, wfx.a)
 assertEquals(7, wgx.aa)
 assertThrows(function() { wh4.q }, Error)
 assertThrows(function() { ws5.x }, Error)
 assertThrows(function() { ws5x.y }, Error)