1  /*
 2   * Copyright (C) 2016 Apple Inc. All Rights Reserved.
 3   *
 4   * Redistribution and use in source and binary forms, with or without
 5   * modification, are permitted provided that the following conditions
 6   * are met:
 7   * 1. Redistributions of source code must retain the above copyright
 8   *    notice, this list of conditions and the following disclaimer.
 9   * 2. Redistributions in binary form must reproduce the above copyright
10   *    notice, this list of conditions and the following disclaimer in the
11   *    documentation and/or other materials provided with the distribution.
12   *
13   * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14   * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16   * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17   * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18   * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19   * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20   * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21   * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22   * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24   */
25  
26  #include "config.h"
27  #include "ProxyConstructor.h"
28  
29  #include "JSCInlines.h"
30  #include "ObjectConstructor.h"
31  #include "ProxyObject.h"
32  #include "ProxyRevoke.h"
33  
34  namespace JSC {
35  
36  STATIC_ASSERT_IS_TRIVIALLY_DESTRUCTIBLE(ProxyConstructor);
37  
38  const ClassInfo ProxyConstructor::s_info = { "Proxy", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(ProxyConstructor) };
39  
40  ProxyConstructor* ProxyConstructor::create(VM& vm, Structure* structure)
41  {
42      ProxyConstructor* constructor = new (NotNull, allocateCell<ProxyConstructor>(vm.heap)) ProxyConstructor(vm, structure);
43      constructor->finishCreation(vm, "Proxy", structure->globalObject());
44      return constructor;
45  }
46  
47  static JSC_DECLARE_HOST_FUNCTION(callProxy);
48  static JSC_DECLARE_HOST_FUNCTION(constructProxyObject);
49  static JSC_DECLARE_HOST_FUNCTION(makeRevocableProxy);
50  
51  ProxyConstructor::ProxyConstructor(VM& vm, Structure* structure)
52      : Base(vm, structure, callProxy, constructProxyObject)
53  {
54  }
55  
56  JSC_DEFINE_HOST_FUNCTION(makeRevocableProxy, (JSGlobalObject* globalObject, CallFrame* callFrame))
57  {
58      VM& vm = globalObject->vm();
59      auto scope = DECLARE_THROW_SCOPE(vm);
60      if (callFrame->argumentCount() < 2)
61          return throwVMTypeError(globalObject, scope, "Proxy.revocable needs to be called with two arguments: the target and the handler"_s);
62  
63      JSValue target = callFrame->argument(0);
64      JSValue handler = callFrame->argument(1);
65      ProxyObject* proxy = ProxyObject::create(globalObject, target, handler);
66      RETURN_IF_EXCEPTION(scope, encodedJSValue());
67      ProxyRevoke* revoke = ProxyRevoke::create(vm, globalObject->proxyRevokeStructure(), proxy);
68      scope.assertNoException();
69  
70      JSObject* result = constructEmptyObject(globalObject);
71      result->putDirect(vm, makeIdentifier(vm, "proxy"), proxy, static_cast<unsigned>(PropertyAttribute::None));
72      result->putDirect(vm, makeIdentifier(vm, "revoke"), revoke, static_cast<unsigned>(PropertyAttribute::None));
73  
74      return JSValue::encode(result);
75  }
76  
77  void ProxyConstructor::finishCreation(VM& vm, const char* name, JSGlobalObject* globalObject)
78  {
79      Base::finishCreation(vm, 2, name, PropertyAdditionMode::WithStructureTransition);
80      putDirect(vm, makeIdentifier(vm, "revocable"), JSFunction::create(vm, globalObject, 2, "revocable"_s, makeRevocableProxy));
81  }
82  
83  JSC_DEFINE_HOST_FUNCTION(constructProxyObject, (JSGlobalObject* globalObject, CallFrame* callFrame))
84  {
85      JSValue target = callFrame->argument(0);
86      JSValue handler = callFrame->argument(1);
87      return JSValue::encode(ProxyObject::create(globalObject, target, handler));
88  }
89  
90  JSC_DEFINE_HOST_FUNCTION(callProxy, (JSGlobalObject* globalObject, CallFrame*))
91  {
92      auto scope = DECLARE_THROW_SCOPE(globalObject->vm());
93      return JSValue::encode(throwConstructorCannotBeCalledAsFunctionTypeError(globalObject, scope, "Proxy"));
94  }
95  
96  } // namespace JSC