dom/bindings/DOMJSProxyHandler.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  * vim: set ts=2 sw=2 et tw=99 ft=cpp: */
   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 file,
   5  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "mozilla/dom/DOMJSProxyHandler.h"
   8 #include "xpcpublic.h"
   9 #include "xpcprivate.h"
  10 #include "XPCWrapper.h"
  11 #include "WrapperFactory.h"
  12 #include "nsDOMClassInfo.h"
  13 #include "nsWrapperCacheInlines.h"
  14 #include "mozilla/dom/BindingUtils.h"
  15
  16 #include "jsapi.h"
  17
  18 using namespace JS;
  19
  20 namespace mozilla {
  21 namespace dom {
  22
  23 jsid s_length_id = JSID_VOID;
  24
  25 bool
  26 DefineStaticJSVals(JSContext* cx)
  27 {
  28   return InternJSString(cx, s_length_id, "length");
  29 }
  30
  31 const char DOMProxyHandler::family = 0;
  32
  33 js::DOMProxyShadowsResult
  34 DOMProxyShadows(JSContext* cx, JS::Handle<JSObject*> proxy, JS::Handle<jsid> id)
  35 {
  36   JS::Value v = js::GetProxyExtra(proxy, JSPROXYSLOT_EXPANDO);
  37   if (v.isObject()) {
  38     bool hasOwn;
  39     Rooted<JSObject*> object(cx, &v.toObject());
  40     if (!JS_AlreadyHasOwnPropertyById(cx, object, id, &hasOwn))
  41       return js::ShadowCheckFailed;
  42
  43     return hasOwn ? js::Shadows : js::DoesntShadow;
  44   }
  45
  46   if (v.isUndefined()) {
  47     return js::DoesntShadow;
  48   }
  49
  50   bool hasOwn;
  51   if (!GetProxyHandler(proxy)->hasOwn(cx, proxy, id, &hasOwn))
  52     return js::ShadowCheckFailed;
  53
  54   return hasOwn ? js::Shadows : js::DoesntShadowUnique;
  55 }
  56
  57 // Store the information for the specialized ICs.
  58 struct SetDOMProxyInformation
  59 {
  60   SetDOMProxyInformation() {
  61     js::SetDOMProxyInformation((const void*) &DOMProxyHandler::family,
  62                                JSPROXYSLOT_EXPANDO, DOMProxyShadows);
  63   }
  64 };
  65
  66 SetDOMProxyInformation gSetDOMProxyInformation;
  67
  68 // static
  69 JSObject*
  70 DOMProxyHandler::GetAndClearExpandoObject(JSObject* obj)
  71 {
  72   MOZ_ASSERT(IsDOMProxy(obj), "expected a DOM proxy object");
  73   JS::Value v = js::GetProxyExtra(obj, JSPROXYSLOT_EXPANDO);
  74   if (v.isUndefined()) {
  75     return nullptr;
  76   }
  77
  78   if (v.isObject()) {
  79     js::SetProxyExtra(obj, JSPROXYSLOT_EXPANDO, UndefinedValue());
  80     xpc::ObjectScope(obj)->RemoveDOMExpandoObject(obj);
  81   } else {
  82     js::ExpandoAndGeneration* expandoAndGeneration =
  83       static_cast<js::ExpandoAndGeneration*>(v.toPrivate());
  84     v = expandoAndGeneration->expando;
  85     if (v.isUndefined()) {
  86       return nullptr;
  87     }
  88     expandoAndGeneration->expando = UndefinedValue();
  89   }
  90
  91
  92   return &v.toObject();
  93 }
  94
  95 // static
  96 JSObject*
  97 DOMProxyHandler::EnsureExpandoObject(JSContext* cx, JS::Handle<JSObject*> obj)
  98 {
  99   NS_ASSERTION(IsDOMProxy(obj), "expected a DOM proxy object");
 100   JS::Value v = js::GetProxyExtra(obj, JSPROXYSLOT_EXPANDO);
 101   if (v.isObject()) {
 102     return &v.toObject();
 103   }
 104
 105   js::ExpandoAndGeneration* expandoAndGeneration;
 106   if (!v.isUndefined()) {
 107     expandoAndGeneration = static_cast<js::ExpandoAndGeneration*>(v.toPrivate());
 108     if (expandoAndGeneration->expando.isObject()) {
 109       return &expandoAndGeneration->expando.toObject();
 110     }
 111   } else {
 112     expandoAndGeneration = nullptr;
 113   }
 114
 115   JS::Rooted<JSObject*> parent(cx, js::GetObjectParent(obj));
 116   JS::Rooted<JSObject*> expando(cx,
 117     JS_NewObjectWithGivenProto(cx, nullptr, JS::NullPtr(), parent));
 118   if (!expando) {
 119     return nullptr;
 120   }
 121
 122   nsISupports* native = UnwrapDOMObject<nsISupports>(obj);
 123   nsWrapperCache* cache;
 124   CallQueryInterface(native, &cache);
 125   if (expandoAndGeneration) {
 126     cache->PreserveWrapper(native);
 127     expandoAndGeneration->expando.setObject(*expando);
 128
 129     return expando;
 130   }
 131
 132   if (!xpc::ObjectScope(obj)->RegisterDOMExpandoObject(obj)) {
 133     return nullptr;
 134   }
 135
 136   cache->SetPreservingWrapper(true);
 137   js::SetProxyExtra(obj, JSPROXYSLOT_EXPANDO, ObjectValue(*expando));
 138
 139   return expando;
 140 }
 141
 142 bool
 143 DOMProxyHandler::preventExtensions(JSContext *cx, JS::Handle<JSObject*> proxy,
 144                                    bool *succeeded) const
 145 {
 146   // always extensible per WebIDL
 147   *succeeded = false;
 148   return true;
 149 }
 150
 151 bool
 152 DOMProxyHandler::isExtensible(JSContext *cx, JS::Handle<JSObject*> proxy, bool *extensible) const
 153 {
 154   *extensible = true;
 155   return true;
 156 }
 157
 158 bool
 159 BaseDOMProxyHandler::getPropertyDescriptor(JSContext* cx,
 160                                            JS::Handle<JSObject*> proxy,
 161                                            JS::Handle<jsid> id,
 162                                            MutableHandle<JSPropertyDescriptor> desc) const
 163 {
 164   if (!getOwnPropertyDescriptor(cx, proxy, id, desc)) {
 165     return false;
 166   }
 167   if (desc.object()) {
 168     return true;
 169   }
 170
 171   JS::Rooted<JSObject*> proto(cx);
 172   if (!js::GetObjectProto(cx, proxy, &proto)) {
 173     return false;
 174   }
 175   if (!proto) {
 176     desc.object().set(nullptr);
 177     return true;
 178   }
 179
 180   return JS_GetPropertyDescriptorById(cx, proto, id, desc);
 181 }
 182
 183 bool
 184 BaseDOMProxyHandler::getOwnPropertyDescriptor(JSContext* cx,
 185                                               JS::Handle<JSObject*> proxy,
 186                                               JS::Handle<jsid> id,
 187                                               MutableHandle<JSPropertyDescriptor> desc) const
 188 {
 189   return getOwnPropDescriptor(cx, proxy, id, /* ignoreNamedProps = */ false,
 190                               desc);
 191 }
 192
 193 bool
 194 DOMProxyHandler::defineProperty(JSContext* cx, JS::Handle<JSObject*> proxy, JS::Handle<jsid> id,
 195                                 MutableHandle<JSPropertyDescriptor> desc, bool* defined) const
 196 {
 197   if (desc.hasGetterObject() && desc.setter() == JS_StrictPropertyStub) {
 198     return JS_ReportErrorFlagsAndNumber(cx,
 199                                         JSREPORT_WARNING | JSREPORT_STRICT |
 200                                         JSREPORT_STRICT_MODE_ERROR,
 201                                         js_GetErrorMessage, nullptr,
 202                                         JSMSG_GETTER_ONLY);
 203   }
 204
 205   if (xpc::WrapperFactory::IsXrayWrapper(proxy)) {
 206     return true;
 207   }
 208
 209   JSObject* expando = EnsureExpandoObject(cx, proxy);
 210   if (!expando) {
 211     return false;
 212   }
 213
 214   bool dummy;
 215   return js_DefineOwnProperty(cx, expando, id, desc, &dummy);
 216 }
 217
 218 bool
 219 DOMProxyHandler::set(JSContext *cx, Handle<JSObject*> proxy, Handle<JSObject*> receiver,
 220                      Handle<jsid> id, bool strict, MutableHandle<JS::Value> vp) const
 221 {
 222   MOZ_ASSERT(!xpc::WrapperFactory::IsXrayWrapper(proxy),
 223              "Should not have a XrayWrapper here");
 224   bool done;
 225   if (!setCustom(cx, proxy, id, vp, &done)) {
 226     return false;
 227   }
 228   if (done) {
 229     return true;
 230   }
 231
 232   // Make sure to ignore our named properties when checking for own
 233   // property descriptors for a set.
 234   JS::Rooted<JSPropertyDescriptor> desc(cx);
 235   if (!getOwnPropDescriptor(cx, proxy, id, /* ignoreNamedProps = */ true,
 236                             &desc)) {
 237     return false;
 238   }
 239   bool descIsOwn = desc.object() != nullptr;
 240   if (!desc.object()) {
 241     // Don't just use getPropertyDescriptor, unlike BaseProxyHandler::set,
 242     // because that would call getOwnPropertyDescriptor on ourselves.  Instead,
 243     // directly delegate to the proto, if any.
 244     JS::Rooted<JSObject*> proto(cx);
 245     if (!js::GetObjectProto(cx, proxy, &proto)) {
 246       return false;
 247     }
 248     if (proto && !JS_GetPropertyDescriptorById(cx, proto, id, &desc)) {
 249       return false;
 250     }
 251   }
 252
 253   return js::SetPropertyIgnoringNamedGetter(cx, this, proxy, receiver, id,
 254                                             &desc, descIsOwn, strict, vp);
 255 }
 256
 257 bool
 258 DOMProxyHandler::delete_(JSContext* cx, JS::Handle<JSObject*> proxy,
 259                          JS::Handle<jsid> id, bool* bp) const
 260 {
 261   JS::Rooted<JSObject*> expando(cx);
 262   if (!xpc::WrapperFactory::IsXrayWrapper(proxy) && (expando = GetExpandoObject(proxy))) {
 263     return JS_DeletePropertyById2(cx, expando, id, bp);
 264   }
 265
 266   *bp = true;
 267   return true;
 268 }
 269
 270 bool
 271 BaseDOMProxyHandler::watch(JSContext* cx, JS::Handle<JSObject*> proxy, JS::Handle<jsid> id,
 272                            JS::Handle<JSObject*> callable) const
 273 {
 274   return js::WatchGuts(cx, proxy, id, callable);
 275 }
 276
 277 bool
 278 BaseDOMProxyHandler::unwatch(JSContext* cx, JS::Handle<JSObject*> proxy, JS::Handle<jsid> id) const
 279 {
 280   return js::UnwatchGuts(cx, proxy, id);
 281 }
 282
 283 bool
 284 BaseDOMProxyHandler::ownPropertyKeys(JSContext* cx,
 285                                      JS::Handle<JSObject*> proxy,
 286                                      JS::AutoIdVector& props) const
 287 {
 288   return ownPropNames(cx, proxy, JSITER_OWNONLY | JSITER_HIDDEN | JSITER_SYMBOLS, props);
 289 }
 290
 291 bool
 292 BaseDOMProxyHandler::getOwnEnumerablePropertyKeys(JSContext* cx,
 293                                                   JS::Handle<JSObject*> proxy,
 294                                                   JS::AutoIdVector& props) const
 295 {
 296   return ownPropNames(cx, proxy, JSITER_OWNONLY, props);
 297 }
 298
 299 bool
 300 BaseDOMProxyHandler::enumerate(JSContext *cx, JS::Handle<JSObject*> proxy,
 301                                JS::MutableHandle<JSObject*> objp) const
 302 {
 303   return BaseProxyHandler::enumerate(cx, proxy, objp);
 304 }
 305
 306 bool
 307 DOMProxyHandler::has(JSContext* cx, JS::Handle<JSObject*> proxy, JS::Handle<jsid> id, bool* bp) const
 308 {
 309   if (!hasOwn(cx, proxy, id, bp)) {
 310     return false;
 311   }
 312
 313   if (*bp) {
 314     // We have the property ourselves; no need to worry about our prototype
 315     // chain.
 316     return true;
 317   }
 318
 319   // OK, now we have to look at the proto
 320   JS::Rooted<JSObject*> proto(cx);
 321   if (!js::GetObjectProto(cx, proxy, &proto)) {
 322     return false;
 323   }
 324   if (!proto) {
 325     return true;
 326   }
 327   bool protoHasProp;
 328   bool ok = JS_HasPropertyById(cx, proto, id, &protoHasProp);
 329   if (ok) {
 330     *bp = protoHasProp;
 331   }
 332   return ok;
 333 }
 334
 335 int32_t
 336 IdToInt32(JSContext* cx, JS::Handle<jsid> id)
 337 {
 338   JS::Rooted<JS::Value> idval(cx);
 339   double array_index;
 340   int32_t i;
 341   if (JSID_IS_SYMBOL(id) ||
 342       !::JS_IdToValue(cx, id, &idval) ||
 343       !JS::ToNumber(cx, idval, &array_index) ||
 344       !::JS_DoubleIsInt32(array_index, &i)) {
 345     return -1;
 346   }
 347
 348   return i;
 349 }
 350
 351 bool
 352 DOMProxyHandler::setCustom(JSContext* cx, JS::Handle<JSObject*> proxy, JS::Handle<jsid> id,
 353                            JS::MutableHandle<JS::Value> vp, bool *done) const
 354 {
 355   *done = false;
 356   return true;
 357 }
 358
 359 //static
 360 JSObject *
 361 DOMProxyHandler::GetExpandoObject(JSObject *obj)
 362 {
 363   MOZ_ASSERT(IsDOMProxy(obj), "expected a DOM proxy object");
 364   JS::Value v = js::GetProxyExtra(obj, JSPROXYSLOT_EXPANDO);
 365   if (v.isObject()) {
 366     return &v.toObject();
 367   }
 368
 369   if (v.isUndefined()) {
 370     return nullptr;
 371   }
 372
 373   js::ExpandoAndGeneration* expandoAndGeneration =
 374     static_cast<js::ExpandoAndGeneration*>(v.toPrivate());
 375   v = expandoAndGeneration->expando;
 376   return v.isUndefined() ? nullptr : &v.toObject();
 377 }
 378
 379 } // namespace dom
 380 } // namespace mozilla