dom/base/DOMRequest.cpp

   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 file,
   5  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "DOMRequest.h"
   8
   9 #include "DOMException.h"
  10 #include "nsThreadUtils.h"
  11 #include "mozilla/HoldDropJSObjects.h"
  12 #include "mozilla/ErrorResult.h"
  13 #include "mozilla/dom/Event.h"
  14 #include "mozilla/dom/Promise.h"
  15 #include "mozilla/dom/ScriptSettings.h"
  16 #include "jsfriendapi.h"
  17 #include "nsContentUtils.h"
  18
  19 using mozilla::dom::AnyCallback;
  20 using mozilla::dom::AutoJSAPI;
  21 using mozilla::dom::DOMException;
  22 using mozilla::dom::DOMRequest;
  23 using mozilla::dom::DOMRequestService;
  24 using mozilla::dom::Promise;
  25 using mozilla::dom::RootingCx;
  26
  27 DOMRequest::DOMRequest(nsPIDOMWindowInner* aWindow)
  28     : DOMEventTargetHelper(aWindow),
  29       mResult(JS::UndefinedValue()),
  30       mDone(false) {}
  31
  32 DOMRequest::DOMRequest(nsIGlobalObject* aGlobal)
  33     : DOMEventTargetHelper(aGlobal),
  34       mResult(JS::UndefinedValue()),
  35       mDone(false) {}
  36
  37 DOMRequest::~DOMRequest() { mozilla::DropJSObjects(this); }
  38
  39 NS_IMPL_CYCLE_COLLECTION_INHERITED_WITH_JS_MEMBERS(DOMRequest,
  40                                                    DOMEventTargetHelper,
  41                                                    (mError, mPromise),
  42                                                    (mResult))
  43
  44 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(DOMRequest)
  45 NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
  46
  47 NS_IMPL_ADDREF_INHERITED(DOMRequest, DOMEventTargetHelper)
  48 NS_IMPL_RELEASE_INHERITED(DOMRequest, DOMEventTargetHelper)
  49
  50 /* virtual */
  51 JSObject* DOMRequest::WrapObject(JSContext* aCx,
  52                                  JS::Handle<JSObject*> aGivenProto) {
  53   return DOMRequest_Binding::Wrap(aCx, this, aGivenProto);
  54 }
  55
  56 void DOMRequest::FireSuccess(JS::Handle<JS::Value> aResult) {
  57   NS_ASSERTION(!mDone, "mDone shouldn't have been set to true already!");
  58   NS_ASSERTION(!mError, "mError shouldn't have been set!");
  59   NS_ASSERTION(mResult.isUndefined(), "mResult shouldn't have been set!");
  60
  61   mDone = true;
  62   if (aResult.isGCThing()) {
  63     RootResultVal();
  64   }
  65   mResult = aResult;
  66
  67   FireEvent(u"success"_ns, false, false);
  68
  69   if (mPromise) {
  70     mPromise->MaybeResolve(mResult);
  71   }
  72 }
  73
  74 void DOMRequest::FireError(const nsAString& aError) {
  75   NS_ASSERTION(!mDone, "mDone shouldn't have been set to true already!");
  76   NS_ASSERTION(!mError, "mError shouldn't have been set!");
  77   NS_ASSERTION(mResult.isUndefined(), "mResult shouldn't have been set!");
  78
  79   mDone = true;
  80   // XXX Error code chosen arbitrarily
  81   mError = DOMException::Create(NS_ERROR_DOM_UNKNOWN_ERR,
  82                                 NS_ConvertUTF16toUTF8(aError));
  83
  84   FireEvent(u"error"_ns, true, true);
  85
  86   if (mPromise) {
  87     mPromise->MaybeRejectBrokenly(mError);
  88   }
  89 }
  90
  91 void DOMRequest::FireError(nsresult aError) {
  92   NS_ASSERTION(!mDone, "mDone shouldn't have been set to true already!");
  93   NS_ASSERTION(!mError, "mError shouldn't have been set!");
  94   NS_ASSERTION(mResult.isUndefined(), "mResult shouldn't have been set!");
  95
  96   mDone = true;
  97   mError = DOMException::Create(aError);
  98
  99   FireEvent(u"error"_ns, true, true);
 100
 101   if (mPromise) {
 102     mPromise->MaybeRejectBrokenly(mError);
 103   }
 104 }
 105
 106 void DOMRequest::FireDetailedError(DOMException& aError) {
 107   NS_ASSERTION(!mDone, "mDone shouldn't have been set to true already!");
 108   NS_ASSERTION(!mError, "mError shouldn't have been set!");
 109   NS_ASSERTION(mResult.isUndefined(), "mResult shouldn't have been set!");
 110
 111   mDone = true;
 112   mError = &aError;
 113
 114   FireEvent(u"error"_ns, true, true);
 115
 116   if (mPromise) {
 117     mPromise->MaybeRejectBrokenly(mError);
 118   }
 119 }
 120
 121 void DOMRequest::FireEvent(const nsAString& aType, bool aBubble,
 122                            bool aCancelable) {
 123   if (NS_FAILED(CheckCurrentGlobalCorrectness())) {
 124     return;
 125   }
 126
 127   RefPtr<Event> event = NS_NewDOMEvent(this, nullptr, nullptr);
 128   event->InitEvent(aType, aBubble, aCancelable);
 129   event->SetTrusted(true);
 130
 131   DispatchEvent(*event);
 132 }
 133
 134 void DOMRequest::RootResultVal() { mozilla::HoldJSObjects(this); }
 135
 136 void DOMRequest::Then(JSContext* aCx, AnyCallback* aResolveCallback,
 137                       AnyCallback* aRejectCallback,
 138                       JS::MutableHandle<JS::Value> aRetval,
 139                       mozilla::ErrorResult& aRv) {
 140   if (!mPromise) {
 141     mPromise = Promise::Create(DOMEventTargetHelper::GetParentObject(), aRv);
 142     if (aRv.Failed()) {
 143       return;
 144     }
 145     if (mDone) {
 146       // Since we create mPromise lazily, it's possible that the DOMRequest
 147       // object has already fired its success/error event.  In that case we
 148       // should manually resolve/reject mPromise here.  mPromise will take care
 149       // of calling the callbacks on |promise| as needed.
 150       if (mError) {
 151         mPromise->MaybeRejectBrokenly(mError);
 152       } else {
 153         mPromise->MaybeResolve(mResult);
 154       }
 155     }
 156   }
 157
 158   // Just use the global of the Promise itself as the callee global.
 159   JS::Rooted<JSObject*> global(aCx, mPromise->PromiseObj());
 160   global = JS::GetNonCCWObjectGlobal(global);
 161   mPromise->Then(aCx, global, aResolveCallback, aRejectCallback, aRetval, aRv);
 162 }
 163
 164 NS_IMPL_ISUPPORTS(DOMRequestService, nsIDOMRequestService)
 165
 166 NS_IMETHODIMP
 167 DOMRequestService::CreateRequest(mozIDOMWindow* aWindow,
 168                                  DOMRequest** aRequest) {
 169   MOZ_ASSERT(NS_IsMainThread());
 170   NS_ENSURE_STATE(aWindow);
 171   auto* win = nsPIDOMWindowInner::From(aWindow);
 172   RefPtr<DOMRequest> req = new DOMRequest(win);
 173   req.forget(aRequest);
 174
 175   return NS_OK;
 176 }
 177
 178 NS_IMETHODIMP
 179 DOMRequestService::FireSuccess(DOMRequest* aRequest,
 180                                JS::Handle<JS::Value> aResult) {
 181   NS_ENSURE_STATE(aRequest);
 182   aRequest->FireSuccess(aResult);
 183
 184   return NS_OK;
 185 }
 186
 187 NS_IMETHODIMP
 188 DOMRequestService::FireError(DOMRequest* aRequest, const nsAString& aError) {
 189   NS_ENSURE_STATE(aRequest);
 190   aRequest->FireError(aError);
 191
 192   return NS_OK;
 193 }
 194
 195 class FireSuccessAsyncTask : public mozilla::Runnable {
 196   FireSuccessAsyncTask(DOMRequest* aRequest, const JS::Value& aResult)
 197       : mozilla::Runnable("FireSuccessAsyncTask"),
 198         mReq(aRequest),
 199         mResult(RootingCx(), aResult) {}
 200
 201  public:
 202   // Due to the fact that initialization can fail during shutdown (since we
 203   // can't fetch a js context), set up an initiatization function to make sure
 204   // we can return the failure appropriately
 205   static nsresult Dispatch(DOMRequest* aRequest, const JS::Value& aResult) {
 206     RefPtr<FireSuccessAsyncTask> asyncTask =
 207         new FireSuccessAsyncTask(aRequest, aResult);
 208     MOZ_ALWAYS_SUCCEEDS(NS_DispatchToCurrentThread(asyncTask));
 209     return NS_OK;
 210   }
 211
 212   NS_IMETHOD
 213   Run() override {
 214     mReq->FireSuccess(
 215         JS::Handle<JS::Value>::fromMarkedLocation(mResult.address()));
 216     return NS_OK;
 217   }
 218
 219  private:
 220   RefPtr<DOMRequest> mReq;
 221   JS::PersistentRooted<JS::Value> mResult;
 222 };
 223
 224 class FireErrorAsyncTask : public mozilla::Runnable {
 225  public:
 226   FireErrorAsyncTask(DOMRequest* aRequest, const nsAString& aError)
 227       : mozilla::Runnable("FireErrorAsyncTask"),
 228         mReq(aRequest),
 229         mError(aError) {}
 230
 231   NS_IMETHOD
 232   Run() override {
 233     mReq->FireError(mError);
 234     return NS_OK;
 235   }
 236
 237  private:
 238   RefPtr<DOMRequest> mReq;
 239   nsString mError;
 240 };
 241
 242 NS_IMETHODIMP
 243 DOMRequestService::FireSuccessAsync(DOMRequest* aRequest,
 244                                     JS::Handle<JS::Value> aResult) {
 245   NS_ENSURE_STATE(aRequest);
 246   return FireSuccessAsyncTask::Dispatch(aRequest, aResult);
 247 }
 248
 249 NS_IMETHODIMP
 250 DOMRequestService::FireErrorAsync(DOMRequest* aRequest,
 251                                   const nsAString& aError) {
 252   NS_ENSURE_STATE(aRequest);
 253   nsCOMPtr<nsIRunnable> asyncTask = new FireErrorAsyncTask(aRequest, aError);
 254   MOZ_ALWAYS_SUCCEEDS(NS_DispatchToCurrentThread(asyncTask));
 255   return NS_OK;
 256 }