--- a/dom/base/nsDOMNavigationTiming.cpp
+++ b/dom/base/nsDOMNavigationTiming.cpp
@@ -38,44 +38,38 @@ nsDOMNavigationTiming::Clear()
mDOMLoading = 0;
mDOMInteractive = 0;
mDOMContentLoadedEventStart = 0;
mDOMContentLoadedEventEnd = 0;
mDOMComplete = 0;
mRedirectCheck = NOT_CHECKED;
}
-nsresult
-nsDOMNavigationTiming::TimeStampToDOM(mozilla::TimeStamp aStamp,
- DOMTimeMilliSec* aResult)
+DOMTimeMilliSec
+nsDOMNavigationTiming::TimeStampToDOM(mozilla::TimeStamp aStamp) const
{
if (aStamp.IsNull()) {
- *aResult = 0;
- return NS_OK;
+ return 0;
}
mozilla::TimeDuration duration = aStamp - mNavigationStartTimeStamp;
- *aResult = mNavigationStart + static_cast<PRInt32>(duration.ToMilliseconds());
- return NS_OK;
+ return mNavigationStart + static_cast<PRInt32>(duration.ToMilliseconds());
}
-nsresult
-nsDOMNavigationTiming::TimeStampToDOMOrFetchStart(mozilla::TimeStamp aStamp,
- DOMTimeMilliSec* aResult)
+DOMTimeMilliSec
+nsDOMNavigationTiming::TimeStampToDOMOrFetchStart(mozilla::TimeStamp aStamp) const
{
if (!aStamp.IsNull()) {
- return TimeStampToDOM(aStamp, aResult);
+ return TimeStampToDOM(aStamp);
} else {
- return GetFetchStart(aResult);
+ return GetFetchStart();
}
}
DOMTimeMilliSec nsDOMNavigationTiming::DurationFromStart(){
- DOMTimeMilliSec result;
- TimeStampToDOM(mozilla::TimeStamp::Now(), &result);
- return result;
+ return TimeStampToDOM(mozilla::TimeStamp::Now());
}
void
nsDOMNavigationTiming::NotifyNavigationStart()
{
mNavigationStart = PR_Now() / PR_USEC_PER_MSEC;
mNavigationStartTimeStamp = mozilla::TimeStamp::Now();
}
@@ -168,17 +162,17 @@ nsDOMNavigationTiming::ReportRedirects()
}
return mRedirectCheck == CHECK_PASSED;
}
void
nsDOMNavigationTiming::SetDOMLoadingTimeStamp(nsIURI* aURI, mozilla::TimeStamp aValue)
{
mLoadedURI = aURI;
- TimeStampToDOM(aValue, &mDOMLoading);
+ mDOMLoading = TimeStampToDOM(aValue);
}
void
nsDOMNavigationTiming::NotifyDOMLoading(nsIURI* aURI)
{
mLoadedURI = aURI;
mDOMLoading = DurationFromStart();
}
@@ -206,132 +200,57 @@ nsDOMNavigationTiming::NotifyDOMContentL
void
nsDOMNavigationTiming::NotifyDOMContentLoadedEnd(nsIURI* aURI)
{
mLoadedURI = aURI;
mDOMContentLoadedEventEnd = DurationFromStart();
}
-nsresult
-nsDOMNavigationTiming::GetType(
- nsDOMPerformanceNavigationType* aNavigationType)
+PRUint16
+nsDOMNavigationTiming::GetRedirectCount()
{
- *aNavigationType = mNavigationType;
- return NS_OK;
-}
-
-nsresult
-nsDOMNavigationTiming::GetRedirectCount(PRUint16* aRedirectCount)
-{
- *aRedirectCount = 0;
if (ReportRedirects()) {
- *aRedirectCount = mRedirectCount;
+ return mRedirectCount;
}
- return NS_OK;
+ return 0;
}
-nsresult
-nsDOMNavigationTiming::GetRedirectStart(DOMTimeMilliSec* aRedirectStart)
+DOMTimeMilliSec
+nsDOMNavigationTiming::GetRedirectStart()
{
- *aRedirectStart = 0;
if (ReportRedirects()) {
- *aRedirectStart = mRedirectStart;
+ return mRedirectStart;
}
- return NS_OK;
+ return 0;
}
-nsresult
-nsDOMNavigationTiming::GetRedirectEnd(DOMTimeMilliSec* aEnd)
+DOMTimeMilliSec
+nsDOMNavigationTiming::GetRedirectEnd()
{
- *aEnd = 0;
if (ReportRedirects()) {
- *aEnd = mRedirectEnd;
+ return mRedirectEnd;
}
- return NS_OK;
+ return 0;
}
-nsresult
-nsDOMNavigationTiming::GetNavigationStart(DOMTimeMilliSec* aNavigationStart)
+DOMTimeMilliSec
+nsDOMNavigationTiming::GetUnloadEventStart()
{
- *aNavigationStart = mNavigationStart;
- return NS_OK;
-}
-
-nsresult
-nsDOMNavigationTiming::GetUnloadEventStart(DOMTimeMilliSec* aStart)
-{
- *aStart = 0;
nsIScriptSecurityManager* ssm = nsContentUtils::GetSecurityManager();
nsresult rv = ssm->CheckSameOriginURI(mLoadedURI, mUnloadedURI, false);
if (NS_SUCCEEDED(rv)) {
- *aStart = mUnloadStart;
+ return mUnloadStart;
}
- return NS_OK;
+ return 0;
}
-nsresult
-nsDOMNavigationTiming::GetUnloadEventEnd(DOMTimeMilliSec* aEnd)
+DOMTimeMilliSec
+nsDOMNavigationTiming::GetUnloadEventEnd()
{
- *aEnd = 0;
nsIScriptSecurityManager* ssm = nsContentUtils::GetSecurityManager();
nsresult rv = ssm->CheckSameOriginURI(mLoadedURI, mUnloadedURI, false);
if (NS_SUCCEEDED(rv)) {
- *aEnd = mUnloadEnd;
+ return mUnloadEnd;
}
- return NS_OK;
-}
-
-nsresult
-nsDOMNavigationTiming::GetFetchStart(DOMTimeMilliSec* aStart)
-{
- *aStart = mFetchStart;
- return NS_OK;
-}
-
-nsresult
-nsDOMNavigationTiming::GetDomLoading(DOMTimeMilliSec* aTime)
-{
- *aTime = mDOMLoading;
- return NS_OK;
-}
-
-nsresult
-nsDOMNavigationTiming::GetDomInteractive(DOMTimeMilliSec* aTime)
-{
- *aTime = mDOMInteractive;
- return NS_OK;
+ return 0;
}
-nsresult
-nsDOMNavigationTiming::GetDomContentLoadedEventStart(DOMTimeMilliSec* aStart)
-{
- *aStart = mDOMContentLoadedEventStart;
- return NS_OK;
-}
-
-nsresult
-nsDOMNavigationTiming::GetDomContentLoadedEventEnd(DOMTimeMilliSec* aEnd)
-{
- *aEnd = mDOMContentLoadedEventEnd;
- return NS_OK;
-}
-
-nsresult
-nsDOMNavigationTiming::GetDomComplete(DOMTimeMilliSec* aTime)
-{
- *aTime = mDOMComplete;
- return NS_OK;
-}
-
-nsresult
-nsDOMNavigationTiming::GetLoadEventStart(DOMTimeMilliSec* aStart)
-{
- *aStart = mLoadEventStart;
- return NS_OK;
-}
-
-nsresult
-nsDOMNavigationTiming::GetLoadEventEnd(DOMTimeMilliSec* aEnd)
-{
- *aEnd = mLoadEventEnd;
- return NS_OK;
-}
--- a/dom/base/nsDOMNavigationTiming.h
+++ b/dom/base/nsDOMNavigationTiming.h
@@ -17,32 +17,53 @@
class nsDOMNavigationTimingClock;
class nsDOMNavigationTiming
{
public:
nsDOMNavigationTiming();
NS_INLINE_DECL_REFCOUNTING(nsDOMNavigationTiming)
- nsresult GetType(nsDOMPerformanceNavigationType* aNavigationType);
- nsresult GetRedirectCount(PRUint16* aCount);
+
+ nsDOMPerformanceNavigationType GetType() const {
+ return mNavigationType;
+ }
+ PRUint16 GetRedirectCount();
- nsresult GetRedirectStart(DOMTimeMilliSec* aRedirectStart);
- nsresult GetRedirectEnd(DOMTimeMilliSec* aEnd);
- nsresult GetNavigationStart(DOMTimeMilliSec* aNavigationStart);
- nsresult GetUnloadEventStart(DOMTimeMilliSec* aStart);
- nsresult GetUnloadEventEnd(DOMTimeMilliSec* aEnd);
- nsresult GetFetchStart(DOMTimeMilliSec* aStart);
- nsresult GetDomLoading(DOMTimeMilliSec* aTime);
- nsresult GetDomInteractive(DOMTimeMilliSec* aTime);
- nsresult GetDomContentLoadedEventStart(DOMTimeMilliSec* aStart);
- nsresult GetDomContentLoadedEventEnd(DOMTimeMilliSec* aEnd);
- nsresult GetDomComplete(DOMTimeMilliSec* aTime);
- nsresult GetLoadEventStart(DOMTimeMilliSec* aStart);
- nsresult GetLoadEventEnd(DOMTimeMilliSec* aEnd);
+ DOMTimeMilliSec GetRedirectStart();
+ DOMTimeMilliSec GetRedirectEnd();
+ DOMTimeMilliSec GetNavigationStart() const {
+ return mNavigationStart;
+ }
+ DOMTimeMilliSec GetUnloadEventStart();
+ DOMTimeMilliSec GetUnloadEventEnd();
+ DOMTimeMilliSec GetFetchStart() const {
+ return mFetchStart;
+ }
+ DOMTimeMilliSec GetDomLoading() const {
+ return mDOMLoading;
+ }
+ DOMTimeMilliSec GetDomInteractive() const {
+ return mDOMInteractive;
+ }
+ DOMTimeMilliSec GetDomContentLoadedEventStart() const {
+ return mDOMContentLoadedEventStart;
+ }
+ DOMTimeMilliSec GetDomContentLoadedEventEnd() const {
+ return mDOMContentLoadedEventEnd;
+ }
+ DOMTimeMilliSec GetDomComplete() const {
+ return mDOMComplete;
+ }
+ DOMTimeMilliSec GetLoadEventStart() const {
+ return mLoadEventStart;
+ }
+ DOMTimeMilliSec GetLoadEventEnd() const {
+ return mLoadEventEnd;
+ }
void NotifyNavigationStart();
void NotifyFetchStart(nsIURI* aURI, nsDOMPerformanceNavigationType aNavigationType);
void NotifyRedirect(nsIURI* aOldURI, nsIURI* aNewURI);
void NotifyBeforeUnload();
void NotifyUnloadAccepted(nsIURI* aOldURI);
void NotifyUnloadEventStart();
void NotifyUnloadEventEnd();
@@ -51,19 +72,18 @@ public:
// Document changes state to 'loading' before connecting to timing
void SetDOMLoadingTimeStamp(nsIURI* aURI, mozilla::TimeStamp aValue);
void NotifyDOMLoading(nsIURI* aURI);
void NotifyDOMInteractive(nsIURI* aURI);
void NotifyDOMComplete(nsIURI* aURI);
void NotifyDOMContentLoadedStart(nsIURI* aURI);
void NotifyDOMContentLoadedEnd(nsIURI* aURI);
- nsresult TimeStampToDOM(mozilla::TimeStamp aStamp, DOMTimeMilliSec* aResult);
- nsresult TimeStampToDOMOrFetchStart(mozilla::TimeStamp aStamp,
- DOMTimeMilliSec* aResult);
+ DOMTimeMilliSec TimeStampToDOM(mozilla::TimeStamp aStamp) const;
+ DOMTimeMilliSec TimeStampToDOMOrFetchStart(mozilla::TimeStamp aStamp) const;
inline DOMHighResTimeStamp TimeStampToDOMHighRes(mozilla::TimeStamp aStamp)
{
mozilla::TimeDuration duration = aStamp - mNavigationStartTimeStamp;
return duration.ToMilliseconds();
}
private:
--- a/dom/base/nsGlobalWindow.cpp
+++ b/dom/base/nsGlobalWindow.cpp
@@ -1251,16 +1251,18 @@ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(
}
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mContext)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mControllers)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mArguments)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mArgumentsLast)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NATIVE_MEMBER(mPerformance, nsPerformance)
+
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mInnerWindowHolder)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mOuterWindow)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mOpenerScriptPrincipal)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NATIVE_MEMBER(mListenerManager,
nsEventListenerManager)
for (nsTimeout* timeout = tmp->FirstTimeout();
@@ -1296,16 +1298,18 @@ NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(ns
nsGlobalWindow::CleanupCachedXBLHandlers(tmp);
NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(mContext)
NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(mControllers)
NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(mArguments)
NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(mArgumentsLast)
+ NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(mPerformance)
+
NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(mInnerWindowHolder)
if (tmp->mOuterWindow) {
static_cast<nsGlobalWindow*>(tmp->mOuterWindow.get())->MaybeClearInnerWindow(tmp);
NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(mOuterWindow)
}
NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(mOpenerScriptPrincipal)
if (tmp->mListenerManager) {
@@ -2931,17 +2935,17 @@ nsGlobalWindow::GetPerformance(nsIDOMPer
nsCOMPtr<nsITimedChannel> timedChannel(do_QueryInterface(mDoc->GetChannel()));
bool timingEnabled = false;
if (!timedChannel ||
!NS_SUCCEEDED(timedChannel->GetTimingEnabled(&timingEnabled)) ||
!timingEnabled) {
timedChannel = nsnull;
}
if (timing) {
- mPerformance = new nsPerformance(timing, timedChannel);
+ mPerformance = new nsPerformance(this, timing, timedChannel);
}
}
NS_IF_ADDREF(*aPerformance = mPerformance);
}
return NS_OK;
}
/**
--- a/dom/base/nsPerformance.cpp
+++ b/dom/base/nsPerformance.cpp
@@ -6,290 +6,420 @@
#include "nsPerformance.h"
#include "TimeStamp.h"
#include "nsCOMPtr.h"
#include "nscore.h"
#include "nsIDocShell.h"
#include "nsITimedChannel.h"
#include "nsDOMClassInfoID.h"
#include "nsDOMNavigationTiming.h"
+#include "nsContentUtils.h"
+#include "nsIDOMWindow.h"
+#include "mozilla/dom/PerformanceBinding.h"
+#include "mozilla/dom/PerformanceTimingBinding.h"
+#include "mozilla/dom/PerformanceNavigationBinding.h"
+
+using namespace mozilla;
DOMCI_DATA(PerformanceTiming, nsPerformanceTiming)
-NS_IMPL_ADDREF(nsPerformanceTiming)
-NS_IMPL_RELEASE(nsPerformanceTiming)
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_1(nsPerformanceTiming, mPerformance)
+NS_IMPL_CYCLE_COLLECTING_ADDREF(nsPerformanceTiming)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(nsPerformanceTiming)
// QueryInterface implementation for nsPerformanceTiming
-NS_INTERFACE_MAP_BEGIN(nsPerformanceTiming)
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsPerformanceTiming)
+ NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDOMPerformanceTiming)
NS_INTERFACE_MAP_ENTRY(nsIDOMPerformanceTiming)
NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(PerformanceTiming)
NS_INTERFACE_MAP_END
-nsPerformanceTiming::nsPerformanceTiming(nsDOMNavigationTiming* aDOMTiming,
+nsPerformanceTiming::nsPerformanceTiming(nsPerformance* aPerformance,
nsITimedChannel* aChannel)
+ : mPerformance(aPerformance),
+ mChannel(aChannel)
{
- NS_ASSERTION(aDOMTiming, "DOM timing data should be provided");
- mDOMTiming = aDOMTiming;
- mChannel = aChannel;
+ MOZ_ASSERT(aPerformance, "Parent performance object should be provided");
+ SetIsDOMBinding();
}
nsPerformanceTiming::~nsPerformanceTiming()
{
}
NS_IMETHODIMP
nsPerformanceTiming::GetNavigationStart(DOMTimeMilliSec* aTime)
{
- return mDOMTiming->GetNavigationStart(aTime);
+ *aTime = GetNavigationStart();
+ return NS_OK;
}
NS_IMETHODIMP
nsPerformanceTiming::GetUnloadEventStart(DOMTimeMilliSec* aTime)
{
- return mDOMTiming->GetUnloadEventStart(aTime);
+ *aTime = GetUnloadEventStart();
+ return NS_OK;
}
NS_IMETHODIMP
nsPerformanceTiming::GetUnloadEventEnd(DOMTimeMilliSec* aTime)
{
- return mDOMTiming->GetUnloadEventEnd(aTime);
+ *aTime = GetUnloadEventEnd();
+ return NS_OK;
}
NS_IMETHODIMP
nsPerformanceTiming::GetRedirectStart(DOMTimeMilliSec* aTime)
{
- return mDOMTiming->GetRedirectStart(aTime);
+ *aTime = GetRedirectStart();
+ return NS_OK;
}
NS_IMETHODIMP
nsPerformanceTiming::GetRedirectEnd(DOMTimeMilliSec* aTime)
{
- return mDOMTiming->GetRedirectEnd(aTime);
+ *aTime = GetRedirectEnd();
+ return NS_OK;
}
NS_IMETHODIMP
nsPerformanceTiming::GetFetchStart(DOMTimeMilliSec* aTime)
{
- return mDOMTiming->GetFetchStart(aTime);
+ *aTime = GetFetchStart();
+ return NS_OK;
}
NS_IMETHODIMP
nsPerformanceTiming::GetDomainLookupStart(DOMTimeMilliSec* aTime)
{
+ *aTime = GetDomainLookupStart();
+ return NS_OK;
+}
+
+DOMTimeMilliSec
+nsPerformanceTiming::GetDomainLookupStart() const
+{
if (!mChannel) {
- return GetFetchStart(aTime);
+ return GetFetchStart();
}
mozilla::TimeStamp stamp;
mChannel->GetDomainLookupStart(&stamp);
- return mDOMTiming->TimeStampToDOMOrFetchStart(stamp, aTime);
+ return GetDOMTiming()->TimeStampToDOMOrFetchStart(stamp);
}
NS_IMETHODIMP
nsPerformanceTiming::GetDomainLookupEnd(DOMTimeMilliSec* aTime)
{
+ *aTime = GetDomainLookupEnd();
+ return NS_OK;
+}
+
+DOMTimeMilliSec
+nsPerformanceTiming::GetDomainLookupEnd() const
+{
if (!mChannel) {
- return GetFetchStart(aTime);
+ return GetFetchStart();
}
mozilla::TimeStamp stamp;
mChannel->GetDomainLookupEnd(&stamp);
- return mDOMTiming->TimeStampToDOMOrFetchStart(stamp, aTime);
+ return GetDOMTiming()->TimeStampToDOMOrFetchStart(stamp);
}
NS_IMETHODIMP
nsPerformanceTiming::GetConnectStart(DOMTimeMilliSec* aTime)
{
+ *aTime = GetConnectStart();
+ return NS_OK;
+}
+
+DOMTimeMilliSec
+nsPerformanceTiming::GetConnectStart() const
+{
if (!mChannel) {
- return GetFetchStart(aTime);
+ return GetFetchStart();
}
mozilla::TimeStamp stamp;
mChannel->GetConnectStart(&stamp);
- return mDOMTiming->TimeStampToDOMOrFetchStart(stamp, aTime);
+ return GetDOMTiming()->TimeStampToDOMOrFetchStart(stamp);
}
NS_IMETHODIMP
nsPerformanceTiming::GetConnectEnd(DOMTimeMilliSec* aTime)
{
+ *aTime = GetConnectEnd();
+ return NS_OK;
+}
+
+DOMTimeMilliSec
+nsPerformanceTiming::GetConnectEnd() const
+{
if (!mChannel) {
- return GetFetchStart(aTime);
+ return GetFetchStart();
}
mozilla::TimeStamp stamp;
mChannel->GetConnectEnd(&stamp);
- return mDOMTiming->TimeStampToDOMOrFetchStart(stamp, aTime);
+ return GetDOMTiming()->TimeStampToDOMOrFetchStart(stamp);
}
NS_IMETHODIMP
nsPerformanceTiming::GetRequestStart(DOMTimeMilliSec* aTime)
{
+ *aTime = GetRequestStart();
+ return NS_OK;
+}
+
+DOMTimeMilliSec
+nsPerformanceTiming::GetRequestStart() const
+{
if (!mChannel) {
- return GetFetchStart(aTime);
+ return GetFetchStart();
}
mozilla::TimeStamp stamp;
mChannel->GetRequestStart(&stamp);
- return mDOMTiming->TimeStampToDOMOrFetchStart(stamp, aTime);
+ return GetDOMTiming()->TimeStampToDOMOrFetchStart(stamp);
}
NS_IMETHODIMP
nsPerformanceTiming::GetResponseStart(DOMTimeMilliSec* aTime)
{
+ *aTime = GetResponseStart();
+ return NS_OK;
+}
+
+DOMTimeMilliSec
+nsPerformanceTiming::GetResponseStart() const
+{
if (!mChannel) {
- return GetFetchStart(aTime);
+ return GetFetchStart();
}
mozilla::TimeStamp stamp;
mChannel->GetResponseStart(&stamp);
mozilla::TimeStamp cacheStamp;
mChannel->GetCacheReadStart(&cacheStamp);
if (stamp.IsNull() || (!cacheStamp.IsNull() && cacheStamp < stamp)) {
stamp = cacheStamp;
}
- return mDOMTiming->TimeStampToDOMOrFetchStart(stamp, aTime);
+ return GetDOMTiming()->TimeStampToDOMOrFetchStart(stamp);
}
NS_IMETHODIMP
nsPerformanceTiming::GetResponseEnd(DOMTimeMilliSec* aTime)
{
+ *aTime = GetResponseEnd();
+ return NS_OK;
+}
+
+DOMTimeMilliSec
+nsPerformanceTiming::GetResponseEnd() const
+{
if (!mChannel) {
- return GetFetchStart(aTime);
+ return GetFetchStart();
}
mozilla::TimeStamp stamp;
mChannel->GetResponseEnd(&stamp);
mozilla::TimeStamp cacheStamp;
mChannel->GetCacheReadEnd(&cacheStamp);
if (stamp.IsNull() || (!cacheStamp.IsNull() && cacheStamp < stamp)) {
stamp = cacheStamp;
}
- return mDOMTiming->TimeStampToDOMOrFetchStart(stamp, aTime);
+ return GetDOMTiming()->TimeStampToDOMOrFetchStart(stamp);
}
NS_IMETHODIMP
nsPerformanceTiming::GetDomLoading(DOMTimeMilliSec* aTime)
{
- return mDOMTiming->GetDomLoading(aTime);
+ *aTime = GetDomLoading();
+ return NS_OK;
}
NS_IMETHODIMP
nsPerformanceTiming::GetDomInteractive(DOMTimeMilliSec* aTime)
{
- return mDOMTiming->GetDomInteractive(aTime);
+ *aTime = GetDomInteractive();
+ return NS_OK;
}
NS_IMETHODIMP
nsPerformanceTiming::GetDomContentLoadedEventStart(DOMTimeMilliSec* aTime)
{
- return mDOMTiming->GetDomContentLoadedEventStart(aTime);
+ *aTime = GetDomContentLoadedEventStart();
+ return NS_OK;
}
NS_IMETHODIMP
nsPerformanceTiming::GetDomContentLoadedEventEnd(DOMTimeMilliSec* aTime)
{
- return mDOMTiming->GetDomContentLoadedEventEnd(aTime);
+ *aTime = GetDomContentLoadedEventEnd();
+ return NS_OK;
}
NS_IMETHODIMP
nsPerformanceTiming::GetDomComplete(DOMTimeMilliSec* aTime)
{
- return mDOMTiming->GetDomComplete(aTime);
+ *aTime = GetDomComplete();
+ return NS_OK;
}
NS_IMETHODIMP
nsPerformanceTiming::GetLoadEventStart(DOMTimeMilliSec* aTime)
{
- return mDOMTiming->GetLoadEventStart(aTime);
+ *aTime = GetLoadEventStart();
+ return NS_OK;
}
NS_IMETHODIMP
nsPerformanceTiming::GetLoadEventEnd(DOMTimeMilliSec* aTime)
{
- return mDOMTiming->GetLoadEventEnd(aTime);
+ *aTime = GetLoadEventEnd();
+ return NS_OK;
+}
+
+JSObject*
+nsPerformanceTiming::WrapObject(JSContext *cx, JSObject *scope,
+ bool *triedToWrap)
+{
+ return dom::PerformanceTimingBinding::Wrap(cx, scope, this,
+ triedToWrap);
}
DOMCI_DATA(PerformanceNavigation, nsPerformanceNavigation)
-NS_IMPL_ADDREF(nsPerformanceNavigation)
-NS_IMPL_RELEASE(nsPerformanceNavigation)
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_1(nsPerformanceNavigation, mPerformance)
+NS_IMPL_CYCLE_COLLECTING_ADDREF(nsPerformanceNavigation)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(nsPerformanceNavigation)
// QueryInterface implementation for nsPerformanceNavigation
-NS_INTERFACE_MAP_BEGIN(nsPerformanceNavigation)
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsPerformanceNavigation)
+ NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDOMPerformanceNavigation)
NS_INTERFACE_MAP_ENTRY(nsIDOMPerformanceNavigation)
NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(PerformanceNavigation)
NS_INTERFACE_MAP_END
-nsPerformanceNavigation::nsPerformanceNavigation(nsDOMNavigationTiming* aData)
+nsPerformanceNavigation::nsPerformanceNavigation(nsPerformance* aPerformance)
+ : mPerformance(aPerformance)
{
- NS_ASSERTION(aData, "Timing data should be provided");
- mData = aData;
+ MOZ_ASSERT(aPerformance, "Parent performance object should be provided");
+ SetIsDOMBinding();
}
nsPerformanceNavigation::~nsPerformanceNavigation()
{
}
NS_IMETHODIMP
nsPerformanceNavigation::GetType(
nsDOMPerformanceNavigationType* aNavigationType)
{
- return mData->GetType(aNavigationType);
+ *aNavigationType = GetType();
+ return NS_OK;
}
NS_IMETHODIMP
nsPerformanceNavigation::GetRedirectCount(PRUint16* aRedirectCount)
{
- return mData->GetRedirectCount(aRedirectCount);
+ *aRedirectCount = GetRedirectCount();
+ return NS_OK;
+}
+
+JSObject*
+nsPerformanceNavigation::WrapObject(JSContext *cx, JSObject *scope,
+ bool *triedToWrap)
+{
+ return dom::PerformanceNavigationBinding::Wrap(cx, scope, this,
+ triedToWrap);
}
DOMCI_DATA(Performance, nsPerformance)
-NS_IMPL_ADDREF(nsPerformance)
-NS_IMPL_RELEASE(nsPerformance)
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_3(nsPerformance,
+ mWindow, mTiming,
+ mNavigation)
+NS_IMPL_CYCLE_COLLECTING_ADDREF(nsPerformance)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(nsPerformance)
-nsPerformance::nsPerformance(nsDOMNavigationTiming* aDOMTiming,
+nsPerformance::nsPerformance(nsIDOMWindow* aWindow,
+ nsDOMNavigationTiming* aDOMTiming,
nsITimedChannel* aChannel)
+ : mWindow(aWindow),
+ mDOMTiming(aDOMTiming),
+ mChannel(aChannel)
{
- NS_ASSERTION(aDOMTiming, "DOM timing data should be provided");
- mDOMTiming = aDOMTiming;
- mChannel = aChannel;
+ MOZ_ASSERT(aWindow, "Parent window object should be provided");
+ SetIsDOMBinding();
}
nsPerformance::~nsPerformance()
{
}
// QueryInterface implementation for nsPerformance
-NS_INTERFACE_MAP_BEGIN(nsPerformance)
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsPerformance)
+ NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDOMPerformance)
NS_INTERFACE_MAP_ENTRY(nsIDOMPerformance)
NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(Performance)
NS_INTERFACE_MAP_END
+
//
// nsIDOMPerformance methods
//
+
+nsPerformanceTiming*
+nsPerformance::GetTiming()
+{
+ if (!mTiming) {
+ mTiming = new nsPerformanceTiming(this, mChannel);
+ }
+ return mTiming;
+}
+
NS_IMETHODIMP
nsPerformance::GetTiming(nsIDOMPerformanceTiming** aTiming)
{
- if (!mTiming) {
- mTiming = new nsPerformanceTiming(mDOMTiming, mChannel);
+ nsRefPtr<nsPerformanceTiming> timing = GetTiming();
+ timing.forget(aTiming);
+ return NS_OK;
+}
+
+nsPerformanceNavigation*
+nsPerformance::GetNavigation()
+{
+ if (!mNavigation) {
+ mNavigation = new nsPerformanceNavigation(this);
}
- NS_IF_ADDREF(*aTiming = mTiming);
- return NS_OK;
+ return mNavigation;
}
NS_IMETHODIMP
nsPerformance::GetNavigation(nsIDOMPerformanceNavigation** aNavigation)
{
- if (!mNavigation) {
- mNavigation = new nsPerformanceNavigation(mDOMTiming);
- }
- NS_IF_ADDREF(*aNavigation = mNavigation);
+ nsRefPtr<nsPerformanceNavigation> navigation = GetNavigation();
+ navigation.forget(aNavigation);
return NS_OK;
}
NS_IMETHODIMP
nsPerformance::Now(DOMHighResTimeStamp* aNow)
{
- *aNow = mDOMTiming->TimeStampToDOMHighRes(mozilla::TimeStamp::Now());
+ *aNow = Now();
return NS_OK;
}
+DOMHighResTimeStamp
+nsPerformance::Now()
+{
+ return GetDOMTiming()->TimeStampToDOMHighRes(mozilla::TimeStamp::Now());
+}
+
+JSObject*
+nsPerformance::WrapObject(JSContext *cx, JSObject *scope,
+ bool *triedToWrap)
+{
+ return dom::PerformanceBinding::Wrap(cx, scope, this,
+ triedToWrap);
+}
+
--- a/dom/base/nsPerformance.h
+++ b/dom/base/nsPerformance.h
@@ -7,58 +7,177 @@
#include "nsIDOMPerformance.h"
#include "nsIDOMPerformanceTiming.h"
#include "nsIDOMPerformanceNavigation.h"
#include "nscore.h"
#include "nsCOMPtr.h"
#include "nsAutoPtr.h"
#include "mozilla/Attributes.h"
+#include "nsWrapperCache.h"
+#include "nsDOMNavigationTiming.h"
class nsIURI;
-class nsDOMNavigationTiming;
class nsITimedChannel;
+class nsPerformance;
+struct JSObject;
+struct JSContext;
// Script "performance.timing" object
-class nsPerformanceTiming MOZ_FINAL : public nsIDOMPerformanceTiming
+class nsPerformanceTiming MOZ_FINAL : public nsIDOMPerformanceTiming,
+ public nsWrapperCache
{
public:
- nsPerformanceTiming(nsDOMNavigationTiming* aDOMTiming, nsITimedChannel* aChannel);
- NS_DECL_ISUPPORTS
+ nsPerformanceTiming(nsPerformance* aPerformance,
+ nsITimedChannel* aChannel);
+ NS_DECL_CYCLE_COLLECTING_ISUPPORTS
NS_DECL_NSIDOMPERFORMANCETIMING
+ NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(nsPerformanceTiming)
+
+ nsDOMNavigationTiming* GetDOMTiming() const;
+
+ nsPerformance* GetParentObject() const
+ {
+ return mPerformance;
+ }
+
+ JSObject* WrapObject(JSContext *cx, JSObject *scope, bool *triedToWrap);
+
+ // PerformanceNavigation WebIDL methods
+ DOMTimeMilliSec GetNavigationStart() const {
+ return GetDOMTiming()->GetNavigationStart();
+ }
+ DOMTimeMilliSec GetUnloadEventStart() {
+ return GetDOMTiming()->GetUnloadEventStart();
+ }
+ DOMTimeMilliSec GetUnloadEventEnd() {
+ return GetDOMTiming()->GetUnloadEventEnd();
+ }
+ DOMTimeMilliSec GetRedirectStart() {
+ return GetDOMTiming()->GetRedirectStart();
+ }
+ DOMTimeMilliSec GetRedirectEnd() {
+ return GetDOMTiming()->GetRedirectEnd();
+ }
+ DOMTimeMilliSec GetFetchStart() const {
+ return GetDOMTiming()->GetFetchStart();
+ }
+ DOMTimeMilliSec GetDomainLookupStart() const;
+ DOMTimeMilliSec GetDomainLookupEnd() const;
+ DOMTimeMilliSec GetConnectStart() const;
+ DOMTimeMilliSec GetConnectEnd() const;
+ DOMTimeMilliSec GetRequestStart() const;
+ DOMTimeMilliSec GetResponseStart() const;
+ DOMTimeMilliSec GetResponseEnd() const;
+ DOMTimeMilliSec GetDomLoading() const {
+ return GetDOMTiming()->GetDomLoading();
+ }
+ DOMTimeMilliSec GetDomInteractive() const {
+ return GetDOMTiming()->GetDomInteractive();
+ }
+ DOMTimeMilliSec GetDomContentLoadedEventStart() const {
+ return GetDOMTiming()->GetDomContentLoadedEventStart();
+ }
+ DOMTimeMilliSec GetDomContentLoadedEventEnd() const {
+ return GetDOMTiming()->GetDomContentLoadedEventEnd();
+ }
+ DOMTimeMilliSec GetDomComplete() const {
+ return GetDOMTiming()->GetDomComplete();
+ }
+ DOMTimeMilliSec GetLoadEventStart() const {
+ return GetDOMTiming()->GetLoadEventStart();
+ }
+ DOMTimeMilliSec GetLoadEventEnd() const {
+ return GetDOMTiming()->GetLoadEventEnd();
+ }
+
private:
~nsPerformanceTiming();
- nsRefPtr<nsDOMNavigationTiming> mDOMTiming;
+ nsRefPtr<nsPerformance> mPerformance;
nsCOMPtr<nsITimedChannel> mChannel;
};
// Script "performance.navigation" object
-class nsPerformanceNavigation MOZ_FINAL : public nsIDOMPerformanceNavigation
+class nsPerformanceNavigation MOZ_FINAL : public nsIDOMPerformanceNavigation,
+ public nsWrapperCache
{
public:
- nsPerformanceNavigation(nsDOMNavigationTiming* data);
- NS_DECL_ISUPPORTS
+ explicit nsPerformanceNavigation(nsPerformance* aPerformance);
+ NS_DECL_CYCLE_COLLECTING_ISUPPORTS
NS_DECL_NSIDOMPERFORMANCENAVIGATION
+ NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(nsPerformanceNavigation)
+
+ nsDOMNavigationTiming* GetDOMTiming() const;
+
+ nsPerformance* GetParentObject() const
+ {
+ return mPerformance;
+ }
+
+ JSObject* WrapObject(JSContext *cx, JSObject *scope, bool *triedToWrap);
+
+ // PerformanceNavigation WebIDL methods
+ PRUint16 GetType() const {
+ return GetDOMTiming()->GetType();
+ }
+ PRUint16 GetRedirectCount() const {
+ return GetDOMTiming()->GetRedirectCount();
+ }
+
private:
~nsPerformanceNavigation();
- nsRefPtr<nsDOMNavigationTiming> mData;
+ nsRefPtr<nsPerformance> mPerformance;
};
// Script "performance" object
-class nsPerformance MOZ_FINAL : public nsIDOMPerformance
+class nsPerformance MOZ_FINAL : public nsIDOMPerformance,
+ public nsWrapperCache
{
public:
- nsPerformance(nsDOMNavigationTiming* aDOMTiming, nsITimedChannel* aChannel);
+ nsPerformance(nsIDOMWindow* aWindow,
+ nsDOMNavigationTiming* aDOMTiming,
+ nsITimedChannel* aChannel);
+
+ NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+ NS_DECL_NSIDOMPERFORMANCE
+ NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(nsPerformance)
- NS_DECL_ISUPPORTS
- NS_DECL_NSIDOMPERFORMANCE
+ nsDOMNavigationTiming* GetDOMTiming() const
+ {
+ return mDOMTiming;
+ }
+
+ nsIDOMWindow* GetParentObject() const
+ {
+ return mWindow.get();
+ }
+
+ JSObject* WrapObject(JSContext *cx, JSObject *scope, bool *triedToWrap);
+
+ // Performance WebIDL methods
+ DOMHighResTimeStamp Now();
+ nsPerformanceTiming* GetTiming();
+ nsPerformanceNavigation* GetNavigation();
private:
~nsPerformance();
+ nsCOMPtr<nsIDOMWindow> mWindow;
nsRefPtr<nsDOMNavigationTiming> mDOMTiming;
nsCOMPtr<nsITimedChannel> mChannel;
- nsCOMPtr<nsIDOMPerformanceTiming> mTiming;
- nsCOMPtr<nsIDOMPerformanceNavigation> mNavigation;
+ nsRefPtr<nsPerformanceTiming> mTiming;
+ nsRefPtr<nsPerformanceNavigation> mNavigation;
};
+inline nsDOMNavigationTiming*
+nsPerformanceNavigation::GetDOMTiming() const
+{
+ return mPerformance->GetDOMTiming();
+}
+
+inline nsDOMNavigationTiming*
+nsPerformanceTiming::GetDOMTiming() const
+{
+ return mPerformance->GetDOMTiming();
+}
+
#endif /* nsPerformance_h___ */
--- a/dom/base/nsWrapperCache.h
+++ b/dom/base/nsWrapperCache.h
@@ -259,9 +259,27 @@ NS_DEFINE_STATIC_IID_ACCESSOR(nsWrapperC
NS_IMPL_CYCLE_COLLECTION_UNLINK_END \
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(_class) \
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_field1) \
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_field2) \
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_SCRIPT_OBJECTS \
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END \
NS_IMPL_CYCLE_COLLECTION_TRACE_WRAPPERCACHE(_class)
+#define NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_3(_class, _field1,\
+ _field2, \
+ _field3) \
+ NS_IMPL_CYCLE_COLLECTION_CLASS(_class) \
+ NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(_class) \
+ NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(_field1) \
+ NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(_field2) \
+ NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(_field3) \
+ NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER \
+ NS_IMPL_CYCLE_COLLECTION_UNLINK_END \
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(_class) \
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_field1) \
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_field2) \
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(_field3) \
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_SCRIPT_OBJECTS \
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END \
+ NS_IMPL_CYCLE_COLLECTION_TRACE_WRAPPERCACHE(_class)
+
#endif /* nsWrapperCache_h___ */
--- a/dom/bindings/Bindings.conf
+++ b/dom/bindings/Bindings.conf
@@ -183,16 +183,31 @@ DOMInterfaces = {
},
{
'workers': True,
'nativeType': 'JSObject',
'headerFile': 'jsapi.h',
'castable': False
}],
+'Performance': {
+ 'nativeType': 'nsPerformance',
+ 'resultNotAddRefed': [ 'timing', 'navigation' ]
+},
+
+'PerformanceTiming': {
+ 'nativeType': 'nsPerformanceTiming',
+ 'headerFile': 'nsPerformance.h'
+},
+
+'PerformanceNavigation': {
+ 'nativeType': 'nsPerformanceNavigation',
+ 'headerFile': 'nsPerformance.h'
+},
+
'WebGLRenderingContext': {
'nativeType': 'mozilla::WebGLContext',
'headerFile': 'WebGLContext.h',
'prefable': True,
'resultNotAddRefed': [ 'canvas', 'getContextAttributes', 'getExtension',
'getAttachedShaders' ],
'implicitJSContext': [ 'texImage2D', 'texSubImage2D' ],
},
new file mode 100644
--- /dev/null
+++ b/dom/webidl/Performance.webidl
@@ -0,0 +1,24 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * The origin of this IDL file is
+ * http://www.w3.org/TR/hr-time/
+ *
+ * Copyright © 2012 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C
+ * liability, trademark and document use rules apply.
+ */
+
+// typedef double DOMHighResTimeStamp;
+
+interface Performance {
+ // DOMHighResTimeStamp now();
+ [Infallible]
+ double now();
+
+ [Infallible]
+ readonly attribute PerformanceTiming timing;
+ [Infallible]
+ readonly attribute PerformanceNavigation navigation;
+};
new file mode 100644
--- /dev/null
+++ b/dom/webidl/PerformanceNavigation.webidl
@@ -0,0 +1,22 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * The origin of this IDL file is
+ * http://www.w3.org/TR/hr-time/
+ *
+ * Copyright © 2012 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C
+ * liability, trademark and document use rules apply.
+ */
+
+interface PerformanceNavigation {
+ const unsigned short TYPE_NAVIGATE = 0;
+ const unsigned short TYPE_RELOAD = 1;
+ const unsigned short TYPE_BACK_FORWARD = 2;
+ const unsigned short TYPE_RESERVED = 255;
+ [Infallible]
+ readonly attribute unsigned short type;
+ [Infallible]
+ readonly attribute unsigned short redirectCount;
+};
new file mode 100644
--- /dev/null
+++ b/dom/webidl/PerformanceTiming.webidl
@@ -0,0 +1,56 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * The origin of this IDL file is
+ * http://www.w3.org/TR/hr-time/
+ *
+ * Copyright © 2012 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C
+ * liability, trademark and document use rules apply.
+ */
+
+interface PerformanceTiming {
+ [Infallible]
+ readonly attribute unsigned long long navigationStart;
+ [Infallible]
+ readonly attribute unsigned long long unloadEventStart;
+ [Infallible]
+ readonly attribute unsigned long long unloadEventEnd;
+ [Infallible]
+ readonly attribute unsigned long long redirectStart;
+ [Infallible]
+ readonly attribute unsigned long long redirectEnd;
+ [Infallible]
+ readonly attribute unsigned long long fetchStart;
+ [Infallible]
+ readonly attribute unsigned long long domainLookupStart;
+ [Infallible]
+ readonly attribute unsigned long long domainLookupEnd;
+ [Infallible]
+ readonly attribute unsigned long long connectStart;
+ [Infallible]
+ readonly attribute unsigned long long connectEnd;
+ // [Infallible]
+ // readonly attribute unsigned long long secureConnectionStart;
+ [Infallible]
+ readonly attribute unsigned long long requestStart;
+ [Infallible]
+ readonly attribute unsigned long long responseStart;
+ [Infallible]
+ readonly attribute unsigned long long responseEnd;
+ [Infallible]
+ readonly attribute unsigned long long domLoading;
+ [Infallible]
+ readonly attribute unsigned long long domInteractive;
+ [Infallible]
+ readonly attribute unsigned long long domContentLoadedEventStart;
+ [Infallible]
+ readonly attribute unsigned long long domContentLoadedEventEnd;
+ [Infallible]
+ readonly attribute unsigned long long domComplete;
+ [Infallible]
+ readonly attribute unsigned long long loadEventStart;
+ [Infallible]
+ readonly attribute unsigned long long loadEventEnd;
+};
--- a/dom/webidl/WebIDL.mk
+++ b/dom/webidl/WebIDL.mk
@@ -4,16 +4,19 @@
webidl_base = $(topsrcdir)/dom/webidl
webidl_files = \
CanvasRenderingContext2D.webidl \
Function.webidl \
EventListener.webidl \
EventTarget.webidl \
+ Performance.webidl \
+ PerformanceNavigation.webidl \
+ PerformanceTiming.webidl \
XMLHttpRequest.webidl \
XMLHttpRequestEventTarget.webidl \
XMLHttpRequestUpload.webidl \
$(NULL)
ifdef MOZ_WEBGL
webidl_files += \
WebGLRenderingContext.webidl \
--- a/js/xpconnect/src/dom_quickstubs.qsconf
+++ b/js/xpconnect/src/dom_quickstubs.qsconf
@@ -454,21 +454,16 @@ members = [
'nsIIDBObjectStore.*',
'nsIIDBRequest.*',
'nsIIDBTransaction.*',
'nsIIDBOpenDBRequest.*',
'nsIIDBVersionChangeEvent.*',
'nsIIndexedDatabaseUsageCallback.*',
'nsIIndexedDatabaseManager.*',
- # Performance
- 'nsIDOMPerformance.*',
- 'nsIDOMPerformanceTiming.*',
- 'nsIDOMPerformanceNavigation.*',
-
'nsIDOMDOMError.*',
# dom/file
'nsIDOMFileHandle.*',
'-nsIDOMFileHandle.getFileId',
'-nsIDOMFileHandle.getFileInfo',
'nsIDOMFileRequest.*',
'nsIDOMLockedFile.*',