tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

OpaqueCrossCompartmentWrapper.cpp (5693B)

      1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
      2 * vim: set ts=8 sts=2 et sw=2 tw=80:
      3 * This Source Code Form is subject to the terms of the Mozilla Public
      4 * License, v. 2.0. If a copy of the MPL was not distributed with this
      5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
      6 
      7 #include "js/friend/ErrorMessages.h"  // js::GetErrorMessage, JSMSG_*
      8 #include "js/Wrapper.h"
      9 
     10 #include "vm/JSObject-inl.h"
     11 
     12 using namespace js;
     13 
     14 bool OpaqueCrossCompartmentWrapper::getOwnPropertyDescriptor(
     15    JSContext* cx, HandleObject wrapper, HandleId id,
     16    MutableHandle<mozilla::Maybe<PropertyDescriptor>> desc) const {
     17  desc.reset();
     18  return true;
     19 }
     20 
     21 bool OpaqueCrossCompartmentWrapper::defineProperty(
     22    JSContext* cx, HandleObject wrapper, HandleId id,
     23    Handle<PropertyDescriptor> desc, ObjectOpResult& result) const {
     24  return result.succeed();
     25 }
     26 
     27 bool OpaqueCrossCompartmentWrapper::ownPropertyKeys(
     28    JSContext* cx, HandleObject wrapper, MutableHandleIdVector props) const {
     29  return true;
     30 }
     31 
     32 bool OpaqueCrossCompartmentWrapper::delete_(JSContext* cx, HandleObject wrapper,
     33                                            HandleId id,
     34                                            ObjectOpResult& result) const {
     35  return result.succeed();
     36 }
     37 
     38 bool OpaqueCrossCompartmentWrapper::enumerate(
     39    JSContext* cx, HandleObject proxy, MutableHandleIdVector props) const {
     40  return BaseProxyHandler::enumerate(cx, proxy, props);
     41 }
     42 
     43 bool OpaqueCrossCompartmentWrapper::getPrototype(
     44    JSContext* cx, HandleObject proxy, MutableHandleObject protop) const {
     45  protop.set(nullptr);
     46  return true;
     47 }
     48 
     49 bool OpaqueCrossCompartmentWrapper::setPrototype(JSContext* cx,
     50                                                 HandleObject proxy,
     51                                                 HandleObject proto,
     52                                                 ObjectOpResult& result) const {
     53  return result.succeed();
     54 }
     55 
     56 bool OpaqueCrossCompartmentWrapper::getPrototypeIfOrdinary(
     57    JSContext* cx, HandleObject proxy, bool* isOrdinary,
     58    MutableHandleObject protop) const {
     59  *isOrdinary = false;
     60  return true;
     61 }
     62 
     63 bool OpaqueCrossCompartmentWrapper::setImmutablePrototype(
     64    JSContext* cx, HandleObject proxy, bool* succeeded) const {
     65  *succeeded = false;
     66  return true;
     67 }
     68 
     69 bool OpaqueCrossCompartmentWrapper::preventExtensions(
     70    JSContext* cx, HandleObject wrapper, ObjectOpResult& result) const {
     71  return result.failCantPreventExtensions();
     72 }
     73 
     74 bool OpaqueCrossCompartmentWrapper::isExtensible(JSContext* cx,
     75                                                 HandleObject wrapper,
     76                                                 bool* extensible) const {
     77  *extensible = true;
     78  return true;
     79 }
     80 
     81 bool OpaqueCrossCompartmentWrapper::has(JSContext* cx, HandleObject wrapper,
     82                                        HandleId id, bool* bp) const {
     83  return BaseProxyHandler::has(cx, wrapper, id, bp);
     84 }
     85 
     86 bool OpaqueCrossCompartmentWrapper::get(JSContext* cx, HandleObject wrapper,
     87                                        HandleValue receiver, HandleId id,
     88                                        MutableHandleValue vp) const {
     89  return BaseProxyHandler::get(cx, wrapper, receiver, id, vp);
     90 }
     91 
     92 bool OpaqueCrossCompartmentWrapper::set(JSContext* cx, HandleObject wrapper,
     93                                        HandleId id, HandleValue v,
     94                                        HandleValue receiver,
     95                                        ObjectOpResult& result) const {
     96  return BaseProxyHandler::set(cx, wrapper, id, v, receiver, result);
     97 }
     98 
     99 bool OpaqueCrossCompartmentWrapper::call(JSContext* cx, HandleObject wrapper,
    100                                         const CallArgs& args) const {
    101  RootedValue v(cx, ObjectValue(*wrapper));
    102  ReportIsNotFunction(cx, v);
    103  return false;
    104 }
    105 
    106 bool OpaqueCrossCompartmentWrapper::construct(JSContext* cx,
    107                                              HandleObject wrapper,
    108                                              const CallArgs& args) const {
    109  RootedValue v(cx, ObjectValue(*wrapper));
    110  ReportIsNotFunction(cx, v);
    111  return false;
    112 }
    113 
    114 bool OpaqueCrossCompartmentWrapper::hasOwn(JSContext* cx, HandleObject wrapper,
    115                                           HandleId id, bool* bp) const {
    116  return BaseProxyHandler::hasOwn(cx, wrapper, id, bp);
    117 }
    118 
    119 bool OpaqueCrossCompartmentWrapper::getOwnEnumerablePropertyKeys(
    120    JSContext* cx, HandleObject wrapper, MutableHandleIdVector props) const {
    121  return BaseProxyHandler::getOwnEnumerablePropertyKeys(cx, wrapper, props);
    122 }
    123 
    124 bool OpaqueCrossCompartmentWrapper::getBuiltinClass(JSContext* cx,
    125                                                    HandleObject wrapper,
    126                                                    ESClass* cls) const {
    127  *cls = ESClass::Other;
    128  return true;
    129 }
    130 
    131 bool OpaqueCrossCompartmentWrapper::isArray(JSContext* cx, HandleObject obj,
    132                                            JS::IsArrayAnswer* answer) const {
    133  *answer = JS::IsArrayAnswer::NotArray;
    134  return true;
    135 }
    136 
    137 const char* OpaqueCrossCompartmentWrapper::className(JSContext* cx,
    138                                                     HandleObject proxy) const {
    139  return "Opaque";
    140 }
    141 
    142 JSString* OpaqueCrossCompartmentWrapper::fun_toString(JSContext* cx,
    143                                                      HandleObject proxy,
    144                                                      bool isToSource) const {
    145  JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
    146                            JSMSG_INCOMPATIBLE_PROTO, "Function", "toString",
    147                            "object");
    148  return nullptr;
    149 }
    150 
    151 const OpaqueCrossCompartmentWrapper OpaqueCrossCompartmentWrapper::singleton;