dom/base/DOMRequest.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=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 "DOMError.h"
  10 #include "nsThreadUtils.h"
  11 #include "DOMCursor.h"
  12 #include "nsIDOMEvent.h"
  13
  14 using mozilla::dom::DOMError;
  15 using mozilla::dom::DOMRequest;
  16 using mozilla::dom::DOMRequestService;
  17 using mozilla::dom::DOMCursor;
  18 using mozilla::AutoSafeJSContext;
  19
  20 DOMRequest::DOMRequest(nsPIDOMWindow* aWindow)
  21   : DOMEventTargetHelper(aWindow->IsInnerWindow() ?
  22                            aWindow : aWindow->GetCurrentInnerWindow())
  23   , mResult(JSVAL_VOID)
  24   , mDone(false)
  25 {
  26 }
  27
  28 NS_IMPL_CYCLE_COLLECTION_CLASS(DOMRequest)
  29
  30 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(DOMRequest,
  31                                                   DOMEventTargetHelper)
  32   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mError)
  33 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
  34
  35 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(DOMRequest,
  36                                                 DOMEventTargetHelper)
  37   NS_IMPL_CYCLE_COLLECTION_UNLINK(mError)
  38   tmp->mResult = JSVAL_VOID;
  39 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
  40
  41 NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(DOMRequest,
  42                                                DOMEventTargetHelper)
  43   // Don't need NS_IMPL_CYCLE_COLLECTION_TRACE_PRESERVED_WRAPPER because
  44   // DOMEventTargetHelper does it for us.
  45   NS_IMPL_CYCLE_COLLECTION_TRACE_JSVAL_MEMBER_CALLBACK(mResult)
  46 NS_IMPL_CYCLE_COLLECTION_TRACE_END
  47
  48 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(DOMRequest)
  49   NS_INTERFACE_MAP_ENTRY(nsIDOMDOMRequest)
  50 NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
  51
  52 NS_IMPL_ADDREF_INHERITED(DOMRequest, DOMEventTargetHelper)
  53 NS_IMPL_RELEASE_INHERITED(DOMRequest, DOMEventTargetHelper)
  54
  55 /* virtual */ JSObject*
  56 DOMRequest::WrapObject(JSContext* aCx)
  57 {
  58   return DOMRequestBinding::Wrap(aCx, this);
  59 }
  60
  61 NS_IMPL_EVENT_HANDLER(DOMRequest, success)
  62 NS_IMPL_EVENT_HANDLER(DOMRequest, error)
  63
  64 NS_IMETHODIMP
  65 DOMRequest::GetReadyState(nsAString& aReadyState)
  66 {
  67   DOMRequestReadyState readyState = ReadyState();
  68   switch (readyState) {
  69     case DOMRequestReadyState::Pending:
  70       aReadyState.AssignLiteral("pending");
  71       break;
  72     case DOMRequestReadyState::Done:
  73       aReadyState.AssignLiteral("done");
  74       break;
  75     default:
  76       MOZ_CRASH("Unrecognized readyState.");
  77   }
  78
  79   return NS_OK;
  80 }
  81
  82 NS_IMETHODIMP
  83 DOMRequest::GetResult(JS::MutableHandle<JS::Value> aResult)
  84 {
  85   GetResult(nullptr, aResult);
  86   return NS_OK;
  87 }
  88
  89 NS_IMETHODIMP
  90 DOMRequest::GetError(nsISupports** aError)
  91 {
  92   NS_IF_ADDREF(*aError = GetError());
  93   return NS_OK;
  94 }
  95
  96 void
  97 DOMRequest::FireSuccess(JS::Handle<JS::Value> aResult)
  98 {
  99   NS_ASSERTION(!mDone, "mDone shouldn't have been set to true already!");
 100   NS_ASSERTION(!mError, "mError shouldn't have been set!");
 101   NS_ASSERTION(mResult == JSVAL_VOID, "mResult shouldn't have been set!");
 102
 103   mDone = true;
 104   if (aResult.isGCThing()) {
 105     RootResultVal();
 106   }
 107   mResult = aResult;
 108
 109   FireEvent(NS_LITERAL_STRING("success"), false, false);
 110 }
 111
 112 void
 113 DOMRequest::FireError(const nsAString& aError)
 114 {
 115   NS_ASSERTION(!mDone, "mDone shouldn't have been set to true already!");
 116   NS_ASSERTION(!mError, "mError shouldn't have been set!");
 117   NS_ASSERTION(mResult == JSVAL_VOID, "mResult shouldn't have been set!");
 118
 119   mDone = true;
 120   mError = new DOMError(GetOwner(), aError);
 121
 122   FireEvent(NS_LITERAL_STRING("error"), true, true);
 123 }
 124
 125 void
 126 DOMRequest::FireError(nsresult aError)
 127 {
 128   NS_ASSERTION(!mDone, "mDone shouldn't have been set to true already!");
 129   NS_ASSERTION(!mError, "mError shouldn't have been set!");
 130   NS_ASSERTION(mResult == JSVAL_VOID, "mResult shouldn't have been set!");
 131
 132   mDone = true;
 133   mError = new DOMError(GetOwner(), aError);
 134
 135   FireEvent(NS_LITERAL_STRING("error"), true, true);
 136 }
 137
 138 void
 139 DOMRequest::FireDetailedError(DOMError* aError)
 140 {
 141   NS_ASSERTION(!mDone, "mDone shouldn't have been set to true already!");
 142   NS_ASSERTION(!mError, "mError shouldn't have been set!");
 143   NS_ASSERTION(mResult == JSVAL_VOID, "mResult shouldn't have been set!");
 144   NS_ASSERTION(aError, "No detailed error provided");
 145
 146   mDone = true;
 147   mError = aError;
 148
 149   FireEvent(NS_LITERAL_STRING("error"), true, true);
 150 }
 151
 152 void
 153 DOMRequest::FireEvent(const nsAString& aType, bool aBubble, bool aCancelable)
 154 {
 155   if (NS_FAILED(CheckInnerWindowCorrectness())) {
 156     return;
 157   }
 158
 159   nsCOMPtr<nsIDOMEvent> event;
 160   NS_NewDOMEvent(getter_AddRefs(event), this, nullptr, nullptr);
 161   nsresult rv = event->InitEvent(aType, aBubble, aCancelable);
 162   if (NS_FAILED(rv)) {
 163     return;
 164   }
 165
 166   event->SetTrusted(true);
 167
 168   bool dummy;
 169   DispatchEvent(event, &dummy);
 170 }
 171
 172 void
 173 DOMRequest::RootResultVal()
 174 {
 175   mozilla::HoldJSObjects(this);
 176 }
 177
 178 NS_IMPL_ISUPPORTS(DOMRequestService, nsIDOMRequestService)
 179
 180 NS_IMETHODIMP
 181 DOMRequestService::CreateRequest(nsIDOMWindow* aWindow,
 182                                  nsIDOMDOMRequest** aRequest)
 183 {
 184   nsCOMPtr<nsPIDOMWindow> win(do_QueryInterface(aWindow));
 185   NS_ENSURE_STATE(win);
 186   NS_ADDREF(*aRequest = new DOMRequest(win));
 187
 188   return NS_OK;
 189 }
 190
 191 NS_IMETHODIMP
 192 DOMRequestService::CreateCursor(nsIDOMWindow* aWindow,
 193                                 nsICursorContinueCallback* aCallback,
 194                                 nsIDOMDOMCursor** aCursor)
 195 {
 196   nsCOMPtr<nsPIDOMWindow> win(do_QueryInterface(aWindow));
 197   NS_ENSURE_STATE(win);
 198   NS_ADDREF(*aCursor = new DOMCursor(win, aCallback));
 199
 200   return NS_OK;
 201 }
 202
 203 NS_IMETHODIMP
 204 DOMRequestService::FireSuccess(nsIDOMDOMRequest* aRequest,
 205                                JS::Handle<JS::Value> aResult)
 206 {
 207   NS_ENSURE_STATE(aRequest);
 208   static_cast<DOMRequest*>(aRequest)->FireSuccess(aResult);
 209
 210   return NS_OK;
 211 }
 212
 213 NS_IMETHODIMP
 214 DOMRequestService::FireError(nsIDOMDOMRequest* aRequest,
 215                              const nsAString& aError)
 216 {
 217   NS_ENSURE_STATE(aRequest);
 218   static_cast<DOMRequest*>(aRequest)->FireError(aError);
 219
 220   return NS_OK;
 221 }
 222
 223 NS_IMETHODIMP
 224 DOMRequestService::FireDetailedError(nsIDOMDOMRequest* aRequest,
 225                                      nsISupports* aError)
 226 {
 227   NS_ENSURE_STATE(aRequest);
 228   nsCOMPtr<DOMError> err = do_QueryInterface(aError);
 229   NS_ENSURE_STATE(err);
 230   static_cast<DOMRequest*>(aRequest)->FireDetailedError(err);
 231
 232   return NS_OK;
 233 }
 234
 235 class FireSuccessAsyncTask : public nsRunnable
 236 {
 237
 238   FireSuccessAsyncTask(JSContext* aCx,
 239                        DOMRequest* aRequest,
 240                        const JS::Value& aResult) :
 241     mReq(aRequest),
 242     mResult(aCx, aResult)
 243   {
 244   }
 245
 246 public:
 247
 248   // Due to the fact that initialization can fail during shutdown (since we
 249   // can't fetch a js context), set up an initiatization function to make sure
 250   // we can return the failure appropriately
 251   static nsresult
 252   Dispatch(DOMRequest* aRequest,
 253            const JS::Value& aResult)
 254   {
 255     NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 256     AutoSafeJSContext cx;
 257     nsRefPtr<FireSuccessAsyncTask> asyncTask = new FireSuccessAsyncTask(cx, aRequest, aResult);
 258     if (NS_FAILED(NS_DispatchToMainThread(asyncTask))) {
 259       NS_WARNING("Failed to dispatch to main thread!");
 260       return NS_ERROR_FAILURE;
 261     }
 262     return NS_OK;
 263   }
 264
 265   NS_IMETHODIMP
 266   Run()
 267   {
 268     mReq->FireSuccess(JS::Handle<JS::Value>::fromMarkedLocation(mResult.address()));
 269     return NS_OK;
 270   }
 271
 272   ~FireSuccessAsyncTask()
 273   {
 274     NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 275   }
 276
 277 private:
 278   nsRefPtr<DOMRequest> mReq;
 279   JS::PersistentRooted<JS::Value> mResult;
 280 };
 281
 282 class FireErrorAsyncTask : public nsRunnable
 283 {
 284 public:
 285   FireErrorAsyncTask(DOMRequest* aRequest,
 286                      const nsAString& aError) :
 287     mReq(aRequest),
 288     mError(aError)
 289   {
 290   }
 291
 292   NS_IMETHODIMP
 293   Run()
 294   {
 295     mReq->FireError(mError);
 296     return NS_OK;
 297   }
 298 private:
 299   nsRefPtr<DOMRequest> mReq;
 300   nsString mError;
 301 };
 302
 303 NS_IMETHODIMP
 304 DOMRequestService::FireSuccessAsync(nsIDOMDOMRequest* aRequest,
 305                                     JS::Handle<JS::Value> aResult)
 306 {
 307   NS_ENSURE_STATE(aRequest);
 308   return FireSuccessAsyncTask::Dispatch(static_cast<DOMRequest*>(aRequest), aResult);
 309 }
 310
 311 NS_IMETHODIMP
 312 DOMRequestService::FireErrorAsync(nsIDOMDOMRequest* aRequest,
 313                                   const nsAString& aError)
 314 {
 315   NS_ENSURE_STATE(aRequest);
 316   nsCOMPtr<nsIRunnable> asyncTask =
 317     new FireErrorAsyncTask(static_cast<DOMRequest*>(aRequest), aError);
 318   if (NS_FAILED(NS_DispatchToMainThread(asyncTask))) {
 319     NS_WARNING("Failed to dispatch to main thread!");
 320     return NS_ERROR_FAILURE;
 321   }
 322   return NS_OK;
 323 }
 324
 325 NS_IMETHODIMP
 326 DOMRequestService::FireDone(nsIDOMDOMCursor* aCursor) {
 327   NS_ENSURE_STATE(aCursor);
 328   static_cast<DOMCursor*>(aCursor)->FireDone();
 329
 330   return NS_OK;
 331 }