dom/workers/WorkerScope.cpp

   1 /* -*- Mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 40 -*- */
   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
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "WorkerScope.h"
   8
   9 #include "Location.h"
  10 #include "Navigator.h"
  11 #include "ScriptLoader.h"
  12 #include "WorkerPrivate.h"
  13
  14 #include "jsapi.h"
  15 #include "mozilla/dom/FunctionBinding.h"
  16 #include "mozilla/dom/DedicatedWorkerGlobalScopeBinding.h"
  17 #include "mozilla/dom/SharedWorkerGlobalScopeBinding.h"
  18
  19 #ifdef ANDROID
  20 #include <android/log.h>
  21 #endif
  22
  23 #include "RuntimeService.h" // For WorkersDumpEnabled().
  24
  25 #define UNWRAP_WORKER_OBJECT(Interface, obj, value)                           \
  26   UnwrapObject<prototypes::id::Interface##_workers,                           \
  27     mozilla::dom::Interface##Binding_workers::NativeType>(obj, value)
  28
  29 using namespace mozilla::dom;
  30 USING_WORKERS_NAMESPACE
  31
  32 BEGIN_WORKERS_NAMESPACE
  33
  34 WorkerGlobalScope::WorkerGlobalScope(WorkerPrivate* aWorkerPrivate)
  35 : mWorkerPrivate(aWorkerPrivate)
  36 {
  37   mWorkerPrivate->AssertIsOnWorkerThread();
  38
  39   SetIsDOMBinding();
  40 }
  41
  42 WorkerGlobalScope::~WorkerGlobalScope()
  43 {
  44   // Matches the HoldJSObjects in CreateGlobal.
  45   mozilla::DropJSObjects(this);
  46 }
  47
  48 NS_IMPL_CYCLE_COLLECTION_CLASS(WorkerGlobalScope)
  49
  50 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(WorkerGlobalScope,
  51                                                   nsDOMEventTargetHelper)
  52   tmp->mWorkerPrivate->AssertIsOnWorkerThread();
  53 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
  54
  55 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(WorkerGlobalScope,
  56                                                 nsDOMEventTargetHelper)
  57   tmp->mWorkerPrivate->AssertIsOnWorkerThread();
  58 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
  59
  60 NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(WorkerGlobalScope,
  61                                                nsDOMEventTargetHelper)
  62   tmp->mWorkerPrivate->AssertIsOnWorkerThread();
  63
  64   tmp->mWorkerPrivate->TraceTimeouts(aCallbacks, aClosure);
  65 NS_IMPL_CYCLE_COLLECTION_TRACE_END
  66
  67 NS_IMPL_ADDREF_INHERITED(WorkerGlobalScope, nsDOMEventTargetHelper)
  68 NS_IMPL_RELEASE_INHERITED(WorkerGlobalScope, nsDOMEventTargetHelper)
  69
  70 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(WorkerGlobalScope)
  71   NS_INTERFACE_MAP_ENTRY(nsIGlobalObject)
  72 NS_INTERFACE_MAP_END_INHERITING(nsDOMEventTargetHelper)
  73
  74 JSObject*
  75 WorkerGlobalScope::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aScope)
  76 {
  77   MOZ_CRASH("We should never get here!");
  78 }
  79
  80 already_AddRefed<WorkerLocation>
  81 WorkerGlobalScope::Location()
  82 {
  83   mWorkerPrivate->AssertIsOnWorkerThread();
  84
  85   if (!mLocation) {
  86     WorkerPrivate::LocationInfo& info = mWorkerPrivate->GetLocationInfo();
  87
  88     mLocation = WorkerLocation::Create(info);
  89     MOZ_ASSERT(mLocation);
  90   }
  91
  92   nsRefPtr<WorkerLocation> location = mLocation;
  93   return location.forget();
  94 }
  95
  96 already_AddRefed<WorkerNavigator>
  97 WorkerGlobalScope::Navigator()
  98 {
  99   mWorkerPrivate->AssertIsOnWorkerThread();
 100
 101   if (!mNavigator) {
 102     mNavigator = WorkerNavigator::Create();
 103     MOZ_ASSERT(mNavigator);
 104   }
 105
 106   nsRefPtr<WorkerNavigator> navigator = mNavigator;
 107   return navigator.forget();
 108 }
 109
 110 void
 111 WorkerGlobalScope::Close(JSContext* aCx)
 112 {
 113   mWorkerPrivate->AssertIsOnWorkerThread();
 114
 115   mWorkerPrivate->CloseInternal(aCx);
 116 }
 117
 118 OnErrorEventHandlerNonNull*
 119 WorkerGlobalScope::GetOnerror()
 120 {
 121   mWorkerPrivate->AssertIsOnWorkerThread();
 122
 123   nsEventListenerManager *elm = GetExistingListenerManager();
 124   return elm ? elm->GetOnErrorEventHandler() : nullptr;
 125 }
 126
 127 void
 128 WorkerGlobalScope::SetOnerror(OnErrorEventHandlerNonNull* aHandler)
 129 {
 130   mWorkerPrivate->AssertIsOnWorkerThread();
 131
 132   nsEventListenerManager *elm = GetOrCreateListenerManager();
 133   if (elm) {
 134     elm->SetEventHandler(aHandler);
 135   }
 136 }
 137
 138 void
 139 WorkerGlobalScope::ImportScripts(JSContext* aCx,
 140                                  const Sequence<nsString>& aScriptURLs,
 141                                  ErrorResult& aRv)
 142 {
 143   mWorkerPrivate->AssertIsOnWorkerThread();
 144   scriptloader::Load(aCx, mWorkerPrivate, aScriptURLs, aRv);
 145 }
 146
 147 int32_t
 148 WorkerGlobalScope::SetTimeout(JSContext* aCx,
 149                               Function& aHandler,
 150                               const int32_t aTimeout,
 151                               const Sequence<JS::Value>& aArguments,
 152                               ErrorResult& aRv)
 153 {
 154   mWorkerPrivate->AssertIsOnWorkerThread();
 155   return mWorkerPrivate->SetTimeout(aCx, &aHandler, EmptyString(), aTimeout,
 156                                     aArguments, false, aRv);
 157 }
 158
 159 int32_t
 160 WorkerGlobalScope::SetTimeout(const nsAString& aHandler,
 161                               const int32_t aTimeout,
 162                               ErrorResult& aRv)
 163 {
 164   mWorkerPrivate->AssertIsOnWorkerThread();
 165   Sequence<JS::Value> dummy;
 166   return mWorkerPrivate->SetTimeout(GetCurrentThreadJSContext(), nullptr,
 167                                     aHandler, aTimeout, dummy, false, aRv);
 168 }
 169
 170 void
 171 WorkerGlobalScope::ClearTimeout(int32_t aHandle, ErrorResult& aRv)
 172 {
 173   mWorkerPrivate->AssertIsOnWorkerThread();
 174   mWorkerPrivate->ClearTimeout(aHandle);
 175 }
 176
 177 int32_t
 178 WorkerGlobalScope::SetInterval(JSContext* aCx,
 179                                Function& aHandler,
 180                                const Optional<int32_t>& aTimeout,
 181                                const Sequence<JS::Value>& aArguments,
 182                                ErrorResult& aRv)
 183 {
 184   mWorkerPrivate->AssertIsOnWorkerThread();
 185
 186   int32_t timeout = aTimeout.WasPassed() ? aTimeout.Value() : 0;
 187
 188   return mWorkerPrivate->SetTimeout(aCx, &aHandler, EmptyString(), timeout,
 189                                     aArguments, !!timeout, aRv);
 190 }
 191
 192 int32_t
 193 WorkerGlobalScope::SetInterval(const nsAString& aHandler,
 194                                const Optional<int32_t>& aTimeout,
 195                                ErrorResult& aRv)
 196 {
 197   mWorkerPrivate->AssertIsOnWorkerThread();
 198
 199   Sequence<JS::Value> dummy;
 200
 201   int32_t timeout = aTimeout.WasPassed() ? aTimeout.Value() : 0;
 202
 203   return mWorkerPrivate->SetTimeout(GetCurrentThreadJSContext(), nullptr,
 204                                     aHandler, timeout, dummy, !!timeout, aRv);
 205 }
 206
 207 void
 208 WorkerGlobalScope::ClearInterval(int32_t aHandle, ErrorResult& aRv)
 209 {
 210   mWorkerPrivate->AssertIsOnWorkerThread();
 211   mWorkerPrivate->ClearTimeout(aHandle);
 212 }
 213
 214 void
 215 WorkerGlobalScope::Atob(const nsAString& aAtob, nsAString& aOutput, ErrorResult& aRv) const
 216 {
 217   mWorkerPrivate->AssertIsOnWorkerThread();
 218   aRv = nsContentUtils::Atob(aAtob, aOutput);
 219 }
 220
 221 void
 222 WorkerGlobalScope::Btoa(const nsAString& aBtoa, nsAString& aOutput, ErrorResult& aRv) const
 223 {
 224   mWorkerPrivate->AssertIsOnWorkerThread();
 225   aRv = nsContentUtils::Btoa(aBtoa, aOutput);
 226 }
 227
 228 void
 229 WorkerGlobalScope::Dump(const Optional<nsAString>& aString) const
 230 {
 231   mWorkerPrivate->AssertIsOnWorkerThread();
 232
 233   if (!aString.WasPassed()) {
 234     return;
 235   }
 236
 237   if (!mWorkerPrivate->DumpEnabled()) {
 238     return;
 239   }
 240
 241   NS_ConvertUTF16toUTF8 str(aString.Value());
 242
 243 #ifdef ANDROID
 244   __android_log_print(ANDROID_LOG_INFO, "Gecko", "%s", str.get());
 245 #endif
 246   fputs(str.get(), stdout);
 247   fflush(stdout);
 248 }
 249
 250 DedicatedWorkerGlobalScope::DedicatedWorkerGlobalScope(WorkerPrivate* aWorkerPrivate)
 251 : WorkerGlobalScope(aWorkerPrivate)
 252 {
 253 }
 254
 255 /* static */ bool
 256 DedicatedWorkerGlobalScope::Visible(JSContext* aCx, JSObject* aObj)
 257 {
 258   DedicatedWorkerGlobalScope* self = nullptr;
 259   nsresult rv = UNWRAP_WORKER_OBJECT(DedicatedWorkerGlobalScope, aObj, self);
 260   return NS_SUCCEEDED(rv) && self;
 261 }
 262
 263 JSObject*
 264 DedicatedWorkerGlobalScope::WrapGlobalObject(JSContext* aCx,
 265                                              JS::CompartmentOptions& aOptions,
 266                                              JSPrincipals* aPrincipal)
 267 {
 268   mWorkerPrivate->AssertIsOnWorkerThread();
 269   MOZ_ASSERT(!mWorkerPrivate->IsSharedWorker());
 270
 271   // We're wrapping the global, so the scope is undefined.
 272   JS::Rooted<JSObject*> scope(aCx);
 273
 274   return DedicatedWorkerGlobalScopeBinding_workers::Wrap(aCx, scope, this,
 275                                                          this, aOptions,
 276                                                          aPrincipal);
 277 }
 278
 279 void
 280 DedicatedWorkerGlobalScope::PostMessage(JSContext* aCx,
 281                                         JS::Handle<JS::Value> aMessage,
 282                                         const Optional<Sequence<JS::Value>>& aTransferable,
 283                                         ErrorResult& aRv)
 284 {
 285   mWorkerPrivate->AssertIsOnWorkerThread();
 286   mWorkerPrivate->PostMessageToParent(aCx, aMessage, aTransferable, aRv);
 287 }
 288
 289 SharedWorkerGlobalScope::SharedWorkerGlobalScope(WorkerPrivate* aWorkerPrivate,
 290                                                  const nsString& aName)
 291 : WorkerGlobalScope(aWorkerPrivate), mName(aName)
 292 {
 293 }
 294
 295 /* static */ bool
 296 SharedWorkerGlobalScope::Visible(JSContext* aCx, JSObject* aObj)
 297 {
 298   SharedWorkerGlobalScope* self = nullptr;
 299   nsresult rv = UNWRAP_WORKER_OBJECT(SharedWorkerGlobalScope, aObj, self);
 300   return NS_SUCCEEDED(rv) && self;
 301 }
 302
 303 JSObject*
 304 SharedWorkerGlobalScope::WrapGlobalObject(JSContext* aCx,
 305                                           JS::CompartmentOptions& aOptions,
 306                                           JSPrincipals* aPrincipal)
 307 {
 308   mWorkerPrivate->AssertIsOnWorkerThread();
 309   MOZ_ASSERT(mWorkerPrivate->IsSharedWorker());
 310
 311   // We're wrapping the global, so the scope is undefined.
 312   JS::Rooted<JSObject*> scope(aCx);
 313
 314   return SharedWorkerGlobalScopeBinding_workers::Wrap(aCx, scope, this, this,
 315                                                       aOptions, aPrincipal);
 316 }
 317
 318 bool
 319 GetterOnlyJSNative(JSContext* aCx, unsigned aArgc, JS::Value* aVp)
 320 {
 321   JS_ReportErrorNumber(aCx, js_GetErrorMessage, nullptr, JSMSG_GETTER_ONLY);
 322   return false;
 323 }
 324
 325 END_WORKERS_NAMESPACE