Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-11-26 06:11:37 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Re-delete dom/src/threads since it has risen from the dead.

Browse Source
This commit is contained in:
Kyle Huey 2011-10-09 11:02:57 -04:00
parent 9ea644607b
commit 3c6914836e
27 changed files with 0 additions and 11806 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1608
dom/src/threads/nsDOMThreadService.cpp
View File

File diff suppressed because it is too large Load Diff

212
dom/src/threads/nsDOMThreadService.h
View File

@ -1,212 +0,0 @@
/* -*- Mode: c++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is worker threads.
*
* The Initial Developer of the Original Code is
* Mozilla Corporation.
* Portions created by the Initial Developer are Copyright (C) 2008
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Vladimir Vukicevic <vladimir@pobox.com> (Original Author)
* Ben Turner <bent.mozilla@gmail.com>
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#ifndef __NSDOMTHREADSERVICE_H__
#define __NSDOMTHREADSERVICE_H__
// Interfaces
#include "nsIEventTarget.h"
#include "nsIObserver.h"
#include "nsIThreadPool.h"
// Other includes
#include "jsapi.h"
#include "mozilla/ReentrantMonitor.h"
#include "nsAutoPtr.h"
#include "nsCOMPtr.h"
#include "nsDataHashtable.h"
#include "nsRefPtrHashtable.h"
#include "nsStringGlue.h"
#include "nsTPtrArray.h"
#include "prlog.h"
#ifdef PR_LOGGING
extern PRLogModuleInfo* gDOMThreadsLog;
#endif
class nsDOMWorker;
class nsDOMWorkerPool;
class nsDOMWorkerRunnable;
class nsDOMWorkerTimeout;
class nsIJSRuntimeService;
class nsIScriptGlobalObject;
class nsIThreadJSContextStack;
class nsIXPConnect;
class nsIXPCSecurityManager;
enum ThreadsafeStatus
{
Threadsafe,
NotThreadsafe,
Unknown
};
class nsDOMThreadService : public nsIEventTarget,
public nsIObserver,
public nsIThreadPoolListener
{
friend class nsDOMWorker;
friend class nsDOMWorkerNavigator;
friend class nsDOMWorkerPool;
friend class nsDOMWorkerRunnable;
friend class nsDOMWorkerThread;
friend class nsDOMWorkerTimeout;
friend class nsDOMWorkerXHR;
friend class nsDOMWorkerXHRProxy;
friend class nsLayoutStatics;
friend class nsReportErrorRunnable;
friend void DOMWorkerErrorReporter(JSContext* aCx,
const char* aMessage,
JSErrorReport* aReport);
public:
NS_DECL_ISUPPORTS
NS_DECL_NSIEVENTTARGET
NS_DECL_NSIOBSERVER
NS_DECL_NSITHREADPOOLLISTENER
// Any DOM consumers that need access to this service should use this method.
static already_AddRefed<nsDOMThreadService> GetOrInitService();
// Simple getter for this service. This does not create the service if it
// hasn't been created already, and it never AddRef's!
static nsDOMThreadService* get();
static JSContext* GetCurrentContext();
// Easy access to the services we care about.
static nsIJSRuntimeService* JSRuntimeService();
static nsIThreadJSContextStack* ThreadJSContextStack();
static nsIXPCSecurityManager* WorkerSecurityManager();
void CancelWorkersForGlobal(nsIScriptGlobalObject* aGlobalObject);
void SuspendWorkersForGlobal(nsIScriptGlobalObject* aGlobalObject);
void ResumeWorkersForGlobal(nsIScriptGlobalObject* aGlobalObject);
nsresult ChangeThreadPoolMaxThreads(PRInt16 aDelta);
void NoteThreadsafeContractId(const nsACString& aContractId,
bool aIsThreadsafe);
ThreadsafeStatus GetContractIdThreadsafeStatus(const nsACString& aContractId);
private:
nsDOMThreadService();
~nsDOMThreadService();
nsresult Init();
void Cleanup();
static void Shutdown();
nsresult Dispatch(nsDOMWorker* aWorker,
nsIRunnable* aRunnable,
PRIntervalTime aTimeoutInterval = 0,
bool aClearQueue = false);
void SetWorkerTimeout(nsDOMWorker* aWorker,
PRIntervalTime aTimeoutInterval);
void WorkerComplete(nsDOMWorkerRunnable* aRunnable);
static JSContext* CreateJSContext();
already_AddRefed<nsDOMWorkerPool>
GetPoolForGlobal(nsIScriptGlobalObject* aGlobalObject,
bool aRemove);
void TriggerOperationCallbackForPool(nsDOMWorkerPool* aPool);
void RescheduleSuspendedWorkerForPool(nsDOMWorkerPool* aPool);
void NoteEmptyPool(nsDOMWorkerPool* aPool);
void TimeoutReady(nsDOMWorkerTimeout* aTimeout);
nsresult RegisterWorker(nsDOMWorker* aWorker,
nsIScriptGlobalObject* aGlobalObject);
void GetAppName(nsAString& aAppName);
void GetAppVersion(nsAString& aAppVersion);
void GetPlatform(nsAString& aPlatform);
void GetUserAgent(nsAString& aUserAgent);
void RegisterPrefCallbacks();
void UnregisterPrefCallbacks();
static int PrefCallback(const char* aPrefName,
void* aClosure);
static PRUint32 GetWorkerCloseHandlerTimeoutMS();
bool QueueSuspendedWorker(nsDOMWorkerRunnable* aRunnable);
// Our internal thread pool.
nsCOMPtr<nsIThreadPool> mThreadPool;
// Maps nsIScriptGlobalObject* to nsDOMWorkerPool.
nsRefPtrHashtable<nsVoidPtrHashKey, nsDOMWorkerPool> mPools;
// mReentrantMonitor protects all access to mWorkersInProgress and
// mCreationsInProgress.
mozilla::ReentrantMonitor mReentrantMonitor;
// A map from nsDOMWorkerThread to nsDOMWorkerRunnable.
nsRefPtrHashtable<nsVoidPtrHashKey, nsDOMWorkerRunnable> mWorkersInProgress;
// A list of active JSContexts that we've created. Always protected with
// mReentrantMonitor.
nsTArray<JSContext*> mJSContexts;
// A list of worker runnables that were never started because the worker was
// suspended. Always protected with mReentrantMonitor.
nsTArray<nsDOMWorkerRunnable*> mSuspendedWorkers;
// Always protected with mReentrantMonitor.
nsDataHashtable<nsCStringHashKey, bool> mThreadsafeContractIDs;
nsString mAppName;
nsString mAppVersion;
nsString mPlatform;
nsString mUserAgent;
bool mNavigatorStringsLoaded;
};
#endif /* __NSDOMTHREADSERVICE_H__ */

2752
dom/src/threads/nsDOMWorker.cpp
View File

File diff suppressed because it is too large Load Diff

471
dom/src/threads/nsDOMWorker.h
View File

@ -1,471 +0,0 @@
/* -*- Mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 40 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Web Workers.
*
* The Initial Developer of the Original Code is
* Mozilla Corporation.
* Portions created by the Initial Developer are Copyright (C) 2008
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Ben Turner <bent.mozilla@gmail.com> (Original Author)
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#ifndef __NSDOMWORKER_H__
#define __NSDOMWORKER_H__
#include "nsIDOMEventTarget.h"
#include "nsIDOMWorkers.h"
#include "nsIJSNativeInitializer.h"
#include "nsIPrincipal.h"
#include "nsITimer.h"
#include "nsIURI.h"
#include "nsIXPCScriptable.h"
#include "jsapi.h"
#include "mozilla/Mutex.h"
#include "nsAutoPtr.h"
#include "nsCOMPtr.h"
#include "nsTPtrArray.h"
#include "nsDOMWorkerMessageHandler.h"
// {1295EFB5-8644-42B2-8B8E-80EEF56E4284}
#define NS_WORKERFACTORY_CID \
{0x1295efb5, 0x8644, 0x42b2, \
{0x8b, 0x8e, 0x80, 0xee, 0xf5, 0x6e, 0x42, 0x84} }
class nsDOMWorker;
class nsDOMWorkerFeature;
class nsDOMWorkerMessageHandler;
class nsDOMWorkerNavigator;
class nsDOMWorkerPool;
class nsDOMWorkerTimeout;
class nsICancelable;
class nsIDOMEventListener;
class nsIEventTarget;
class nsIRunnable;
class nsIScriptGlobalObject;
class nsIXPConnectWrappedNative;
class nsDOMWorkerScope : public nsDOMWorkerMessageHandler,
public nsIWorkerScope,
public nsIXPCScriptable
{
friend class nsDOMWorker;
public:
NS_DECL_ISUPPORTS_INHERITED
// nsIDOMEventHandler
NS_FORWARD_INTERNAL_NSIDOMEVENTTARGET(nsDOMWorkerMessageHandler::)
NS_IMETHOD AddEventListener(const nsAString& aType,
nsIDOMEventListener* aListener,
bool aUseCapture,
bool aWantsUntrusted,
PRUint8 optional_argc);
NS_IMETHOD RemoveEventListener(const nsAString& aType,
nsIDOMEventListener* aListener,
bool aUseCapture);
NS_IMETHOD DispatchEvent(nsIDOMEvent* aEvent,
bool* _retval);
NS_DECL_NSIWORKERGLOBALSCOPE
NS_DECL_NSIWORKERSCOPE
NS_DECL_NSIXPCSCRIPTABLE
NS_DECL_NSICLASSINFO
typedef NS_STDCALL_FUNCPROTO(nsresult, SetListenerFunc, nsDOMWorkerScope,
SetOnmessage, (nsIDOMEventListener*));
nsDOMWorkerScope(nsDOMWorker* aWorker);
protected:
already_AddRefed<nsIXPConnectWrappedNative> GetWrappedNative();
private:
nsDOMWorker* mWorker;
nsIXPConnectWrappedNative* mWrappedNative;
nsRefPtr<nsDOMWorkerNavigator> mNavigator;
bool mHasOnerror;
};
class nsLazyAutoRequest
{
public:
nsLazyAutoRequest() : mCx(nsnull) {}
~nsLazyAutoRequest() {
if (mCx)
JS_EndRequest(mCx);
}
void enter(JSContext *aCx) {
JS_BeginRequest(aCx);
mCx = aCx;
}
bool entered() const { return mCx != nsnull; }
void swap(nsLazyAutoRequest &other) {
JSContext *tmp = mCx;
mCx = other.mCx;
other.mCx = tmp;
}
private:
JSContext *mCx;
};
class nsDOMWorker : public nsDOMWorkerMessageHandler,
public nsIWorker,
public nsITimerCallback,
public nsIJSNativeInitializer,
public nsIXPCScriptable
{
typedef mozilla::Mutex Mutex;
friend class nsDOMWorkerFeature;
friend class nsDOMWorkerFunctions;
friend class nsDOMWorkerScope;
friend class nsDOMWorkerScriptLoader;
friend class nsDOMWorkerTimeout;
friend class nsDOMWorkerXHR;
friend class nsDOMWorkerXHRProxy;
friend class nsReportErrorRunnable;
friend class nsDOMFireEventRunnable;
friend JSBool DOMWorkerOperationCallback(JSContext* aCx);
friend void DOMWorkerErrorReporter(JSContext* aCx,
const char* aMessage,
JSErrorReport* aReport);
public:
NS_DECL_ISUPPORTS_INHERITED
// nsIDOMEventHandler
NS_FORWARD_INTERNAL_NSIDOMEVENTTARGET(nsDOMWorkerMessageHandler::)
NS_IMETHOD AddEventListener(const nsAString& aType,
nsIDOMEventListener* aListener,
bool aUseCapture,
bool aWantsUntrusted,
PRUint8 optional_argc);
NS_IMETHOD RemoveEventListener(const nsAString& aType,
nsIDOMEventListener* aListener,
bool aUseCapture);
NS_IMETHOD DispatchEvent(nsIDOMEvent* aEvent,
bool* _retval);
NS_DECL_NSIABSTRACTWORKER
NS_DECL_NSIWORKER
NS_DECL_NSITIMERCALLBACK
NS_DECL_NSICLASSINFO
NS_DECL_NSIXPCSCRIPTABLE
static nsresult NewWorker(nsISupports** aNewObject);
static nsresult NewChromeWorker(nsISupports** aNewObject);
static nsresult NewChromeDOMWorker(nsDOMWorker** aNewObject);
enum WorkerPrivilegeModel { CONTENT, CHROME };
nsDOMWorker(nsDOMWorker* aParent,
nsIXPConnectWrappedNative* aParentWN,
WorkerPrivilegeModel aModel);
NS_IMETHOD Initialize(nsISupports* aOwner,
JSContext* aCx,
JSObject* aObj,
PRUint32 aArgc,
jsval* aArgv);
nsresult InitializeInternal(nsIScriptGlobalObject* aOwner,
JSContext* aCx,
JSObject* aObj,
PRUint32 aArgc,
jsval* aArgv);
void Cancel();
void Kill();
void Suspend();
void Resume();
// This just calls IsCanceledNoLock with an autolock around the call.
bool IsCanceled();
bool IsClosing();
bool IsSuspended();
bool SetGlobalForContext(JSContext* aCx, nsLazyAutoRequest *aRequest, JSAutoEnterCompartment *aComp);
void SetPool(nsDOMWorkerPool* aPool);
nsDOMWorkerPool* Pool() {
return mPool;
}
Mutex& GetLock() {
return mLock;
}
already_AddRefed<nsIXPConnectWrappedNative> GetWrappedNative();
already_AddRefed<nsDOMWorker> GetParent();
nsDOMWorkerScope* GetInnerScope() {
return mInnerScope;
}
void SetExpirationTime(PRIntervalTime aExpirationTime);
#ifdef DEBUG
PRIntervalTime GetExpirationTime();
#endif
bool IsPrivileged() {
return mPrivilegeModel == CHROME;
}
static JSObject* ReadStructuredClone(JSContext* aCx,
JSStructuredCloneReader* aReader,
uint32 aTag,
uint32 aData,
void* aClosure);
/**
* Use this chart to help figure out behavior during each of the closing
* statuses. Details below.
*
* +=============+=============+=================+=======================+
* | status | clear queue | abort execution | close handler timeout |
* +=============+=============+=================+=======================+
* | eClosed | yes | no | no |
* +-------------+-------------+-----------------+-----------------------+
* | eTerminated | yes | yes | no |
* +-------------+-------------+-----------------+-----------------------+
* | eCanceled | yes | yes | yes |
* +-------------+-------------+-----------------+-----------------------+
*
*/
enum DOMWorkerStatus {
// This status means that the close handler has not yet been scheduled.
eRunning = 0,
// Inner script called Close() on the worker global scope. Setting this
// status causes the worker to clear its queue of events but does not abort
// the currently running script. The close handler is also scheduled with
// no expiration time. This status may be superseded by 'eTerminated' in
// which case the currently running script will be aborted as detailed
// below. It may also be superseded by 'eCanceled' at which point the close
// handler will be assigned an expiration time. Once the close handler has
// completed or timed out the status will be changed to 'eKilled'.
eClosed,
// Outer script called Terminate() on the worker or the worker object was
// garbage collected in its outer script. Setting this status causes the
// worker to abort immediately, clear its queue of events, and schedules the
// close handler with no expiration time. This status may be superseded by
// 'eCanceled' at which point the close handler will have an expiration time
// assigned. Once the close handler has completed or timed out the status
// will be changed to 'eKilled'.
eTerminated,
// Either the user navigated away from the owning page, the owning page fell
// out of bfcache, or the user quit the application. Setting this status
// causes the worker to abort immediately and schedules the close handler
// with an expiration time. Since the page has gone away the worker may not
// post any messages. Once the close handler has completed or timed out the
// status will be changed to 'eKilled'.
eCanceled,
// The close handler has run and the worker is effectively dead.
eKilled
};
private:
~nsDOMWorker();
nsresult PostMessageInternal(bool aToInner);
bool CompileGlobalObject(JSContext* aCx, nsLazyAutoRequest *aRequest, JSAutoEnterCompartment *aComp);
PRUint32 NextTimeoutId() {
return ++mNextTimeoutId;
}
nsresult AddFeature(nsDOMWorkerFeature* aFeature,
JSContext* aCx);
void RemoveFeature(nsDOMWorkerFeature* aFeature,
JSContext* aCx);
void CancelTimeoutWithId(PRUint32 aId);
void SuspendFeatures();
void ResumeFeatures();
nsIPrincipal* GetPrincipal() {
return mPrincipal;
}
void SetPrincipal(nsIPrincipal* aPrincipal);
nsIURI* GetBaseURI() {
return mBaseURI;
}
nsresult SetBaseURI(nsIURI* aURI);
void ClearBaseURI();
nsresult FireCloseRunnable(PRIntervalTime aTimeoutInterval,
bool aClearQueue,
bool aFromFinalize);
nsresult Close();
nsresult TerminateInternal(bool aFromFinalize);
nsIWorkerLocation* GetLocation() {
return mLocation;
}
bool QueueSuspendedRunnable(nsIRunnable* aRunnable);
// Determines if the worker should be considered "canceled". See the large
// comment in the implementation for more details.
bool IsCanceledNoLock();
private:
// mParent will live as long as mParentWN but only mParentWN will keep the JS
// reflection alive, so we only hold one strong reference to mParentWN.
nsDOMWorker* mParent;
nsCOMPtr<nsIXPConnectWrappedNative> mParentWN;
// Whether or not this worker has chrome privileges. Never changed after the
// worker is created.
WorkerPrivilegeModel mPrivilegeModel;
Mutex mLock;
nsRefPtr<nsDOMWorkerPool> mPool;
nsDOMWorkerScope* mInnerScope;
nsCOMPtr<nsIXPConnectWrappedNative> mScopeWN;
JSObject* mGlobal;
PRUint32 mNextTimeoutId;
nsTArray<nsDOMWorkerFeature*> mFeatures;
PRUint32 mFeatureSuspendDepth;
nsString mScriptURL;
nsIXPConnectWrappedNative* mWrappedNative;
nsCOMPtr<nsIPrincipal> mPrincipal;
nsCOMPtr<nsIURI> mBaseURI;
PRInt32 mErrorHandlerRecursionCount;
// Always protected by mLock
DOMWorkerStatus mStatus;
// Always protected by mLock
PRIntervalTime mExpirationTime;
nsCOMPtr<nsITimer> mKillTimer;
nsCOMPtr<nsIWorkerLocation> mLocation;
nsTArray<nsCOMPtr<nsIRunnable> > mQueuedRunnables;
bool mSuspended;
bool mCompileAttempted;
};
/**
* A worker "feature" holds the worker alive yet can be canceled, paused, and
* resumed by the worker. It is up to each derived class to implement these
* methods. This class uses a custom implementation of Release in order to
* ensure no races between Cancel and object destruction can occur, so derived
* classes must use the ISUPPORTS_INHERITED macros.
*
* To use this class you should inherit it and use the ISUPPORTS_INHERITED
* macros. Then add or remove an instance to the worker using the
* AddFeature/RemoveFeature functions.
*/
class nsDOMWorkerFeature : public nsISupports
{
friend class nsDOMWorker;
public:
NS_DECL_ISUPPORTS
nsDOMWorkerFeature(nsDOMWorker* aWorker)
: mWorker(aWorker), mWorkerWN(aWorker->GetWrappedNative()), mId(0),
mHasId(PR_FALSE), mFreeToDie(PR_TRUE) { }
nsDOMWorkerFeature(nsDOMWorker* aWorker, PRUint32 aId)
: mWorker(aWorker), mWorkerWN(aWorker->GetWrappedNative()), mId(aId),
mHasId(PR_TRUE), mFreeToDie(PR_TRUE) { }
virtual void Cancel() = 0;
virtual void Suspend() { }
virtual void Resume() { }
PRUint32 GetId() {
return mId;
}
bool HasId() {
return mHasId;
}
protected:
virtual ~nsDOMWorkerFeature() { }
private:
void FreeToDie(bool aFreeToDie) {
mFreeToDie = aFreeToDie;
}
protected:
nsRefPtr<nsDOMWorker> mWorker;
nsCOMPtr<nsIXPConnectWrappedNative> mWorkerWN;
PRUint32 mId;
private:
bool mHasId;
bool mFreeToDie;
};
class nsWorkerFactory : public nsIWorkerFactory
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSIWORKERFACTORY
};
#endif /* __NSDOMWORKER_H__ */

635
dom/src/threads/nsDOMWorkerEvents.cpp
View File

