The Tor Browser: js/xpconnect/wrappers/XrayWrapper.h@129ffea94266

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

     1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

     2 /* vim: set ts=8 sts=4 et sw=4 tw=99: */

     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/. */

     7 #ifndef XrayWrapper_h

     8 #define XrayWrapper_h

    10 #include "mozilla/Attributes.h"

    12 #include "jswrapper.h"

    14 // Xray wrappers re-resolve the original native properties on the native

    15 // object and always directly access to those properties.

    16 // Because they work so differently from the rest of the wrapper hierarchy,

    17 // we pull them out of the Wrapper inheritance hierarchy and create a

    18 // little world around them.

    20 namespace xpc {

    22 bool

    23 holder_get(JSContext *cx, JS::HandleObject holder, JS::HandleId id, JS::MutableHandleValue vp);

    24 bool

    25 holder_set(JSContext *cx, JS::HandleObject holder, JS::HandleId id, bool strict,

    26            JS::MutableHandleValue vp);

    28 namespace XrayUtils {

    30 bool IsXPCWNHolderClass(const JSClass *clasp);

    32 bool CloneExpandoChain(JSContext *cx, JSObject *src, JSObject *dst);

    34 bool

    35 IsTransparent(JSContext *cx, JS::HandleObject wrapper, JS::HandleId id);

    37 JSObject *

    38 GetNativePropertiesObject(JSContext *cx, JSObject *wrapper);

    40 bool

    41 IsXrayResolving(JSContext *cx, JS::HandleObject wrapper, JS::HandleId id);

    43 bool

    44 HasNativeProperty(JSContext *cx, JS::HandleObject wrapper, JS::HandleId id,

    45                   bool *hasProp);

    46 }

    48 class XrayTraits;

    49 class XPCWrappedNativeXrayTraits;

    50 class DOMXrayTraits;

    51 class JSXrayTraits;

    54 enum XrayType {

    55     XrayForDOMObject,

    56     XrayForWrappedNative,

    57     XrayForJSObject,

    58     NotXray

    59 };

    61 XrayType GetXrayType(JSObject *obj);

    62 XrayTraits* GetXrayTraits(JSObject *obj);

    64 // NB: Base *must* derive from JSProxyHandler

    65 template <typename Base, typename Traits = XPCWrappedNativeXrayTraits >

    66 class XrayWrapper : public Base {

    67   public:

    68     XrayWrapper(unsigned flags);

    69     virtual ~XrayWrapper();

    71     /* Fundamental proxy traps. */

    72     virtual bool isExtensible(JSContext *cx, JS::Handle<JSObject*> wrapper, bool *extensible) MOZ_OVERRIDE;

    73     virtual bool preventExtensions(JSContext *cx, JS::Handle<JSObject*> wrapper) MOZ_OVERRIDE;

    74     virtual bool getPropertyDescriptor(JSContext *cx, JS::Handle<JSObject*> wrapper, JS::Handle<jsid> id,

    75                                        JS::MutableHandle<JSPropertyDescriptor> desc);

    76     virtual bool getOwnPropertyDescriptor(JSContext *cx, JS::Handle<JSObject*> wrapper, JS::Handle<jsid> id,

    77                                           JS::MutableHandle<JSPropertyDescriptor> desc);

    78     virtual bool defineProperty(JSContext *cx, JS::Handle<JSObject*> wrapper, JS::Handle<jsid> id,

    79                                 JS::MutableHandle<JSPropertyDescriptor> desc);

    80     virtual bool getOwnPropertyNames(JSContext *cx, JS::Handle<JSObject*> wrapper,

    81                                      JS::AutoIdVector &props);

    82     virtual bool delete_(JSContext *cx, JS::Handle<JSObject*> wrapper,

    83                          JS::Handle<jsid> id, bool *bp);

    84     virtual bool enumerate(JSContext *cx, JS::Handle<JSObject*> wrapper, JS::AutoIdVector &props);

    86     /* Derived proxy traps. */

    87     virtual bool get(JSContext *cx, JS::Handle<JSObject*> wrapper, JS::Handle<JSObject*> receiver,

    88                      JS::Handle<jsid> id, JS::MutableHandle<JS::Value> vp);

    89     virtual bool set(JSContext *cx, JS::Handle<JSObject*> wrapper, JS::Handle<JSObject*> receiver,

    90                      JS::Handle<jsid> id, bool strict, JS::MutableHandle<JS::Value> vp);

    91     virtual bool has(JSContext *cx, JS::Handle<JSObject*> wrapper, JS::Handle<jsid> id,

    92                      bool *bp);

    93     virtual bool hasOwn(JSContext *cx, JS::Handle<JSObject*> wrapper, JS::Handle<jsid> id,

    94                         bool *bp);

    95     virtual bool keys(JSContext *cx, JS::Handle<JSObject*> wrapper,

    96                       JS::AutoIdVector &props);

    97     virtual bool iterate(JSContext *cx, JS::Handle<JSObject*> wrapper, unsigned flags,

    98                          JS::MutableHandle<JS::Value> vp);

   100     virtual bool call(JSContext *cx, JS::Handle<JSObject*> wrapper,

   101                       const JS::CallArgs &args) MOZ_OVERRIDE;

   102     virtual bool construct(JSContext *cx, JS::Handle<JSObject*> wrapper,

   103                            const JS::CallArgs &args) MOZ_OVERRIDE;

   105     virtual bool defaultValue(JSContext *cx, JS::HandleObject wrapper,

   106                               JSType hint, JS::MutableHandleValue vp)

   107                               MOZ_OVERRIDE;

   109     virtual bool getPrototypeOf(JSContext *cx, JS::HandleObject wrapper,

   110                                 JS::MutableHandleObject protop) MOZ_OVERRIDE;

   111     virtual bool setPrototypeOf(JSContext *cx, JS::HandleObject wrapper,

   112                                 JS::HandleObject proto, bool *bp) MOZ_OVERRIDE;

   114     static XrayWrapper singleton;

   116   private:

   117     template <bool HasPrototype>

   118     typename mozilla::EnableIf<HasPrototype, bool>::Type

   119         getPrototypeOfHelper(JSContext *cx, JS::HandleObject wrapper,

   120                              JS::HandleObject target, JS::MutableHandleObject protop)

   121     {

   122         return Traits::singleton.getPrototypeOf(cx, wrapper, target, protop);

   123     }

   124     template <bool HasPrototype>

   125     typename mozilla::EnableIf<!HasPrototype, bool>::Type

   126         getPrototypeOfHelper(JSContext *cx, JS::HandleObject wrapper,

   127                              JS::HandleObject target, JS::MutableHandleObject protop)

   128     {

   129         return Base::getPrototypeOf(cx, wrapper, protop);

   130     }

   131     bool getPrototypeOfHelper(JSContext *cx, JS::HandleObject wrapper,

   132                               JS::HandleObject target, JS::MutableHandleObject protop)

   133     {

   134         return getPrototypeOfHelper<Traits::HasPrototype>(cx, wrapper, target,

   135                                                           protop);

   136     }

   138     bool enumerate(JSContext *cx, JS::Handle<JSObject*> wrapper, unsigned flags,

   139                    JS::AutoIdVector &props);

   140 };

   142 #define PermissiveXrayXPCWN xpc::XrayWrapper<js::CrossCompartmentWrapper, xpc::XPCWrappedNativeXrayTraits>

   143 #define SecurityXrayXPCWN xpc::XrayWrapper<js::CrossCompartmentSecurityWrapper, xpc::XPCWrappedNativeXrayTraits>

   144 #define PermissiveXrayDOM xpc::XrayWrapper<js::CrossCompartmentWrapper, xpc::DOMXrayTraits>

   145 #define SecurityXrayDOM xpc::XrayWrapper<js::CrossCompartmentSecurityWrapper, xpc::DOMXrayTraits>

   146 #define PermissiveXrayJS xpc::XrayWrapper<js::CrossCompartmentWrapper, xpc::JSXrayTraits>

   147 #define SCSecurityXrayXPCWN xpc::XrayWrapper<js::SameCompartmentSecurityWrapper, xpc::XPCWrappedNativeXrayTraits>

   149 class SandboxProxyHandler : public js::Wrapper {

   150 public:

   151     SandboxProxyHandler() : js::Wrapper(0)

   152     {

   153     }

   155     virtual bool getPropertyDescriptor(JSContext *cx, JS::Handle<JSObject*> proxy,

   156                                        JS::Handle<jsid> id,

   157                                        JS::MutableHandle<JSPropertyDescriptor> desc) MOZ_OVERRIDE;

   158     virtual bool getOwnPropertyDescriptor(JSContext *cx, JS::Handle<JSObject*> proxy,

   159                                           JS::Handle<jsid> id,

   160                                           JS::MutableHandle<JSPropertyDescriptor> desc) MOZ_OVERRIDE;

   162     // We just forward the derived traps to the BaseProxyHandler versions which

   163     // implement them in terms of the fundamental traps.

   164     virtual bool has(JSContext *cx, JS::Handle<JSObject*> proxy, JS::Handle<jsid> id,

   165                      bool *bp) MOZ_OVERRIDE;

   166     virtual bool hasOwn(JSContext *cx, JS::Handle<JSObject*> proxy, JS::Handle<jsid> id,

   167                         bool *bp) MOZ_OVERRIDE;

   168     virtual bool get(JSContext *cx, JS::Handle<JSObject*> proxy, JS::Handle<JSObject*> receiver,

   169                      JS::Handle<jsid> id, JS::MutableHandle<JS::Value> vp) MOZ_OVERRIDE;

   170     virtual bool set(JSContext *cx, JS::Handle<JSObject*> proxy, JS::Handle<JSObject*> receiver,

   171                      JS::Handle<jsid> id, bool strict, JS::MutableHandle<JS::Value> vp) MOZ_OVERRIDE;

   172     virtual bool keys(JSContext *cx, JS::Handle<JSObject*> proxy,

   173                       JS::AutoIdVector &props) MOZ_OVERRIDE;

   174     virtual bool iterate(JSContext *cx, JS::Handle<JSObject*> proxy, unsigned flags,

   175                          JS::MutableHandle<JS::Value> vp) MOZ_OVERRIDE;

   176 };

   178 extern SandboxProxyHandler sandboxProxyHandler;

   180 // A proxy handler that lets us wrap callables and invoke them with

   181 // the correct this object, while forwarding all other operations down

   182 // to them directly.

   183 class SandboxCallableProxyHandler : public js::Wrapper {

   184 public:

   185     SandboxCallableProxyHandler() : js::Wrapper(0)

   186     {

   187     }

   189     virtual bool call(JSContext *cx, JS::Handle<JSObject*> proxy,

   190                       const JS::CallArgs &args) MOZ_OVERRIDE;

   191 };

   193 extern SandboxCallableProxyHandler sandboxCallableProxyHandler;

   195 class AutoSetWrapperNotShadowing;

   196 class XPCWrappedNativeXrayTraits;

   198 class MOZ_STACK_CLASS ResolvingId {

   199 public:

   200     ResolvingId(JSContext *cx, JS::HandleObject wrapper, JS::HandleId id);

   201     ~ResolvingId();

   203     bool isXrayShadowing(jsid id);

   204     bool isResolving(jsid id);

   205     static ResolvingId* getResolvingId(JSObject *holder);

   206     static JSObject* getHolderObject(JSObject *wrapper);

   207     static ResolvingId *getResolvingIdFromWrapper(JSObject *wrapper);

   209 private:

   210     friend class AutoSetWrapperNotShadowing;

   211     friend class XPCWrappedNativeXrayTraits;

   213     JS::HandleId mId;

   214     JS::RootedObject mHolder;

   215     ResolvingId *mPrev;

   216     bool mXrayShadowing;

   217 };

   219 }

   221 #endif

The Tor Browser / file revision

js/xpconnect/wrappers/XrayWrapper.h@129ffea94266

js/xpconnect/wrappers/XrayWrapper.h