The Tor Browser: dom/base/nsPerformance.cpp@6474c204b198 (annotated)

dom/base/nsPerformance.cpp@6474c204b198 (annotated)

dom/base/nsPerformance.cpp

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- Mode: C++; 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/. */
 #include "nsPerformance.h"
 #include "nsCOMPtr.h"
 #include "nsIHttpChannel.h"
 #include "nsITimedChannel.h"
 #include "nsDOMNavigationTiming.h"
 #include "nsContentUtils.h"
 #include "nsIScriptSecurityManager.h"
 #include "nsIDOMWindow.h"
 #include "nsIURI.h"
 #include "PerformanceEntry.h"
 #include "PerformanceResourceTiming.h"
 #include "mozilla/dom/PerformanceBinding.h"
 #include "mozilla/dom/PerformanceTimingBinding.h"
 #include "mozilla/dom/PerformanceNavigationBinding.h"
 #include "mozilla/TimeStamp.h"
 #include "nsThreadUtils.h"
 using namespace mozilla;
 NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_1(nsPerformanceTiming, mPerformance)
 NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(nsPerformanceTiming, AddRef)
 NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(nsPerformanceTiming, Release)
 nsPerformanceTiming::nsPerformanceTiming(nsPerformance* aPerformance,
                                          nsITimedChannel* aChannel,
                                          nsIHttpChannel* aHttpChannel,
                                          DOMHighResTimeStamp aZeroTime)
   : mPerformance(aPerformance),
     mChannel(aChannel),
     mFetchStart(0.0),
     mZeroTime(aZeroTime),
     mReportCrossOriginResources(true)
 {
   MOZ_ASSERT(aPerformance, "Parent performance object should be provided");
   SetIsDOMBinding();
   if (!nsContentUtils::IsPerformanceTimingEnabled()) {
     mZeroTime = 0;
   }
  // The aHttpChannel argument is null if this nsPerformanceTiming object
   // is being used for the navigation timing (document) and has a non-null
   // value for the resource timing (any resources within the page).
   if (aHttpChannel) {
     CheckRedirectCrossOrigin(aHttpChannel);
   }
 }
 nsPerformanceTiming::~nsPerformanceTiming()
 {
 }
 DOMHighResTimeStamp
 nsPerformanceTiming::FetchStartHighRes()
 {
   if (!mFetchStart) {
     if (!nsContentUtils::IsPerformanceTimingEnabled() || !IsInitialized()) {
       return mZeroTime;
     }
     TimeStamp stamp;
     mChannel->GetAsyncOpen(&stamp);
     MOZ_ASSERT(!stamp.IsNull(), "The fetch start time stamp should always be "
         "valid if the performance timing is enabled");
     mFetchStart = (!stamp.IsNull())
         ? TimeStampToDOMHighRes(stamp)
         : 0.0;
   }
   return mFetchStart;
 }
 DOMTimeMilliSec
 nsPerformanceTiming::FetchStart()
 {
   return static_cast<int64_t>(FetchStartHighRes());
 }
 // This method will implement the timing allow check algorithm
 // http://w3c-test.org/webperf/specs/ResourceTiming/#timing-allow-check
 // https://bugzilla.mozilla.org/show_bug.cgi?id=936814
 void
 nsPerformanceTiming::CheckRedirectCrossOrigin(nsIHttpChannel* aResourceChannel)
 {
   if (!IsInitialized()) {
     return;
   }
   uint16_t redirectCount;
   mChannel->GetRedirectCount(&redirectCount);
   if (redirectCount == 0) {
     return;
   }
   nsCOMPtr<nsIURI> resourceURI, referrerURI;
   aResourceChannel->GetReferrer(getter_AddRefs(referrerURI));
   aResourceChannel->GetURI(getter_AddRefs(resourceURI));
   nsIScriptSecurityManager* ssm = nsContentUtils::GetSecurityManager();
   nsresult rv = ssm->CheckSameOriginURI(resourceURI, referrerURI, false);
   if (!NS_SUCCEEDED(rv)) {
     mReportCrossOriginResources = false;
   }
 }
 bool
 nsPerformanceTiming::IsSameOriginAsReferral() const
 {
   return mReportCrossOriginResources;
 }
 uint16_t
 nsPerformanceTiming::GetRedirectCount() const
 {
   if (!nsContentUtils::IsPerformanceTimingEnabled() || !IsInitialized()) {
     return 0;
   }
   bool sameOrigin;
   mChannel->GetAllRedirectsSameOrigin(&sameOrigin);
   if (!sameOrigin) {
     return 0;
   }
   uint16_t redirectCount;
   mChannel->GetRedirectCount(&redirectCount);
   return redirectCount;
 }
 /**
  * RedirectStartHighRes() is used by both the navigation timing and the
  * resource timing. Since, navigation timing and resource timing check and
  * interpret cross-domain redirects in a different manner,
  * RedirectStartHighRes() will make no checks for cross-domain redirect.
  * It's up to the consumers of this method (nsPerformanceTiming::RedirectStart()
  * and PerformanceResourceTiming::RedirectStart() to make such verifications.
  *
  * @return a valid timing if the Performance Timing is enabled
  */
 DOMHighResTimeStamp
 nsPerformanceTiming::RedirectStartHighRes()
 {
   if (!nsContentUtils::IsPerformanceTimingEnabled() || !IsInitialized()) {
     return mZeroTime;
   }
   mozilla::TimeStamp stamp;
   mChannel->GetRedirectStart(&stamp);
   return TimeStampToDOMHighResOrFetchStart(stamp);
 }
 DOMTimeMilliSec
 nsPerformanceTiming::RedirectStart()
 {
   if (!IsInitialized()) {
     return mZeroTime;
   }
   // We have to check if all the redirect URIs had the same origin (since there
   // is no check in RedirectStartHighRes())
   bool sameOrigin;
   mChannel->GetAllRedirectsSameOrigin(&sameOrigin);
   if (sameOrigin) {
     return static_cast<int64_t>(RedirectStartHighRes());
   }
   return 0;
 }
 /**
  * RedirectEndHighRes() is used by both the navigation timing and the resource
  * timing. Since, navigation timing and resource timing check and interpret
  * cross-domain redirects in a different manner, RedirectEndHighRes() will make
  * no checks for cross-domain redirect. It's up to the consumers of this method
  * (nsPerformanceTiming::RedirectEnd() and
  * PerformanceResourceTiming::RedirectEnd() to make such verifications.
  *
  * @return a valid timing if the Performance Timing is enabled
  */
 DOMHighResTimeStamp
 nsPerformanceTiming::RedirectEndHighRes()
 {
   if (!nsContentUtils::IsPerformanceTimingEnabled() || !IsInitialized()) {
     return mZeroTime;
   }
   mozilla::TimeStamp stamp;
   mChannel->GetRedirectEnd(&stamp);
   return TimeStampToDOMHighResOrFetchStart(stamp);
 }
 DOMTimeMilliSec
 nsPerformanceTiming::RedirectEnd()
 {
   if (!IsInitialized()) {
     return mZeroTime;
   }
   // We have to check if all the redirect URIs had the same origin (since there
   // is no check in RedirectEndHighRes())
   bool sameOrigin;
   mChannel->GetAllRedirectsSameOrigin(&sameOrigin);
   if (sameOrigin) {
     return static_cast<int64_t>(RedirectEndHighRes());
   }
   return 0;
 }
 DOMHighResTimeStamp
 nsPerformanceTiming::DomainLookupStartHighRes()
 {
   if (!nsContentUtils::IsPerformanceTimingEnabled() || !IsInitialized()) {
     return mZeroTime;
   }
   mozilla::TimeStamp stamp;
   mChannel->GetDomainLookupStart(&stamp);
   return TimeStampToDOMHighResOrFetchStart(stamp);
 }
 DOMTimeMilliSec
 nsPerformanceTiming::DomainLookupStart()
 {
   return static_cast<int64_t>(DomainLookupStartHighRes());
 }
 DOMHighResTimeStamp
 nsPerformanceTiming::DomainLookupEndHighRes()
 {
   if (!nsContentUtils::IsPerformanceTimingEnabled() || !IsInitialized()) {
     return mZeroTime;
   }
   mozilla::TimeStamp stamp;
   mChannel->GetDomainLookupEnd(&stamp);
   return TimeStampToDOMHighResOrFetchStart(stamp);
 }
 DOMTimeMilliSec
 nsPerformanceTiming::DomainLookupEnd()
 {
   return static_cast<int64_t>(DomainLookupEndHighRes());
 }
 DOMHighResTimeStamp
 nsPerformanceTiming::ConnectStartHighRes()
 {
   if (!nsContentUtils::IsPerformanceTimingEnabled() || !IsInitialized()) {
     return mZeroTime;
   }
   mozilla::TimeStamp stamp;
   mChannel->GetConnectStart(&stamp);
   return TimeStampToDOMHighResOrFetchStart(stamp);
 }
 DOMTimeMilliSec
 nsPerformanceTiming::ConnectStart()
 {
   return static_cast<int64_t>(ConnectStartHighRes());
 }
 DOMHighResTimeStamp
 nsPerformanceTiming::ConnectEndHighRes()
 {
   if (!nsContentUtils::IsPerformanceTimingEnabled() || !IsInitialized()) {
     return mZeroTime;
   }
   mozilla::TimeStamp stamp;
   mChannel->GetConnectEnd(&stamp);
   return TimeStampToDOMHighResOrFetchStart(stamp);
 }
 DOMTimeMilliSec
 nsPerformanceTiming::ConnectEnd()
 {
   return static_cast<int64_t>(ConnectEndHighRes());
 }
 DOMHighResTimeStamp
 nsPerformanceTiming::RequestStartHighRes()
 {
   if (!nsContentUtils::IsPerformanceTimingEnabled() || !IsInitialized()) {
     return mZeroTime;
   }
   mozilla::TimeStamp stamp;
   mChannel->GetRequestStart(&stamp);
   return TimeStampToDOMHighResOrFetchStart(stamp);
 }
 DOMTimeMilliSec
 nsPerformanceTiming::RequestStart()
 {
   return static_cast<int64_t>(RequestStartHighRes());
 }
 DOMHighResTimeStamp
 nsPerformanceTiming::ResponseStartHighRes()
 {
   if (!nsContentUtils::IsPerformanceTimingEnabled() || !IsInitialized()) {
     return mZeroTime;
   }
   mozilla::TimeStamp stamp;
   mChannel->GetResponseStart(&stamp);
   mozilla::TimeStamp cacheStamp;
   mChannel->GetCacheReadStart(&cacheStamp);
   if (stamp.IsNull() || (!cacheStamp.IsNull() && cacheStamp < stamp)) {
     stamp = cacheStamp;
   }
   return TimeStampToDOMHighResOrFetchStart(stamp);
 }
 DOMTimeMilliSec
 nsPerformanceTiming::ResponseStart()
 {
   return static_cast<int64_t>(ResponseStartHighRes());
 }
 DOMHighResTimeStamp
 nsPerformanceTiming::ResponseEndHighRes()
 {
   if (!nsContentUtils::IsPerformanceTimingEnabled() || !IsInitialized()) {
     return mZeroTime;
   }
   mozilla::TimeStamp stamp;
   mChannel->GetResponseEnd(&stamp);
   mozilla::TimeStamp cacheStamp;
   mChannel->GetCacheReadEnd(&cacheStamp);
   if (stamp.IsNull() || (!cacheStamp.IsNull() && cacheStamp < stamp)) {
     stamp = cacheStamp;
   }
   return TimeStampToDOMHighResOrFetchStart(stamp);
 }
 DOMTimeMilliSec
 nsPerformanceTiming::ResponseEnd()
 {
   return static_cast<int64_t>(ResponseEndHighRes());
 }
 bool
 nsPerformanceTiming::IsInitialized() const
 {
   return !!mChannel;
 }
 JSObject*
 nsPerformanceTiming::WrapObject(JSContext *cx)
 {
   return dom::PerformanceTimingBinding::Wrap(cx, this);
 }
 NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_1(nsPerformanceNavigation, mPerformance)
 NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(nsPerformanceNavigation, AddRef)
 NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(nsPerformanceNavigation, Release)
 nsPerformanceNavigation::nsPerformanceNavigation(nsPerformance* aPerformance)
   : mPerformance(aPerformance)
 {
   MOZ_ASSERT(aPerformance, "Parent performance object should be provided");
   SetIsDOMBinding();
 }
 nsPerformanceNavigation::~nsPerformanceNavigation()
 {
 }
 JSObject*
 nsPerformanceNavigation::WrapObject(JSContext *cx)
 {
   return dom::PerformanceNavigationBinding::Wrap(cx, this);
 }
 NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_5(nsPerformance,
                                         mWindow, mTiming,
                                         mNavigation, mEntries,
                                         mParentPerformance)
 NS_IMPL_CYCLE_COLLECTING_ADDREF(nsPerformance)
 NS_IMPL_CYCLE_COLLECTING_RELEASE(nsPerformance)
 nsPerformance::nsPerformance(nsIDOMWindow* aWindow,
                              nsDOMNavigationTiming* aDOMTiming,
                              nsITimedChannel* aChannel,
                              nsPerformance* aParentPerformance)
   : mWindow(aWindow),
     mDOMTiming(aDOMTiming),
     mChannel(aChannel),
     mParentPerformance(aParentPerformance),
     mBufferSizeSet(kDefaultBufferSize),
     mPrimaryBufferSize(kDefaultBufferSize)
 {
   MOZ_ASSERT(aWindow, "Parent window object should be provided");
   SetIsDOMBinding();
 }
 nsPerformance::~nsPerformance()
 {
 }
 // QueryInterface implementation for nsPerformance
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsPerformance)
   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
   NS_INTERFACE_MAP_ENTRY(nsISupports)
 NS_INTERFACE_MAP_END
 nsPerformanceTiming*
 nsPerformance::Timing()
 {
   if (!mTiming) {
     // For navigation timing, the third argument (an nsIHtttpChannel) is null
     // since the cross-domain redirect were already checked.
     // The last argument (zero time) for performance.timing is the navigation
     // start value.
     mTiming = new nsPerformanceTiming(this, mChannel, nullptr,
         mDOMTiming->GetNavigationStart());
   }
   return mTiming;
 }
 nsPerformanceNavigation*
 nsPerformance::Navigation()
 {
   if (!mNavigation) {
     mNavigation = new nsPerformanceNavigation(this);
   }
   return mNavigation;
 }
 DOMHighResTimeStamp
 nsPerformance::Now()
 {
   return GetDOMTiming()->TimeStampToDOMHighRes(mozilla::TimeStamp::Now());
 }
 JSObject*
 nsPerformance::WrapObject(JSContext *cx)
 {
   return dom::PerformanceBinding::Wrap(cx, this);
 }
 void
 nsPerformance::GetEntries(nsTArray<nsRefPtr<PerformanceEntry> >& retval)
 {
   MOZ_ASSERT(NS_IsMainThread());
   retval.Clear();
   uint32_t count = mEntries.Length();
   if (count > mPrimaryBufferSize) {
     count = mPrimaryBufferSize;
   }
   retval.AppendElements(mEntries.Elements(), count);
 }
 void
 nsPerformance::GetEntriesByType(const nsAString& entryType,
                                 nsTArray<nsRefPtr<PerformanceEntry> >& retval)
 {
   MOZ_ASSERT(NS_IsMainThread());
   retval.Clear();
   uint32_t count = mEntries.Length();
   for (uint32_t i = 0 ; i < count && i < mPrimaryBufferSize ; i++) {
     if (mEntries[i]->GetEntryType().Equals(entryType)) {
       retval.AppendElement(mEntries[i]);
     }
   }
 }
 void
 nsPerformance::GetEntriesByName(const nsAString& name,
                                 const mozilla::dom::Optional<nsAString>& entryType,
                                 nsTArray<nsRefPtr<PerformanceEntry> >& retval)
 {
   MOZ_ASSERT(NS_IsMainThread());
   retval.Clear();
   uint32_t count = mEntries.Length();
   for (uint32_t i = 0 ; i < count && i < mPrimaryBufferSize ; i++) {
     if (mEntries[i]->GetName().Equals(name) &&
         (!entryType.WasPassed() ||
          mEntries[i]->GetEntryType().Equals(entryType.Value()))) {
       retval.AppendElement(mEntries[i]);
     }
   }
 }
 void
 nsPerformance::ClearResourceTimings()
 {
   MOZ_ASSERT(NS_IsMainThread());
   mPrimaryBufferSize = mBufferSizeSet;
   mEntries.Clear();
 }
 void
 nsPerformance::SetResourceTimingBufferSize(uint64_t maxSize)
 {
   MOZ_ASSERT(NS_IsMainThread());
   mBufferSizeSet = maxSize;
   if (mBufferSizeSet < mEntries.Length()) {
     // call onresourcetimingbufferfull
     // https://bugzilla.mozilla.org/show_bug.cgi?id=936813
   }
 }
 /**
  * An entry should be added only after the resource is loaded.
  * This method is not thread safe and can only be called on the main thread.
  */
 void
 nsPerformance::AddEntry(nsIHttpChannel* channel,
                         nsITimedChannel* timedChannel)
 {
   MOZ_ASSERT(NS_IsMainThread());
   // Check if resource timing is prefed off.
   if (!nsContentUtils::IsResourceTimingEnabled()) {
     return;
   }
   if (channel && timedChannel) {
     nsAutoCString name;
     nsAutoString initiatorType;
     nsCOMPtr<nsIURI> originalURI;
     timedChannel->GetInitiatorType(initiatorType);
     // According to the spec, "The name attribute must return the resolved URL
     // of the requested resource. This attribute must not change even if the
     // fetch redirected to a different URL."
     channel->GetOriginalURI(getter_AddRefs(originalURI));
     originalURI->GetSpec(name);
     NS_ConvertUTF8toUTF16 entryName(name);
     // The nsITimedChannel argument will be used to gather all the timings.
     // The nsIHttpChannel argument will be used to check if any cross-origin
     // redirects occurred.
     // The last argument is the "zero time" (offset). Since we don't want
     // any offset for the resource timing, this will be set to "0" - the
     // resource timing returns a relative timing (no offset).
     nsRefPtr<nsPerformanceTiming> performanceTiming =
         new nsPerformanceTiming(this, timedChannel, channel,
 );
     // The PerformanceResourceTiming object will use the nsPerformanceTiming
     // object to get all the required timings.
     nsRefPtr<dom::PerformanceResourceTiming> performanceEntry =
         new dom::PerformanceResourceTiming(performanceTiming, this);
     performanceEntry->SetName(entryName);
     performanceEntry->SetEntryType(NS_LITERAL_STRING("resource"));
     // If the initiator type had no valid value, then set it to the default
     // ("other") value.
     if (initiatorType.IsEmpty()) {
       initiatorType = NS_LITERAL_STRING("other");
     }
     performanceEntry->SetInitiatorType(initiatorType);
     mEntries.InsertElementSorted(performanceEntry,
         PerformanceEntryComparator());
     if (mEntries.Length() > mPrimaryBufferSize) {
       // call onresourcetimingbufferfull
       // https://bugzilla.mozilla.org/show_bug.cgi?id=936813
     }
   }
 }
 bool
 nsPerformance::PerformanceEntryComparator::Equals(
     const PerformanceEntry* aElem1,
     const PerformanceEntry* aElem2) const
 {
   NS_ABORT_IF_FALSE(aElem1 && aElem2,
       "Trying to compare null performance entries");
   return aElem1->StartTime() == aElem2->StartTime();
 }
 bool
 nsPerformance::PerformanceEntryComparator::LessThan(
     const PerformanceEntry* aElem1,
     const PerformanceEntry* aElem2) const
 {
   NS_ABORT_IF_FALSE(aElem1 && aElem2,
       "Trying to compare null performance entries");
   return aElem1->StartTime() < aElem2->StartTime();
 }

The Tor Browser / annotate

dom/base/nsPerformance.cpp@6474c204b198 (annotated)

dom/base/nsPerformance.cpp