@ -1,635 +0,0 @@
/* -*- Mode: c++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Web Workers.
*
* The Initial Developer of the Original Code is
* Mozilla Corporation.
* Portions created by the Initial Developer are Copyright (C) 2008
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Ben Turner <bent.mozilla@gmail.com> (Original Author)
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#include "nsDOMWorkerEvents.h"
#include "nsIXMLHttpRequest.h"
#include "nsIXPConnect.h"
#include "jsapi.h"
#include "nsAXPCNativeCallContext.h"
#include "nsContentUtils.h"
#include "nsThreadUtils.h"
#include "nsDOMWorkerMessageHandler.h"
#include "nsDOMThreadService.h"
#include "nsDOMWorkerXHR.h"
#include "nsDOMWorkerXHRProxy.h"
NS_DEFINE_STATIC_IID_ACCESSOR(nsIDOMWorkerPrivateEvent,
NS_IDOMWORKERPRIVATEEVENT_IID)
nsDOMWorkerPrivateEvent::nsDOMWorkerPrivateEvent(nsIDOMEvent* aEvent)
: mEvent(aEvent),
mProgressEvent(do_QueryInterface(aEvent)),
mMessageEvent(do_QueryInterface(aEvent)),
mErrorEvent(do_QueryInterface(aEvent)),
mPreventDefaultCalled(PR_FALSE)
{
NS_ASSERTION(aEvent, "Null pointer!");
}
NS_IMPL_THREADSAFE_ADDREF(nsDOMWorkerPrivateEvent)
NS_IMPL_THREADSAFE_RELEASE(nsDOMWorkerPrivateEvent)
NS_INTERFACE_MAP_BEGIN(nsDOMWorkerPrivateEvent)
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDOMWorkerPrivateEvent)
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsIDOMEvent, nsIDOMWorkerPrivateEvent)
NS_INTERFACE_MAP_ENTRY(nsIDOMWorkerPrivateEvent)
NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIDOMProgressEvent, mProgressEvent)
NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIWorkerMessageEvent, mMessageEvent)
NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIWorkerErrorEvent, mErrorEvent)
NS_INTERFACE_MAP_ENTRY(nsIClassInfo)
NS_INTERFACE_MAP_END
NS_IMPL_CI_INTERFACE_GETTER1(nsDOMWorkerPrivateEvent, nsIDOMEvent)
NS_IMPL_THREADSAFE_DOM_CI_HELPER(nsDOMWorkerPrivateEvent)
NS_IMPL_THREADSAFE_DOM_CI_ALL_THE_REST(nsDOMWorkerPrivateEvent)
NS_IMETHODIMP
nsDOMWorkerPrivateEvent::GetInterfaces(PRUint32* aCount, nsIID*** aArray)
{
nsCOMPtr<nsIClassInfo> ci(do_QueryInterface(mEvent));
if (ci) {
return ci->GetInterfaces(aCount, aArray);
}
return NS_CI_INTERFACE_GETTER_NAME(nsDOMWorkerPrivateEvent)(aCount, aArray);
}
NS_IMETHODIMP
nsDOMWorkerPrivateEvent::PreventDefault()
{
bool cancelable = false;
mEvent->GetCancelable(&cancelable);
if (cancelable) {
mPreventDefaultCalled = PR_TRUE;
}
return mEvent->PreventDefault();
}
NS_IMETHODIMP
nsDOMWorkerPrivateEvent::GetDefaultPrevented(bool* aRetVal)
{
*aRetVal = mPreventDefaultCalled;
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerPrivateEvent::InitEvent(const nsAString& aEventType,
bool aCanBubble,
bool aCancelable)
{
mPreventDefaultCalled = PR_FALSE;
return mEvent->InitEvent(aEventType, aCanBubble, aCancelable);
}
NS_IMETHODIMP
nsDOMWorkerPrivateEvent::InitProgressEvent(const nsAString& aTypeArg,
bool aCanBubbleArg,
bool aCancelableArg,
bool aLengthComputableArg,
PRUint64 aLoadedArg,
PRUint64 aTotalArg)
{
NS_ASSERTION(mProgressEvent, "Impossible!");
mPreventDefaultCalled = PR_FALSE;
return mProgressEvent->InitProgressEvent(aTypeArg, aCanBubbleArg,
aCancelableArg, aLengthComputableArg,
aLoadedArg, aTotalArg);
}
NS_IMETHODIMP
nsDOMWorkerPrivateEvent::InitMessageEvent(const nsAString& aTypeArg,
bool aCanBubbleArg,
bool aCancelableArg,
const nsAString& aDataArg,
const nsAString& aOriginArg,
nsISupports* aSourceArg)
{
NS_ASSERTION(mMessageEvent, "Impossible!");
mPreventDefaultCalled = PR_FALSE;
return mMessageEvent->InitMessageEvent(aTypeArg, aCanBubbleArg,
aCancelableArg, aDataArg, aOriginArg,
aSourceArg);
}
NS_IMETHODIMP
nsDOMWorkerPrivateEvent::InitErrorEvent(const nsAString& aTypeArg,
bool aCanBubbleArg,
bool aCancelableArg,
const nsAString& aMessageArg,
const nsAString& aFilenameArg,
PRUint32 aLinenoArg)
{
NS_ASSERTION(mErrorEvent, "Impossible!");
mPreventDefaultCalled = PR_FALSE;
return mErrorEvent->InitErrorEvent(aTypeArg, aCanBubbleArg, aCancelableArg,
aMessageArg, aFilenameArg, aLinenoArg);
}
bool
nsDOMWorkerPrivateEvent::PreventDefaultCalled()
{
return mPreventDefaultCalled;
}
NS_IMPL_THREADSAFE_ISUPPORTS2(nsDOMWorkerEvent, nsIDOMEvent,
nsIClassInfo)
NS_IMPL_CI_INTERFACE_GETTER1(nsDOMWorkerEvent, nsIDOMEvent)
NS_IMPL_THREADSAFE_DOM_CI(nsDOMWorkerEvent)
NS_IMETHODIMP
nsDOMWorkerEvent::GetType(nsAString& aType)
{
aType.Assign(mType);
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerEvent::GetTarget(nsIDOMEventTarget** aTarget)
{
NS_ENSURE_ARG_POINTER(aTarget);
NS_IF_ADDREF(*aTarget = mTarget);
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerEvent::GetCurrentTarget(nsIDOMEventTarget** aCurrentTarget)
{
NS_ENSURE_ARG_POINTER(aCurrentTarget);
NS_IF_ADDREF(*aCurrentTarget = mTarget);
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerEvent::GetEventPhase(PRUint16* aEventPhase)
{
NS_ENSURE_ARG_POINTER(aEventPhase);
*aEventPhase = mEventPhase;
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerEvent::GetBubbles(bool* aBubbles)
{
NS_ENSURE_ARG_POINTER(aBubbles);
*aBubbles = mBubbles;
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerEvent::GetCancelable(bool* aCancelable)
{
NS_ENSURE_ARG_POINTER(aCancelable);
*aCancelable = mCancelable;
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerEvent::GetTimeStamp(DOMTimeStamp* aTimeStamp)
{
NS_ENSURE_ARG_POINTER(aTimeStamp);
*aTimeStamp = mTimeStamp;
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerEvent::StopPropagation()
{
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsDOMWorkerEvent::PreventDefault()
{
mPreventDefaultCalled = PR_TRUE;
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerEvent::GetDefaultPrevented(bool* aRetVal)
{
*aRetVal = mPreventDefaultCalled;
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerEvent::InitEvent(const nsAString& aEventTypeArg,
bool aCanBubbleArg,
bool aCancelableArg)
{
NS_ENSURE_FALSE(aEventTypeArg.IsEmpty(), NS_ERROR_INVALID_ARG);
mType.Assign(aEventTypeArg);
mBubbles = aCanBubbleArg;
mCancelable = aCancelableArg;
mPreventDefaultCalled = PR_FALSE;
mTimeStamp = PR_Now();
return NS_OK;
}
nsDOMWorkerMessageEvent::~nsDOMWorkerMessageEvent()
{
if (mData) {
JSContext* cx = nsDOMThreadService::GetCurrentContext();
if (cx) {
JS_free(cx, mData);
}
else {
NS_WARNING("Failed to get safe JSContext, leaking event data!");
}
}
}
NS_IMPL_ISUPPORTS_INHERITED1(nsDOMWorkerMessageEvent, nsDOMWorkerEvent,
nsIWorkerMessageEvent)
NS_IMPL_CI_INTERFACE_GETTER2(nsDOMWorkerMessageEvent, nsIDOMEvent,
nsIWorkerMessageEvent)
NS_IMPL_THREADSAFE_DOM_CI_GETINTERFACES(nsDOMWorkerMessageEvent)
nsresult
nsDOMWorkerMessageEvent::SetJSData(
JSContext* aCx,
JSAutoStructuredCloneBuffer& aBuffer,
nsTArray<nsCOMPtr<nsISupports> >& aWrappedNatives)
{
NS_ASSERTION(aCx, "Null context!");
if (!mDataVal.Hold(aCx)) {
NS_WARNING("Failed to hold jsval!");
return NS_ERROR_FAILURE;
}
if (!mWrappedNatives.SwapElements(aWrappedNatives)) {
NS_ERROR("This should never fail!");
}
aBuffer.steal(&mData, &mDataLen);
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerMessageEvent::GetData(nsAString& aData)
{
nsIXPConnect* xpc = nsContentUtils::XPConnect();
NS_ENSURE_TRUE(xpc, NS_ERROR_UNEXPECTED);
nsAXPCNativeCallContext* cc;
nsresult rv = xpc->GetCurrentNativeCallContext(&cc);
NS_ENSURE_SUCCESS(rv, rv);
NS_ENSURE_TRUE(cc, NS_ERROR_UNEXPECTED);
if (mData) {
JSContext* cx;
rv = cc->GetJSContext(&cx);
NS_ENSURE_SUCCESS(rv, rv);
JSAutoRequest ar(cx);
JSAutoStructuredCloneBuffer buffer;
buffer.adopt(cx, mData, mDataLen);
mData = nsnull;
mDataLen = 0;
JSStructuredCloneCallbacks callbacks = {
nsDOMWorker::ReadStructuredClone, nsnull, nsnull
};
JSBool ok = buffer.read(mDataVal.ToJSValPtr(), cx, &callbacks);
// Release wrapped natives now, regardless of whether or not the deserialize
// succeeded.
mWrappedNatives.Clear();
if (!ok) {
NS_WARNING("Failed to deserialize!");
return NS_ERROR_FAILURE;
}
}
jsval* retval;
rv = cc->GetRetValPtr(&retval);
NS_ENSURE_SUCCESS(rv, rv);
cc->SetReturnValueWasSet(PR_TRUE);
*retval = mDataVal;
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerMessageEvent::GetOrigin(nsAString& aOrigin)
{
aOrigin.Assign(mOrigin);
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerMessageEvent::GetSource(nsISupports** aSource)
{
NS_ENSURE_ARG_POINTER(aSource);
NS_IF_ADDREF(*aSource = mSource);
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerMessageEvent::InitMessageEvent(const nsAString& aTypeArg,
bool aCanBubbleArg,
bool aCancelableArg,
const nsAString& aDataArg,
const nsAString& aOriginArg,
nsISupports* aSourceArg)
{
mOrigin.Assign(aOriginArg);
mSource = aSourceArg;
return nsDOMWorkerEvent::InitEvent(aTypeArg, aCanBubbleArg, aCancelableArg);
}
NS_IMPL_ISUPPORTS_INHERITED1(nsDOMWorkerProgressEvent, nsDOMWorkerEvent,
nsIDOMProgressEvent)
NS_IMPL_CI_INTERFACE_GETTER2(nsDOMWorkerProgressEvent, nsIDOMEvent,
nsIDOMProgressEvent)
NS_IMPL_THREADSAFE_DOM_CI_GETINTERFACES(nsDOMWorkerProgressEvent)
NS_IMETHODIMP
nsDOMWorkerProgressEvent::GetLengthComputable(bool* aLengthComputable)
{
NS_ENSURE_ARG_POINTER(aLengthComputable);
*aLengthComputable = mLengthComputable;
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerProgressEvent::GetLoaded(PRUint64* aLoaded)
{
NS_ENSURE_ARG_POINTER(aLoaded);
*aLoaded = mLoaded;
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerProgressEvent::GetTotal(PRUint64* aTotal)
{
NS_ENSURE_ARG_POINTER(aTotal);
*aTotal = mTotal;
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerProgressEvent::InitProgressEvent(const nsAString_internal& aTypeArg,
bool aCanBubbleArg,
bool aCancelableArg,
bool aLengthComputableArg,
PRUint64 aLoadedArg,
PRUint64 aTotalArg)
{
mLengthComputable = aLengthComputableArg;
mLoaded = aLoadedArg;
mTotal = aTotalArg;
return nsDOMWorkerEvent::InitEvent(aTypeArg, aCanBubbleArg, aCancelableArg);
}
NS_IMPL_THREADSAFE_ADDREF(nsDOMWorkerXHRState)
NS_IMPL_THREADSAFE_RELEASE(nsDOMWorkerXHRState)
nsDOMWorkerXHREvent::nsDOMWorkerXHREvent(nsDOMWorkerXHRProxy* aXHRProxy)
: mXHRProxy(aXHRProxy),
mXHREventType(PR_UINT32_MAX),
mChannelID(-1),
mUploadEvent(PR_FALSE),
mProgressEvent(PR_FALSE)
{
NS_ASSERTION(aXHRProxy, "Can't be null!");
}
NS_IMPL_ADDREF_INHERITED(nsDOMWorkerXHREvent, nsDOMWorkerProgressEvent)
NS_IMPL_RELEASE_INHERITED(nsDOMWorkerXHREvent, nsDOMWorkerProgressEvent)
NS_INTERFACE_MAP_BEGIN(nsDOMWorkerXHREvent)
NS_INTERFACE_MAP_ENTRY(nsIRunnable)
NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIDOMProgressEvent, mProgressEvent)
NS_INTERFACE_MAP_END_INHERITING(nsDOMWorkerEvent)
NS_IMETHODIMP
nsDOMWorkerXHREvent::GetInterfaces(PRUint32* aCount,
nsIID*** aArray)
{
PRUint32 count = *aCount = mProgressEvent ? 2 : 1;
*aArray = (nsIID**)nsMemory::Alloc(sizeof(nsIID*) * count);
if (mProgressEvent) {
(*aArray)[--count] =
(nsIID*)nsMemory::Clone(&NS_GET_IID(nsIDOMProgressEvent), sizeof(nsIID));
}
(*aArray)[--count] =
(nsIID *)nsMemory::Clone(&NS_GET_IID(nsIDOMEvent), sizeof(nsIID));
NS_ASSERTION(!count, "Bad math!");
return NS_OK;
}
nsresult
nsDOMWorkerXHREvent::Init(PRUint32 aXHREventType,
const nsAString& aType,
nsIDOMEvent* aEvent,
SnapshotChoice aSnapshot)
{
NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
NS_ASSERTION(aEvent, "Don't pass null here!");
mXHREventType = aXHREventType;
// Only set a channel id if we're not going to be run immediately.
mChannelID = mXHRProxy->mSyncEventQueue ? -1 : mXHRProxy->ChannelID();
mTarget = static_cast<nsDOMWorkerMessageHandler*>(mXHRProxy->mWorkerXHR);
NS_ENSURE_TRUE(mTarget, NS_ERROR_UNEXPECTED);
mXHRWN = mXHRProxy->mWorkerXHR->GetWrappedNative();
NS_ENSURE_STATE(mXHRWN);
nsCOMPtr<nsIDOMEventTarget> mainThreadTarget;
nsresult rv = aEvent->GetTarget(getter_AddRefs(mainThreadTarget));
NS_ENSURE_SUCCESS(rv, rv);
NS_ENSURE_STATE(mainThreadTarget);
nsCOMPtr<nsIXMLHttpRequestUpload> upload(do_QueryInterface(mainThreadTarget));
if (upload) {
mUploadEvent = PR_TRUE;
mTarget =
static_cast<nsDOMWorkerMessageHandler*>(mXHRProxy->mWorkerXHR->mUpload);
}
else {
mUploadEvent = PR_FALSE;
mTarget = static_cast<nsDOMWorkerMessageHandler*>(mXHRProxy->mWorkerXHR);
}
NS_ASSERTION(mTarget, "Null target!");
bool bubbles;
rv = aEvent->GetBubbles(&bubbles);
NS_ENSURE_SUCCESS(rv, rv);
bool cancelable;
rv = aEvent->GetCancelable(&cancelable);
NS_ENSURE_SUCCESS(rv, rv);
rv = aEvent->GetTimeStamp(&mTimeStamp);
NS_ENSURE_SUCCESS(rv, rv);
rv = aEvent->GetEventPhase(&mEventPhase);
NS_ENSURE_SUCCESS(rv, rv);
NS_ASSERTION(mEventPhase == nsIDOMEvent::AT_TARGET, "Unsupported phase!");
nsCOMPtr<nsIDOMProgressEvent> progressEvent(do_QueryInterface(aEvent));
if (progressEvent) {
mProgressEvent = PR_TRUE;
bool lengthComputable;
rv = progressEvent->GetLengthComputable(&lengthComputable);
NS_ENSURE_SUCCESS(rv, rv);
PRUint64 loaded;
rv = progressEvent->GetLoaded(&loaded);
NS_ENSURE_SUCCESS(rv, rv);
PRUint64 total;
rv = progressEvent->GetTotal(&total);
NS_ENSURE_SUCCESS(rv, rv);
rv = InitProgressEvent(aType, bubbles, cancelable, lengthComputable, loaded,
total);
NS_ENSURE_SUCCESS(rv, rv);
}
else {
mProgressEvent = PR_FALSE;
rv = InitEvent(aType, bubbles, cancelable);
NS_ENSURE_SUCCESS(rv, rv);
}
mState = new nsDOMWorkerXHRState();
NS_ENSURE_TRUE(mState, NS_ERROR_OUT_OF_MEMORY);
if (aSnapshot == SNAPSHOT) {
SnapshotXHRState(mXHRProxy->mXHR, mState);
}
return NS_OK;
}
/* static */
void
nsDOMWorkerXHREvent::SnapshotXHRState(nsIXMLHttpRequest* aXHR,
nsDOMWorkerXHRState* aState)
{
NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
NS_ASSERTION(aXHR && aState, "Don't pass null here!");
aState->responseTextResult = aXHR->GetResponseText(aState->responseText);
aState->statusTextResult = aXHR->GetStatusText(aState->statusText);
aState->statusResult = aXHR->GetStatus(&aState->status);
aState->readyStateResult = aXHR->GetReadyState(&aState->readyState);
}
NS_IMETHODIMP
nsDOMWorkerXHREvent::Run()
{
nsresult rv = mXHRProxy->HandleWorkerEvent(this, mUploadEvent);
// Prevent reference cycles by releasing this here.
mXHRProxy = nsnull;
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
NS_IMPL_ISUPPORTS_INHERITED1(nsDOMWorkerErrorEvent, nsDOMWorkerEvent,
nsIWorkerErrorEvent)
NS_IMPL_CI_INTERFACE_GETTER2(nsDOMWorkerErrorEvent, nsIDOMEvent,
nsIWorkerErrorEvent)
NS_IMPL_THREADSAFE_DOM_CI_GETINTERFACES(nsDOMWorkerErrorEvent)
nsresult
nsDOMWorkerErrorEvent::GetMessage(nsAString& aMessage)
{
aMessage.Assign(mMessage);
return NS_OK;
}
nsresult
nsDOMWorkerErrorEvent::GetFilename(nsAString& aFilename)
{
aFilename.Assign(mFilename);
return NS_OK;
}
nsresult
nsDOMWorkerErrorEvent::GetLineno(PRUint32* aLineno)
{
NS_ENSURE_ARG_POINTER(aLineno);
*aLineno = mLineno;
return NS_OK;
}
nsresult
nsDOMWorkerErrorEvent::InitErrorEvent(const nsAString& aTypeArg,
bool aCanBubbleArg,
bool aCancelableArg,
const nsAString& aMessageArg,
const nsAString& aFilenameArg,
PRUint32 aLinenoArg)
{
mMessage.Assign(aMessageArg);
mFilename.Assign(aFilenameArg);
mLineno = aLinenoArg;
return InitEvent(aTypeArg, aCanBubbleArg, aCancelableArg);
}

340
dom/src/threads/nsDOMWorkerEvents.h
View File

@ -1,340 +0,0 @@
/* -*- Mode: c++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Web Workers.
*
* The Initial Developer of the Original Code is
* Mozilla Corporation.
* Portions created by the Initial Developer are Copyright (C) 2008
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Ben Turner <bent.mozilla@gmail.com> (Original Author)
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#ifndef __NSDOMWORKEREVENTS_H__
#define __NSDOMWORKEREVENTS_H__
#include "nsIClassInfo.h"
#include "nsIDOMEvent.h"
#include "nsIDOMEventTarget.h"
#include "nsIDOMProgressEvent.h"
#include "nsIDOMWorkers.h"
#include "nsIRunnable.h"
#include "jsapi.h"
#include "jsutil.h"
#include "nsAutoJSValHolder.h"
#include "nsAutoPtr.h"
#include "nsCOMPtr.h"
#include "nsStringGlue.h"
#include "nsDOMWorkerMacros.h"
class nsDOMWorkerXHRProxy;
class nsIXMLHttpRequest;
class nsIXPConnectWrappedNative;
/* 4d5794d6-98ab-4a6b-ad5a-8ed1fa1d4839 */
#define NS_IDOMWORKERPRIVATEEVENT_IID \
{ \
0x4d5794d6, \
0x98ab, \
0x4a6b, \
{ 0xad, 0x5a, 0x8e, 0xd1, 0xfa, 0x1d, 0x48, 0x39 } \
}
class nsIDOMWorkerPrivateEvent : public nsIDOMEvent
{
public:
NS_DECLARE_STATIC_IID_ACCESSOR(NS_IDOMWORKERPRIVATEEVENT_IID)
virtual bool PreventDefaultCalled() = 0;
};
#define NS_FORWARD_NSIDOMEVENT_SPECIAL \
NS_IMETHOD GetType(nsAString& aType) \
{ return mEvent->GetType(aType); } \
NS_IMETHOD GetTarget(nsIDOMEventTarget** aTarget) \
{ return mEvent->GetTarget(aTarget); } \
NS_IMETHOD GetCurrentTarget(nsIDOMEventTarget** aCurrentTarget) \
{ return mEvent->GetCurrentTarget(aCurrentTarget); } \
NS_IMETHOD GetEventPhase(PRUint16* aEventPhase) \
{ return mEvent->GetEventPhase(aEventPhase); } \
NS_IMETHOD GetBubbles(bool* aBubbles) \
{ return mEvent->GetBubbles(aBubbles); } \
NS_IMETHOD GetCancelable(bool* aCancelable) \
{ return mEvent->GetCancelable(aCancelable); } \
NS_IMETHOD GetTimeStamp(DOMTimeStamp* aTimeStamp) \
{ return mEvent->GetTimeStamp(aTimeStamp); } \
NS_IMETHOD StopPropagation() \
{ return mEvent->StopPropagation(); }
#define NS_FORWARD_NSIDOMPROGRESSEVENT_SPECIAL \
NS_IMETHOD GetLengthComputable(bool* aLengthComputable) \
{ return mProgressEvent->GetLengthComputable(aLengthComputable); } \
NS_IMETHOD GetLoaded(PRUint64* aLoaded) \
{ return mProgressEvent->GetLoaded(aLoaded); } \
NS_IMETHOD GetTotal(PRUint64* aTotal) \
{ return mProgressEvent->GetTotal(aTotal); }
#define NS_FORWARD_NSIWORKERMESSAGEEVENT_SPECIAL \
NS_IMETHOD GetData(nsAString& aData) \
{ return mMessageEvent->GetData(aData); } \
NS_IMETHOD GetOrigin(nsAString& aOrigin) \
{ return mMessageEvent->GetOrigin(aOrigin); } \
NS_IMETHOD GetSource(nsISupports** aSource) \
{ return mMessageEvent->GetSource(aSource); }
#define NS_FORWARD_NSIWORKERERROREVENT_SPECIAL \
NS_IMETHOD GetMessage(nsAString& aMessage) \
{ return mErrorEvent->GetMessage(aMessage); } \
NS_IMETHOD GetFilename(nsAString& aFilename) \
{ return mErrorEvent->GetFilename(aFilename); } \
NS_IMETHOD GetLineno(PRUint32* aLineno) \
{ return mErrorEvent->GetLineno(aLineno); }
class nsDOMWorkerPrivateEvent : public nsIDOMWorkerPrivateEvent,
public nsIDOMProgressEvent,
public nsIWorkerMessageEvent,
public nsIWorkerErrorEvent,
public nsIClassInfo
{
public:
NS_DECL_ISUPPORTS
NS_FORWARD_NSIDOMEVENT_SPECIAL
NS_FORWARD_NSIWORKERMESSAGEEVENT_SPECIAL
NS_FORWARD_NSIDOMPROGRESSEVENT_SPECIAL
NS_FORWARD_NSIWORKERERROREVENT_SPECIAL
NS_DECL_NSICLASSINFO
nsDOMWorkerPrivateEvent(nsIDOMEvent* aEvent);
NS_IMETHOD PreventDefault();
NS_IMETHOD InitEvent(const nsAString& aEventType,
bool aCanBubble,
bool aCancelable);
NS_IMETHOD InitProgressEvent(const nsAString& aTypeArg,
bool aCanBubbleArg,
bool aCancelableArg,
bool aLengthComputableArg,
PRUint64 aLoadedArg,
PRUint64 aTotalArg);
NS_IMETHOD InitMessageEvent(const nsAString& aTypeArg,
bool aCanBubbleArg,
bool aCancelableArg,
const nsAString& aDataArg,
const nsAString& aOriginArg,
nsISupports* aSourceArg);
NS_IMETHOD InitErrorEvent(const nsAString& aTypeArg,
bool aCanBubbleArg,
bool aCancelableArg,
const nsAString& aMessageArg,
const nsAString& aFilenameArg,
PRUint32 aLinenoArg);
NS_IMETHOD GetDefaultPrevented(bool* aRetVal);
virtual bool PreventDefaultCalled();
private:
nsCOMPtr<nsIDOMEvent> mEvent;
nsCOMPtr<nsIDOMProgressEvent> mProgressEvent;
nsCOMPtr<nsIWorkerMessageEvent> mMessageEvent;
nsCOMPtr<nsIWorkerErrorEvent> mErrorEvent;
bool mPreventDefaultCalled;
};
class nsDOMWorkerEvent : public nsIDOMEvent,
public nsIClassInfo
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSIDOMEVENT
NS_DECL_NSICLASSINFO
nsDOMWorkerEvent()
: mEventPhase(nsIDOMEvent::AT_TARGET), mTimeStamp(0), mBubbles(PR_FALSE),
mCancelable(PR_FALSE), mPreventDefaultCalled(PR_FALSE) { }
void SetTarget(nsIDOMEventTarget* aTarget) {
mTarget = aTarget;
}
bool PreventDefaultCalled() {
return bool(mPreventDefaultCalled);
}
protected:
virtual ~nsDOMWorkerEvent() { }
nsString mType;
nsCOMPtr<nsIDOMEventTarget> mTarget;
PRUint16 mEventPhase;
DOMTimeStamp mTimeStamp;
bool mBubbles;
bool mCancelable;
bool mPreventDefaultCalled;
};
class nsDOMWorkerMessageEvent : public nsDOMWorkerEvent,
public nsIWorkerMessageEvent
{
public:
NS_DECL_ISUPPORTS_INHERITED
NS_FORWARD_NSIDOMEVENT(nsDOMWorkerEvent::)
NS_DECL_NSIWORKERMESSAGEEVENT
NS_DECL_NSICLASSINFO_GETINTERFACES
nsDOMWorkerMessageEvent() : mData(nsnull) { }
~nsDOMWorkerMessageEvent();
nsresult SetJSData(JSContext* aCx,
JSAutoStructuredCloneBuffer& aBuffer,
nsTArray<nsCOMPtr<nsISupports> >& aWrappedNatives);
protected:
nsString mOrigin;
nsCOMPtr<nsISupports> mSource;
nsAutoJSValHolder mDataVal;
uint64* mData;
size_t mDataLen;
nsTArray<nsCOMPtr<nsISupports> > mWrappedNatives;
};
class nsDOMWorkerProgressEvent : public nsDOMWorkerEvent,
public nsIDOMProgressEvent
{
public:
NS_DECL_ISUPPORTS_INHERITED
NS_FORWARD_NSIDOMEVENT(nsDOMWorkerEvent::)
NS_DECL_NSIDOMPROGRESSEVENT
NS_DECL_NSICLASSINFO_GETINTERFACES
nsDOMWorkerProgressEvent()
: mLoaded(0), mTotal(0), mLengthComputable(PR_FALSE) { }
protected:
PRUint64 mLoaded;
PRUint64 mTotal;
bool mLengthComputable;
};
class nsDOMWorkerXHRState
{
public:
nsDOMWorkerXHRState()
: responseTextResult(NS_OK), statusTextResult(NS_OK), status(NS_OK),
statusResult(NS_OK), readyState(0), readyStateResult(NS_OK) { }
NS_IMETHOD_(nsrefcnt) AddRef();
NS_IMETHOD_(nsrefcnt) Release();
nsString responseText;
nsresult responseTextResult;
nsCString statusText;
nsresult statusTextResult;
nsresult status;
nsresult statusResult;
PRUint16 readyState;
nsresult readyStateResult;
protected:
virtual ~nsDOMWorkerXHRState() { }
nsAutoRefCnt mRefCnt;
};
class nsDOMWorkerXHREvent : public nsDOMWorkerProgressEvent,
public nsIRunnable
{
friend class nsDOMWorkerXHRProxy;
public:
NS_DECL_ISUPPORTS_INHERITED
NS_DECL_NSIRUNNABLE
NS_DECL_NSICLASSINFO_GETINTERFACES
enum SnapshotChoice {
SNAPSHOT,
NO_SNAPSHOT
};
nsDOMWorkerXHREvent(nsDOMWorkerXHRProxy* aXHRProxy);
nsresult Init(PRUint32 aXHREventType,
const nsAString& aType,
nsIDOMEvent* aEvent,
SnapshotChoice = SNAPSHOT);
static void SnapshotXHRState(nsIXMLHttpRequest* aXHR,
nsDOMWorkerXHRState* aState);
already_AddRefed<nsDOMWorkerXHRState> ForgetState() {
return mState.forget();
}
protected:
nsDOMWorkerXHRState* GetState() {
return mState;
}
nsRefPtr<nsDOMWorkerXHRProxy> mXHRProxy;
nsCOMPtr<nsIXPConnectWrappedNative> mXHRWN;
nsRefPtr<nsDOMWorkerXHRState> mState;
PRUint32 mXHREventType;
PRInt32 mChannelID;
bool mUploadEvent;
bool mProgressEvent;
};
class nsDOMWorkerErrorEvent : public nsDOMWorkerEvent,
public nsIWorkerErrorEvent
{
public:
NS_DECL_ISUPPORTS_INHERITED
NS_FORWARD_NSIDOMEVENT(nsDOMWorkerEvent::)
NS_DECL_NSIWORKERERROREVENT
NS_DECL_NSICLASSINFO_GETINTERFACES
nsDOMWorkerErrorEvent()
: mLineno(0) { }
protected:
nsString mMessage;
nsString mFilename;
PRUint32 mLineno;
};
#endif /* __NSDOMWORKEREVENTS_H__ */

