The Tor Browser: dom/workers/WorkerScope.cpp@925c144e1f1f (annotated)

dom/workers/WorkerScope.cpp@925c144e1f1f (annotated)

dom/workers/WorkerScope.cpp

Fri, 16 Jan 2015 18:13:44 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Fri, 16 Jan 2015 18:13:44 +0100
branch: TOR_BUG_9701
changeset 14: 925c144e1f1f
permissions: -rw-r--r--

Integrate suggestion from review to improve consistency with existing code.

 /* -*- Mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 40 -*- */
 /* vim: set ts=2 et sw=2 tw=80: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include "WorkerScope.h"
 #include "jsapi.h"
 #include "mozilla/EventListenerManager.h"
 #include "mozilla/dom/FunctionBinding.h"
 #include "mozilla/dom/DedicatedWorkerGlobalScopeBinding.h"
 #include "mozilla/dom/SharedWorkerGlobalScopeBinding.h"
 #include "mozilla/dom/Console.h"
 #ifdef ANDROID
 #include <android/log.h>
 #endif
 #include "Location.h"
 #include "Navigator.h"
 #include "Principal.h"
 #include "RuntimeService.h"
 #include "ScriptLoader.h"
 #include "WorkerPrivate.h"
 #define UNWRAP_WORKER_OBJECT(Interface, obj, value)                           \
   UnwrapObject<prototypes::id::Interface##_workers,                           \
     mozilla::dom::Interface##Binding_workers::NativeType>(obj, value)
 using namespace mozilla;
 using namespace mozilla::dom;
 USING_WORKERS_NAMESPACE
 BEGIN_WORKERS_NAMESPACE
 WorkerGlobalScope::WorkerGlobalScope(WorkerPrivate* aWorkerPrivate)
 : mWorkerPrivate(aWorkerPrivate)
 {
   mWorkerPrivate->AssertIsOnWorkerThread();
   SetIsDOMBinding();
 }
 WorkerGlobalScope::~WorkerGlobalScope()
 {
   mWorkerPrivate->AssertIsOnWorkerThread();
 }
 NS_IMPL_CYCLE_COLLECTION_CLASS(WorkerGlobalScope)
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(WorkerGlobalScope,
                                                   DOMEventTargetHelper)
   tmp->mWorkerPrivate->AssertIsOnWorkerThread();
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mLocation)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mNavigator)
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(WorkerGlobalScope,
                                                 DOMEventTargetHelper)
   tmp->mWorkerPrivate->AssertIsOnWorkerThread();
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mLocation)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mNavigator)
 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
 NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(WorkerGlobalScope,
                                                DOMEventTargetHelper)
   tmp->mWorkerPrivate->AssertIsOnWorkerThread();
   tmp->mWorkerPrivate->TraceTimeouts(aCallbacks, aClosure);
 NS_IMPL_CYCLE_COLLECTION_TRACE_END
 NS_IMPL_ADDREF_INHERITED(WorkerGlobalScope, DOMEventTargetHelper)
 NS_IMPL_RELEASE_INHERITED(WorkerGlobalScope, DOMEventTargetHelper)
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(WorkerGlobalScope)
   NS_INTERFACE_MAP_ENTRY(nsIGlobalObject)
 NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
 JSObject*
 WorkerGlobalScope::WrapObject(JSContext* aCx)
 {
   MOZ_CRASH("We should never get here!");
 }
 already_AddRefed<Console>
 WorkerGlobalScope::GetConsole()
 {
   mWorkerPrivate->AssertIsOnWorkerThread();
   if (!mConsole) {
     mConsole = new Console(nullptr);
     MOZ_ASSERT(mConsole);
   }
   return mConsole.forget();
 }
 already_AddRefed<WorkerLocation>
 WorkerGlobalScope::Location()
 {
   mWorkerPrivate->AssertIsOnWorkerThread();
   if (!mLocation) {
     WorkerPrivate::LocationInfo& info = mWorkerPrivate->GetLocationInfo();
     mLocation = WorkerLocation::Create(info);
     MOZ_ASSERT(mLocation);
   }
   nsRefPtr<WorkerLocation> location = mLocation;
   return location.forget();
 }
 already_AddRefed<WorkerNavigator>
 WorkerGlobalScope::Navigator()
 {
   mWorkerPrivate->AssertIsOnWorkerThread();
   if (!mNavigator) {
     mNavigator = WorkerNavigator::Create(mWorkerPrivate->OnLine());
     MOZ_ASSERT(mNavigator);
   }
   nsRefPtr<WorkerNavigator> navigator = mNavigator;
   return navigator.forget();
 }
 already_AddRefed<WorkerNavigator>
 WorkerGlobalScope::GetExistingNavigator() const
 {
   mWorkerPrivate->AssertIsOnWorkerThread();
   nsRefPtr<WorkerNavigator> navigator = mNavigator;
   return navigator.forget();
 }
 void
 WorkerGlobalScope::Close(JSContext* aCx)
 {
   mWorkerPrivate->AssertIsOnWorkerThread();
   mWorkerPrivate->CloseInternal(aCx);
 }
 OnErrorEventHandlerNonNull*
 WorkerGlobalScope::GetOnerror()
 {
   mWorkerPrivate->AssertIsOnWorkerThread();
   EventListenerManager* elm = GetExistingListenerManager();
   return elm ? elm->GetOnErrorEventHandler() : nullptr;
 }
 void
 WorkerGlobalScope::SetOnerror(OnErrorEventHandlerNonNull* aHandler)
 {
   mWorkerPrivate->AssertIsOnWorkerThread();
   EventListenerManager* elm = GetOrCreateListenerManager();
   if (elm) {
     elm->SetEventHandler(aHandler);
   }
 }
 void
 WorkerGlobalScope::ImportScripts(JSContext* aCx,
                                  const Sequence<nsString>& aScriptURLs,
                                  ErrorResult& aRv)
 {
   mWorkerPrivate->AssertIsOnWorkerThread();
   scriptloader::Load(aCx, mWorkerPrivate, aScriptURLs, aRv);
 }
 int32_t
 WorkerGlobalScope::SetTimeout(JSContext* aCx,
                               Function& aHandler,
                               const int32_t aTimeout,
                               const Sequence<JS::Value>& aArguments,
                               ErrorResult& aRv)
 {
   mWorkerPrivate->AssertIsOnWorkerThread();
   return mWorkerPrivate->SetTimeout(aCx, &aHandler, EmptyString(), aTimeout,
                                     aArguments, false, aRv);
 }
 int32_t
 WorkerGlobalScope::SetTimeout(JSContext* /* unused */,
                               const nsAString& aHandler,
                               const int32_t aTimeout,
                               const Sequence<JS::Value>& /* unused */,
                               ErrorResult& aRv)
 {
   mWorkerPrivate->AssertIsOnWorkerThread();
   Sequence<JS::Value> dummy;
   return mWorkerPrivate->SetTimeout(GetCurrentThreadJSContext(), nullptr,
                                     aHandler, aTimeout, dummy, false, aRv);
 }
 void
 WorkerGlobalScope::ClearTimeout(int32_t aHandle, ErrorResult& aRv)
 {
   mWorkerPrivate->AssertIsOnWorkerThread();
   mWorkerPrivate->ClearTimeout(aHandle);
 }
 int32_t
 WorkerGlobalScope::SetInterval(JSContext* aCx,
                                Function& aHandler,
                                const Optional<int32_t>& aTimeout,
                                const Sequence<JS::Value>& aArguments,
                                ErrorResult& aRv)
 {
   mWorkerPrivate->AssertIsOnWorkerThread();
   int32_t timeout = aTimeout.WasPassed() ? aTimeout.Value() : 0;
   return mWorkerPrivate->SetTimeout(aCx, &aHandler, EmptyString(), timeout,
                                     aArguments, !!timeout, aRv);
 }
 int32_t
 WorkerGlobalScope::SetInterval(JSContext* /* unused */,
                                const nsAString& aHandler,
                                const Optional<int32_t>& aTimeout,
                                const Sequence<JS::Value>& /* unused */,
                                ErrorResult& aRv)
 {
   mWorkerPrivate->AssertIsOnWorkerThread();
   Sequence<JS::Value> dummy;
   int32_t timeout = aTimeout.WasPassed() ? aTimeout.Value() : 0;
   return mWorkerPrivate->SetTimeout(GetCurrentThreadJSContext(), nullptr,
                                     aHandler, timeout, dummy, !!timeout, aRv);
 }
 void
 WorkerGlobalScope::ClearInterval(int32_t aHandle, ErrorResult& aRv)
 {
   mWorkerPrivate->AssertIsOnWorkerThread();
   mWorkerPrivate->ClearTimeout(aHandle);
 }
 void
 WorkerGlobalScope::Atob(const nsAString& aAtob, nsAString& aOutput, ErrorResult& aRv) const
 {
   mWorkerPrivate->AssertIsOnWorkerThread();
   aRv = nsContentUtils::Atob(aAtob, aOutput);
 }
 void
 WorkerGlobalScope::Btoa(const nsAString& aBtoa, nsAString& aOutput, ErrorResult& aRv) const
 {
   mWorkerPrivate->AssertIsOnWorkerThread();
   aRv = nsContentUtils::Btoa(aBtoa, aOutput);
 }
 void
 WorkerGlobalScope::Dump(const Optional<nsAString>& aString) const
 {
   mWorkerPrivate->AssertIsOnWorkerThread();
   if (!aString.WasPassed()) {
     return;
   }
   if (!mWorkerPrivate->DumpEnabled()) {
     return;
   }
   NS_ConvertUTF16toUTF8 str(aString.Value());
 #ifdef ANDROID
   __android_log_print(ANDROID_LOG_INFO, "Gecko", "%s", str.get());
 #endif
   fputs(str.get(), stdout);
   fflush(stdout);
 }
 DedicatedWorkerGlobalScope::DedicatedWorkerGlobalScope(WorkerPrivate* aWorkerPrivate)
 : WorkerGlobalScope(aWorkerPrivate)
 {
 }
 /* static */ bool
 DedicatedWorkerGlobalScope::Visible(JSContext* aCx, JSObject* aObj)
 {
   DedicatedWorkerGlobalScope* self = nullptr;
   nsresult rv = UNWRAP_WORKER_OBJECT(DedicatedWorkerGlobalScope, aObj, self);
   return NS_SUCCEEDED(rv) && self;
 }
 JSObject*
 DedicatedWorkerGlobalScope::WrapGlobalObject(JSContext* aCx)
 {
   mWorkerPrivate->AssertIsOnWorkerThread();
   MOZ_ASSERT(!mWorkerPrivate->IsSharedWorker());
   JS::CompartmentOptions options;
   mWorkerPrivate->CopyJSCompartmentOptions(options);
   // We're wrapping the global, so the scope is undefined.
   JS::Rooted<JSObject*> scope(aCx);
   return DedicatedWorkerGlobalScopeBinding_workers::Wrap(aCx, this, this,
                                                          options,
                                                          GetWorkerPrincipal());
 }
 void
 DedicatedWorkerGlobalScope::PostMessage(JSContext* aCx,
                                         JS::Handle<JS::Value> aMessage,
                                         const Optional<Sequence<JS::Value>>& aTransferable,
                                         ErrorResult& aRv)
 {
   mWorkerPrivate->AssertIsOnWorkerThread();
   mWorkerPrivate->PostMessageToParent(aCx, aMessage, aTransferable, aRv);
 }
 SharedWorkerGlobalScope::SharedWorkerGlobalScope(WorkerPrivate* aWorkerPrivate,
                                                  const nsCString& aName)
 : WorkerGlobalScope(aWorkerPrivate), mName(aName)
 {
 }
 /* static */ bool
 SharedWorkerGlobalScope::Visible(JSContext* aCx, JSObject* aObj)
 {
   SharedWorkerGlobalScope* self = nullptr;
   nsresult rv = UNWRAP_WORKER_OBJECT(SharedWorkerGlobalScope, aObj, self);
   return NS_SUCCEEDED(rv) && self;
 }
 JSObject*
 SharedWorkerGlobalScope::WrapGlobalObject(JSContext* aCx)
 {
   mWorkerPrivate->AssertIsOnWorkerThread();
   MOZ_ASSERT(mWorkerPrivate->IsSharedWorker());
   JS::CompartmentOptions options;
   mWorkerPrivate->CopyJSCompartmentOptions(options);
   // We're wrapping the global, so the scope is undefined.
   JS::Rooted<JSObject*> scope(aCx);
   return SharedWorkerGlobalScopeBinding_workers::Wrap(aCx, this, this, options,
                                                       GetWorkerPrincipal());
 }
 bool
 GetterOnlyJSNative(JSContext* aCx, unsigned aArgc, JS::Value* aVp)
 {
   JS_ReportErrorNumber(aCx, js_GetErrorMessage, nullptr, JSMSG_GETTER_ONLY);
   return false;
 }
 END_WORKERS_NAMESPACE

The Tor Browser / annotate

dom/workers/WorkerScope.cpp@925c144e1f1f (annotated)

dom/workers/WorkerScope.cpp