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   nsACString& mURL;
  22
  23  public:
  24   CreateURLRunnable(WorkerPrivate* aWorkerPrivate, BlobImpl* aBlobImpl,
  25                     nsACString& 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     nsCOMPtr<nsICookieJarSettings> cookieJarSettings =
  40         mWorkerPrivate->CookieJarSettings();
  41
  42     nsAutoString partKey;
  43     cookieJarSettings->GetPartitionKey(partKey);
  44
  45     nsresult rv = BlobURLProtocolHandler::AddDataEntry(
  46         mBlobImpl, principal, NS_ConvertUTF16toUTF8(partKey), mURL);
  47     if (NS_FAILED(rv)) {
  48       NS_WARNING("Failed to add data entry for the blob!");
  49       mURL.SetIsVoid(true);
  50       return false;
  51     }
  52     return true;
  53   }
  54 };
  55
  56 // This class revokes an URL on the main thread.
  57 class RevokeURLRunnable : public WorkerMainThreadRunnable {
  58  private:
  59   const nsCString mURL;
  60
  61  public:
  62   RevokeURLRunnable(WorkerPrivate* aWorkerPrivate, const nsACString& aURL)
  63       : WorkerMainThreadRunnable(aWorkerPrivate, "URL :: RevokeURL"_ns),
  64         mURL(aURL) {}
  65
  66   bool MainThreadRun() override {
  67     AssertIsOnMainThread();
  68
  69     nsCOMPtr<nsICookieJarSettings> cookieJarSettings =
  70         mWorkerPrivate->CookieJarSettings();
  71
  72     nsAutoString partKey;
  73     cookieJarSettings->GetPartitionKey(partKey);
  74
  75     BlobURLProtocolHandler::RemoveDataEntry(
  76         mURL, mWorkerPrivate->GetPrincipal(), NS_ConvertUTF16toUTF8(partKey));
  77     return true;
  78   }
  79 };
  80
  81 // This class checks if an URL is valid on the main thread.
  82 class IsValidURLRunnable : public WorkerMainThreadRunnable {
  83  private:
  84   const nsCString mURL;
  85   bool mValid;
  86
  87  public:
  88   IsValidURLRunnable(WorkerPrivate* aWorkerPrivate, const nsACString& aURL)
  89       : WorkerMainThreadRunnable(aWorkerPrivate, "URL :: IsValidURL"_ns),
  90         mURL(aURL),
  91         mValid(false) {}
  92
  93   bool MainThreadRun() override {
  94     AssertIsOnMainThread();
  95
  96     mValid = BlobURLProtocolHandler::HasDataEntry(mURL);
  97
  98     return true;
  99   }
 100
 101   bool IsValidURL() const { return mValid; }
 102 };
 103
 104 /* static */
 105 void URLWorker::CreateObjectURL(const GlobalObject& aGlobal, Blob& aBlob,
 106                                 nsACString& aResult,
 107                                 mozilla::ErrorResult& aRv) {
 108   JSContext* cx = aGlobal.Context();
 109   WorkerPrivate* workerPrivate = GetWorkerPrivateFromContext(cx);
 110
 111   RefPtr<BlobImpl> blobImpl = aBlob.Impl();
 112   MOZ_ASSERT(blobImpl);
 113
 114   RefPtr<CreateURLRunnable> runnable =
 115       new CreateURLRunnable(workerPrivate, blobImpl, aResult);
 116
 117   runnable->Dispatch(Canceling, aRv);
 118   if (NS_WARN_IF(aRv.Failed())) {
 119     return;
 120   }
 121
 122   WorkerGlobalScope* scope = workerPrivate->GlobalScope();
 123   MOZ_ASSERT(scope);
 124
 125   scope->RegisterHostObjectURI(aResult);
 126 }
 127
 128 /* static */
 129 void URLWorker::RevokeObjectURL(const GlobalObject& aGlobal,
 130                                 const nsACString& aUrl, ErrorResult& aRv) {
 131   JSContext* cx = aGlobal.Context();
 132   WorkerPrivate* workerPrivate = GetWorkerPrivateFromContext(cx);
 133
 134   RefPtr<RevokeURLRunnable> runnable =
 135       new RevokeURLRunnable(workerPrivate, aUrl);
 136
 137   runnable->Dispatch(Canceling, aRv);
 138   if (NS_WARN_IF(aRv.Failed())) {
 139     return;
 140   }
 141
 142   WorkerGlobalScope* scope = workerPrivate->GlobalScope();
 143   MOZ_ASSERT(scope);
 144
 145   scope->UnregisterHostObjectURI(aUrl);
 146 }
 147
 148 /* static */
 149 bool URLWorker::IsValidObjectURL(const GlobalObject& aGlobal,
 150                                  const nsACString& aUrl, ErrorResult& aRv) {
 151   JSContext* cx = aGlobal.Context();
 152   WorkerPrivate* workerPrivate = GetWorkerPrivateFromContext(cx);
 153
 154   RefPtr<IsValidURLRunnable> runnable =
 155       new IsValidURLRunnable(workerPrivate, aUrl);
 156
 157   runnable->Dispatch(Canceling, aRv);
 158   if (NS_WARN_IF(aRv.Failed())) {
 159     return false;
 160   }
 161
 162   return runnable->IsValidURL();
 163 }
 164
 165 }  // namespace mozilla::dom