dom/xbl/nsXBLProtoImplMethod.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 "nsIAtom.h"
   7 #include "nsString.h"
   8 #include "jsapi.h"
   9 #include "nsIContent.h"
  10 #include "nsIDocument.h"
  11 #include "nsIGlobalObject.h"
  12 #include "nsUnicharUtils.h"
  13 #include "nsReadableUtils.h"
  14 #include "nsXBLProtoImplMethod.h"
  15 #include "nsJSUtils.h"
  16 #include "nsContentUtils.h"
  17 #include "nsIScriptSecurityManager.h"
  18 #include "nsIXPConnect.h"
  19 #include "xpcpublic.h"
  20 #include "nsXBLPrototypeBinding.h"
  21 #include "mozilla/dom/Element.h"
  22 #include "mozilla/dom/ScriptSettings.h"
  23
  24 using namespace mozilla;
  25 using namespace mozilla::dom;
  26
  27 nsXBLProtoImplMethod::nsXBLProtoImplMethod(const char16_t* aName) :
  28   nsXBLProtoImplMember(aName),
  29   mMethod()
  30 {
  31   MOZ_COUNT_CTOR(nsXBLProtoImplMethod);
  32 }
  33
  34 nsXBLProtoImplMethod::~nsXBLProtoImplMethod()
  35 {
  36   MOZ_COUNT_DTOR(nsXBLProtoImplMethod);
  37
  38   if (!IsCompiled()) {
  39     delete GetUncompiledMethod();
  40   }
  41 }
  42
  43 void
  44 nsXBLProtoImplMethod::AppendBodyText(const nsAString& aText)
  45 {
  46   NS_PRECONDITION(!IsCompiled(),
  47                   "Must not be compiled when accessing uncompiled method");
  48
  49   nsXBLUncompiledMethod* uncompiledMethod = GetUncompiledMethod();
  50   if (!uncompiledMethod) {
  51     uncompiledMethod = new nsXBLUncompiledMethod();
  52     if (!uncompiledMethod)
  53       return;
  54     SetUncompiledMethod(uncompiledMethod);
  55   }
  56
  57   uncompiledMethod->AppendBodyText(aText);
  58 }
  59
  60 void
  61 nsXBLProtoImplMethod::AddParameter(const nsAString& aText)
  62 {
  63   NS_PRECONDITION(!IsCompiled(),
  64                   "Must not be compiled when accessing uncompiled method");
  65
  66   if (aText.IsEmpty()) {
  67     NS_WARNING("Empty name attribute in xbl:parameter!");
  68     return;
  69   }
  70
  71   nsXBLUncompiledMethod* uncompiledMethod = GetUncompiledMethod();
  72   if (!uncompiledMethod) {
  73     uncompiledMethod = new nsXBLUncompiledMethod();
  74     if (!uncompiledMethod)
  75       return;
  76     SetUncompiledMethod(uncompiledMethod);
  77   }
  78
  79   uncompiledMethod->AddParameter(aText);
  80 }
  81
  82 void
  83 nsXBLProtoImplMethod::SetLineNumber(uint32_t aLineNumber)
  84 {
  85   NS_PRECONDITION(!IsCompiled(),
  86                   "Must not be compiled when accessing uncompiled method");
  87
  88   nsXBLUncompiledMethod* uncompiledMethod = GetUncompiledMethod();
  89   if (!uncompiledMethod) {
  90     uncompiledMethod = new nsXBLUncompiledMethod();
  91     if (!uncompiledMethod)
  92       return;
  93     SetUncompiledMethod(uncompiledMethod);
  94   }
  95
  96   uncompiledMethod->SetLineNumber(aLineNumber);
  97 }
  98
  99 nsresult
 100 nsXBLProtoImplMethod::InstallMember(JSContext* aCx,
 101                                     JS::Handle<JSObject*> aTargetClassObject)
 102 {
 103   NS_PRECONDITION(IsCompiled(),
 104                   "Should not be installing an uncompiled method");
 105   MOZ_ASSERT(js::IsObjectInContextCompartment(aTargetClassObject, aCx));
 106
 107 #ifdef DEBUG
 108   {
 109     JS::Rooted<JSObject*> globalObject(aCx, JS_GetGlobalForObject(aCx, aTargetClassObject));
 110     MOZ_ASSERT(xpc::IsInContentXBLScope(globalObject) ||
 111                xpc::IsInAddonScope(globalObject) ||
 112                globalObject == xpc::GetXBLScope(aCx, globalObject));
 113     MOZ_ASSERT(JS::CurrentGlobalOrNull(aCx) == globalObject);
 114   }
 115 #endif
 116
 117   JS::Rooted<JSObject*> jsMethodObject(aCx, GetCompiledMethod());
 118   if (jsMethodObject) {
 119     nsDependentString name(mName);
 120
 121     JS::Rooted<JSObject*> method(aCx, JS::CloneFunctionObject(aCx, jsMethodObject));
 122     NS_ENSURE_TRUE(method, NS_ERROR_OUT_OF_MEMORY);
 123
 124     if (!::JS_DefineUCProperty(aCx, aTargetClassObject,
 125                                static_cast<const char16_t*>(mName),
 126                                name.Length(), method,
 127                                JSPROP_ENUMERATE)) {
 128       return NS_ERROR_OUT_OF_MEMORY;
 129     }
 130   }
 131   return NS_OK;
 132 }
 133
 134 nsresult
 135 nsXBLProtoImplMethod::CompileMember(AutoJSAPI& jsapi, const nsCString& aClassStr,
 136                                     JS::Handle<JSObject*> aClassObject)
 137 {
 138   AssertInCompilationScope();
 139   NS_PRECONDITION(!IsCompiled(),
 140                   "Trying to compile an already-compiled method");
 141   NS_PRECONDITION(aClassObject,
 142                   "Must have class object to compile");
 143
 144   nsXBLUncompiledMethod* uncompiledMethod = GetUncompiledMethod();
 145
 146   // No parameters or body was supplied, so don't install method.
 147   if (!uncompiledMethod) {
 148     // Early return after which we consider ourselves compiled.
 149     SetCompiledMethod(nullptr);
 150
 151     return NS_OK;
 152   }
 153
 154   // Don't install method if no name was supplied.
 155   if (!mName) {
 156     delete uncompiledMethod;
 157
 158     // Early return after which we consider ourselves compiled.
 159     SetCompiledMethod(nullptr);
 160
 161     return NS_OK;
 162   }
 163
 164   // We have a method.
 165   // Allocate an array for our arguments.
 166   int32_t paramCount = uncompiledMethod->GetParameterCount();
 167   char** args = nullptr;
 168   if (paramCount > 0) {
 169     args = new char*[paramCount];
 170     if (!args)
 171       return NS_ERROR_OUT_OF_MEMORY;
 172
 173     // Add our parameters to our args array.
 174     int32_t argPos = 0;
 175     for (nsXBLParameter* curr = uncompiledMethod->mParameters;
 176          curr;
 177          curr = curr->mNext) {
 178       args[argPos] = curr->mName;
 179       argPos++;
 180     }
 181   }
 182
 183   // Get the body
 184   nsDependentString body;
 185   char16_t *bodyText = uncompiledMethod->mBodyText.GetText();
 186   if (bodyText)
 187     body.Rebind(bodyText);
 188
 189   // Now that we have a body and args, compile the function
 190   // and then define it.
 191   NS_ConvertUTF16toUTF8 cname(mName);
 192   nsAutoCString functionUri(aClassStr);
 193   int32_t hash = functionUri.RFindChar('#');
 194   if (hash != kNotFound) {
 195     functionUri.Truncate(hash);
 196   }
 197
 198   JSContext *cx = jsapi.cx();
 199   JSAutoCompartment ac(cx, aClassObject);
 200   JS::CompileOptions options(cx);
 201   options.setFileAndLine(functionUri.get(),
 202                          uncompiledMethod->mBodyText.GetLineNumber())
 203          .setVersion(JSVERSION_LATEST);
 204   JS::Rooted<JSObject*> methodObject(cx);
 205   JS::AutoObjectVector emptyVector(cx);
 206   nsresult rv = nsJSUtils::CompileFunction(jsapi, emptyVector, options, cname,
 207                                            paramCount,
 208                                            const_cast<const char**>(args),
 209                                            body, methodObject.address());
 210
 211   // Destroy our uncompiled method and delete our arg list.
 212   delete uncompiledMethod;
 213   delete [] args;
 214   if (NS_FAILED(rv)) {
 215     SetUncompiledMethod(nullptr);
 216     return rv;
 217   }
 218
 219   SetCompiledMethod(methodObject);
 220
 221   return NS_OK;
 222 }
 223
 224 void
 225 nsXBLProtoImplMethod::Trace(const TraceCallbacks& aCallbacks, void *aClosure)
 226 {
 227   if (IsCompiled() && GetCompiledMethodPreserveColor()) {
 228     aCallbacks.Trace(&mMethod.AsHeapObject(), "mMethod", aClosure);
 229   }
 230 }
 231
 232 nsresult
 233 nsXBLProtoImplMethod::Read(nsIObjectInputStream* aStream)
 234 {
 235   AssertInCompilationScope();
 236   MOZ_ASSERT(!IsCompiled() && !GetUncompiledMethod());
 237
 238   AutoJSContext cx;
 239   JS::Rooted<JSObject*> methodObject(cx);
 240   nsresult rv = XBL_DeserializeFunction(aStream, &methodObject);
 241   if (NS_FAILED(rv)) {
 242     SetUncompiledMethod(nullptr);
 243     return rv;
 244   }
 245
 246   SetCompiledMethod(methodObject);
 247
 248   return NS_OK;
 249 }
 250
 251 nsresult
 252 nsXBLProtoImplMethod::Write(nsIObjectOutputStream* aStream)
 253 {
 254   AssertInCompilationScope();
 255   MOZ_ASSERT(IsCompiled());
 256   if (GetCompiledMethodPreserveColor()) {
 257     nsresult rv = aStream->Write8(XBLBinding_Serialize_Method);
 258     NS_ENSURE_SUCCESS(rv, rv);
 259
 260     rv = aStream->WriteWStringZ(mName);
 261     NS_ENSURE_SUCCESS(rv, rv);
 262
 263     // Calling fromMarkedLocation() is safe because mMethod is traced by the
 264     // Trace() method above, and because its value is never changed after it has
 265     // been set to a compiled method.
 266     JS::Handle<JSObject*> method =
 267       JS::Handle<JSObject*>::fromMarkedLocation(mMethod.AsHeapObject().address());
 268     return XBL_SerializeFunction(aStream, method);
 269   }
 270
 271   return NS_OK;
 272 }
 273
 274 nsresult
 275 nsXBLProtoImplAnonymousMethod::Execute(nsIContent* aBoundElement, JSAddonId* aAddonId)
 276 {
 277   MOZ_ASSERT(aBoundElement->IsElement());
 278   NS_PRECONDITION(IsCompiled(), "Can't execute uncompiled method");
 279
 280   if (!GetCompiledMethod()) {
 281     // Nothing to do here
 282     return NS_OK;
 283   }
 284
 285   // Get the script context the same way
 286   // nsXBLProtoImpl::InstallImplementation does.
 287   nsIDocument* document = aBoundElement->OwnerDoc();
 288
 289   nsCOMPtr<nsIGlobalObject> global =
 290     do_QueryInterface(document->GetInnerWindow());
 291   if (!global) {
 292     return NS_OK;
 293   }
 294
 295   nsAutoMicroTask mt;
 296
 297   // We are going to run script via JS::Call, so we need a script entry point,
 298   // but as this is XBL related it does not appear in the HTML spec.
 299   dom::AutoEntryScript aes(global);
 300   aes.TakeOwnershipOfErrorReporting();
 301   JSContext* cx = aes.cx();
 302
 303   JS::Rooted<JSObject*> globalObject(cx, global->GetGlobalJSObject());
 304
 305   JS::Rooted<JSObject*> scopeObject(cx, xpc::GetScopeForXBLExecution(cx, globalObject, aAddonId));
 306   NS_ENSURE_TRUE(scopeObject, NS_ERROR_OUT_OF_MEMORY);
 307
 308   JSAutoCompartment ac(cx, scopeObject);
 309   JS::AutoObjectVector scopeChain(cx);
 310   if (!nsJSUtils::GetScopeChainForElement(cx, aBoundElement->AsElement(),
 311                                           scopeChain)) {
 312     return NS_ERROR_OUT_OF_MEMORY;
 313   }
 314   MOZ_ASSERT(scopeChain.length() != 0);
 315
 316   // Clone the function object, using our scope chain (for backwards
 317   // compat to the days when this was an event handler).
 318   JS::Rooted<JSObject*> jsMethodObject(cx, GetCompiledMethod());
 319   JS::Rooted<JSObject*> method(cx, JS::CloneFunctionObject(cx, jsMethodObject,
 320                                                            scopeChain));
 321   if (!method)
 322     return NS_ERROR_OUT_OF_MEMORY;
 323
 324   // Now call the method
 325
 326   // Check whether script is enabled.
 327   bool scriptAllowed = nsContentUtils::GetSecurityManager()->
 328                          ScriptAllowed(js::GetGlobalForObjectCrossCompartment(method));
 329
 330   if (scriptAllowed) {
 331     JS::Rooted<JS::Value> retval(cx);
 332     JS::Rooted<JS::Value> methodVal(cx, JS::ObjectValue(*method));
 333     // No need to check the return here as AutoEntryScript has taken ownership
 334     // of error reporting.
 335     ::JS::Call(cx, scopeChain[0], methodVal, JS::HandleValueArray::empty(), &retval);
 336   }
 337
 338   return NS_OK;
 339 }
 340
 341 nsresult
 342 nsXBLProtoImplAnonymousMethod::Write(nsIObjectOutputStream* aStream,
 343                                      XBLBindingSerializeDetails aType)
 344 {
 345   AssertInCompilationScope();
 346   MOZ_ASSERT(IsCompiled());
 347   if (GetCompiledMethodPreserveColor()) {
 348     nsresult rv = aStream->Write8(aType);
 349     NS_ENSURE_SUCCESS(rv, rv);
 350
 351     rv = aStream->WriteWStringZ(mName);
 352     NS_ENSURE_SUCCESS(rv, rv);
 353
 354     // Calling fromMarkedLocation() is safe because mMethod is traced by the
 355     // Trace() method above, and because its value is never changed after it has
 356     // been set to a compiled method.
 357     JS::Handle<JSObject*> method =
 358       JS::Handle<JSObject*>::fromMarkedLocation(mMethod.AsHeapObject().address());
 359     rv = XBL_SerializeFunction(aStream, method);
 360     NS_ENSURE_SUCCESS(rv, rv);
 361   }
 362
 363   return NS_OK;
 364 }