135
dom/src/threads/nsDOMWorkerMacros.h
View File

@ -1,135 +0,0 @@
/* -*- Mode: c++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Web Workers.
*
* The Initial Developer of the Original Code is
* Mozilla Corporation.
* Portions created by the Initial Developer are Copyright (C) 2008
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Ben Turner <bent.mozilla@gmail.com> (Original Author)
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#ifndef __NSDOMWORKERMACROS_H__
#define __NSDOMWORKERMACROS_H__
// Macro to generate nsIClassInfo methods for these threadsafe DOM classes
#define NS_IMPL_THREADSAFE_DOM_CI_GETINTERFACES(_class) \
NS_IMETHODIMP \
_class::GetInterfaces(PRUint32* _count, nsIID*** _array) \
{ \
return NS_CI_INTERFACE_GETTER_NAME(_class)(_count, _array); \
} \
#define NS_IMPL_THREADSAFE_DOM_CI_HELPER(_class) \
NS_IMETHODIMP \
_class::GetHelperForLanguage(PRUint32 _language, nsISupports** _retval) \
{ \
*_retval = nsnull; \
return NS_OK; \
}
#define NS_IMPL_THREADSAFE_DOM_CI_ALL_THE_REST(_class) \
NS_IMETHODIMP \
_class::GetContractID(char** _contractID) \
{ \
*_contractID = nsnull; \
return NS_OK; \
} \
\
NS_IMETHODIMP \
_class::GetClassDescription(char** _classDescription) \
{ \
*_classDescription = nsnull; \
return NS_OK; \
} \
\
NS_IMETHODIMP \
_class::GetClassID(nsCID** _classID) \
{ \
*_classID = nsnull; \
return NS_OK; \
} \
\
NS_IMETHODIMP \
_class::GetImplementationLanguage(PRUint32* _language) \
{ \
*_language = nsIProgrammingLanguage::CPLUSPLUS; \
return NS_OK; \
} \
\
NS_IMETHODIMP \
_class::GetFlags(PRUint32* _flags) \
{ \
*_flags = nsIClassInfo::THREADSAFE | nsIClassInfo::DOM_OBJECT; \
return NS_OK; \
} \
\
NS_IMETHODIMP \
_class::GetClassIDNoAlloc(nsCID* _classIDNoAlloc) \
{ \
return NS_ERROR_NOT_AVAILABLE; \
}
#define NS_IMPL_THREADSAFE_DOM_CI(_class) \
NS_IMPL_THREADSAFE_DOM_CI_GETINTERFACES(_class) \
NS_IMPL_THREADSAFE_DOM_CI_HELPER(_class) \
NS_IMPL_THREADSAFE_DOM_CI_ALL_THE_REST(_class)
#define NS_FORWARD_NSICLASSINFO_NOGETINTERFACES(_to) \
NS_IMETHOD GetHelperForLanguage(PRUint32 aLanguage, nsISupports** _retval) \
{ return _to GetHelperForLanguage(aLanguage, _retval); } \
NS_IMETHOD GetContractID(char** aContractID) \
{ return _to GetContractID(aContractID); } \
NS_IMETHOD GetClassDescription(char** aClassDescription) \
{ return _to GetClassDescription(aClassDescription); } \
NS_IMETHOD GetClassID(nsCID** aClassID) \
{ return _to GetClassID(aClassID); } \
NS_IMETHOD GetImplementationLanguage(PRUint32* aImplementationLanguage) \
{ return _to GetImplementationLanguage(aImplementationLanguage); } \
NS_IMETHOD GetFlags(PRUint32* aFlags) \
{ return _to GetFlags(aFlags); } \
NS_IMETHOD GetClassIDNoAlloc(nsCID* aClassIDNoAlloc) \
{ return _to GetClassIDNoAlloc(aClassIDNoAlloc); }
#define NS_DECL_NSICLASSINFO_GETINTERFACES \
NS_IMETHOD GetInterfaces(PRUint32* aCount, nsIID*** aArray);
// Don't know why nsISupports.idl defines this out...
#define NS_FORWARD_NSISUPPORTS(_to) \
NS_IMETHOD QueryInterface(const nsIID& uuid, void** result) { \
return _to QueryInterface(uuid, result); \
} \
NS_IMETHOD_(nsrefcnt) AddRef(void) { return _to AddRef(); } \
NS_IMETHOD_(nsrefcnt) Release(void) { return _to Release(); }
#define JSON_PRIMITIVE_PROPNAME \
"primitive"
#endif /* __NSDOMWORKERMACROS_H__ */

440
dom/src/threads/nsDOMWorkerMessageHandler.cpp
View File

@ -1,440 +0,0 @@
/* -*- Mode: c++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Web Workers.
*
* The Initial Developer of the Original Code is
* Mozilla Corporation.
* Portions created by the Initial Developer are Copyright (C) 2008
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Ben Turner <bent.mozilla@gmail.com> (Original Author)
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#include "nsDOMWorkerMessageHandler.h"
#include "nsIDOMEvent.h"
#include "nsIXPConnect.h"
#include "nsContentUtils.h"
#include "nsDOMThreadService.h"
#include "nsDOMWorkerEvents.h"
NS_IMPL_THREADSAFE_ADDREF(nsDOMWorkerEventListenerBase)
NS_IMPL_THREADSAFE_RELEASE(nsDOMWorkerEventListenerBase)
nsresult
nsDOMWorkerWeakEventListener::Init(nsIDOMEventListener* aListener)
{
NS_ENSURE_ARG_POINTER(aListener);
nsCOMPtr<nsIXPConnectWrappedJS> wrappedJS(do_QueryInterface(aListener));
NS_ENSURE_TRUE(wrappedJS, NS_NOINTERFACE);
JSObject* obj;
nsresult rv = wrappedJS->GetJSObject(&obj);
NS_ENSURE_SUCCESS(rv, rv);
mObj = obj;
return NS_OK;
}
already_AddRefed<nsIDOMEventListener>
nsDOMWorkerWeakEventListener::GetListener()
{
JSContext* cx = nsDOMThreadService::GetCurrentContext();
NS_ENSURE_TRUE(cx, nsnull);
nsIXPConnect* xpc = nsContentUtils::XPConnect();
nsCOMPtr<nsIDOMEventListener> listener;
nsresult rv = xpc->WrapJS(cx, mObj, NS_GET_IID(nsIDOMEventListener),
getter_AddRefs(listener));
NS_ENSURE_SUCCESS(rv, nsnull);
return listener.forget();
}
nsDOMWorkerWrappedWeakEventListener::
nsDOMWorkerWrappedWeakEventListener(nsDOMWorkerWeakEventListener* aInner)
: mInner(aInner)
{
NS_ASSERTION(aInner, "Null pointer!");
}
NS_IMPL_THREADSAFE_ISUPPORTS2(nsDOMWorkerMessageHandler,
nsIDOMEventTarget,
nsIClassInfo)
NS_IMPL_CI_INTERFACE_GETTER1(nsDOMWorkerMessageHandler,
nsIDOMEventTarget)
NS_IMPL_THREADSAFE_DOM_CI(nsDOMWorkerMessageHandler)
const nsDOMWorkerMessageHandler::ListenerCollection*
nsDOMWorkerMessageHandler::GetListenerCollection(const nsAString& aType) const
{
PRUint32 count = mCollections.Length();
for (PRUint32 index = 0; index < count; index++) {
const ListenerCollection& collection = mCollections[index];
if (collection.type.Equals(aType)) {
return &collection;
}
}
return nsnull;
}
void
nsDOMWorkerMessageHandler::GetListenersForType(const nsAString& aType,
ListenerArray& _retval) const
{
_retval.Clear();
const ListenerCollection* collection = GetListenerCollection(aType);
if (collection) {
PRUint32 count = collection->listeners.Length();
if (!_retval.SetLength(count)) {
NS_WARNING("Out of memory!");
return;
}
for (PRUint32 index = 0; index < count; index++) {
nsCOMPtr<nsIDOMEventListener> listener =
collection->listeners[index]->GetListener();
_retval[index].swap(listener);
}
}
}
nsresult
nsDOMWorkerMessageHandler::SetOnXListener(const nsAString& aType,
nsIDOMEventListener* aListener)
{
nsRefPtr<nsDOMWorkerWrappedWeakEventListener> wrappedListener;
ListenerCollection* collection =
const_cast<ListenerCollection*>(GetListenerCollection(aType));
#ifdef DEBUG
bool removed;
#endif
if (collection) {
wrappedListener.swap(collection->onXListener);
if (wrappedListener) {
#ifdef DEBUG
removed =
#endif
collection->listeners.RemoveElement(wrappedListener);
NS_ASSERTION(removed, "Element wasn't in the list!");
}
}
if (!aListener) {
if (collection && !collection->listeners.Length()) {
#ifdef DEBUG
removed =
#endif
mCollections.RemoveElement(*collection);
NS_ASSERTION(removed, "Element wasn't in the list!");
}
return NS_OK;
}
nsRefPtr<nsDOMWorkerWeakEventListener> weakListener =
new nsDOMWorkerWeakEventListener();
NS_ENSURE_TRUE(weakListener, NS_ERROR_OUT_OF_MEMORY);
nsresult rv = weakListener->Init(aListener);
NS_ENSURE_SUCCESS(rv, rv);
wrappedListener = new nsDOMWorkerWrappedWeakEventListener(weakListener);
NS_ENSURE_TRUE(wrappedListener, NS_ERROR_OUT_OF_MEMORY);
if (!collection) {
collection = mCollections.AppendElement(aType);
NS_ENSURE_TRUE(collection, NS_ERROR_OUT_OF_MEMORY);
}
WeakListener* newListener =
collection->listeners.AppendElement(wrappedListener);
NS_ENSURE_TRUE(newListener, NS_ERROR_OUT_OF_MEMORY);
wrappedListener.swap(collection->onXListener);
return NS_OK;
}
already_AddRefed<nsIDOMEventListener>
nsDOMWorkerMessageHandler::GetOnXListener(const nsAString& aType) const
{
const ListenerCollection* collection = GetListenerCollection(aType);
if (collection && collection->onXListener) {
return collection->onXListener->GetListener();
}
return nsnull;
}
void
nsDOMWorkerMessageHandler::ClearListeners(const nsAString& aType)
{
PRUint32 count = mCollections.Length();
for (PRUint32 index = 0; index < count; index++) {
if (mCollections[index].type.Equals(aType)) {
mCollections.RemoveElementAt(index);
return;
}
}
}
bool
nsDOMWorkerMessageHandler::HasListeners(const nsAString& aType)
{
const ListenerCollection* collection = GetListenerCollection(aType);
return collection && collection->listeners.Length();
}
void
nsDOMWorkerMessageHandler::ClearAllListeners()
{
mCollections.Clear();
}
void
nsDOMWorkerMessageHandler::Trace(JSTracer* aTracer)
{
PRUint32 cCount = mCollections.Length();
for (PRUint32 cIndex = 0; cIndex < cCount; cIndex++) {
const ListenerCollection& collection = mCollections[cIndex];
PRUint32 lCount = collection.listeners.Length();
for (PRUint32 lIndex = 0; lIndex < lCount; lIndex++) {
JSObject* obj = collection.listeners[lIndex]->GetJSObject();
NS_ASSERTION(obj, "Null object!");
JS_SET_TRACING_DETAILS(aTracer, nsnull, this, 0);
JS_CallTracer(aTracer, obj, JSTRACE_OBJECT);
}
}
}
/**
* See nsIDOMEventTarget
*/
NS_IMETHODIMP
nsDOMWorkerMessageHandler::RemoveEventListener(const nsAString& aType,
nsIDOMEventListener* aListener,
bool aUseCapture)
{
ListenerCollection* collection =
const_cast<ListenerCollection*>(GetListenerCollection(aType));
if (collection) {
PRUint32 count = collection->listeners.Length();
for (PRUint32 index = 0; index < count; index++) {
WeakListener& weakListener = collection->listeners[index];
if (weakListener == collection->onXListener) {
continue;
}
nsCOMPtr<nsIDOMEventListener> listener = weakListener->GetListener();
if (listener == aListener) {
collection->listeners.RemoveElementAt(index);
break;
}
}
if (!collection->listeners.Length()) {
#ifdef DEBUG
bool removed =
#endif
mCollections.RemoveElement(*collection);
NS_ASSERTION(removed, "Somehow this wasn't in the list!");
}
}
return NS_OK;
}
/**
* See nsIDOMEventTarget
*/
NS_IMETHODIMP
nsDOMWorkerMessageHandler::DispatchEvent(nsIDOMEvent* aEvent,
bool* _retval)
{
NS_ENSURE_ARG_POINTER(aEvent);
nsCOMPtr<nsIDOMWorkerPrivateEvent> event;
if (_retval) {
event = do_QueryInterface(aEvent);
if (!event) {
event = new nsDOMWorkerPrivateEvent(aEvent);
NS_ENSURE_TRUE(event, NS_ERROR_OUT_OF_MEMORY);
}
aEvent = event;
}
nsAutoString type;
nsresult rv = aEvent->GetType(type);
NS_ENSURE_SUCCESS(rv, rv);
nsAutoTArray<Listener, 10> listeners;
GetListenersForType(type, listeners);
PRUint32 count = listeners.Length();
for (PRUint32 index = 0; index < count; index++) {
const Listener& listener = listeners[index];
NS_ASSERTION(listener, "Null listener in array!");
listener->HandleEvent(aEvent);
}
if (_retval) {
*_retval = event->PreventDefaultCalled();
}
return NS_OK;
}
/**
* See nsIDOMEventTarget
*/
NS_IMETHODIMP
nsDOMWorkerMessageHandler::AddEventListener(const nsAString& aType,
nsIDOMEventListener* aListener,
bool aUseCapture,
bool aWantsUntrusted,
PRUint8 aOptionalArgc)
{
// We don't support aWantsUntrusted yet.
NS_ENSURE_TRUE(aOptionalArgc < 2, NS_ERROR_NOT_IMPLEMENTED);
ListenerCollection* collection =
const_cast<ListenerCollection*>(GetListenerCollection(aType));
if (!collection) {
collection = mCollections.AppendElement(aType);
NS_ENSURE_TRUE(collection, NS_ERROR_OUT_OF_MEMORY);
}
nsRefPtr<nsDOMWorkerWeakEventListener> weakListener =
new nsDOMWorkerWeakEventListener();
NS_ENSURE_TRUE(weakListener, NS_ERROR_OUT_OF_MEMORY);
nsresult rv = weakListener->Init(aListener);
NS_ENSURE_SUCCESS(rv, rv);
WeakListener* newListener = collection->listeners.AppendElement(weakListener);
NS_ENSURE_TRUE(newListener, NS_ERROR_OUT_OF_MEMORY);
return NS_OK;
}
nsIDOMEventTarget *
nsDOMWorkerMessageHandler::GetTargetForDOMEvent()
{
NS_ERROR("Should not be called");
return nsnull;
}
nsIDOMEventTarget *
nsDOMWorkerMessageHandler::GetTargetForEventTargetChain()
{
NS_ERROR("Should not be called");
return nsnull;
}
nsresult
nsDOMWorkerMessageHandler::PreHandleEvent(nsEventChainPreVisitor & aVisitor)
{
NS_ERROR("Should not be called");
return NS_ERROR_NOT_IMPLEMENTED;
}
nsresult
nsDOMWorkerMessageHandler::WillHandleEvent(nsEventChainPostVisitor & aVisitor)
{
NS_ERROR("Should not be called");
return NS_ERROR_NOT_IMPLEMENTED;
}
nsresult
nsDOMWorkerMessageHandler::PostHandleEvent(nsEventChainPostVisitor & aVisitor)
{
NS_ERROR("Should not be called");
return NS_ERROR_NOT_IMPLEMENTED;
}
nsresult
nsDOMWorkerMessageHandler::DispatchDOMEvent(nsEvent *aEvent, nsIDOMEvent *aDOMEvent,
nsPresContext *aPresContext,
nsEventStatus *aEventStatus)
{
NS_ERROR("Should not be called");
return NS_ERROR_NOT_IMPLEMENTED;
}
nsEventListenerManager*
nsDOMWorkerMessageHandler::GetListenerManager(bool aMayCreate)
{
NS_ERROR("Should not be called");
return nsnull;
}
nsresult
nsDOMWorkerMessageHandler::AddEventListenerByIID(nsIDOMEventListener *aListener,
const nsIID & aIID)
{
NS_ERROR("Should not be called");
return NS_ERROR_NOT_IMPLEMENTED;
}
nsresult
nsDOMWorkerMessageHandler::RemoveEventListenerByIID(nsIDOMEventListener *aListener,
const nsIID & aIID)
{
NS_ERROR("Should not be called");
return NS_ERROR_NOT_IMPLEMENTED;
}
nsIScriptContext*
nsDOMWorkerMessageHandler::GetContextForEventHandlers(nsresult *aRv)
{
NS_ERROR("Should not be called");
*aRv = NS_ERROR_NOT_IMPLEMENTED;
return nsnull;
}
JSContext*
nsDOMWorkerMessageHandler::GetJSContextForEventHandlers()
{
NS_ERROR("Should not be called");
return nsnull;
}

