dom/url/URLWorker.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
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "URLWorker.h"
   8
   9 #include "mozilla/dom/Blob.h"
  10 #include "mozilla/dom/BlobImpl.h"
  11 #include "mozilla/dom/BlobURLProtocolHandler.h"
  12 #include "mozilla/dom/WorkerRunnable.h"
  13 #include "mozilla/dom/WorkerScope.h"
  14
  15 namespace mozilla::dom {
  16
  17 // This class creates an URL from a DOM Blob on the main thread.
  18 class CreateURLRunnable : public WorkerMainThreadRunnable {
  19  private:
  20   BlobImpl* mBlobImpl;
  21   nsAString& mURL;
  22
  23  public:
  24   CreateURLRunnable(WorkerPrivate* aWorkerPrivate, BlobImpl* aBlobImpl,
  25                     nsAString& aURL)
  26       : WorkerMainThreadRunnable(aWorkerPrivate, "URL :: CreateURL"_ns),
  27         mBlobImpl(aBlobImpl),
  28         mURL(aURL) {
  29     MOZ_ASSERT(aBlobImpl);
  30   }
  31
  32   bool MainThreadRun() override {
  33     using namespace mozilla::ipc;
  34
  35     AssertIsOnMainThread();
  36
  37     nsCOMPtr<nsIPrincipal> principal = mWorkerPrivate->GetPrincipal();
  38
  39     nsAutoCString url;
  40     nsresult rv = BlobURLProtocolHandler::AddDataEntry(
  41         mBlobImpl, principal, Some(mWorkerPrivate->AgentClusterId()), url);
  42
  43     if (NS_FAILED(rv)) {
  44       NS_WARNING("Failed to add data entry for the blob!");
  45       SetDOMStringToNull(mURL);
  46       return false;
  47     }
  48
  49     CopyUTF8toUTF16(url, mURL);
  50     return true;
  51   }
  52 };
  53
  54 // This class revokes an URL on the main thread.
  55 class RevokeURLRunnable : public WorkerMainThreadRunnable {
  56  private:
  57   const nsString mURL;
  58
  59  public:
  60   RevokeURLRunnable(WorkerPrivate* aWorkerPrivate, const nsAString& aURL)
  61       : WorkerMainThreadRunnable(aWorkerPrivate, "URL :: RevokeURL"_ns),
  62         mURL(aURL) {}
  63
  64   bool MainThreadRun() override {
  65     AssertIsOnMainThread();
  66
  67     NS_ConvertUTF16toUTF8 url(mURL);
  68
  69     BlobURLProtocolHandler::RemoveDataEntry(
  70         url, mWorkerPrivate->GetPrincipal(),
  71         Some(mWorkerPrivate->AgentClusterId()));
  72     return true;
  73   }
  74 };
  75
  76 // This class checks if an URL is valid on the main thread.
  77 class IsValidURLRunnable : public WorkerMainThreadRunnable {
  78  private:
  79   const nsString mURL;
  80   bool mValid;
  81
  82  public:
  83   IsValidURLRunnable(WorkerPrivate* aWorkerPrivate, const nsAString& aURL)
  84       : WorkerMainThreadRunnable(aWorkerPrivate, "URL :: IsValidURL"_ns),
  85         mURL(aURL),
  86         mValid(false) {}
  87
  88   bool MainThreadRun() override {
  89     AssertIsOnMainThread();
  90
  91     NS_ConvertUTF16toUTF8 url(mURL);
  92     mValid = BlobURLProtocolHandler::HasDataEntry(url);
  93
  94     return true;
  95   }
  96
  97   bool IsValidURL() const { return mValid; }
  98 };
  99
 100 /* static */
 101 void URLWorker::CreateObjectURL(const GlobalObject& aGlobal, Blob& aBlob,
 102                                 nsAString& aResult, mozilla::ErrorResult& aRv) {
 103   JSContext* cx = aGlobal.Context();
 104   WorkerPrivate* workerPrivate = GetWorkerPrivateFromContext(cx);
 105
 106   RefPtr<BlobImpl> blobImpl = aBlob.Impl();
 107   MOZ_ASSERT(blobImpl);
 108
 109   RefPtr<CreateURLRunnable> runnable =
 110       new CreateURLRunnable(workerPrivate, blobImpl, aResult);
 111
 112   runnable->Dispatch(Canceling, aRv);
 113   if (NS_WARN_IF(aRv.Failed())) {
 114     return;
 115   }
 116
 117   WorkerGlobalScope* scope = workerPrivate->GlobalScope();
 118   MOZ_ASSERT(scope);
 119
 120   scope->RegisterHostObjectURI(NS_ConvertUTF16toUTF8(aResult));
 121 }
 122
 123 /* static */
 124 void URLWorker::RevokeObjectURL(const GlobalObject& aGlobal,
 125                                 const nsAString& aUrl, ErrorResult& aRv) {
 126   JSContext* cx = aGlobal.Context();
 127   WorkerPrivate* workerPrivate = GetWorkerPrivateFromContext(cx);
 128
 129   RefPtr<RevokeURLRunnable> runnable =
 130       new RevokeURLRunnable(workerPrivate, aUrl);
 131
 132   runnable->Dispatch(Canceling, aRv);
 133   if (NS_WARN_IF(aRv.Failed())) {
 134     return;
 135   }
 136
 137   WorkerGlobalScope* scope = workerPrivate->GlobalScope();
 138   MOZ_ASSERT(scope);
 139
 140   scope->UnregisterHostObjectURI(NS_ConvertUTF16toUTF8(aUrl));
 141 }
 142
 143 /* static */
 144 bool URLWorker::IsValidObjectURL(const GlobalObject& aGlobal,
 145                                  const nsAString& aUrl, ErrorResult& aRv) {
 146   JSContext* cx = aGlobal.Context();
 147   WorkerPrivate* workerPrivate = GetWorkerPrivateFromContext(cx);
 148
 149   RefPtr<IsValidURLRunnable> runnable =
 150       new IsValidURLRunnable(workerPrivate, aUrl);
 151
 152   runnable->Dispatch(Canceling, aRv);
 153   if (NS_WARN_IF(aRv.Failed())) {
 154     return false;
 155   }
 156
 157   return runnable->IsValidURL();
 158 }
 159
 160 }  // namespace mozilla::dom