dom/workers/URL.cpp

   1 /* -*- Mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 40 -*- */
   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 "URL.h"
   7 #include "File.h"
   8
   9 #include "nsTraceRefcnt.h"
  10
  11 #include "WorkerPrivate.h"
  12 #include "nsThreadUtils.h"
  13
  14 #include "nsPIDOMWindow.h"
  15 #include "nsGlobalWindow.h"
  16 #include "nsHostObjectProtocolHandler.h"
  17
  18 #include "nsIDocument.h"
  19 #include "nsIDOMFile.h"
  20
  21 USING_WORKERS_NAMESPACE
  22 using mozilla::dom::WorkerGlobalObject;
  23
  24 // Base class for the Revoke and Create runnable objects.
  25 class URLRunnable : public nsRunnable
  26 {
  27 protected:
  28   WorkerPrivate* mWorkerPrivate;
  29   uint32_t mSyncQueueKey;
  30
  31 private:
  32   class ResponseRunnable : public WorkerSyncRunnable
  33   {
  34     uint32_t mSyncQueueKey;
  35
  36   public:
  37     ResponseRunnable(WorkerPrivate* aWorkerPrivate,
  38                      uint32_t aSyncQueueKey)
  39     : WorkerSyncRunnable(aWorkerPrivate, aSyncQueueKey, false),
  40       mSyncQueueKey(aSyncQueueKey)
  41     {
  42       NS_ASSERTION(aWorkerPrivate, "Don't hand me a null WorkerPrivate!");
  43     }
  44
  45     bool
  46     WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate)
  47     {
  48       aWorkerPrivate->StopSyncLoop(mSyncQueueKey, true);
  49       return true;
  50     }
  51
  52     bool
  53     PreDispatch(JSContext* aCx, WorkerPrivate* aWorkerPrivate)
  54     {
  55       AssertIsOnMainThread();
  56       return true;
  57     }
  58
  59     void
  60     PostDispatch(JSContext* aCx, WorkerPrivate* aWorkerPrivate,
  61                  bool aDispatchResult)
  62     {
  63       AssertIsOnMainThread();
  64     }
  65   };
  66
  67 protected:
  68   URLRunnable(WorkerPrivate* aWorkerPrivate)
  69   : mWorkerPrivate(aWorkerPrivate)
  70   {
  71     mWorkerPrivate->AssertIsOnWorkerThread();
  72   }
  73
  74 public:
  75   bool
  76   Dispatch(JSContext* aCx)
  77   {
  78     mWorkerPrivate->AssertIsOnWorkerThread();
  79     mSyncQueueKey = mWorkerPrivate->CreateNewSyncLoop();
  80
  81     if (NS_FAILED(NS_DispatchToMainThread(this, NS_DISPATCH_NORMAL))) {
  82       JS_ReportError(aCx, "Failed to dispatch to main thread!");
  83       mWorkerPrivate->StopSyncLoop(mSyncQueueKey, false);
  84       return false;
  85     }
  86
  87     return mWorkerPrivate->RunSyncLoop(aCx, mSyncQueueKey);
  88   }
  89
  90 private:
  91   NS_IMETHOD Run()
  92   {
  93     AssertIsOnMainThread();
  94
  95     MainThreadRun();
  96
  97     nsRefPtr<ResponseRunnable> response =
  98       new ResponseRunnable(mWorkerPrivate, mSyncQueueKey);
  99     if (!response->Dispatch(nullptr)) {
 100       NS_WARNING("Failed to dispatch response!");
 101     }
 102
 103     return NS_OK;
 104   }
 105
 106 protected:
 107   virtual void
 108   MainThreadRun() = 0;
 109 };
 110
 111 // This class creates an URL from a DOM Blob on the main thread.
 112 class CreateURLRunnable : public URLRunnable
 113 {
 114 private:
 115   nsIDOMBlob* mBlob;
 116   nsString& mURL;
 117
 118 public:
 119   CreateURLRunnable(WorkerPrivate* aWorkerPrivate, nsIDOMBlob* aBlob,
 120                     const mozilla::dom::objectURLOptionsWorkers& aOptions,
 121                     nsString& aURL)
 122   : URLRunnable(aWorkerPrivate),
 123     mBlob(aBlob),
 124     mURL(aURL)
 125   {
 126     MOZ_ASSERT(aBlob);
 127   }
 128
 129   void
 130   MainThreadRun()
 131   {
 132     AssertIsOnMainThread();
 133
 134     nsCOMPtr<nsIPrincipal> principal;
 135     nsIDocument* doc = nullptr;
 136
 137     nsCOMPtr<nsPIDOMWindow> window = mWorkerPrivate->GetWindow();
 138     if (window) {
 139       doc = window->GetExtantDoc();
 140       if (!doc) {
 141         SetDOMStringToNull(mURL);
 142         return;
 143       }
 144
 145       principal = doc->NodePrincipal();
 146     } else {
 147       MOZ_ASSERT(mWorkerPrivate->IsChromeWorker());
 148       principal = mWorkerPrivate->GetPrincipal();
 149     }
 150
 151     nsCString url;
 152     nsresult rv = nsHostObjectProtocolHandler::AddDataEntry(
 153         NS_LITERAL_CSTRING(BLOBURI_SCHEME),
 154         mBlob, principal, url);
 155
 156     if (NS_FAILED(rv)) {
 157       NS_WARNING("Failed to add data entry for the blob!");
 158       SetDOMStringToNull(mURL);
 159       return;
 160     }
 161
 162     if (doc) {
 163       doc->RegisterHostObjectUri(url);
 164     } else {
 165       mWorkerPrivate->RegisterHostObjectURI(url);
 166     }
 167
 168     mURL = NS_ConvertUTF8toUTF16(url);
 169   }
 170 };
 171
 172 // This class revokes an URL on the main thread.
 173 class RevokeURLRunnable : public URLRunnable
 174 {
 175 private:
 176   const nsString mURL;
 177
 178 public:
 179   RevokeURLRunnable(WorkerPrivate* aWorkerPrivate,
 180                     const nsAString& aURL)
 181   : URLRunnable(aWorkerPrivate),
 182     mURL(aURL)
 183   {}
 184
 185   void
 186   MainThreadRun()
 187   {
 188     AssertIsOnMainThread();
 189
 190     nsCOMPtr<nsIPrincipal> principal;
 191     nsIDocument* doc = nullptr;
 192
 193     nsCOMPtr<nsPIDOMWindow> window = mWorkerPrivate->GetWindow();
 194     if (window) {
 195       doc = window->GetExtantDoc();
 196       if (!doc) {
 197         return;
 198       }
 199
 200       principal = doc->NodePrincipal();
 201     } else {
 202       MOZ_ASSERT(mWorkerPrivate->IsChromeWorker());
 203       principal = mWorkerPrivate->GetPrincipal();
 204     }
 205
 206     NS_ConvertUTF16toUTF8 url(mURL);
 207
 208     nsIPrincipal* urlPrincipal =
 209       nsHostObjectProtocolHandler::GetDataEntryPrincipal(url);
 210
 211     bool subsumes;
 212     if (urlPrincipal &&
 213         NS_SUCCEEDED(principal->Subsumes(urlPrincipal, &subsumes)) &&
 214         subsumes) {
 215       if (doc) {
 216         doc->UnregisterHostObjectUri(url);
 217       }
 218
 219       nsHostObjectProtocolHandler::RemoveDataEntry(url);
 220     }
 221
 222     if (!window) {
 223       mWorkerPrivate->UnregisterHostObjectURI(url);
 224     }
 225   }
 226 };
 227
 228 // static
 229 void
 230 URL::CreateObjectURL(const WorkerGlobalObject& aGlobal, JSObject* aBlob,
 231                      const mozilla::dom::objectURLOptionsWorkers& aOptions,
 232                      nsString& aResult, mozilla::ErrorResult& aRv)
 233 {
 234   JSContext* cx = aGlobal.GetContext();
 235   WorkerPrivate* workerPrivate = GetWorkerPrivateFromContext(cx);
 236
 237   nsCOMPtr<nsIDOMBlob> blob = file::GetDOMBlobFromJSObject(aBlob);
 238   if (!blob) {
 239     SetDOMStringToNull(aResult);
 240
 241     NS_NAMED_LITERAL_STRING(argStr, "Argument 1 of URL.createObjectURL");
 242     NS_NAMED_LITERAL_STRING(blobStr, "Blob");
 243     aRv.ThrowTypeError(MSG_DOES_NOT_IMPLEMENT_INTERFACE, &argStr, &blobStr);
 244     return;
 245   }
 246
 247   nsRefPtr<CreateURLRunnable> runnable =
 248     new CreateURLRunnable(workerPrivate, blob, aOptions, aResult);
 249
 250   if (!runnable->Dispatch(cx)) {
 251     JS_ReportPendingException(cx);
 252   }
 253 }
 254
 255 // static
 256 void
 257 URL::CreateObjectURL(const WorkerGlobalObject& aGlobal, JSObject& aBlob,
 258                      const mozilla::dom::objectURLOptionsWorkers& aOptions,
 259                      nsString& aResult, mozilla::ErrorResult& aRv)
 260 {
 261   return CreateObjectURL(aGlobal, &aBlob, aOptions, aResult, aRv);
 262 }
 263
 264 // static
 265 void
 266 URL::RevokeObjectURL(const WorkerGlobalObject& aGlobal, const nsAString& aUrl)
 267 {
 268   JSContext* cx = aGlobal.GetContext();
 269   WorkerPrivate* workerPrivate = GetWorkerPrivateFromContext(cx);
 270
 271   nsRefPtr<RevokeURLRunnable> runnable =
 272     new RevokeURLRunnable(workerPrivate, aUrl);
 273
 274   if (!runnable->Dispatch(cx)) {
 275     JS_ReportPendingException(cx);
 276   }
 277 }
 278