175
dom/src/threads/nsDOMWorkerMessageHandler.h
View File

@ -1,175 +0,0 @@
/* -*- Mode: c++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Web Workers.
*
* The Initial Developer of the Original Code is
* Mozilla Corporation.
* Portions created by the Initial Developer are Copyright (C) 2008
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Ben Turner <bent.mozilla@gmail.com> (Original Author)
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#ifndef __NSDOMWORKERMESSAGEHANDLER_H__
#define __NSDOMWORKERMESSAGEHANDLER_H__
#include "nsIClassInfo.h"
#include "nsIDOMEventListener.h"
#include "nsIDOMEventTarget.h"
#include "nsIDOMWorkers.h"
#include "nsIProgrammingLanguage.h"
#include "jsapi.h"
#include "nsAutoPtr.h"
#include "nsCOMPtr.h"
#include "nsIClassInfoImpl.h"
#include "nsStringGlue.h"
#include "nsTArray.h"
#include "nsIWeakReference.h"
class nsDOMWorkerEventListenerBase
{
public:
NS_IMETHOD_(nsrefcnt) AddRef();
NS_IMETHOD_(nsrefcnt) Release();
virtual already_AddRefed<nsIDOMEventListener> GetListener() = 0;
virtual JSObject* GetJSObject() = 0;
protected:
virtual ~nsDOMWorkerEventListenerBase() { }
nsAutoRefCnt mRefCnt;
};
class nsDOMWorkerWeakEventListener : public nsDOMWorkerEventListenerBase
{
public:
nsDOMWorkerWeakEventListener()
: mObj(NULL) { }
nsresult Init(nsIDOMEventListener* aListener);
already_AddRefed<nsIDOMEventListener> GetListener();
virtual JSObject* GetJSObject() {
return mObj;
}
private:
JSObject* mObj;
};
class nsDOMWorkerWrappedWeakEventListener : public nsDOMWorkerEventListenerBase
{
public:
nsDOMWorkerWrappedWeakEventListener(nsDOMWorkerWeakEventListener* aInner);
already_AddRefed<nsIDOMEventListener> GetListener() {
return mInner->GetListener();
}
virtual JSObject* GetJSObject() {
return mInner->GetJSObject();
}
private:
nsRefPtr<nsDOMWorkerWeakEventListener> mInner;
};
class nsDOMWorkerMessageHandler : public nsIDOMEventTarget,
public nsIClassInfo
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSIDOMEVENTTARGET
NS_DECL_NSICLASSINFO
virtual nsresult SetOnXListener(const nsAString& aType,
nsIDOMEventListener* aListener);
already_AddRefed<nsIDOMEventListener>
GetOnXListener(const nsAString& aType) const;
void ClearListeners(const nsAString& aType);
bool HasListeners(const nsAString& aType);
void ClearAllListeners();
void Trace(JSTracer* aTracer);
protected:
virtual ~nsDOMWorkerMessageHandler() { }
private:
typedef nsCOMPtr<nsIDOMEventListener> Listener;
typedef nsTArray<Listener> ListenerArray;
typedef nsRefPtr<nsDOMWorkerEventListenerBase> WeakListener;
typedef nsTArray<WeakListener> WeakListenerArray;
struct ListenerCollection {
bool operator==(const ListenerCollection& aOther) const {
return this == &aOther;
}
ListenerCollection(const nsAString& aType)
: type(aType) { }
nsString type;
WeakListenerArray listeners;
nsRefPtr<nsDOMWorkerWrappedWeakEventListener> onXListener;
};
const ListenerCollection* GetListenerCollection(const nsAString& aType) const;
void GetListenersForType(const nsAString& aType,
ListenerArray& _retval) const;
nsTArray<ListenerCollection> mCollections;
};
#define NS_FORWARD_INTERNAL_NSIDOMEVENTTARGET(_to) \
virtual nsIDOMEventTarget * GetTargetForDOMEvent(void) { return _to GetTargetForDOMEvent(); } \
virtual nsIDOMEventTarget * GetTargetForEventTargetChain(void) { return _to GetTargetForEventTargetChain(); } \
virtual nsresult PreHandleEvent(nsEventChainPreVisitor & aVisitor) { return _to PreHandleEvent(aVisitor); } \
virtual nsresult WillHandleEvent(nsEventChainPostVisitor & aVisitor) { return _to WillHandleEvent(aVisitor); } \
virtual nsresult PostHandleEvent(nsEventChainPostVisitor & aVisitor) { return _to PostHandleEvent(aVisitor); } \
virtual nsresult DispatchDOMEvent(nsEvent *aEvent, nsIDOMEvent *aDOMEvent, nsPresContext *aPresContext, nsEventStatus *aEventStatus) { return _to DispatchDOMEvent(aEvent, aDOMEvent, aPresContext, aEventStatus); } \
virtual nsEventListenerManager * GetListenerManager(bool aMayCreate) { return _to GetListenerManager(aMayCreate); } \
virtual nsresult AddEventListenerByIID(nsIDOMEventListener *aListener, const nsIID & aIID) { return _to AddEventListenerByIID(aListener, aIID); } \
virtual nsresult RemoveEventListenerByIID(nsIDOMEventListener *aListener, const nsIID & aIID) { return _to RemoveEventListenerByIID(aListener, aIID); } \
virtual nsIScriptContext * GetContextForEventHandlers(nsresult *aRv NS_OUTPARAM) { return _to GetContextForEventHandlers(aRv); } \
virtual JSContext * GetJSContextForEventHandlers(void) { return _to GetJSContextForEventHandlers(); }
#endif /* __NSDOMWORKERMESSAGEHANDLER_H__ */

238
dom/src/threads/nsDOMWorkerPool.cpp
View File

@ -1,238 +0,0 @@
/* -*- Mode: c++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is worker threads.
*
* The Initial Developer of the Original Code is
* Mozilla Corporation.
* Portions created by the Initial Developer are Copyright (C) 2008
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Vladimir Vukicevic <vladimir@pobox.com> (Original Author)
* Ben Turner <bent.mozilla@gmail.com>
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#include "nsDOMWorkerPool.h"
// Interfaces
#include "nsIDocument.h"
#include "nsIDOMClassInfo.h"
#include "nsIJSContextStack.h"
#include "nsIScriptGlobalObject.h"
#include "nsIServiceManager.h"
#include "nsIThreadManager.h"
#include "nsIXPConnect.h"
#include "nsPIDOMWindow.h"
// Other includes
#include "nsContentUtils.h"
#include "nsDOMJSUtils.h"
#include "nsProxyRelease.h"
#include "nsThreadUtils.h"
// DOMWorker includes
#include "nsDOMThreadService.h"
#include "nsDOMWorker.h"
using namespace mozilla;
#define LOG(_args) PR_LOG(gDOMThreadsLog, PR_LOG_DEBUG, _args)
nsDOMWorkerPool::nsDOMWorkerPool(nsIScriptGlobalObject* aGlobalObject,
nsIDocument* aDocument)
: mParentGlobal(aGlobalObject),
mParentDocument(aDocument),
mReentrantMonitor("nsDOMWorkerPool.mReentrantMonitor"),
mCanceled(PR_FALSE),
mSuspended(PR_FALSE),
mWindowID(aDocument ? aDocument->OuterWindowID() : 0)
{
}
nsDOMWorkerPool::~nsDOMWorkerPool()
{
nsCOMPtr<nsIThread> mainThread;
NS_GetMainThread(getter_AddRefs(mainThread));
nsIScriptGlobalObject* global;
mParentGlobal.forget(&global);
if (global) {
NS_ProxyRelease(mainThread, global, PR_FALSE);
}
nsIDocument* document;
mParentDocument.forget(&document);
if (document) {
NS_ProxyRelease(mainThread, document, PR_FALSE);
}
}
NS_IMPL_THREADSAFE_ADDREF(nsDOMWorkerPool)
NS_IMPL_THREADSAFE_RELEASE(nsDOMWorkerPool)
nsresult
nsDOMWorkerPool::Init()
{
NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
return NS_OK;
}
nsresult
nsDOMWorkerPool::NoteWorker(nsDOMWorker* aWorker)
{
NS_ASSERTION(aWorker, "Null pointer!");
bool suspendWorker;
{
ReentrantMonitorAutoEnter mon(mReentrantMonitor);
if (mCanceled) {
return NS_ERROR_ABORT;
}
nsDOMWorker** newWorker = mWorkers.AppendElement(aWorker);
NS_ENSURE_TRUE(newWorker, NS_ERROR_OUT_OF_MEMORY);
suspendWorker = mSuspended;
}
if (suspendWorker) {
aWorker->Suspend();
}
return NS_OK;
}
void
nsDOMWorkerPool::NoteDyingWorker(nsDOMWorker* aWorker)
{
NS_ASSERTION(aWorker, "Null pointer!");
bool removeFromThreadService = false;
{
ReentrantMonitorAutoEnter mon(mReentrantMonitor);
NS_ASSERTION(mWorkers.Contains(aWorker), "Worker from a different pool?!");
mWorkers.RemoveElement(aWorker);
if (!mCanceled && !mWorkers.Length()) {
removeFromThreadService = PR_TRUE;
}
}
if (removeFromThreadService) {
nsRefPtr<nsDOMWorkerPool> kungFuDeathGrip(this);
nsDOMThreadService::get()->NoteEmptyPool(this);
}
}
void
nsDOMWorkerPool::GetWorkers(nsTArray<nsDOMWorker*>& aArray)
{
mReentrantMonitor.AssertCurrentThreadIn();
NS_ASSERTION(!aArray.Length(), "Should be empty!");
#ifdef DEBUG
nsDOMWorker** newWorkers =
#endif
aArray.AppendElements(mWorkers);
NS_WARN_IF_FALSE(newWorkers, "Out of memory!");
}
void
nsDOMWorkerPool::Cancel()
{
NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
NS_ASSERTION(!mCanceled, "Canceled more than once!");
nsAutoTArray<nsDOMWorker*, 10> workers;
{
ReentrantMonitorAutoEnter mon(mReentrantMonitor);
mCanceled = PR_TRUE;
GetWorkers(workers);
}
PRUint32 count = workers.Length();
if (count) {
for (PRUint32 index = 0; index < count; index++) {
workers[index]->Cancel();
}
ReentrantMonitorAutoEnter mon(mReentrantMonitor);
mon.NotifyAll();
}
}
void
nsDOMWorkerPool::Suspend()
{
NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
nsAutoTArray<nsDOMWorker*, 10> workers;
{
ReentrantMonitorAutoEnter mon(mReentrantMonitor);
NS_ASSERTION(!mSuspended, "Suspended more than once!");
mSuspended = PR_TRUE;
GetWorkers(workers);
}
PRUint32 count = workers.Length();
for (PRUint32 index = 0; index < count; index++) {
workers[index]->Suspend();
}
}
void
nsDOMWorkerPool::Resume()
{
NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
nsAutoTArray<nsDOMWorker*, 10> workers;
{
ReentrantMonitorAutoEnter mon(mReentrantMonitor);
NS_ASSERTION(mSuspended, "Not suspended!");
mSuspended = PR_FALSE;
GetWorkers(workers);
}
PRUint32 count = workers.Length();
if (count) {
for (PRUint32 index = 0; index < count; index++) {
workers[index]->Resume();
}
ReentrantMonitorAutoEnter mon(mReentrantMonitor);
mon.NotifyAll();
}
}

118
dom/src/threads/nsDOMWorkerPool.h
View File

@ -1,118 +0,0 @@
/* -*- Mode: c++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is worker threads.
*
* The Initial Developer of the Original Code is
* Mozilla Corporation.
* Portions created by the Initial Developer are Copyright (C) 2008
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Vladimir Vukicevic <vladimir@pobox.com> (Original Author)
* Ben Turner <bent.mozilla@gmail.com>
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#ifndef __NSDOMWORKERPOOL_H__
#define __NSDOMWORKERPOOL_H__
// Other includes
#include "jsapi.h"
#include "mozilla/ReentrantMonitor.h"
#include "nsCOMPtr.h"
#include "nsStringGlue.h"
#include "nsTArray.h"
class nsDOMWorker;
class nsIDocument;
class nsIScriptContext;
class nsIScriptError;
class nsIScriptGlobalObject;
class nsDOMWorkerPool
{
typedef mozilla::ReentrantMonitor ReentrantMonitor;
public:
nsDOMWorkerPool(nsIScriptGlobalObject* aGlobalObject,
nsIDocument* aDocument);
NS_IMETHOD_(nsrefcnt) AddRef();
NS_IMETHOD_(nsrefcnt) Release();
nsIScriptGlobalObject* ScriptGlobalObject() {
return mParentGlobal;
}
nsIDocument* ParentDocument() {
return mParentDocument;
}
nsresult Init();
void Cancel();
void Suspend();
void Resume();
nsresult NoteWorker(nsDOMWorker* aWorker);
void NoteDyingWorker(nsDOMWorker* aWorker);
ReentrantMonitor& GetReentrantMonitor() {
return mReentrantMonitor;
}
const PRUint64 WindowID() const {
return mWindowID;
}
private:
virtual ~nsDOMWorkerPool();
void GetWorkers(nsTArray<nsDOMWorker*>& aArray);
nsAutoRefCnt mRefCnt;
// Reference to the window that created and owns this pool.
nsCOMPtr<nsIScriptGlobalObject> mParentGlobal;
// Reference to the document that created this pool.
nsCOMPtr<nsIDocument> mParentDocument;
// Weak array of workers. The idea is that workers can be garbage collected
// independently of the owning pool and other workers.
nsTArray<nsDOMWorker*> mWorkers;
// ReentrantMonitor for suspending and resuming workers.
ReentrantMonitor mReentrantMonitor;
bool mCanceled;
bool mSuspended;
const PRUint64 mWindowID;
};
#endif /* __NSDOMWORKERPOOL_H__ */

881
dom/src/threads/nsDOMWorkerScriptLoader.cpp
View File

