dom/xbl/nsXBLProtoImpl.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "mozilla/DebugOnly.h"
   7
   8 #include "nsXBLProtoImpl.h"
   9 #include "nsIContent.h"
  10 #include "nsIDocument.h"
  11 #include "nsContentUtils.h"
  12 #include "nsIXPConnect.h"
  13 #include "nsIServiceManager.h"
  14 #include "nsIDOMNode.h"
  15 #include "nsXBLPrototypeBinding.h"
  16 #include "nsXBLProtoImplProperty.h"
  17 #include "nsIURI.h"
  18 #include "mozilla/AddonPathService.h"
  19 #include "mozilla/dom/ScriptSettings.h"
  20 #include "mozilla/dom/XULElementBinding.h"
  21 #include "xpcpublic.h"
  22 #include "js/CharacterEncoding.h"
  23
  24 using namespace mozilla;
  25 using js::GetGlobalForObjectCrossCompartment;
  26 using js::AssertSameCompartment;
  27
  28 nsresult
  29 nsXBLProtoImpl::InstallImplementation(nsXBLPrototypeBinding* aPrototypeBinding,
  30                                       nsXBLBinding* aBinding)
  31 {
  32   // This function is called to install a concrete implementation on a bound element using
  33   // this prototype implementation as a guide.  The prototype implementation is compiled lazily,
  34   // so for the first bound element that needs a concrete implementation, we also build the
  35   // prototype implementation.
  36   if (!mMembers && !mFields)  // Constructor and destructor also live in mMembers
  37     return NS_OK; // Nothing to do, so let's not waste time.
  38
  39   // If the way this gets the script context changes, fix
  40   // nsXBLProtoImplAnonymousMethod::Execute
  41   nsIDocument* document = aBinding->GetBoundElement()->OwnerDoc();
  42
  43   // This sometimes gets called when we have no outer window and if we don't
  44   // catch this, we get leaks during crashtests and reftests.
  45   if (NS_WARN_IF(!document->GetWindow())) {
  46     return NS_OK;
  47   }
  48
  49   // |propertyHolder| (below) can be an existing object, so in theory we might
  50   // hit something that could end up running script. We never want that to
  51   // happen here, so we use an AutoJSAPI instead of an AutoEntryScript.
  52   dom::AutoJSAPI jsapi;
  53   if (NS_WARN_IF(!jsapi.Init(document->GetScopeObject()))) {
  54     return NS_OK;
  55   }
  56   JSContext* cx = jsapi.cx();
  57
  58   // InitTarget objects gives us back the JS object that represents the bound element and the
  59   // class object in the bound document that represents the concrete version of this implementation.
  60   // This function also has the side effect of building up the prototype implementation if it has
  61   // not been built already.
  62   JS::Rooted<JSObject*> targetClassObject(cx, nullptr);
  63   bool targetObjectIsNew = false;
  64   nsresult rv = InitTargetObjects(aPrototypeBinding,
  65                                   aBinding->GetBoundElement(),
  66                                   &targetClassObject,
  67                                   &targetObjectIsNew);
  68   NS_ENSURE_SUCCESS(rv, rv); // kick out if we were unable to properly intialize our target objects
  69   MOZ_ASSERT(targetClassObject);
  70
  71   // If the prototype already existed, we don't need to install anything. return early.
  72   if (!targetObjectIsNew)
  73     return NS_OK;
  74
  75   // We want to define the canonical set of members in a safe place. If we're
  76   // using a separate XBL scope, we want to define them there first (so that
  77   // they'll be available for Xray lookups, among other things), and then copy
  78   // the properties to the content-side prototype as needed. We don't need to
  79   // bother about the field accessors here, since we don't use/support those
  80   // for in-content bindings.
  81
  82   // First, start by entering the compartment of the XBL scope. This may or may
  83   // not be the same compartment as globalObject.
  84   JSAddonId* addonId = MapURIToAddonID(aPrototypeBinding->BindingURI());
  85   JS::Rooted<JSObject*> globalObject(cx,
  86     GetGlobalForObjectCrossCompartment(targetClassObject));
  87   JS::Rooted<JSObject*> scopeObject(cx, xpc::GetScopeForXBLExecution(cx, globalObject, addonId));
  88   NS_ENSURE_TRUE(scopeObject, NS_ERROR_OUT_OF_MEMORY);
  89   JSAutoCompartment ac(cx, scopeObject);
  90
  91   // Determine the appropriate property holder.
  92   //
  93   // Note: If |targetIsNew| is false, we'll early-return above. However, that only
  94   // tells us if the content-side object is new, which may be the case even if
  95   // we've already set up the binding on the XBL side. For example, if we apply
  96   // a binding #foo to a <span> when we've already applied it to a <div>, we'll
  97   // end up with a different content prototype, but we'll already have a property
  98   // holder called |foo| in the XBL scope. Check for that to avoid wasteful and
  99   // weird property holder duplication.
 100   const char* className = aPrototypeBinding->ClassName().get();
 101   JS::Rooted<JSObject*> propertyHolder(cx);
 102   JS::Rooted<JSPropertyDescriptor> existingHolder(cx);
 103   if (scopeObject != globalObject &&
 104       !JS_GetOwnPropertyDescriptor(cx, scopeObject, className, &existingHolder)) {
 105     return NS_ERROR_FAILURE;
 106   }
 107   bool propertyHolderIsNew = !existingHolder.object() || !existingHolder.value().isObject();
 108
 109   if (!propertyHolderIsNew) {
 110     propertyHolder = &existingHolder.value().toObject();
 111   } else if (scopeObject != globalObject) {
 112
 113     // This is just a property holder, so it doesn't need any special JSClass.
 114     propertyHolder = JS_NewObjectWithGivenProto(cx, nullptr, JS::NullPtr(), scopeObject);
 115     NS_ENSURE_TRUE(propertyHolder, NS_ERROR_OUT_OF_MEMORY);
 116
 117     // Define it as a property on the scopeObject, using the same name used on
 118     // the content side.
 119     bool ok = JS_DefineProperty(cx, scopeObject, className, propertyHolder,
 120                                 JSPROP_PERMANENT | JSPROP_READONLY,
 121                                 JS_PropertyStub, JS_StrictPropertyStub);
 122     NS_ENSURE_TRUE(ok, NS_ERROR_UNEXPECTED);
 123   } else {
 124     propertyHolder = targetClassObject;
 125   }
 126
 127   // Walk our member list and install each one in turn on the XBL scope object.
 128   if (propertyHolderIsNew) {
 129     for (nsXBLProtoImplMember* curr = mMembers;
 130          curr;
 131          curr = curr->GetNext())
 132       curr->InstallMember(cx, propertyHolder);
 133   }
 134
 135   // Now, if we're using a separate XBL scope, enter the compartment of the
 136   // bound node and copy exposable properties to the prototype there. This
 137   // rewraps them appropriately, which should result in cross-compartment
 138   // function wrappers.
 139   if (propertyHolder != targetClassObject) {
 140     AssertSameCompartment(propertyHolder, scopeObject);
 141     AssertSameCompartment(targetClassObject, globalObject);
 142     bool inContentXBLScope = xpc::IsInContentXBLScope(scopeObject);
 143     for (nsXBLProtoImplMember* curr = mMembers; curr; curr = curr->GetNext()) {
 144       if (!inContentXBLScope || curr->ShouldExposeToUntrustedContent()) {
 145         JS::Rooted<jsid> id(cx);
 146         JS::TwoByteChars chars(curr->GetName(), NS_strlen(curr->GetName()));
 147         bool ok = JS_CharsToId(cx, chars, &id);
 148         NS_ENSURE_TRUE(ok, NS_ERROR_UNEXPECTED);
 149
 150         bool found;
 151         ok = JS_HasPropertyById(cx, propertyHolder, id, &found);
 152         NS_ENSURE_TRUE(ok, NS_ERROR_UNEXPECTED);
 153         if (!found) {
 154           // Some members don't install anything in InstallMember (e.g.,
 155           // nsXBLProtoImplAnonymousMethod). We need to skip copying in
 156           // those cases.
 157           continue;
 158         }
 159
 160         ok = JS_CopyPropertyFrom(cx, id, targetClassObject, propertyHolder);
 161         NS_ENSURE_TRUE(ok, NS_ERROR_UNEXPECTED);
 162       }
 163     }
 164   }
 165
 166   // From here on out, work in the scope of the bound element.
 167   JSAutoCompartment ac2(cx, targetClassObject);
 168
 169   // Install all of our field accessors.
 170   for (nsXBLProtoImplField* curr = mFields;
 171        curr;
 172        curr = curr->GetNext())
 173     curr->InstallAccessors(cx, targetClassObject);
 174
 175   return NS_OK;
 176 }
 177
 178 nsresult
 179 nsXBLProtoImpl::InitTargetObjects(nsXBLPrototypeBinding* aBinding,
 180                                   nsIContent* aBoundElement,
 181                                   JS::MutableHandle<JSObject*> aTargetClassObject,
 182                                   bool* aTargetIsNew)
 183 {
 184   nsresult rv = NS_OK;
 185
 186   if (!mPrecompiledMemberHolder) {
 187     rv = CompilePrototypeMembers(aBinding); // This is the first time we've ever installed this binding on an element.
 188                                  // We need to go ahead and compile all methods and properties on a class
 189                                  // in our prototype binding.
 190     if (NS_FAILED(rv))
 191       return rv;
 192
 193     MOZ_ASSERT(mPrecompiledMemberHolder);
 194   }
 195
 196   nsIDocument *ownerDoc = aBoundElement->OwnerDoc();
 197   nsIGlobalObject *sgo;
 198
 199   if (!(sgo = ownerDoc->GetScopeObject())) {
 200     return NS_ERROR_UNEXPECTED;
 201   }
 202
 203   // Because our prototype implementation has a class, we need to build up a corresponding
 204   // class for the concrete implementation in the bound document.
 205   AutoJSContext cx;
 206   JS::Rooted<JSObject*> global(cx, sgo->GetGlobalJSObject());
 207   JS::Rooted<JS::Value> v(cx);
 208
 209   JSAutoCompartment ac(cx, global);
 210   // Make sure the interface object is created before the prototype object
 211   // so that XULElement is hidden from content. See bug 909340.
 212   bool defineOnGlobal = dom::XULElementBinding::ConstructorEnabled(cx, global);
 213   dom::XULElementBinding::GetConstructorObject(cx, global, defineOnGlobal);
 214
 215   rv = nsContentUtils::WrapNative(cx, aBoundElement, &v,
 216                                   /* aAllowWrapping = */ false);
 217   NS_ENSURE_SUCCESS(rv, rv);
 218
 219   JS::Rooted<JSObject*> value(cx, &v.toObject());
 220   JSAutoCompartment ac2(cx, value);
 221
 222   // All of the above code was just obtaining the bound element's script object and its immediate
 223   // concrete base class.  We need to alter the object so that our concrete class is interposed
 224   // between the object and its base class.  We become the new base class of the object, and the
 225   // object's old base class becomes the new class' base class.
 226   rv = aBinding->InitClass(mClassName, cx, value, aTargetClassObject, aTargetIsNew);
 227   if (NS_FAILED(rv)) {
 228     return rv;
 229   }
 230
 231   aBoundElement->PreserveWrapper(aBoundElement);
 232
 233   return rv;
 234 }
 235
 236 nsresult
 237 nsXBLProtoImpl::CompilePrototypeMembers(nsXBLPrototypeBinding* aBinding)
 238 {
 239   // We want to pre-compile our implementation's members against a "prototype context". Then when we actually
 240   // bind the prototype to a real xbl instance, we'll clone the pre-compiled JS into the real instance's
 241   // context.
 242   AutoSafeJSContext cx;
 243   JS::Rooted<JSObject*> compilationGlobal(cx, xpc::CompilationScope());
 244   JSAutoCompartment ac(cx, compilationGlobal);
 245
 246   mPrecompiledMemberHolder = JS_NewObjectWithGivenProto(cx, nullptr, JS::NullPtr(), compilationGlobal);
 247   if (!mPrecompiledMemberHolder)
 248     return NS_ERROR_OUT_OF_MEMORY;
 249
 250   // Now that we have a class object installed, we walk our member list and compile each of our
 251   // properties and methods in turn.
 252   JS::Rooted<JSObject*> rootedHolder(cx, mPrecompiledMemberHolder);
 253   for (nsXBLProtoImplMember* curr = mMembers;
 254        curr;
 255        curr = curr->GetNext()) {
 256     nsresult rv = curr->CompileMember(mClassName, rootedHolder);
 257     if (NS_FAILED(rv)) {
 258       DestroyMembers();
 259       return rv;
 260     }
 261   }
 262
 263   return NS_OK;
 264 }
 265
 266 bool
 267 nsXBLProtoImpl::LookupMember(JSContext* aCx, nsString& aName,
 268                              JS::Handle<jsid> aNameAsId,
 269                              JS::MutableHandle<JSPropertyDescriptor> aDesc,
 270                              JS::Handle<JSObject*> aClassObject)
 271 {
 272   for (nsXBLProtoImplMember* m = mMembers; m; m = m->GetNext()) {
 273     if (aName.Equals(m->GetName())) {
 274       return JS_GetPropertyDescriptorById(aCx, aClassObject, aNameAsId, aDesc);
 275     }
 276   }
 277   return true;
 278 }
 279
 280 void
 281 nsXBLProtoImpl::Trace(const TraceCallbacks& aCallbacks, void *aClosure)
 282 {
 283   // If we don't have a class object then we either didn't compile members
 284   // or we only have fields, in both cases there are no cycles through our
 285   // members.
 286   if (!mPrecompiledMemberHolder) {
 287     return;
 288   }
 289
 290   nsXBLProtoImplMember *member;
 291   for (member = mMembers; member; member = member->GetNext()) {
 292     member->Trace(aCallbacks, aClosure);
 293   }
 294 }
 295
 296 void
 297 nsXBLProtoImpl::UnlinkJSObjects()
 298 {
 299   if (mPrecompiledMemberHolder) {
 300     DestroyMembers();
 301   }
 302 }
 303
 304 nsXBLProtoImplField*
 305 nsXBLProtoImpl::FindField(const nsString& aFieldName) const
 306 {
 307   for (nsXBLProtoImplField* f = mFields; f; f = f->GetNext()) {
 308     if (aFieldName.Equals(f->GetName())) {
 309       return f;
 310     }
 311   }
 312
 313   return nullptr;
 314 }
 315
 316 bool
 317 nsXBLProtoImpl::ResolveAllFields(JSContext *cx, JS::Handle<JSObject*> obj) const
 318 {
 319   for (nsXBLProtoImplField* f = mFields; f; f = f->GetNext()) {
 320     // Using OBJ_LOOKUP_PROPERTY is a pain, since what we have is a
 321     // char16_t* for the property name.  Let's just use the public API and
 322     // all.
 323     nsDependentString name(f->GetName());
 324     JS::Rooted<JS::Value> dummy(cx);
 325     if (!::JS_LookupUCProperty(cx, obj, name.get(), name.Length(), &dummy)) {
 326       return false;
 327     }
 328   }
 329
 330   return true;
 331 }
 332
 333 void
 334 nsXBLProtoImpl::UndefineFields(JSContext *cx, JS::Handle<JSObject*> obj) const
 335 {
 336   JSAutoRequest ar(cx);
 337   for (nsXBLProtoImplField* f = mFields; f; f = f->GetNext()) {
 338     nsDependentString name(f->GetName());
 339
 340     const jschar* s = name.get();
 341     bool hasProp;
 342     if (::JS_AlreadyHasOwnUCProperty(cx, obj, s, name.Length(), &hasProp) &&
 343         hasProp) {
 344       bool dummy;
 345       ::JS_DeleteUCProperty2(cx, obj, s, name.Length(), &dummy);
 346     }
 347   }
 348 }
 349
 350 void
 351 nsXBLProtoImpl::DestroyMembers()
 352 {
 353   MOZ_ASSERT(mPrecompiledMemberHolder);
 354
 355   delete mMembers;
 356   mMembers = nullptr;
 357   mConstructor = nullptr;
 358   mDestructor = nullptr;
 359 }
 360
 361 nsresult
 362 nsXBLProtoImpl::Read(nsIObjectInputStream* aStream,
 363                      nsXBLPrototypeBinding* aBinding)
 364 {
 365   AssertInCompilationScope();
 366   AutoJSContext cx;
 367   // Set up a class object first so that deserialization is possible
 368   JS::Rooted<JSObject*> global(cx, JS::CurrentGlobalOrNull(cx));
 369   mPrecompiledMemberHolder = JS_NewObjectWithGivenProto(cx, nullptr, JS::NullPtr(), global);
 370   if (!mPrecompiledMemberHolder)
 371     return NS_ERROR_OUT_OF_MEMORY;
 372
 373   nsXBLProtoImplField* previousField = nullptr;
 374   nsXBLProtoImplMember* previousMember = nullptr;
 375
 376   do {
 377     XBLBindingSerializeDetails type;
 378     nsresult rv = aStream->Read8(&type);
 379     NS_ENSURE_SUCCESS(rv, rv);
 380     if (type == XBLBinding_Serialize_NoMoreItems)
 381       break;
 382
 383     switch (type & XBLBinding_Serialize_Mask) {
 384       case XBLBinding_Serialize_Field:
 385       {
 386         nsXBLProtoImplField* field =
 387           new nsXBLProtoImplField(type & XBLBinding_Serialize_ReadOnly);
 388         rv = field->Read(aStream);
 389         if (NS_FAILED(rv)) {
 390           delete field;
 391           return rv;
 392         }
 393
 394         if (previousField) {
 395           previousField->SetNext(field);
 396         }
 397         else {
 398           mFields = field;
 399         }
 400         previousField = field;
 401
 402         break;
 403       }
 404       case XBLBinding_Serialize_GetterProperty:
 405       case XBLBinding_Serialize_SetterProperty:
 406       case XBLBinding_Serialize_GetterSetterProperty:
 407       {
 408         nsAutoString name;
 409         nsresult rv = aStream->ReadString(name);
 410         NS_ENSURE_SUCCESS(rv, rv);
 411
 412         nsXBLProtoImplProperty* prop =
 413           new nsXBLProtoImplProperty(name.get(), type & XBLBinding_Serialize_ReadOnly);
 414         rv = prop->Read(aStream, type & XBLBinding_Serialize_Mask);
 415         if (NS_FAILED(rv)) {
 416           delete prop;
 417           return rv;
 418         }
 419
 420         previousMember = AddMember(prop, previousMember);
 421         break;
 422       }
 423       case XBLBinding_Serialize_Method:
 424       {
 425         nsAutoString name;
 426         rv = aStream->ReadString(name);
 427         NS_ENSURE_SUCCESS(rv, rv);
 428
 429         nsXBLProtoImplMethod* method = new nsXBLProtoImplMethod(name.get());
 430         rv = method->Read(aStream);
 431         if (NS_FAILED(rv)) {
 432           delete method;
 433           return rv;
 434         }
 435
 436         previousMember = AddMember(method, previousMember);
 437         break;
 438       }
 439       case XBLBinding_Serialize_Constructor:
 440       {
 441         nsAutoString name;
 442         rv = aStream->ReadString(name);
 443         NS_ENSURE_SUCCESS(rv, rv);
 444
 445         mConstructor = new nsXBLProtoImplAnonymousMethod(name.get());
 446         rv = mConstructor->Read(aStream);
 447         if (NS_FAILED(rv)) {
 448           delete mConstructor;
 449           mConstructor = nullptr;
 450           return rv;
 451         }
 452
 453         previousMember = AddMember(mConstructor, previousMember);
 454         break;
 455       }
 456       case XBLBinding_Serialize_Destructor:
 457       {
 458         nsAutoString name;
 459         rv = aStream->ReadString(name);
 460         NS_ENSURE_SUCCESS(rv, rv);
 461
 462         mDestructor = new nsXBLProtoImplAnonymousMethod(name.get());
 463         rv = mDestructor->Read(aStream);
 464         if (NS_FAILED(rv)) {
 465           delete mDestructor;
 466           mDestructor = nullptr;
 467           return rv;
 468         }
 469
 470         previousMember = AddMember(mDestructor, previousMember);
 471         break;
 472       }
 473       default:
 474         NS_ERROR("Unexpected binding member type");
 475         break;
 476     }
 477   } while (1);
 478
 479   return NS_OK;
 480 }
 481
 482 nsresult
 483 nsXBLProtoImpl::Write(nsIObjectOutputStream* aStream,
 484                       nsXBLPrototypeBinding* aBinding)
 485 {
 486   nsresult rv;
 487
 488   if (!mPrecompiledMemberHolder) {
 489     rv = CompilePrototypeMembers(aBinding);
 490     NS_ENSURE_SUCCESS(rv, rv);
 491   }
 492
 493   rv = aStream->WriteStringZ(mClassName.get());
 494   NS_ENSURE_SUCCESS(rv, rv);
 495
 496   for (nsXBLProtoImplField* curr = mFields; curr; curr = curr->GetNext()) {
 497     rv = curr->Write(aStream);
 498     NS_ENSURE_SUCCESS(rv, rv);
 499   }
 500   for (nsXBLProtoImplMember* curr = mMembers; curr; curr = curr->GetNext()) {
 501     if (curr == mConstructor) {
 502       rv = mConstructor->Write(aStream, XBLBinding_Serialize_Constructor);
 503     }
 504     else if (curr == mDestructor) {
 505       rv = mDestructor->Write(aStream, XBLBinding_Serialize_Destructor);
 506     }
 507     else {
 508       rv = curr->Write(aStream);
 509     }
 510     NS_ENSURE_SUCCESS(rv, rv);
 511   }
 512
 513   return aStream->Write8(XBLBinding_Serialize_NoMoreItems);
 514 }
 515
 516 nsresult
 517 NS_NewXBLProtoImpl(nsXBLPrototypeBinding* aBinding,
 518                    const char16_t* aClassName,
 519                    nsXBLProtoImpl** aResult)
 520 {
 521   nsXBLProtoImpl* impl = new nsXBLProtoImpl();
 522   if (!impl)
 523     return NS_ERROR_OUT_OF_MEMORY;
 524   if (aClassName)
 525     impl->mClassName.AssignWithConversion(aClassName);
 526   else
 527     aBinding->BindingURI()->GetSpec(impl->mClassName);
 528   aBinding->SetImplementation(impl);
 529   *aResult = impl;
 530
 531   return NS_OK;
 532 }
 533