@ -1,881 +0,0 @@
/* -*- Mode: c++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is worker threads.
*
* The Initial Developer of the Original Code is
* Mozilla Corporation.
* Portions created by the Initial Developer are Copyright (C) 2008
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Ben Turner <bent.mozilla@gmail.com> (Original Author)
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#include "nsDOMWorkerScriptLoader.h"
// Interfaces
#include "nsIChannel.h"
#include "nsIContentPolicy.h"
#include "nsIHttpChannel.h"
#include "nsIIOService.h"
#include "nsIProtocolHandler.h"
#include "nsIRequest.h"
#include "nsIScriptSecurityManager.h"
#include "nsIStreamLoader.h"
// Other includes
#include "nsContentErrors.h"
#include "nsContentPolicyUtils.h"
#include "nsContentUtils.h"
#include "nsISupportsPrimitives.h"
#include "nsNetError.h"
#include "nsNetUtil.h"
#include "nsScriptLoader.h"
#include "nsThreadUtils.h"
#include "pratom.h"
#include "nsDocShellCID.h"
#include "nsIChannelPolicy.h"
#include "nsChannelPolicy.h"
#include "nsIContentSecurityPolicy.h"
// DOMWorker includes
#include "nsDOMWorkerPool.h"
#include "nsDOMWorkerSecurityManager.h"
#include "nsDOMThreadService.h"
#include "nsDOMWorkerTimeout.h"
using namespace mozilla;
#define LOG(_args) PR_LOG(gDOMThreadsLog, PR_LOG_DEBUG, _args)
nsDOMWorkerScriptLoader::nsDOMWorkerScriptLoader(nsDOMWorker* aWorker)
: nsDOMWorkerFeature(aWorker),
mTarget(nsnull),
mScriptCount(0),
mCanceled(PR_FALSE),
mForWorker(PR_FALSE)
{
// Created on worker thread.
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
NS_ASSERTION(aWorker, "Null worker!");
}
NS_IMPL_ISUPPORTS_INHERITED2(nsDOMWorkerScriptLoader, nsDOMWorkerFeature,
nsIRunnable,
nsIStreamLoaderObserver)
nsresult
nsDOMWorkerScriptLoader::LoadScripts(JSContext* aCx,
const nsTArray<nsString>& aURLs,
bool aExecute)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
NS_ASSERTION(aCx, "Null context!");
mTarget = NS_GetCurrentThread();
NS_ASSERTION(mTarget, "This should never be null!");
if (mCanceled) {
return NS_ERROR_ABORT;
}
mScriptCount = aURLs.Length();
if (!mScriptCount) {
return NS_ERROR_INVALID_ARG;
}
// Do all the memory work for these arrays now rather than checking for
// failures all along the way.
bool success = mLoadInfos.SetCapacity(mScriptCount);
NS_ENSURE_TRUE(success, NS_ERROR_OUT_OF_MEMORY);
// Need one runnable per script and then an extra for the finished
// notification.
success = mPendingRunnables.SetCapacity(mScriptCount + 1);
NS_ENSURE_TRUE(success, NS_ERROR_OUT_OF_MEMORY);
for (PRUint32 index = 0; index < mScriptCount; index++) {
ScriptLoadInfo* newInfo = mLoadInfos.AppendElement();
NS_ASSERTION(newInfo, "Shouldn't fail if SetCapacity succeeded above!");
newInfo->url.Assign(aURLs[index]);
if (newInfo->url.IsEmpty()) {
return NS_ERROR_INVALID_ARG;
}
success = newInfo->scriptObj.Hold(aCx);
NS_ENSURE_TRUE(success, NS_ERROR_FAILURE);
}
// Don't want timeouts, etc., from queuing up while we're waiting on the
// network or compiling.
AutoSuspendWorkerEvents aswe(this);
nsresult rv = DoRunLoop(aCx);
if (NS_FAILED(rv)) {
return rv;
}
// Verify that all scripts downloaded and compiled.
rv = VerifyScripts(aCx);
if (NS_FAILED(rv)) {
return rv;
}
if (aExecute) {
rv = ExecuteScripts(aCx);
if (NS_FAILED(rv)) {
return rv;
}
}
return NS_OK;
}
nsresult
nsDOMWorkerScriptLoader::LoadWorkerScript(JSContext* aCx,
const nsString& aURL)
{
mForWorker = PR_TRUE;
nsAutoTArray<nsString, 1> url;
url.AppendElement(aURL);
return LoadScripts(aCx, url, PR_FALSE);
}
nsresult
nsDOMWorkerScriptLoader::DoRunLoop(JSContext* aCx)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
volatile bool done = false;
mDoneRunnable = new ScriptLoaderDone(this, &done);
NS_ENSURE_TRUE(mDoneRunnable, NS_ERROR_OUT_OF_MEMORY);
nsresult rv = NS_DispatchToMainThread(this);
NS_ENSURE_SUCCESS(rv, rv);
while (!(done || mCanceled)) {
JSAutoSuspendRequest asr(aCx);
NS_ProcessNextEvent(mTarget);
}
return mCanceled ? NS_ERROR_ABORT : NS_OK;
}
nsresult
nsDOMWorkerScriptLoader::VerifyScripts(JSContext* aCx)
{
NS_ASSERTION(aCx, "Shouldn't be null!");
nsresult rv = NS_OK;
for (PRUint32 index = 0; index < mScriptCount; index++) {
ScriptLoadInfo& loadInfo = mLoadInfos[index];
NS_ASSERTION(loadInfo.done, "Inconsistent state!");
if (NS_SUCCEEDED(loadInfo.result) && loadInfo.scriptObj.ToJSObject()) {
continue;
}
NS_ASSERTION(!loadInfo.scriptObj.ToJSObject(), "Inconsistent state!");
// Flag failure before worrying about whether or not to report an error.
rv = NS_FAILED(loadInfo.result) ? loadInfo.result : NS_ERROR_FAILURE;
// If loadInfo.result is a success code then the compiler probably reported
// an error already. Also we don't really care about NS_BINDING_ABORTED
// since that's the code we set when some other script had a problem and the
// rest were canceled.
if (NS_SUCCEEDED(loadInfo.result) || loadInfo.result == NS_BINDING_ABORTED) {
continue;
}
// Ok, this is the script that caused us to fail.
JSAutoRequest ar(aCx);
// Only throw an error if there is no other pending exception.
if (!JS_IsExceptionPending(aCx)) {
const char* message;
switch (loadInfo.result) {
case NS_ERROR_MALFORMED_URI:
message = "Malformed script URI: %s";
break;
case NS_ERROR_FILE_NOT_FOUND:
case NS_ERROR_NOT_AVAILABLE:
message = "Script file not found: %s";
break;
default:
message = "Failed to load script: %s (nsresult = 0x%x)";
break;
}
NS_ConvertUTF16toUTF8 url(loadInfo.url);
JS_ReportError(aCx, message, url.get(), loadInfo.result);
}
break;
}
return rv;
}
nsresult
nsDOMWorkerScriptLoader::ExecuteScripts(JSContext* aCx)
{
NS_ASSERTION(aCx, "Shouldn't be null!");
// Now execute all the scripts.
for (PRUint32 index = 0; index < mScriptCount; index++) {
ScriptLoadInfo& loadInfo = mLoadInfos[index];
JSAutoRequest ar(aCx);
JSObject* scriptObj = loadInfo.scriptObj.ToJSObject();
NS_ASSERTION(scriptObj, "This shouldn't ever be null!");
JSObject* global = mWorker->mGlobal ?
mWorker->mGlobal :
JS_GetGlobalObject(aCx);
NS_ENSURE_STATE(global);
// Because we may have nested calls to this function we don't want the
// execution to automatically report errors. We let them propagate instead.
uint32 oldOpts =
JS_SetOptions(aCx, JS_GetOptions(aCx) | JSOPTION_DONT_REPORT_UNCAUGHT);
bool success = JS_ExecuteScript(aCx, global, scriptObj, NULL);
JS_SetOptions(aCx, oldOpts);
if (!success) {
return NS_ERROR_FAILURE;
}
}
return NS_OK;
}
void
nsDOMWorkerScriptLoader::Cancel()
{
NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
NS_ASSERTION(!mCanceled, "Cancel called more than once!");
mCanceled = PR_TRUE;
for (PRUint32 index = 0; index < mScriptCount; index++) {
ScriptLoadInfo& loadInfo = mLoadInfos[index];
nsIRequest* request =
static_cast<nsIRequest*>(loadInfo.channel.get());
if (request) {
#ifdef DEBUG
nsresult rv =
#endif
request->Cancel(NS_BINDING_ABORTED);
NS_WARN_IF_FALSE(NS_SUCCEEDED(rv), "Failed to cancel channel!");
}
}
nsAutoTArray<ScriptLoaderRunnable*, 10> runnables;
{
MutexAutoLock lock(mWorker->GetLock());
runnables.AppendElements(mPendingRunnables);
mPendingRunnables.Clear();
}
PRUint32 runnableCount = runnables.Length();
for (PRUint32 index = 0; index < runnableCount; index++) {
runnables[index]->Revoke();
}
// We're about to post a revoked event to the worker thread, which seems
// silly, but we have to do this because the worker thread may be sleeping
// waiting on its event queue.
NotifyDone();
}
NS_IMETHODIMP
nsDOMWorkerScriptLoader::Run()
{
NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
// We may have been canceled already.
if (mCanceled) {
return NS_BINDING_ABORTED;
}
nsresult rv = RunInternal();
if (NS_SUCCEEDED(rv)) {
return rv;
}
// Ok, something failed beyond a normal cancel.
// If necko is holding a ref to us then we'll end up notifying in the
// OnStreamComplete method, not here.
bool needsNotify = true;
// Cancel any async channels that were already opened.
for (PRUint32 index = 0; index < mScriptCount; index++) {
ScriptLoadInfo& loadInfo = mLoadInfos[index];
nsIRequest* request = static_cast<nsIRequest*>(loadInfo.channel.get());
if (request) {
#ifdef DEBUG
nsresult rvInner =
#endif
request->Cancel(NS_BINDING_ABORTED);
NS_WARN_IF_FALSE(NS_SUCCEEDED(rvInner), "Failed to cancel channel!");
// Necko is holding a ref to us so make sure that the OnStreamComplete
// code sends the done event.
needsNotify = PR_FALSE;
}
else {
// Make sure to set this so that the OnStreamComplete code will dispatch
// the done event.
loadInfo.done = PR_TRUE;
}
}
if (needsNotify) {
NotifyDone();
}
return rv;
}
NS_IMETHODIMP
nsDOMWorkerScriptLoader::OnStreamComplete(nsIStreamLoader* aLoader,
nsISupports* aContext,
nsresult aStatus,
PRUint32 aStringLen,
const PRUint8* aString)
{
NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
// We may have been canceled already.
if (mCanceled) {
return NS_BINDING_ABORTED;
}
nsresult rv = OnStreamCompleteInternal(aLoader, aContext, aStatus, aStringLen,
aString);
// Dispatch the done event if we've received all the data.
for (PRUint32 index = 0; index < mScriptCount; index++) {
if (!mLoadInfos[index].done) {
// Some async load is still outstanding, don't notify yet.
break;
}
if (index == mScriptCount - 1) {
// All loads complete, signal the thread.
NotifyDone();
}
}
return rv;
}
nsresult
nsDOMWorkerScriptLoader::RunInternal()
{
NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
if (mForWorker) {
NS_ASSERTION(mScriptCount == 1, "Bad state!");
}
nsRefPtr<nsDOMWorker> parentWorker = mWorker->GetParent();
// Figure out which principal to use.
nsIPrincipal* principal = mWorker->GetPrincipal();
if (!principal) {
if (!parentWorker) {
NS_ERROR("Must have a principal if this is not a subworker!");
}
principal = parentWorker->GetPrincipal();
}
NS_ASSERTION(principal, "This should never be null here!");
// Figure out our base URI.
nsCOMPtr<nsIURI> baseURI;
if (mForWorker) {
if (parentWorker) {
baseURI = parentWorker->GetBaseURI();
NS_ASSERTION(baseURI, "Should have been set already!");
}
else {
// May be null.
baseURI = mWorker->GetBaseURI();
// Don't leave a temporary URI hanging around.
mWorker->ClearBaseURI();
}
NS_ASSERTION(!mWorker->GetBaseURI(), "Should not be set here!");
}
else {
baseURI = mWorker->GetBaseURI();
NS_ASSERTION(baseURI, "Should have been set already!");
}
nsCOMPtr<nsIDocument> parentDoc = mWorker->Pool()->ParentDocument();
// All of these can potentially be null, but that should be ok. We'll either
// succeed without them or fail below.
nsCOMPtr<nsILoadGroup> loadGroup;
if (parentDoc) {
loadGroup = parentDoc->GetDocumentLoadGroup();
}
nsCOMPtr<nsIIOService> ios(do_GetIOService());
nsIScriptSecurityManager* secMan = nsContentUtils::GetSecurityManager();
NS_ASSERTION(secMan, "This should never be null!");
for (PRUint32 index = 0; index < mScriptCount; index++) {
ScriptLoadInfo& loadInfo = mLoadInfos[index];
nsresult& rv = loadInfo.result;
nsCOMPtr<nsIURI>& uri = loadInfo.finalURI;
rv = nsContentUtils::NewURIWithDocumentCharset(getter_AddRefs(uri),
loadInfo.url, parentDoc,
baseURI);
if (NS_FAILED(rv)) {
return rv;
}
// If we're part of a document then check the content load policy.
if (parentDoc) {
PRInt16 shouldLoad = nsIContentPolicy::ACCEPT;
rv = NS_CheckContentLoadPolicy(nsIContentPolicy::TYPE_SCRIPT, uri,
principal, parentDoc,
NS_LITERAL_CSTRING("text/javascript"),
nsnull, &shouldLoad,
nsContentUtils::GetContentPolicy(),
secMan);
if (NS_FAILED(rv) || NS_CP_REJECTED(shouldLoad)) {
if (NS_FAILED(rv) || shouldLoad != nsIContentPolicy::REJECT_TYPE) {
return (rv = NS_ERROR_CONTENT_BLOCKED);
}
return (rv = NS_ERROR_CONTENT_BLOCKED_SHOW_ALT);
}
}
// If this script loader is being used to make a new worker then we need to
// do a same-origin check. Otherwise we need to clear the load with the
// security manager.
rv = mForWorker ?
principal->CheckMayLoad(uri, PR_FALSE):
secMan->CheckLoadURIWithPrincipal(principal, uri, 0);
NS_ENSURE_SUCCESS(rv, rv);
// We need to know which index we're on in OnStreamComplete so we know where
// to put the result.
nsCOMPtr<nsISupportsPRUint32> indexSupports =
do_CreateInstance(NS_SUPPORTS_PRUINT32_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
rv = indexSupports->SetData(index);
NS_ENSURE_SUCCESS(rv, rv);
// We don't care about progress so just use the simple stream loader for
// OnStreamComplete notification only.
nsCOMPtr<nsIStreamLoader> loader;
rv = NS_NewStreamLoader(getter_AddRefs(loader), this);
NS_ENSURE_SUCCESS(rv, rv);
// Get Content Security Policy from parent document to pass into channel
nsCOMPtr<nsIContentSecurityPolicy> csp;
rv = principal->GetCsp(getter_AddRefs(csp));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIChannelPolicy> channelPolicy;
if (csp) {
channelPolicy = do_CreateInstance("@mozilla.org/nschannelpolicy;1", &rv);
NS_ENSURE_SUCCESS(rv, rv);
rv = channelPolicy->SetContentSecurityPolicy(csp);
NS_ENSURE_SUCCESS(rv, rv);
rv = channelPolicy->SetLoadType(nsIContentPolicy::TYPE_SCRIPT);
NS_ENSURE_SUCCESS(rv, rv);
}
rv = NS_NewChannel(getter_AddRefs(loadInfo.channel),
uri, ios, loadGroup, nsnull,
nsIRequest::LOAD_NORMAL | nsIChannel::LOAD_CLASSIFY_URI,
channelPolicy);
NS_ENSURE_SUCCESS(rv, rv);
rv = loadInfo.channel->AsyncOpen(loader, indexSupports);
if (NS_FAILED(rv)) {
// Null this out so we don't try to cancel it later.
loadInfo.channel = nsnull;
return rv;
}
}
return NS_OK;
}
nsresult
nsDOMWorkerScriptLoader::OnStreamCompleteInternal(nsIStreamLoader* aLoader,
nsISupports* aContext,
nsresult aStatus,
PRUint32 aStringLen,
const PRUint8* aString)
{
NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
nsCOMPtr<nsISupportsPRUint32> indexSupports(do_QueryInterface(aContext));
NS_ENSURE_TRUE(indexSupports, NS_ERROR_NO_INTERFACE);
PRUint32 index = PR_UINT32_MAX;
indexSupports->GetData(&index);
if (index >= mScriptCount) {
NS_NOTREACHED("This really can't fail or we'll hang!");
return NS_ERROR_FAILURE;
}
ScriptLoadInfo& loadInfo = mLoadInfos[index];
NS_ASSERTION(!loadInfo.done, "Got complete on the same load twice!");
loadInfo.done = PR_TRUE;
// Use an alias to keep rv and loadInfo.result in sync.
nsresult& rv = loadInfo.result;
if (NS_FAILED(aStatus)) {
return rv = aStatus;
}
if (!(aStringLen && aString)) {
return rv = NS_ERROR_UNEXPECTED;
}
// Make sure we're not seeing the result of a 404 or something by checking the
// 'requestSucceeded' attribute on the http channel.
nsCOMPtr<nsIRequest> request;
rv = aLoader->GetRequest(getter_AddRefs(request));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(request);
if (httpChannel) {
bool requestSucceeded;
rv = httpChannel->GetRequestSucceeded(&requestSucceeded);
NS_ENSURE_SUCCESS(rv, rv);
if (!requestSucceeded) {
return rv = NS_ERROR_NOT_AVAILABLE;
}
}
// May be null.
nsIDocument* parentDoc = mWorker->Pool()->ParentDocument();
// Use the regular nsScriptLoader for this grunt work! Should be just fine
// because we're running on the main thread.
rv = nsScriptLoader::ConvertToUTF16(loadInfo.channel, aString, aStringLen,
EmptyString(), parentDoc,
loadInfo.scriptText);
if (NS_FAILED(rv)) {
return rv;
}
if (loadInfo.scriptText.IsEmpty()) {
return rv = NS_ERROR_FAILURE;
}
nsCString filename;
rv = loadInfo.finalURI->GetSpec(filename);
NS_ENSURE_SUCCESS(rv, rv);
if (filename.IsEmpty()) {
filename.Assign(NS_LossyConvertUTF16toASCII(loadInfo.url));
}
else {
// This will help callers figure out what their script url resolved to in
// case of errors.
loadInfo.url.Assign(NS_ConvertUTF8toUTF16(filename));
}
// Update the principal of the worker and its base URI if we just loaded the
// worker's primary script.
if (mForWorker) {
nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
NS_ASSERTION(channel, "This should never fail!");
// Take care of the base URI first.
nsCOMPtr<nsIURI> finalURI;
rv = NS_GetFinalChannelURI(channel, getter_AddRefs(finalURI));
NS_ENSURE_SUCCESS(rv, rv);
mWorker->SetBaseURI(finalURI);
// Now to figure out which principal to give this worker.
nsRefPtr<nsDOMWorker> parent = mWorker->GetParent();
NS_ASSERTION(mWorker->GetPrincipal() || parent, "Must have one of these!");
nsCOMPtr<nsIPrincipal> loadPrincipal = mWorker->GetPrincipal() ?
mWorker->GetPrincipal() :
parent->GetPrincipal();
nsIScriptSecurityManager* ssm = nsContentUtils::GetSecurityManager();
NS_ASSERTION(ssm, "Should never be null!");
nsCOMPtr<nsIPrincipal> channelPrincipal;
rv = ssm->GetChannelPrincipal(channel, getter_AddRefs(channelPrincipal));
NS_ENSURE_SUCCESS(rv, rv);
// See if this is a resource URI. Since JSMs usually come from resource://
// URIs we're currently considering all URIs with the URI_IS_UI_RESOURCE
// flag as valid for creating privileged workers.
if (!nsContentUtils::IsSystemPrincipal(channelPrincipal)) {
bool isResource;
rv = NS_URIChainHasFlags(finalURI,
nsIProtocolHandler::URI_IS_UI_RESOURCE,
&isResource);
NS_ENSURE_SUCCESS(rv, rv);
if (isResource) {
rv = ssm->GetSystemPrincipal(getter_AddRefs(channelPrincipal));
NS_ENSURE_SUCCESS(rv, rv);
}
}
// If the load principal is the system principal then the channel principal
// must also be the system principal (we do not allow chrome code to create
// workers with non-chrome scripts). Otherwise this channel principal must
// be same origin with the load principal (we check again here in case
// redirects changed the location of the script).
if (nsContentUtils::IsSystemPrincipal(loadPrincipal)) {
if (!nsContentUtils::IsSystemPrincipal(channelPrincipal)) {
return rv = NS_ERROR_DOM_BAD_URI;
}
}
else if (NS_FAILED(loadPrincipal->CheckMayLoad(finalURI, PR_FALSE))) {
return rv = NS_ERROR_DOM_BAD_URI;
}
mWorker->SetPrincipal(channelPrincipal);
}
nsRefPtr<ScriptCompiler> compiler =
new ScriptCompiler(this, loadInfo.scriptText, filename, loadInfo.scriptObj);
NS_ASSERTION(compiler, "Out of memory!");
if (!compiler) {
return rv = NS_ERROR_OUT_OF_MEMORY;
}
rv = mTarget->Dispatch(compiler, NS_DISPATCH_NORMAL);
NS_ENSURE_SUCCESS(rv, rv);
return rv;
}
void
nsDOMWorkerScriptLoader::NotifyDone()
{
NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
if (!mDoneRunnable) {
// We've already completed, no need to cancel anything.
return;
}
for (PRUint32 index = 0; index < mScriptCount; index++) {
ScriptLoadInfo& loadInfo = mLoadInfos[index];
// Null both of these out because they aren't threadsafe and must be
// destroyed on this thread.
loadInfo.channel = nsnull;
loadInfo.finalURI = nsnull;
if (mCanceled) {
// Simulate a complete, yet failed, load.
loadInfo.done = PR_TRUE;
loadInfo.result = NS_BINDING_ABORTED;
}
}
#ifdef DEBUG
nsresult rv =
#endif
mTarget->Dispatch(mDoneRunnable, NS_DISPATCH_NORMAL);
NS_WARN_IF_FALSE(NS_SUCCEEDED(rv), "Couldn't dispatch done event!");
mDoneRunnable = nsnull;
}
void
nsDOMWorkerScriptLoader::SuspendWorkerEvents()
{
NS_ASSERTION(mWorker, "No worker yet!");
mWorker->SuspendFeatures();
}
void
nsDOMWorkerScriptLoader::ResumeWorkerEvents()
{
NS_ASSERTION(mWorker, "No worker yet!");
mWorker->ResumeFeatures();
}
nsDOMWorkerScriptLoader::
ScriptLoaderRunnable::ScriptLoaderRunnable(nsDOMWorkerScriptLoader* aLoader)
: mRevoked(PR_FALSE),
mLoader(aLoader)
{
MutexAutoLock lock(aLoader->GetLock());
#ifdef DEBUG
nsDOMWorkerScriptLoader::ScriptLoaderRunnable** added =
#endif
aLoader->mPendingRunnables.AppendElement(this);
NS_ASSERTION(added, "This shouldn't fail because we SetCapacity earlier!");
}
nsDOMWorkerScriptLoader::
ScriptLoaderRunnable::~ScriptLoaderRunnable()
{
if (!mRevoked) {
MutexAutoLock lock(mLoader->GetLock());
#ifdef DEBUG
bool removed =
#endif
mLoader->mPendingRunnables.RemoveElement(this);
NS_ASSERTION(removed, "Someone has changed the array!");
}
}
NS_IMPL_THREADSAFE_ISUPPORTS1(nsDOMWorkerScriptLoader::ScriptLoaderRunnable,
nsIRunnable)
void
nsDOMWorkerScriptLoader::ScriptLoaderRunnable::Revoke()
{
mRevoked = PR_TRUE;
}
nsDOMWorkerScriptLoader::
ScriptCompiler::ScriptCompiler(nsDOMWorkerScriptLoader* aLoader,
const nsString& aScriptText,
const nsCString& aFilename,
nsAutoJSValHolder& aScriptObj)
: ScriptLoaderRunnable(aLoader),
mScriptText(aScriptText),
mFilename(aFilename),
mScriptObj(aScriptObj)
{
NS_ASSERTION(!aScriptText.IsEmpty(), "No script to compile!");
NS_ASSERTION(aScriptObj.IsHeld(), "Should be held!");
}
NS_IMETHODIMP
nsDOMWorkerScriptLoader::ScriptCompiler::Run()
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
if (mRevoked) {
return NS_OK;
}
NS_ASSERTION(!mScriptObj.ToJSObject(), "Already have a script object?!");
NS_ASSERTION(mScriptObj.IsHeld(), "Not held?!");
NS_ASSERTION(!mScriptText.IsEmpty(), "Shouldn't have empty source here!");
JSContext* cx = nsDOMThreadService::GetCurrentContext();
NS_ENSURE_STATE(cx);
JSAutoRequest ar(cx);
JSObject* global = JS_GetGlobalObject(cx);
NS_ENSURE_STATE(global);
// Because we may have nested calls to this function we don't want the
// execution to automatically report errors. We let them propagate instead.
uint32 oldOpts =
JS_SetOptions(cx, JS_GetOptions(cx) | JSOPTION_DONT_REPORT_UNCAUGHT |
JSOPTION_NO_SCRIPT_RVAL);
JSPrincipals* principal = nsDOMWorkerSecurityManager::WorkerPrincipal();
JSObject* scriptObj =
JS_CompileUCScriptForPrincipals(cx, global, principal,
reinterpret_cast<const jschar*>
(mScriptText.BeginReading()),
mScriptText.Length(), mFilename.get(), 1);
JS_SetOptions(cx, oldOpts);
if (!scriptObj) {
return NS_ERROR_FAILURE;
}
mScriptObj = scriptObj;
return NS_OK;
}
nsDOMWorkerScriptLoader::
ScriptLoaderDone::ScriptLoaderDone(nsDOMWorkerScriptLoader* aLoader,
volatile bool* aDoneFlag)
: ScriptLoaderRunnable(aLoader),
mDoneFlag(aDoneFlag)
{
NS_ASSERTION(aDoneFlag && !*aDoneFlag, "Bad setup!");
}
NS_IMETHODIMP
nsDOMWorkerScriptLoader::ScriptLoaderDone::Run()
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
if (mRevoked) {
return NS_OK;
}
*mDoneFlag = PR_TRUE;
return NS_OK;
}
nsDOMWorkerScriptLoader::
AutoSuspendWorkerEvents::AutoSuspendWorkerEvents(nsDOMWorkerScriptLoader* aLoader)
: mLoader(aLoader)
{
NS_ASSERTION(aLoader, "Don't hand me null!");
aLoader->SuspendWorkerEvents();
}
nsDOMWorkerScriptLoader::
AutoSuspendWorkerEvents::~AutoSuspendWorkerEvents()
{
mLoader->ResumeWorkerEvents();
}

148
dom/src/threads/nsDOMWorkerSecurityManager.cpp
View File

@ -1,148 +0,0 @@
/* -*- Mode: c++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is worker threads.
*
* The Initial Developer of the Original Code is
* Mozilla Corporation.
* Portions created by the Initial Developer are Copyright (C) 2008
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Ben Turner <bent.mozilla@gmail.com> (Original Author)
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#include "nsDOMWorkerSecurityManager.h"
// Interfaces
#include "nsIClassInfo.h"
// Other includes
#include "jsapi.h"
#include "nsDOMError.h"
#include "nsThreadUtils.h"
// DOMWorker includes
#include "nsDOMThreadService.h"
#include "nsDOMWorker.h"
#define LOG(_args) PR_LOG(gDOMThreadsLog, PR_LOG_DEBUG, _args)
class nsDOMWorkerPrincipal
{
public:
static void Destroy(JSContext*, JSPrincipals*) {
// nothing
}
static JSBool Subsume(JSPrincipals*, JSPrincipals*) {
return JS_TRUE;
}
};
static JSPrincipals gWorkerPrincipal =
{ "domworkerthread" /* codebase */,
NULL /* getPrincipalArray */,
NULL /* globalPrivilegesEnabled */,
1 /* refcount */,
nsDOMWorkerPrincipal::Destroy /* destroy */,
nsDOMWorkerPrincipal::Subsume /* subsume */ };
NS_IMPL_THREADSAFE_ISUPPORTS1(nsDOMWorkerSecurityManager,
nsIXPCSecurityManager)
NS_IMETHODIMP
nsDOMWorkerSecurityManager::CanCreateWrapper(JSContext* aCx,
const nsIID& aIID,
nsISupports* aObj,
nsIClassInfo* aClassInfo,
void** aPolicy)
{
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerSecurityManager::CanCreateInstance(JSContext* aCx,
const nsCID& aCID)
{
return CanGetService(aCx, aCID);
}
NS_IMETHODIMP
nsDOMWorkerSecurityManager::CanGetService(JSContext* aCx,
const nsCID& aCID)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
nsDOMWorker* worker = static_cast<nsDOMWorker*>(JS_GetContextPrivate(aCx));
NS_ASSERTION(worker, "This should be set by the DOM thread service!");
return worker->IsPrivileged() ? NS_OK : NS_ERROR_DOM_XPCONNECT_ACCESS_DENIED;
}
NS_IMETHODIMP
nsDOMWorkerSecurityManager::CanAccess(PRUint32 aAction,
nsAXPCNativeCallContext* aCallContext,
JSContext* aJSContext,
JSObject* aJSObject,
nsISupports* aObj,
nsIClassInfo* aClassInfo,
jsid aName,
void** aPolicy)
{
return NS_OK;
}
JSPrincipals*
nsDOMWorkerSecurityManager::WorkerPrincipal()
{
return &gWorkerPrincipal;
}
JSBool
nsDOMWorkerSecurityManager::JSCheckAccess(JSContext* aCx,
JSObject* aObj,
jsid aId,
JSAccessMode aMode,
jsval* aVp)
{
return JS_TRUE;
}
JSPrincipals*
nsDOMWorkerSecurityManager::JSFindPrincipal(JSContext* aCx, JSObject* aObj)
{
return WorkerPrincipal();
}
JSBool
nsDOMWorkerSecurityManager::JSTranscodePrincipals(JSXDRState* aXdr,
JSPrincipals** aJsprinp)
{
NS_NOTREACHED("Shouldn't ever call this!");
return JS_FALSE;
}

62
dom/src/threads/nsDOMWorkerSecurityManager.h
View File

@ -1,62 +0,0 @@
/* -*- Mode: c++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is worker threads.
*
* The Initial Developer of the Original Code is
* Mozilla Corporation.
* Portions created by the Initial Developer are Copyright (C) 2008
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Ben Turner <bent.mozilla@gmail.com> (Original Author)
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#ifndef __NSDOMWORKERSECURITYMANAGER_H__
#define __NSDOMWORKERSECURITYMANAGER_H__
#include "nsIXPCSecurityManager.h"
#include "jsapi.h"
class nsDOMWorkerSecurityManager : public nsIXPCSecurityManager
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSIXPCSECURITYMANAGER
static JSPrincipals* WorkerPrincipal();
static JSBool JSCheckAccess(JSContext* aCx, JSObject* aObj, jsid aId,
JSAccessMode aMode, jsval* aVp);
static JSPrincipals* JSFindPrincipal(JSContext* aCx, JSObject* aObj);
static JSBool JSTranscodePrincipals(JSXDRState* aXdr,
JSPrincipals** aJsprinp);
};
#endif /* __NSDOMWORKERSECURITYMANAGER_H__ */

485
dom/src/threads/nsDOMWorkerTimeout.cpp
View File

@ -1,485 +0,0 @@
/* -*- Mode: c++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is worker threads.
*
* The Initial Developer of the Original Code is
* Mozilla Corporation.
* Portions created by the Initial Developer are Copyright (C) 2008
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Ben Turner <bent.mozilla@gmail.com> (Original Author)
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#include "nsDOMWorkerTimeout.h"
// Interfaces
#include "nsIJSContextStack.h"
#include "nsIJSRuntimeService.h"
#include "nsITimer.h"
#include "nsIXPConnect.h"
// Other includes
#include "nsContentUtils.h"
#include "nsJSUtils.h"
#include "nsThreadUtils.h"
#include "pratom.h"
#include "prtime.h"
// DOMWorker includes
#include "nsDOMThreadService.h"
#include "nsDOMWorkerSecurityManager.h"
#define LOG(_args) PR_LOG(gDOMThreadsLog, PR_LOG_DEBUG, _args)
#define CONSTRUCTOR_ENSURE_TRUE(_cond, _rv) \
PR_BEGIN_MACRO \
if (NS_UNLIKELY(!(_cond))) { \
NS_WARNING("CONSTRUCTOR_ENSURE_TRUE(" #_cond ") failed"); \
(_rv) = NS_ERROR_FAILURE; \
return; \
} \
PR_END_MACRO
#define SUSPEND_SPINLOCK_COUNT 5000
static const char* kSetIntervalStr = "setInterval";
static const char* kSetTimeoutStr = "setTimeout";
nsDOMWorkerTimeout::FunctionCallback::FunctionCallback(PRUint32 aArgc,
jsval* aArgv,
nsresult* aRv)
: mCallbackArgsLength(0)
{
MOZ_COUNT_CTOR(nsDOMWorkerTimeout::FunctionCallback);
JSRuntime* rt;
*aRv = nsDOMThreadService::JSRuntimeService()->GetRuntime(&rt);
if (NS_FAILED(*aRv))
return;
JSBool ok = mCallback.Hold(rt);
CONSTRUCTOR_ENSURE_TRUE(ok, *aRv);
mCallback = aArgv[0];
// We want enough space for an extra lateness arg.
mCallbackArgsLength = aArgc > 2 ? aArgc - 1 : 1;
bool success = mCallbackArgs.SetLength(mCallbackArgsLength);
CONSTRUCTOR_ENSURE_TRUE(success, *aRv);
PRUint32 index = 0;
for (; index < mCallbackArgsLength - 1; index++) {
ok = mCallbackArgs[index].Hold(rt);
CONSTRUCTOR_ENSURE_TRUE(ok, *aRv);
mCallbackArgs[index] = aArgv[index + 2];
}
// Take care of the last arg.
index = mCallbackArgsLength - 1;
ok = mCallbackArgs[index].Hold(rt);
CONSTRUCTOR_ENSURE_TRUE(ok, *aRv);
*aRv = NS_OK;
}
nsDOMWorkerTimeout::FunctionCallback::~FunctionCallback()
{
MOZ_COUNT_DTOR(nsDOMWorkerTimeout::FunctionCallback);
}
nsresult
nsDOMWorkerTimeout::FunctionCallback::Run(nsDOMWorkerTimeout* aTimeout,
JSContext* aCx)
{
PRInt32 lateness = NS_MAX(0, PRInt32(PR_Now() - aTimeout->mTargetTime)) /
(PRTime)PR_USEC_PER_MSEC;
mCallbackArgs[mCallbackArgsLength - 1] = INT_TO_JSVAL(lateness);
JSObject* global = JS_GetGlobalObject(aCx);
NS_ENSURE_TRUE(global, NS_ERROR_FAILURE);
nsTArray<jsval> argv;
bool success = argv.SetCapacity(mCallbackArgsLength);
NS_ENSURE_TRUE(success, NS_ERROR_OUT_OF_MEMORY);
for (PRUint32 index = 0; index < mCallbackArgsLength; index++) {
argv.AppendElement(mCallbackArgs[index]);
}
jsval rval;
JSBool ok =
JS_CallFunctionValue(aCx, global, mCallback, mCallbackArgsLength,
argv.Elements(), &rval);
NS_ENSURE_TRUE(ok, NS_ERROR_FAILURE);
return NS_OK;
}
nsDOMWorkerTimeout::ExpressionCallback::ExpressionCallback(PRUint32 aArgc,
jsval* aArgv,
JSContext* aCx,
nsresult* aRv)
: mLineNumber(0)
{
MOZ_COUNT_CTOR(nsDOMWorkerTimeout::ExpressionCallback);
JSString* expr = JS_ValueToString(aCx, aArgv[0]);
*aRv = expr ? NS_OK : NS_ERROR_FAILURE;
if (NS_FAILED(*aRv))
return;
JSRuntime* rt;
*aRv = nsDOMThreadService::JSRuntimeService()->GetRuntime(&rt);
if (NS_FAILED(*aRv))
return;
JSBool ok = mExpression.Hold(rt);
CONSTRUCTOR_ENSURE_TRUE(ok, *aRv);
mExpression = aArgv[0];
// Get the calling location.
const char* fileName;
PRUint32 lineNumber;
if (nsJSUtils::GetCallingLocation(aCx, &fileName, &lineNumber)) {
mFileName.Assign(fileName);
mLineNumber = lineNumber;
}
*aRv = NS_OK;
}
nsDOMWorkerTimeout::ExpressionCallback::~ExpressionCallback()
{
MOZ_COUNT_DTOR(nsDOMWorkerTimeout::ExpressionCallback);
}
nsresult
nsDOMWorkerTimeout::ExpressionCallback::Run(nsDOMWorkerTimeout* aTimeout,
JSContext* aCx)
{
JSObject* global = JS_GetGlobalObject(aCx);
NS_ENSURE_TRUE(global, NS_ERROR_FAILURE);
JSPrincipals* principal = nsDOMWorkerSecurityManager::WorkerPrincipal();
NS_ENSURE_TRUE(principal, NS_ERROR_FAILURE);
JSString* expression = JS_ValueToString(aCx, mExpression);
NS_ENSURE_TRUE(expression, NS_ERROR_FAILURE);
size_t stringLength;
const jschar* string = JS_GetStringCharsAndLength(aCx, expression, &stringLength);
NS_ENSURE_TRUE(string, NS_ERROR_FAILURE);
bool success = JS_EvaluateUCScriptForPrincipals(aCx, global, principal,
string, stringLength,
mFileName.get(),
mLineNumber, nsnull);
if (!success) {
return NS_ERROR_FAILURE;
}
return NS_OK;
}
nsDOMWorkerTimeout::nsDOMWorkerTimeout(nsDOMWorker* aWorker,
PRUint32 aId)
: nsDOMWorkerFeature(aWorker, aId),
mInterval(0),
mSuspendSpinlock(0),
mSuspendInterval(0),
mIsInterval(PR_FALSE),
mIsSuspended(PR_FALSE),
mSuspendedBeforeStart(PR_FALSE),
mStarted(PR_FALSE)
{
NS_ASSERTION(mWorker, "Need a worker here!");
}
NS_IMPL_ISUPPORTS_INHERITED1(nsDOMWorkerTimeout, nsDOMWorkerFeature,
nsITimerCallback)
nsresult
nsDOMWorkerTimeout::Init(JSContext* aCx, PRUint32 aArgc, jsval* aArgv,
bool aIsInterval)
{
NS_ASSERTION(aCx, "Null pointer!");
NS_ASSERTION(aArgv, "Null pointer!");
JSAutoRequest ar(aCx);
if (!aArgc) {
JS_ReportError(aCx, "Function %s requires at least 1 parameter",
aIsInterval ? kSetIntervalStr : kSetTimeoutStr);
return NS_ERROR_INVALID_ARG;
}
PRUint32 interval;
if (aArgc > 1) {
if (!JS_ValueToECMAUint32(aCx, aArgv[1], (uint32*)&interval)) {
JS_ReportError(aCx, "Second argument to %s must be a millisecond value",
aIsInterval ? kSetIntervalStr : kSetTimeoutStr);
return NS_ERROR_INVALID_ARG;
}
}
else {
// If no interval was specified, treat this like a timeout, to avoid
// setting an interval of 0 milliseconds.
interval = 0;
aIsInterval = PR_FALSE;
}
mInterval = interval;
mIsInterval = aIsInterval;
mTargetTime = PR_Now() + interval * (PRTime)PR_USEC_PER_MSEC;
nsresult rv;
switch (JS_TypeOfValue(aCx, aArgv[0])) {
case JSTYPE_FUNCTION:
mCallback = new FunctionCallback(aArgc, aArgv, &rv);
NS_ENSURE_TRUE(mCallback, NS_ERROR_OUT_OF_MEMORY);
NS_ENSURE_SUCCESS(rv, rv);
break;
case JSTYPE_STRING:
case JSTYPE_OBJECT:
mCallback = new ExpressionCallback(aArgc, aArgv, aCx, &rv);
NS_ENSURE_TRUE(mCallback, NS_ERROR_OUT_OF_MEMORY);
NS_ENSURE_SUCCESS(rv, rv);
break;
default:
JS_ReportError(aCx, "useless %s call (missing quotes around argument?)",
aIsInterval ? kSetIntervalStr : kSetTimeoutStr);
// Return an error that nsGlobalWindow can recognize and turn into NS_OK.
return NS_ERROR_INVALID_ARG;
}
nsCOMPtr<nsITimer> timer = do_CreateInstance(NS_TIMER_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
nsIEventTarget* target =
static_cast<nsIEventTarget*>(nsDOMThreadService::get());
rv = timer->SetTarget(target);
NS_ENSURE_SUCCESS(rv, rv);
mTimer.swap(timer);
return NS_OK;
}
nsresult
nsDOMWorkerTimeout::Start()
{
if (IsSuspended()) {
NS_ASSERTION(mSuspendedBeforeStart, "Bad state!");
return NS_OK;
}
nsresult rv = mTimer->InitWithCallback(this, mInterval,
nsITimer::TYPE_ONE_SHOT);
NS_ENSURE_SUCCESS(rv, rv);
mStarted = PR_TRUE;
return NS_OK;
}
nsresult
nsDOMWorkerTimeout::Run()
{
NS_ENSURE_TRUE(mCallback, NS_ERROR_NOT_INITIALIZED);
LOG(("Worker [0x%p] running timeout [0x%p] with id %u",
static_cast<void*>(mWorker.get()), static_cast<void*>(this), mId));
JSContext* cx;
nsresult rv =
nsDOMThreadService::ThreadJSContextStack()->GetSafeJSContext(&cx);
NS_ENSURE_SUCCESS(rv, rv);
JSAutoRequest ar(cx);
rv = mCallback->Run(this, cx);
// Make sure any pending exceptions are converted to errors for the pool.
JS_ReportPendingException(cx);
if (mIsInterval) {
mTargetTime = PR_Now() + mInterval * (PRTime)PR_USEC_PER_MSEC;
nsresult rv2 = mTimer->InitWithCallback(this, mInterval,
nsITimer::TYPE_ONE_SHOT);
NS_ENSURE_SUCCESS(rv2, rv2);
}
return rv;
}
void
nsDOMWorkerTimeout::Cancel()
{
NS_ASSERTION(mTimer, "Impossible to get here without a timer!");
LOG(("Worker [0x%p] canceling timeout [0x%p] with id %u",
static_cast<void*>(mWorker.get()), static_cast<void*>(this), mId));
{
AutoSpinlock lock(this);
if (IsSuspendedNoLock()) {
mIsSuspended = PR_FALSE;
// This should kill us when all is said and done.
mSuspendedRef = nsnull;
}
}
// This call to Cancel should kill us.
mTimer->Cancel();
}
void
nsDOMWorkerTimeout::Suspend()
{
AutoSpinlock lock(this);
NS_ASSERTION(!IsSuspendedNoLock(), "Bad state!");
mIsSuspended = PR_TRUE;
mSuspendedRef = this;
if (!mStarted) {
mSuspendedBeforeStart = PR_TRUE;
return;
}
mTimer->Cancel();
mSuspendInterval = NS_MAX(0, PRInt32(mTargetTime - PR_Now())) /
(PRTime)PR_USEC_PER_MSEC;
LOG(("Worker [0x%p] suspending timeout [0x%p] with id %u (interval = %u)",
static_cast<void*>(mWorker.get()), static_cast<void*>(this), mId,
mSuspendInterval));
}
void
nsDOMWorkerTimeout::Resume()
{
NS_ASSERTION(mTimer, "Impossible to get here without a timer!");
LOG(("Worker [0x%p] resuming timeout [0x%p] with id %u",
static_cast<void*>(mWorker.get()), static_cast<void*>(this), mId));
AutoSpinlock lock(this);
NS_ASSERTION(IsSuspendedNoLock(), "Should be suspended!");
if (mSuspendedBeforeStart) {
NS_ASSERTION(!mSuspendInterval, "Bad state!");
mSuspendedBeforeStart = PR_FALSE;
mSuspendInterval = mInterval;
mStarted = PR_TRUE;
}
mTargetTime = PR_Now() + mSuspendInterval * (PRTime)PR_USEC_PER_MSEC;
#ifdef DEBUG
nsresult rv =
#endif
mTimer->InitWithCallback(this, mSuspendInterval, nsITimer::TYPE_ONE_SHOT);
NS_WARN_IF_FALSE(NS_SUCCEEDED(rv), "Failed to init timer!");
}
void
nsDOMWorkerTimeout::AcquireSpinlock()
{
PRUint32 loopCount = 0;
while (PR_ATOMIC_SET(&mSuspendSpinlock, 1) == 1) {
if (++loopCount > SUSPEND_SPINLOCK_COUNT) {
LOG(("AcquireSpinlock taking too long (looped %u times), yielding.",
loopCount));
loopCount = 0;
PR_Sleep(PR_INTERVAL_NO_WAIT);
}
}
#ifdef PR_LOGGING
if (loopCount) {
LOG(("AcquireSpinlock needed %u loops", loopCount));
}
#endif
}
void
nsDOMWorkerTimeout::ReleaseSpinlock()
{
#ifdef DEBUG
PRInt32 suspended =
#endif
PR_ATOMIC_SET(&mSuspendSpinlock, 0);
NS_ASSERTION(suspended == 1, "Huh?!");
}
NS_IMETHODIMP
nsDOMWorkerTimeout::Notify(nsITimer* aTimer)
{
// Should be on the timer thread.
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
NS_ASSERTION(aTimer == mTimer, "Wrong timer?!");
PRUint32 type;
nsresult rv = aTimer->GetType(&type);
NS_ENSURE_SUCCESS(rv, rv);
// We only care about one-shot timers here because that may be the one that
// we set from Resume().
if (type == nsITimer::TYPE_ONE_SHOT) {
AutoSpinlock lock(this);
if (mIsSuspended) {
mIsSuspended = PR_FALSE;
mSuspendedRef = nsnull;
if (mIsInterval) {
// This is the first fire since we resumed. Set our interval back to the
// real interval.
mTargetTime = PR_Now() + mInterval * (PRTime)PR_USEC_PER_MSEC;
rv = aTimer->InitWithCallback(this, mInterval,
nsITimer::TYPE_REPEATING_SLACK);
NS_ENSURE_SUCCESS(rv, rv);
}
}
}
nsDOMThreadService::get()->TimeoutReady(this);
return NS_OK;
}

190
dom/src/threads/nsDOMWorkerTimeout.h
View File

@ -1,190 +0,0 @@
/* -*- Mode: c++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is worker threads.
*
* The Initial Developer of the Original Code is
* Mozilla Corporation.
* Portions created by the Initial Developer are Copyright (C) 2008
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Ben Turner <bent.mozilla@gmail.com> (Original Author)
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#ifndef __NSDOMWORKERTIMEOUT_H__
#define __NSDOMWORKERTIMEOUT_H__
// Interfaces
#include "nsITimer.h"
// Other includes
#include "jsapi.h"
#include "nsAutoJSValHolder.h"
#include "nsAutoPtr.h"
#include "nsCOMPtr.h"
#include "nsStringGlue.h"
#include "nsTArray.h"
// DOMWorker includes
#include "nsDOMWorker.h"
/**
* The nsDOMWorkerTimeout has a slightly complicated life cycle. It's created
* by an nsDOMWorker (or one of its JS context functions) and immediately takes
* a strong reference to the worker that created it. It does this so that the
* worker can't be collected while a timeout is outstanding. However, the worker
* needs a weak reference to the timeout so that it can be canceled if the
* worker is canceled (in the event that the page falls out of the fastback
* cache or the application is exiting, for instance). The only thing that holds
* the timeout alive is its mTimer via the nsITimerCallback interface. If the
* timer is single-shot and has run already or if the timer is canceled then
* this object should die.
*/
class nsDOMWorkerTimeout : public nsDOMWorkerFeature,
public nsITimerCallback
{
public:
NS_DECL_ISUPPORTS_INHERITED
NS_DECL_NSITIMERCALLBACK
nsDOMWorkerTimeout(nsDOMWorker* aWorker,
PRUint32 aId);
nsresult Init(JSContext* aCx,
PRUint32 aArgc,
jsval* aArgv,
bool aIsInterval);
nsresult Start();
nsresult Run();
virtual void Cancel();
virtual void Suspend();
virtual void Resume();
PRIntervalTime GetInterval() {
return mInterval;
}
nsDOMWorker* GetWorker() {
return mWorker;
}
bool IsSuspended() {
AutoSpinlock lock(this);
return IsSuspendedNoLock();
}
private:
~nsDOMWorkerTimeout() { }
void AcquireSpinlock();
void ReleaseSpinlock();
bool IsSuspendedNoLock() {
return mIsSuspended;
}
class AutoSpinlock
{
public:
AutoSpinlock(nsDOMWorkerTimeout* aTimeout)
: mTimeout(aTimeout) {
aTimeout->AcquireSpinlock();
}
~AutoSpinlock() {
mTimeout->ReleaseSpinlock();
}
private:
nsDOMWorkerTimeout* mTimeout;
};
// We support two types of callbacks (functions and expressions) just like the
// normal window timeouts. Each type has its own member and rooting needs so
// we split them into two classes with a common base.
class CallbackBase
{
public:
virtual ~CallbackBase() { }
virtual nsresult Run(nsDOMWorkerTimeout* aTimeout,
JSContext* aCx) = 0;
};
class FunctionCallback : public CallbackBase
{
public:
FunctionCallback(PRUint32 aArgc,
jsval* aArgv,
nsresult* aRv);
virtual ~FunctionCallback();
virtual nsresult Run(nsDOMWorkerTimeout* aTimeout,
JSContext* aCx);
protected:
nsAutoJSValHolder mCallback;
nsTArray<nsAutoJSValHolder> mCallbackArgs;
PRUint32 mCallbackArgsLength;
};
class ExpressionCallback : public CallbackBase
{
public:
ExpressionCallback(PRUint32 aArgc,
jsval* aArgv,
JSContext* aCx,
nsresult* aRv);
virtual ~ExpressionCallback();
virtual nsresult Run(nsDOMWorkerTimeout* aTimeout,
JSContext* aCx);
protected:
nsAutoJSValHolder mExpression;
nsCString mFileName;
PRUint32 mLineNumber;
};
// Hold this object alive!
nsCOMPtr<nsITimer> mTimer;
PRUint32 mInterval;
PRTime mTargetTime;
nsAutoPtr<CallbackBase> mCallback;
PRInt32 mSuspendSpinlock;
PRUint32 mSuspendInterval;
nsRefPtr<nsDOMWorkerTimeout> mSuspendedRef;
bool mIsInterval;
bool mIsSuspended;
bool mSuspendedBeforeStart;
bool mStarted;
};
#endif /* __NSDOMWORKERTIMEOUT_H__ */

910
dom/src/threads/nsDOMWorkerXHR.cpp
View File

@ -1,910 +0,0 @@
/* -*- Mode: c++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is worker threads.
*
* The Initial Developer of the Original Code is
* Mozilla Corporation.
* Portions created by the Initial Developer are Copyright (C) 2008
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Ben Turner <bent.mozilla@gmail.com> (Original Author)
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#include "nsDOMWorkerXHR.h"
// Interfaces
#include "nsIDocument.h"
#include "nsIDOMEvent.h"
#include "nsIThread.h"
#include "nsIXPConnect.h"
// Other includes
#include "nsAXPCNativeCallContext.h"
#include "nsComponentManagerUtils.h"
#include "nsContentUtils.h"
#include "nsIClassInfoImpl.h"
#include "nsJSUtils.h"
#include "nsThreadUtils.h"
// DOMWorker includes
#include "nsDOMThreadService.h"
#include "nsDOMWorkerEvents.h"
#include "nsDOMWorkerPool.h"
#include "nsDOMWorkerXHRProxy.h"
using namespace mozilla;
// The list of event types that we support. This list and the defines based on
// it determine the sizes of the listener arrays in nsDOMWorkerXHRProxy. Make
// sure that any event types shared by both the XHR and Upload objects are
// together at the beginning of the list. Any changes made to this list may
// affect sMaxUploadEventTypes, so make sure that it is adjusted accordingly or
// things will break!
const char* const nsDOMWorkerXHREventTarget::sListenerTypes[] = {
// nsIXMLHttpRequestEventTarget listeners.
"abort", /* LISTENER_TYPE_ABORT */
"error", /* LISTENER_TYPE_ERROR */
"load", /* LISTENER_TYPE_LOAD */
"loadstart", /* LISTENER_TYPE_LOADSTART */
"progress", /* LISTENER_TYPE_PROGRESS */
// nsIXMLHttpRequest listeners.
"readystatechange", /* LISTENER_TYPE_READYSTATECHANGE */
"loadend"
};
// This should always be set to the length of sListenerTypes.
const PRUint32 nsDOMWorkerXHREventTarget::sMaxXHREventTypes =
NS_ARRAY_LENGTH(nsDOMWorkerXHREventTarget::sListenerTypes);
// This should be set to the index of the first event type that is *not*
// supported by the Upload object.
const PRUint32 nsDOMWorkerXHREventTarget::sMaxUploadEventTypes =
LISTENER_TYPE_READYSTATECHANGE;
// Enforce the invariant that the upload object supports no more event types
// than the xhr object.
PR_STATIC_ASSERT(nsDOMWorkerXHREventTarget::sMaxXHREventTypes >=
nsDOMWorkerXHREventTarget::sMaxUploadEventTypes);
NS_IMPL_ISUPPORTS_INHERITED1(nsDOMWorkerXHREventTarget,
nsDOMWorkerMessageHandler,
nsIXMLHttpRequestEventTarget)
PRUint32
nsDOMWorkerXHREventTarget::GetListenerTypeFromString(const nsAString& aString)
{
for (PRUint32 index = 0; index < sMaxXHREventTypes; index++) {
if (aString.EqualsASCII(sListenerTypes[index])) {
return index;
}
}
return PR_UINT32_MAX;
}
NS_IMETHODIMP
nsDOMWorkerXHREventTarget::GetOnabort(nsIDOMEventListener** aOnabort)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
NS_ENSURE_ARG_POINTER(aOnabort);
nsAutoString type;
type.AssignASCII(sListenerTypes[LISTENER_TYPE_ABORT]);
nsCOMPtr<nsIDOMEventListener> listener = GetOnXListener(type);
listener.forget(aOnabort);
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerXHREventTarget::SetOnabort(nsIDOMEventListener* aOnabort)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
nsAutoString type;
type.AssignASCII(sListenerTypes[LISTENER_TYPE_ABORT]);
return SetOnXListener(type, aOnabort);
}
NS_IMETHODIMP
nsDOMWorkerXHREventTarget::GetOnerror(nsIDOMEventListener** aOnerror)
{
NS_ENSURE_ARG_POINTER(aOnerror);
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
nsAutoString type;
type.AssignASCII(sListenerTypes[LISTENER_TYPE_ERROR]);
nsCOMPtr<nsIDOMEventListener> listener = GetOnXListener(type);
listener.forget(aOnerror);
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerXHREventTarget::SetOnerror(nsIDOMEventListener* aOnerror)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
nsAutoString type;
type.AssignASCII(sListenerTypes[LISTENER_TYPE_ERROR]);
return SetOnXListener(type, aOnerror);
}
NS_IMETHODIMP
nsDOMWorkerXHREventTarget::GetOnload(nsIDOMEventListener** aOnload)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
NS_ENSURE_ARG_POINTER(aOnload);
nsAutoString type;
type.AssignASCII(sListenerTypes[LISTENER_TYPE_LOAD]);
nsCOMPtr<nsIDOMEventListener> listener = GetOnXListener(type);
listener.forget(aOnload);
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerXHREventTarget::SetOnload(nsIDOMEventListener* aOnload)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
nsAutoString type;
type.AssignASCII(sListenerTypes[LISTENER_TYPE_LOAD]);
return SetOnXListener(type, aOnload);
}
NS_IMETHODIMP
nsDOMWorkerXHREventTarget::GetOnloadstart(nsIDOMEventListener** aOnloadstart)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
NS_ENSURE_ARG_POINTER(aOnloadstart);
nsAutoString type;
type.AssignASCII(sListenerTypes[LISTENER_TYPE_LOADSTART]);
nsCOMPtr<nsIDOMEventListener> listener = GetOnXListener(type);
listener.forget(aOnloadstart);
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerXHREventTarget::SetOnloadstart(nsIDOMEventListener* aOnloadstart)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
nsAutoString type;
type.AssignASCII(sListenerTypes[LISTENER_TYPE_LOADSTART]);
return SetOnXListener(type, aOnloadstart);
}
NS_IMETHODIMP
nsDOMWorkerXHREventTarget::GetOnprogress(nsIDOMEventListener** aOnprogress)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
NS_ENSURE_ARG_POINTER(aOnprogress);
nsAutoString type;
type.AssignASCII(sListenerTypes[LISTENER_TYPE_PROGRESS]);
nsCOMPtr<nsIDOMEventListener> listener = GetOnXListener(type);
listener.forget(aOnprogress);
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerXHREventTarget::SetOnprogress(nsIDOMEventListener* aOnprogress)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
nsAutoString type;
type.AssignASCII(sListenerTypes[LISTENER_TYPE_PROGRESS]);
return SetOnXListener(type, aOnprogress);
}
NS_IMETHODIMP
nsDOMWorkerXHREventTarget::GetOnloadend(nsIDOMEventListener** aOnloadend)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
NS_ENSURE_ARG_POINTER(aOnloadend);
nsAutoString type;
type.AssignASCII(sListenerTypes[LISTENER_TYPE_LOADEND]);
nsCOMPtr<nsIDOMEventListener> listener = GetOnXListener(type);
listener.forget(aOnloadend);
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerXHREventTarget::SetOnloadend(nsIDOMEventListener* aOnloadend)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
nsAutoString type;
type.AssignASCII(sListenerTypes[LISTENER_TYPE_LOADEND]);
return SetOnXListener(type, aOnloadend);
}
nsDOMWorkerXHRUpload::nsDOMWorkerXHRUpload(nsDOMWorkerXHR* aWorkerXHR)
: mWorkerXHR(aWorkerXHR)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
NS_ASSERTION(aWorkerXHR, "Null pointer!");
}
NS_IMPL_ISUPPORTS_INHERITED1(nsDOMWorkerXHRUpload, nsDOMWorkerXHREventTarget,
nsIXMLHttpRequestUpload)
NS_IMPL_CI_INTERFACE_GETTER3(nsDOMWorkerXHRUpload, nsIDOMEventTarget,
nsIXMLHttpRequestEventTarget,
nsIXMLHttpRequestUpload)
NS_IMPL_THREADSAFE_DOM_CI_GETINTERFACES(nsDOMWorkerXHRUpload)
NS_IMETHODIMP
nsDOMWorkerXHRUpload::RemoveEventListener(const nsAString& aType,
nsIDOMEventListener* aListener,
bool aUseCapture)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
NS_ENSURE_ARG_POINTER(aListener);
if (mWorkerXHR->mWorker->IsCanceled()) {
return NS_ERROR_ABORT;
}
return nsDOMWorkerXHREventTarget::RemoveEventListener(aType, aListener,
aUseCapture);
}
NS_IMETHODIMP
nsDOMWorkerXHRUpload::DispatchEvent(nsIDOMEvent* aEvent,
bool* _retval)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
NS_ENSURE_ARG_POINTER(aEvent);
if (mWorkerXHR->mWorker->IsCanceled()) {
return NS_ERROR_ABORT;
}
return nsDOMWorkerXHREventTarget::DispatchEvent(aEvent, _retval);
}
NS_IMETHODIMP
nsDOMWorkerXHRUpload::AddEventListener(const nsAString& aType,
nsIDOMEventListener* aListener,
bool aUseCapture,
bool aWantsUntrusted,
PRUint8 optional_argc)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
NS_ENSURE_ARG_POINTER(aListener);
if (mWorkerXHR->mWorker->IsCanceled()) {
return NS_ERROR_ABORT;
}
nsresult rv = nsDOMWorkerXHREventTarget::AddEventListener(aType, aListener,
aUseCapture,
aWantsUntrusted,
optional_argc);
NS_ENSURE_SUCCESS(rv, rv);
rv = mWorkerXHR->mXHRProxy->UploadEventListenerAdded();
if (NS_FAILED(rv)) {
NS_WARNING("UploadEventListenerAdded failed!");
RemoveEventListener(aType, aListener, aUseCapture);
return rv;
}
return NS_OK;
}
nsresult
nsDOMWorkerXHRUpload::SetOnXListener(const nsAString& aType,
nsIDOMEventListener* aListener)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
if (mWorkerXHR->mCanceled) {
return NS_ERROR_ABORT;
}
PRUint32 type = GetListenerTypeFromString(aType);
if (type > sMaxUploadEventTypes) {
// Silently ignore junk events.
return NS_OK;
}
return nsDOMWorkerXHREventTarget::SetOnXListener(aType, aListener);
}
nsDOMWorkerXHR::nsDOMWorkerXHR(nsDOMWorker* aWorker)
: nsDOMWorkerFeature(aWorker),
mWrappedNative(nsnull),
mCanceled(PR_FALSE)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
NS_ASSERTION(aWorker, "Must have a worker!");
}
nsDOMWorkerXHR::~nsDOMWorkerXHR()
{
if (mXHRProxy) {
if (!NS_IsMainThread()) {
nsCOMPtr<nsIRunnable> runnable =
NS_NewRunnableMethod(mXHRProxy, &nsDOMWorkerXHRProxy::Destroy);
if (runnable) {
mXHRProxy = nsnull;
NS_DispatchToMainThread(runnable, NS_DISPATCH_NORMAL);
}
}
else {
mXHRProxy->Destroy();
}
}
}
// Tricky! We use the AddRef/Release method of nsDOMWorkerFeature (to make sure
// we properly remove ourselves from the worker array) but inherit the QI of
// nsDOMWorkerXHREventTarget.
NS_IMPL_ADDREF_INHERITED(nsDOMWorkerXHR, nsDOMWorkerFeature)
NS_IMPL_RELEASE_INHERITED(nsDOMWorkerXHR, nsDOMWorkerFeature)
NS_IMPL_QUERY_INTERFACE_INHERITED2(nsDOMWorkerXHR, nsDOMWorkerXHREventTarget,
nsIXMLHttpRequest,
nsIXPCScriptable)
NS_IMPL_CI_INTERFACE_GETTER3(nsDOMWorkerXHR, nsIDOMEventTarget,
nsIXMLHttpRequestEventTarget,
nsIXMLHttpRequest)
NS_IMPL_THREADSAFE_DOM_CI_GETINTERFACES(nsDOMWorkerXHR)
#define XPC_MAP_CLASSNAME nsDOMWorkerXHR
#define XPC_MAP_QUOTED_CLASSNAME "XMLHttpRequest"
#define XPC_MAP_WANT_POSTCREATE
#define XPC_MAP_WANT_TRACE
#define XPC_MAP_WANT_FINALIZE
#define XPC_MAP_FLAGS \
nsIXPCScriptable::DONT_ENUM_QUERY_INTERFACE | \
nsIXPCScriptable::CLASSINFO_INTERFACES_ONLY | \
nsIXPCScriptable::DONT_REFLECT_INTERFACE_NAMES
#include "xpc_map_end.h"
NS_IMETHODIMP
nsDOMWorkerXHR::Trace(nsIXPConnectWrappedNative* /* aWrapper */,
JSTracer* aTracer,
JSObject* /*aObj */)
{
if (!mCanceled) {
nsDOMWorkerMessageHandler::Trace(aTracer);
if (mUpload) {
mUpload->Trace(aTracer);
}
}
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerXHR::Finalize(nsIXPConnectWrappedNative* /* aWrapper */,
JSContext* /* aCx */,
JSObject* /* aObj */)
{
NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
nsDOMWorkerMessageHandler::ClearAllListeners();
if (mUpload) {
mUpload->ClearAllListeners();
}
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerXHR::PostCreate(nsIXPConnectWrappedNative* aWrapper,
JSContext* /* aCx */,
JSObject* /* aObj */)
{
mWrappedNative = aWrapper;
return NS_OK;
}
nsresult
nsDOMWorkerXHR::Init()
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
nsRefPtr<nsDOMWorkerXHRProxy> proxy = new nsDOMWorkerXHRProxy(this);
NS_ENSURE_TRUE(proxy, NS_ERROR_OUT_OF_MEMORY);
nsresult rv = proxy->Init();
NS_ENSURE_SUCCESS(rv, rv);
proxy.swap(mXHRProxy);
return NS_OK;
}
void
nsDOMWorkerXHR::Cancel()
{
NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
// Just in case mUpload holds the only ref to this object we make sure to stay
// alive through this call.
nsRefPtr<nsDOMWorkerXHR> kungFuDeathGrip(this);
{
// This lock is here to prevent a race between Cancel and GetUpload, not to
// protect mCanceled.
MutexAutoLock lock(mWorker->GetLock());
mCanceled = PR_TRUE;
mUpload = nsnull;
}
if (mXHRProxy) {
mXHRProxy->Destroy();
mXHRProxy = nsnull;
}
mWorker = nsnull;
}
nsresult
nsDOMWorkerXHR::SetOnXListener(const nsAString& aType,
nsIDOMEventListener* aListener)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
if (mCanceled) {
return NS_ERROR_ABORT;
}
PRUint32 type = GetListenerTypeFromString(aType);
if (type > sMaxXHREventTypes) {
// Silently ignore junk events.
return NS_OK;
}
return nsDOMWorkerXHREventTarget::SetOnXListener(aType, aListener);
}
NS_IMETHODIMP
nsDOMWorkerXHR::GetChannel(nsIChannel** aChannel)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
NS_ENSURE_ARG_POINTER(aChannel);
*aChannel = nsnull;
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerXHR::GetResponseXML(nsIDOMDocument** aResponseXML)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
NS_ENSURE_ARG_POINTER(aResponseXML);
*aResponseXML = nsnull;
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerXHR::GetResponseText(nsAString& aResponseText)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
if (mCanceled) {
return NS_ERROR_ABORT;
}
nsresult rv = mXHRProxy->GetResponseText(aResponseText);
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerXHR::GetStatus(PRUint32* aStatus)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
NS_ENSURE_ARG_POINTER(aStatus);
if (mCanceled) {
return NS_ERROR_ABORT;
}
nsresult rv = mXHRProxy->GetStatus(aStatus);
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerXHR::GetStatusText(nsACString& aStatusText)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
if (mCanceled) {
return NS_ERROR_ABORT;
}
nsresult rv = mXHRProxy->GetStatusText(aStatusText);
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerXHR::Abort()
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
if (mCanceled) {
return NS_ERROR_ABORT;
}
nsresult rv = mXHRProxy->Abort();
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerXHR::GetAllResponseHeaders(char** _retval)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
NS_ENSURE_ARG_POINTER(_retval);
if (mCanceled) {
return NS_ERROR_ABORT;
}
nsresult rv = mXHRProxy->GetAllResponseHeaders(_retval);
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerXHR::GetResponseHeader(const nsACString& aHeader,
nsACString& _retval)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
if (mCanceled) {
return NS_ERROR_ABORT;
}
nsresult rv = mXHRProxy->GetResponseHeader(aHeader, _retval);
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerXHR::Open(const nsACString& aMethod, const nsACString& aUrl,
bool aAsync, const nsAString& aUser,
const nsAString& aPassword, PRUint8 optional_argc)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
if (mCanceled) {
return NS_ERROR_ABORT;
}
if (!optional_argc) {
aAsync = PR_TRUE;
}
nsresult rv = mXHRProxy->Open(aMethod, aUrl, aAsync, aUser, aPassword);
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerXHR::Send(nsIVariant* aBody)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
if (mCanceled) {
return NS_ERROR_ABORT;
}
if (mWorker->IsClosing() && !mXHRProxy->mSyncRequest) {
// Cheat and don't start this request since we know we'll never be able to
// use the data.
return NS_OK;
}
nsresult rv = mXHRProxy->Send(aBody);
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerXHR::SendAsBinary(const nsAString& aBody)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
if (mCanceled) {
return NS_ERROR_ABORT;
}
if (mWorker->IsClosing() && !mXHRProxy->mSyncRequest) {
// Cheat and don't start this request since we know we'll never be able to
// use the data.
return NS_OK;
}
nsresult rv = mXHRProxy->SendAsBinary(aBody);
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerXHR::SetRequestHeader(const nsACString& aHeader,
const nsACString& aValue)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
if (mCanceled) {
return NS_ERROR_ABORT;
}
nsresult rv = mXHRProxy->SetRequestHeader(aHeader, aValue);
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerXHR::GetReadyState(PRUint16* aReadyState)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
if (mCanceled) {
return NS_ERROR_ABORT;
}
NS_ENSURE_ARG_POINTER(aReadyState);
nsresult rv = mXHRProxy->GetReadyState(aReadyState);
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerXHR::OverrideMimeType(const nsACString& aMimetype)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
if (mCanceled) {
return NS_ERROR_ABORT;
}
nsresult rv = mXHRProxy->OverrideMimeType(aMimetype);
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerXHR::GetMultipart(bool* aMultipart)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
if (mCanceled) {
return NS_ERROR_ABORT;
}
NS_ENSURE_ARG_POINTER(aMultipart);
nsresult rv = mXHRProxy->GetMultipart(aMultipart);
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerXHR::SetMultipart(bool aMultipart)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
if (mCanceled) {
return NS_ERROR_ABORT;
}
nsresult rv = mXHRProxy->SetMultipart(aMultipart);
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerXHR::GetMozBackgroundRequest(bool* aMozBackgroundRequest)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
if (mCanceled) {
return NS_ERROR_ABORT;
}
NS_ENSURE_ARG_POINTER(aMozBackgroundRequest);
*aMozBackgroundRequest = PR_FALSE;
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerXHR::SetMozBackgroundRequest(bool aMozBackgroundRequest)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
if (aMozBackgroundRequest) {
return NS_ERROR_NOT_AVAILABLE;
}
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerXHR::Init(nsIPrincipal* aPrincipal,
nsIScriptContext* aScriptContext,
nsPIDOMWindow* aOwnerWindow,
nsIURI* aBaseURI)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
NS_NOTREACHED("No one should be calling this!");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsDOMWorkerXHR::GetUpload(nsIXMLHttpRequestUpload** aUpload)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
nsRefPtr<nsDOMWorker> worker = mWorker;
if (!worker) {
return NS_ERROR_ABORT;
}
MutexAutoLock lock(worker->GetLock());
if (mCanceled) {
return NS_ERROR_ABORT;
}
NS_ENSURE_ARG_POINTER(aUpload);
if (!mUpload) {
mUpload = new nsDOMWorkerXHRUpload(this);
NS_ENSURE_TRUE(mUpload, NS_ERROR_OUT_OF_MEMORY);
}
NS_ADDREF(*aUpload = mUpload);
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerXHR::GetOnreadystatechange(nsIDOMEventListener** aOnreadystatechange)
{
NS_ENSURE_ARG_POINTER(aOnreadystatechange);
nsAutoString type;
type.AssignASCII(sListenerTypes[LISTENER_TYPE_READYSTATECHANGE]);
nsCOMPtr<nsIDOMEventListener> listener = GetOnXListener(type);
listener.forget(aOnreadystatechange);
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerXHR::SetOnreadystatechange(nsIDOMEventListener* aOnreadystatechange)
{
nsAutoString type;
type.AssignASCII(sListenerTypes[LISTENER_TYPE_READYSTATECHANGE]);
return SetOnXListener(type, aOnreadystatechange);
}
NS_IMETHODIMP
nsDOMWorkerXHR::GetWithCredentials(bool* aWithCredentials)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
if (mCanceled) {
return NS_ERROR_ABORT;
}
NS_ENSURE_ARG_POINTER(aWithCredentials);
nsresult rv = mXHRProxy->GetWithCredentials(aWithCredentials);
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerXHR::SetWithCredentials(bool aWithCredentials)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
if (mCanceled) {
return NS_ERROR_ABORT;
}
nsresult rv = mXHRProxy->SetWithCredentials(aWithCredentials);
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
NS_IMETHODIMP
nsDOMWorkerXHR::GetResponseType(nsAString& aResponseText)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsDOMWorkerXHR::SetResponseType(const nsAString& aResponseText)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* readonly attribute jsval response; */
NS_IMETHODIMP
nsDOMWorkerXHR::GetResponse(JSContext *aCx, jsval *aResult)
{
return NS_ERROR_NOT_IMPLEMENTED;
}

172
dom/src/threads/nsDOMWorkerXHR.h
View File

@ -1,172 +0,0 @@
/* -*- Mode: c++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is worker threads.
*
* The Initial Developer of the Original Code is
* Mozilla Corporation.
* Portions created by the Initial Developer are Copyright (C) 2008
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Ben Turner <bent.mozilla@gmail.com> (Original Author)
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#ifndef __NSDOMWORKERXHR_H__
#define __NSDOMWORKERXHR_H__
// Bases
#include "nsIClassInfo.h"
#include "nsIXMLHttpRequest.h"
#include "nsIXPCScriptable.h"
// Other includes
#include "nsAutoPtr.h"
#include "nsCOMPtr.h"
#include "nsTArray.h"
// DOMWorker includes
#include "nsDOMWorker.h"
#include "nsDOMWorkerMacros.h"
#include "nsDOMWorkerXHRProxy.h"
// Convenience defines for event *indexes* in the sListenerTypes array.
#define LISTENER_TYPE_ABORT 0
#define LISTENER_TYPE_ERROR 1
#define LISTENER_TYPE_LOAD 2
#define LISTENER_TYPE_LOADSTART 3
#define LISTENER_TYPE_PROGRESS 4
#define LISTENER_TYPE_READYSTATECHANGE 5
#define LISTENER_TYPE_LOADEND 6
class nsIXPConnectWrappedNative;
class nsDOMWorkerXHREventTarget : public nsDOMWorkerMessageHandler,
public nsIXMLHttpRequestEventTarget
{
public:
NS_DECL_ISUPPORTS_INHERITED
NS_FORWARD_NSIDOMEVENTTARGET(nsDOMWorkerMessageHandler::)
NS_DECL_NSIXMLHTTPREQUESTEVENTTARGET
static const char* const sListenerTypes[];
static const PRUint32 sMaxXHREventTypes;
static const PRUint32 sMaxUploadEventTypes;
static PRUint32 GetListenerTypeFromString(const nsAString& aString);
protected:
virtual ~nsDOMWorkerXHREventTarget() { }
};
class nsDOMWorkerXHRUpload;
class nsDOMWorkerXHR : public nsDOMWorkerFeature,
public nsDOMWorkerXHREventTarget,
public nsIXMLHttpRequest,
public nsIXPCScriptable
{
typedef mozilla::Mutex Mutex;
friend class nsDOMWorkerXHREvent;
friend class nsDOMWorkerXHRLastProgressOrLoadEvent;
friend class nsDOMWorkerXHRProxy;
friend class nsDOMWorkerXHRUpload;
public:
NS_DECL_ISUPPORTS_INHERITED
NS_DECL_NSIXMLHTTPREQUEST
NS_FORWARD_NSICLASSINFO_NOGETINTERFACES(nsDOMWorkerXHREventTarget::)
NS_DECL_NSICLASSINFO_GETINTERFACES
NS_DECL_NSIXPCSCRIPTABLE
nsDOMWorkerXHR(nsDOMWorker* aWorker);
nsresult Init();
virtual void Cancel();
virtual nsresult SetOnXListener(const nsAString& aType,
nsIDOMEventListener* aListener);
private:
virtual ~nsDOMWorkerXHR();
Mutex& GetLock() {
return mWorker->GetLock();
}
already_AddRefed<nsIXPConnectWrappedNative> GetWrappedNative() {
nsCOMPtr<nsIXPConnectWrappedNative> wrappedNative(mWrappedNative);
return wrappedNative.forget();
}
nsRefPtr<nsDOMWorkerXHRProxy> mXHRProxy;
nsRefPtr<nsDOMWorkerXHRUpload> mUpload;
nsIXPConnectWrappedNative* mWrappedNative;
volatile bool mCanceled;
};
class nsDOMWorkerXHRUpload : public nsDOMWorkerXHREventTarget,
public nsIXMLHttpRequestUpload
{
friend class nsDOMWorkerXHR;
public:
NS_DECL_ISUPPORTS_INHERITED
// nsIDOMEventHandler
NS_FORWARD_INTERNAL_NSIDOMEVENTTARGET(nsDOMWorkerMessageHandler::)
NS_IMETHOD AddEventListener(const nsAString& aType,
nsIDOMEventListener* aListener,
bool aUseCapture,
bool aWantsUntrusted,
PRUint8 optional_argc);
NS_IMETHOD RemoveEventListener(const nsAString& aType,
nsIDOMEventListener* aListener,
bool aUseCapture);
NS_IMETHOD DispatchEvent(nsIDOMEvent* aEvent,
bool* _retval);
NS_FORWARD_NSIXMLHTTPREQUESTEVENTTARGET(nsDOMWorkerXHREventTarget::)
NS_DECL_NSIXMLHTTPREQUESTUPLOAD
NS_FORWARD_NSICLASSINFO_NOGETINTERFACES(nsDOMWorkerXHREventTarget::)
NS_DECL_NSICLASSINFO_GETINTERFACES
nsDOMWorkerXHRUpload(nsDOMWorkerXHR* aWorkerXHR);
virtual nsresult SetOnXListener(const nsAString& aType,
nsIDOMEventListener* aListener);
protected:
virtual ~nsDOMWorkerXHRUpload() { }
nsRefPtr<nsDOMWorkerXHR> mWorkerXHR;
};
#endif /* __NSDOMWORKERXHR_H__ */

182
dom/src/threads/nsDOMWorkerXHRProxiedFunctions.h
View File

@ -1,182 +0,0 @@
/* -*- Mode: c++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is worker threads.
*
* The Initial Developer of the Original Code is
* Mozilla Corporation.
* Portions created by the Initial Developer are Copyright (C) 2008
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Ben Turner <bent.mozilla@gmail.com> (Original Author)
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#ifndef __NSDOMWORKERXHRPROXIEDFUNCTIONS_H__
#define __NSDOMWORKERXHRPROXIEDFUNCTIONS_H__
#define MAKE_PROXIED_FUNCTION0(_name) \
class _name : public SyncEventCapturingRunnable \
{ \
public: \
virtual nsresult RunInternal() \
{ \
nsCOMPtr<nsIXMLHttpRequest> xhr = mXHR->GetXMLHttpRequest(); \
if (xhr) { \
return xhr-> _name (); \
} \
return NS_OK; \
} \
}
#define MAKE_PROXIED_FUNCTION1(_name, _arg1) \
class _name : public SyncEventCapturingRunnable \
{ \
public: \
_name (_arg1 aArg1) : mArg1(aArg1) { } \
\
virtual nsresult RunInternal() \
{ \
nsCOMPtr<nsIXMLHttpRequest> xhr = mXHR->GetXMLHttpRequest(); \
if (xhr) { \
return xhr-> _name (mArg1); \
} \
return NS_OK; \
} \
private: \
_arg1 mArg1; \
}
#define MAKE_PROXIED_FUNCTION2(_name, _arg1, _arg2) \
class _name : public SyncEventCapturingRunnable \
{ \
public: \
_name (_arg1 aArg1, _arg2 aArg2) : mArg1(aArg1), mArg2(aArg2) { } \
\
virtual nsresult RunInternal() \
{ \
nsCOMPtr<nsIXMLHttpRequest> xhr = mXHR->GetXMLHttpRequest(); \
if (xhr) { \
return xhr-> _name (mArg1, mArg2); \
} \
return NS_OK; \
} \
private: \
_arg1 mArg1; \
_arg2 mArg2; \
}
namespace nsDOMWorkerProxiedXHRFunctions
{
typedef nsDOMWorkerXHRProxy::SyncEventQueue SyncEventQueue;
class SyncEventCapturingRunnable : public nsRunnable
{
public:
SyncEventCapturingRunnable()
: mXHR(nsnull), mQueue(nsnull) { }
void Init(nsDOMWorkerXHRProxy* aXHR,
SyncEventQueue* aQueue) {
NS_ASSERTION(aXHR, "Null pointer!");
NS_ASSERTION(aQueue, "Null pointer!");
mXHR = aXHR;
mQueue = aQueue;
}
virtual nsresult RunInternal() = 0;
NS_IMETHOD Run() {
NS_ASSERTION(mXHR && mQueue, "Forgot to call Init!");
SyncEventQueue* oldQueue = mXHR->SetSyncEventQueue(mQueue);
nsresult rv = RunInternal();
mXHR->SetSyncEventQueue(oldQueue);
return rv;
}
protected:
nsRefPtr<nsDOMWorkerXHRProxy> mXHR;
SyncEventQueue* mQueue;
};
class Abort : public SyncEventCapturingRunnable
{
public:
virtual nsresult RunInternal() {
return mXHR->Abort();
}
};
class Open : public SyncEventCapturingRunnable
{
public:
Open(const nsACString& aMethod, const nsACString& aUrl,
bool aAsync, const nsAString& aUser,
const nsAString& aPassword)
: mMethod(aMethod), mUrl(aUrl), mAsync(aAsync), mUser(aUser),
mPassword(aPassword) { }
virtual nsresult RunInternal() {
return mXHR->Open(mMethod, mUrl, mAsync, mUser, mPassword);
}
private:
nsCString mMethod;
nsCString mUrl;
bool mAsync;
nsString mUser;
nsString mPassword;
};
MAKE_PROXIED_FUNCTION1(GetAllResponseHeaders, char**);
MAKE_PROXIED_FUNCTION2(GetResponseHeader, const nsACString&, nsACString&);
MAKE_PROXIED_FUNCTION1(Send, nsIVariant*);
MAKE_PROXIED_FUNCTION1(SendAsBinary, const nsAString&);
MAKE_PROXIED_FUNCTION2(SetRequestHeader, const nsACString&,
const nsACString&);
MAKE_PROXIED_FUNCTION1(OverrideMimeType, const nsACString&);
MAKE_PROXIED_FUNCTION1(SetMultipart, bool);
MAKE_PROXIED_FUNCTION1(GetMultipart, bool*);
MAKE_PROXIED_FUNCTION1(GetWithCredentials, bool*);
MAKE_PROXIED_FUNCTION1(SetWithCredentials, bool);
}
#endif /* __NSDOMWORKERXHRPROXIEDFUNCTIONS_H__ */

1187
dom/src/threads/nsDOMWorkerXHRProxy.cpp
View File

File diff suppressed because it is too large Load Diff

198
dom/src/threads/nsDOMWorkerXHRProxy.h
View File

@ -1,198 +0,0 @@
/* -*- Mode: c++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is worker threads.
*
* The Initial Developer of the Original Code is
* Mozilla Corporation.
* Portions created by the Initial Developer are Copyright (C) 2008
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Ben Turner <bent.mozilla@gmail.com> (Original Author)
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#ifndef __NSDOMWORKERXHRPROXY_H__
#define __NSDOMWORKERXHRPROXY_H__
// Bases
#include "nsThreadUtils.h"
#include "nsIDOMEventListener.h"
#include "nsIRequestObserver.h"
// Other includes
#include "nsIDOMEventTarget.h"
#include "nsAutoPtr.h"
#include "nsCOMPtr.h"
#include "nsStringGlue.h"
#include "nsTArray.h"
class nsIJSXMLHttpRequest;
class nsIThread;
class nsIVariant;
class nsIXMLHttpRequest;
class nsIXMLHttpRequestUpload;
class nsIXPConnectWrappedNative;
class nsDOMWorkerXHR;
class nsDOMWorkerXHREvent;
class nsDOMWorkerXHRFinishSyncXHRRunnable;
class nsDOMWorkerXHRState;
class nsDOMWorkerXHRWrappedListener;
class nsXMLHttpRequest;
class nsDOMWorkerXHRProxy : public nsIRunnable,
public nsIDOMEventListener,
public nsIRequestObserver
{
friend class nsDOMWorkerXHRAttachUploadListenersRunnable;
friend class nsDOMWorkerXHREvent;
friend class nsDOMWorkerXHRFinishSyncXHRRunnable;
friend class nsDOMWorkerXHRLastProgressOrLoadEvent;
friend class nsDOMWorkerXHR;
friend class nsDOMWorkerXHRUpload;
public:
typedef nsAutoTArray<nsCOMPtr<nsIRunnable>, 5> SyncEventQueue;
NS_DECL_ISUPPORTS
NS_DECL_NSIDOMEVENTLISTENER
NS_DECL_NSIRUNNABLE
NS_DECL_NSIREQUESTOBSERVER
nsDOMWorkerXHRProxy(nsDOMWorkerXHR* aWorkerXHR);
virtual ~nsDOMWorkerXHRProxy();
nsresult Init();
nsIXMLHttpRequest* GetXMLHttpRequest();
nsresult Open(const nsACString& aMethod,
const nsACString& aUrl,
bool aAsync,
const nsAString& aUser,
const nsAString& aPassword);
nsresult Abort();
SyncEventQueue* SetSyncEventQueue(SyncEventQueue* aQueue);
PRInt32 ChannelID() {
return mChannelID;
}
protected:
struct ProgressInfo {
ProgressInfo() : computable(PR_FALSE), loaded(0), total(0) { }
bool computable;
PRUint64 loaded;
PRUint64 total;
};
nsresult InitInternal();
void DestroyInternal();
nsresult Destroy();
void AddRemoveXHRListeners(bool aAdd);
void FlipOwnership();
nsresult UploadEventListenerAdded();
nsresult HandleWorkerEvent(nsDOMWorkerXHREvent* aEvent,
bool aUploadEvent);
nsresult HandleEventRunnable(nsIRunnable* aRunnable);
// Methods of nsIXMLHttpRequest that we implement
nsresult GetAllResponseHeaders(char** _retval);
nsresult GetResponseHeader(const nsACString& aHeader,
nsACString& _retval);
nsresult Send(nsIVariant* aBody);
nsresult SendAsBinary(const nsAString& aBody);
nsresult GetResponseText(nsAString& _retval);
nsresult GetStatusText(nsACString& _retval);
nsresult GetStatus(nsresult* _retval);
nsresult GetReadyState(PRUint16* _retval);
nsresult SetRequestHeader(const nsACString& aHeader,
const nsACString& aValue);
nsresult OverrideMimeType(const nsACString& aMimetype);
nsresult GetMultipart(bool* aMultipart);
nsresult SetMultipart(bool aMultipart);
nsresult GetWithCredentials(bool* aWithCredentials);
nsresult SetWithCredentials(bool aWithCredentials);
nsresult RunSyncEventLoop();
bool IsUploadEvent(nsIDOMEvent* aEvent);
nsresult DispatchPrematureAbortEvents(PRUint32 aType,
nsIDOMEventTarget* aTarget,
ProgressInfo* aProgressInfo);
nsresult MaybeDispatchPrematureAbortEvents(bool aFromOpenRequest);
// May be weak or strong, check mOwnedByXHR.
nsDOMWorkerXHR* mWorkerXHR;
nsCOMPtr<nsIXPConnectWrappedNative> mWorkerXHRWN;
// May be weak or strong, check mOwnedByXHR.
nsIXMLHttpRequest* mXHR;
// Always weak!
nsXMLHttpRequest* mConcreteXHR;
nsIXMLHttpRequestUpload* mUpload;
nsCOMPtr<nsIThread> mMainThread;
nsRefPtr<nsDOMWorkerXHRState> mLastXHRState;
nsRefPtr<nsDOMWorkerXHREvent> mLastProgressOrLoadEvent;
SyncEventQueue* mSyncEventQueue;
PRInt32 mChannelID;
// Only touched on the worker thread!
nsCOMPtr<nsIThread> mSyncXHRThread;
// Touched on more than one thread, protected by the worker's lock.
nsRefPtr<nsDOMWorkerXHRFinishSyncXHRRunnable> mSyncFinishedRunnable;
nsAutoPtr<ProgressInfo> mDownloadProgressInfo;
nsAutoPtr<ProgressInfo> mUploadProgressInfo;
// Whether or not this object is owned by the real XHR object.
bool mOwnedByXHR;
bool mWantUploadListeners;
bool mCanceled;
bool mSyncRequest;
};
#endif /* __NSDOMWORKERXHRPROXY_H__ */

26
dom/src/threads/test/errorPropagation_worker1.js
View File

@ -1,26 +0,0 @@
var worker = new Worker("errorPropagation_worker2.js");
var errorCount = 0;
worker.onerror = function(event) {
switch (errorCount++) {
case 0:
case 1:
// Let it propagate.
break;
case 2:
// Stop and rethrow.
event.preventDefault();
throw event.message;
break;
case 3:
event.preventDefault();
postMessage(event.message);
worker.onerror = null;
break;
default:
}
};
onmessage = function(event) {
worker.postMessage(event.data);
};

26
dom/src/threads/test/regExpStatics_worker.js
View File

@ -1,26 +0,0 @@
var runCount = 0;
var timeout;
onmessage = function() {
run();
timeout = setTimeout(run, 0);
timeout = setTimeout(run, 5000);
};
function run() {
if (RegExp.$1) {
throw "RegExp.$1 already set!";
cancelTimeout(timeout);
}
var match = /a(sd)f/.exec("asdf");
if (!RegExp.$1) {
throw "RegExp.$1 didn't get set!";
cancelTimeout(timeout);
}
if (++runCount == 3) {
postMessage("done");
}
}

88
dom/src/threads/test/test_chromeWorkerComponent.xul
View File

@ -1,88 +0,0 @@
<?xml version="1.0"?>
<!-- ***** BEGIN LICENSE BLOCK *****
- Version: MPL 1.1/GPL 2.0/LGPL 2.1
-
- The contents of this file are subject to the Mozilla Public License Version
- 1.1 (the "License"); you may not use this file except in compliance with
- the License. You may obtain a copy of the License at
- http://www.mozilla.org/MPL/
-
- Software distributed under the License is distributed on an "AS IS" basis,
- WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- for the specific language governing rights and limitations under the
- License.
-
- The Original Code is DOM Worker tests.
-
- The Initial Developer of the Original Code is
- The Mozilla Foundation.
- Portions created by the Initial Developer are Copyright (C) 2010
- the Initial Developer. All Rights Reserved.
-
- Contributor(s):
- Ben Turner <bent.mozilla@gmail.com>
-
- Alternatively, the contents of this file may be used under the terms of
- either the GNU General Public License Version 2 or later (the "GPL"), or
- the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- in which case the provisions of the GPL or the LGPL are applicable instead
- of those above. If you wish to allow use of your version of this file only
- under the terms of either the GPL or the LGPL, and not to allow others to
- use your version of this file under the terms of the MPL, indicate your
- decision by deleting the provisions above and replace them with the notice
- and other provisions required by the LGPL or the GPL. If you do not delete
- the provisions above, a recipient may use your version of this file under
- the terms of any one of the MPL, the GPL or the LGPL.
-
- ***** END LICENSE BLOCK ***** -->
<window title="DOM Worker Threads Test"
xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
onload="test();">
<script type="application/javascript"
src="chrome://mochikit/content/MochiKit/packed.js"/>
<script type="application/javascript"
src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/>
<script type="application/javascript"
src="chrome://mochikit/content/tests/SimpleTest/EventUtils.js"/>
<script type="application/javascript">
<![CDATA[
function test()
{
SimpleTest.waitForExplicitFinish();
const Cc = Components.classes;
const Ci = Components.interfaces;
var wf = Cc["@mozilla.org/threads/workerfactory;1"]
.createInstance(Ci.nsIWorkerFactory);
var worker = wf.newChromeWorker("chromeWorker_worker.js");
worker.onmessage = function(event) {
is(event.data, "Done!", "Wrong message!");
SimpleTest.finish();
}
worker.onerror = function(event) {
ok(false, "Worker had an error: " + event.message);
worker.terminate();
SimpleTest.finish();
}
// Test passing a wrapped native to the worker.
var thread = Components.classes["@mozilla.org/thread-manager;1"]
.getService().newThread(0);
worker.postMessage(thread);
}
]]>
</script>
<body xmlns="http://www.w3.org/1999/xhtml">
<p id="display"></p>
<div id="content" style="display:none;"></div>
<pre id="test"></pre>
</body>
<label id="test-result"/>
</window>

36
dom/src/threads/test/test_functionHandlers.html
View File

@ -1,36 +0,0 @@
<!DOCTYPE HTML>
<html>
<!--
Tests of DOM Worker Threads
-->
<head>
<title>Test for DOM Worker Threads Recursion</title>
<script type="text/javascript" src="/MochiKit/packed.js"></script>
<script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
<link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
</head>
<body>
<p id="display"></p>
<div id="content" style="display: none">
</div>
<pre id="test">
<script class="testbody" type="text/javascript">
var worker = new Worker("functionHandlers_worker.js");
var message = "hello!";
worker.onmessage = function(event) {
is(event.data, "uncaught exception: " + message, "Bad message!");
SimpleTest.finish();
};
worker.postMessage(message);
SimpleTest.waitForExplicitFinish();
</script>
</pre>
</body>
</html>

47
dom/src/threads/test/test_regExpStatics.html
View File

@ -1,47 +0,0 @@
<!DOCTYPE HTML>
<html>
<!--
Tests of DOM Worker Threads RegExp statics
-->
<head>
<title>Test for DOM Worker Threads RegExp statics</title>
<script type="text/javascript" src="/MochiKit/packed.js"></script>
<script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
<link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
</head>
<body>
<p id="display"></p>
<div id="content" style="display: none">
</div>
<pre id="test">
<script class="testbody" type="text/javascript">
const WORKER_COUNT = 25;
var doneWorkers = 0;
function onmessage(event) {
if (++doneWorkers == WORKER_COUNT) {
ok(true, "All messages received from workers");
SimpleTest.finish();
}
}
function onerror(event) {
ok(false, "Worker had an error: " + event.data);
SimpleTest.finish();
};
for (var i = 0; i < WORKER_COUNT; i++) {
var worker = new Worker("regExpStatics_worker.js");
worker.onmessage = onmessage;
worker.onerror = onerror;
worker.postMessage("start");
}
SimpleTest.waitForExplicitFinish();
</script>
</pre>
</body>
</html>

44
dom/src/threads/test/test_scopeOnerror.html
View File

@ -1,44 +0,0 @@
<!DOCTYPE HTML>
<html>
<!--
Tests of DOM Worker Threads
-->
<head>
<title>Test for DOM Worker Threads</title>
<script type="text/javascript" src="/MochiKit/packed.js"></script>
<script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
<link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
</head>
<body>
<pre id="test">
<script class="testbody" type="text/javascript">
var errors = [
"This exception should make it to onerror",
"This error should not make it back out"
];
var worker = new Worker("scopeOnerror_worker.js");
worker.onmessage = function(event) {
ok(event.data == "Done");
SimpleTest.finish();
}
worker.onerror = function(event) {
is(event.target, worker);
is(event.message, "uncaught exception: " + errors[0]);
event.preventDefault();
};
for (var index in errors) {
worker.postMessage(errors[index]);
}
SimpleTest.waitForExplicitFinish();
</script>
</pre>
</body>
</html>