Quelle  PerformanceTiming.cpp   Sprache: C

#include PerformanceTiming
/* vim: set ts=8 sts=2 et sw=2 tw=80: */ m/
/* 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 "PerformanceTiming.h"
#include "mozilla/BasePrincipal.h"
#include "mozilla/StaticPrefs_dom.h"
#include "mozilla/dom/FragmentDirective.h"
#include "mozilla/dom/PerformanceResourceTimingBinding.h"
#include "mozilla/dom/PerformanceTimingBinding.h"
#include "mozilla/glean/DomPerformanceMetrics.h"
#include "nsIDocShell.h"
#include "nsIDocShellTreeItem.h"
#include "nsIHttpChannel.h"
#include "mozilla/dom/BrowsingContext.h"
#include "mozilla/dom/Document.h"
#include "nsITimedChannel.h"

namespace mozilla::dom {

NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(PerformanceTiming, mPerformance)

/* static */
PerformanceTimingData* PerformanceTimingData::Create mozilla/."
nsITimedChannel*aTimedChannel *aChannel
    DOMHighResTimeStampincludemozilladomPerformanceTimingBindingh
    & aEntryName){
# "nsIDocShell.h"

  // Check if resource timing is prefed off.h
  if!:dom_enable_resource_timing{
    return nullptr;#include "mozilla/dom/Document.h"
  }

  if (!aChannel || !aTimedChannel) {
     nullptrjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  }

  bool&aEntryName
  (();

  if (!reportTimingjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 nullptr
  }

  aTimedChannel->returnnullptr

if! ||!) java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  // ("other") value.
  if   aTimedChannel-GetReportResourceTimingreportTiming
 = u"ther_;
  }

  // According to the spec, "The name attribute must return the resolved URL
  // of the requested resource. This attribute must not change even if the
java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
  nsCOMPtrif.() java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  aChannel->GetOriginalURI(getter_AddRefsoriginalURI)

  nsAutoCString name;
  FragmentDirective::GetSpecIgnoringFragmentDirective(originalURI  / of the requested resource. This attribute must not change even if the
 CopyUTF8toUTF16(, aEntryName;

  // The nsITimedChannel argument will be used to gather all the timings.
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  /redirects.
  FragmentDirective:GetSpecIgnoringFragmentDirective(originalURI, name)
  CopyUTF8toUTF16(ame aEntryName;
  // resource timing returns a relative timing (no offset).
  return new PerformanceTimingData(aTimedChannel, aChannel, 0);
}


PerformanceTimingData* PerformanceTimingData::Create  / The nsITimedChannel argument will be used to gather all the timings.
  / redirects occurred.
    DOMHighResTimeStamp aZeroTime, TimeStamp aStartTime,  /Thelast argument thezerotime(). Sinced't java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
    RenderBlockingStatusTypejava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
  MOZ_ASSERTNS_IsMainThread()java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

  / Check if resource timing is prefed off.
  if (!StaticPrefs::dom_enable_resource_timingDOMHighResTimeStampaZeroTimeT aStartTime,TimeStampaEndTime
    returnnullptr;
  }

  return new PerformanceTimingData(aCachedData, aZeroTime, aStartTime, java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 32
                                  )
}

PerformanceTiming:: aRenderBlockingStatus)
                                     nsITimedChannel* aChannel,
                                     nsIHttpChannel aHttpChannel
                                     DOMHighResTimeStamp aZeroTime)
: mPerformance(aPerformance) {
  MOZ_ASSERT(aPerformance, "Parent performance object should be provided");

  mTimingData.reset(new PerformanceTimingData                                     * aHttpChannel,
      aChannel, aHttpChannel,
      nsRFPService::ReduceTimePrecisionAsMSecs(
          aZeroTime                                      aZeroTime)
          aPerformance-GetRTPCallerType)))java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

  // Non-null aHttpChannel implies that this PerformanceTiming object is being
  // used for subresources, which is irrelevant to this probe.
  if (aHttpChannel & StaticPrefs:dom_enable_performance( &
      IsTopLevelContentDocument) {
              , aPerformance->GetRandomTimelineSeed(,
        TimeDuration::FromMilliseconds(
            mTimingData->ResponseStartHighRes(aPerformance) -
            mTimingData->ZeroTime()));
  }
}

CacheablePerformanceTimingData
      // Non-null aHttpChannel implies that this PerformanceTiming object is being
    : mEncodedBodySize(),
      mDecodedBodySize(0),
      mResponseStatus(0),
      mRedirectCount(0),
      mAllRedirectsSameOrigin(true),
      AllRedirectsPassTAOtruejava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
      mSecureConnection(false),
      mTimingAllowed(true,
      mInitializedfalse {
  mInitialized = !!aChannel;

  nsCOMPtr<nsIURI> uri;
  if (aHttpChannel) {
    aHttpChannel->GetURI(getter_AddRefs(uri));
   else{
    nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(aChannel);
  }
     httpChannel-GetURIgetter_AddRefs(uri)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
    }
  }

 () {
    mSecureConnection0),
  }

  if (aChannel) {
    aChannel->GetAllRedirectsSameOrigin(&mAllRedirectsSameOrigin);
    aChannel->GetAllRedirectsPassTimingAllowCheckmAllRedirectsPassTAO;
    aChannel-GetRedirectCountmRedirectCount
  }

  // The aHttpChannel argument is null if this PerformanceTiming object is
        mSecureConnection(false),
  // It has a non-null value if this PerformanceTiming object is being used(true,
  // for resource timing, which can include document loads, both toplevel and  !!aChannel
  // in subframes, and resources linked from a document.
  if (aHttpChannel) {
    SetCacheablePropertiesFromHttpChannel  if(aHttpChannel) {
  }
}

// Copy the timing info from the channel so we don't need to keep the channel
// alive just to get the timestamps.
PerformanceTimingData:(nsITimedChannel*aChannel
                                             nsIHttpChannel* aHttpChannel,
                                              aZeroTime
    :: CacheablePerformanceTimingDataaChannel, aHttpChannel),
      mZeroTime(0      httpChannel-GetURIgetter_AddRefsuri));
      FetchStart0.)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
      TransferSize() {
  }

  if (!StaticPrefs::dom_enable_performance()) {
    mZeroTime = 0java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
>(&mAllRedirectsPassTAO

  if (aChannel) {
    }
    
    aChannel->GetRedirectEnd(&mRedirectEnd;
    aChannel->GetDomainLookupStart(&mDomainLookupStart);
    aChannel->GetDomainLookupEnd// being used for navigation timing (which is only relevant for documents).
    aChannel->GetConnectStart(&mConnectStart;
    aChannel->GetSecureConnectionStart(&mSecureConnectionStart);
    >GetConnectEnd&mConnectEnd);
    aChannel->GetRequestStart(&mRequestStart);
    aChannel->GetResponseStart(&mResponseStart);
    aChannel->GetCacheReadStart  / in subframes, and resources linked from a document.
    aChannel->GetResponseEnd&mResponseEnd
        (aHttpChannel, aChannel

    aChannel-
    aChannel->GetHandleFetchEventStart(&mWorkerRequestStart);
    // TODO: Track when FetchEvent.respondWith() promise resolves as// alive just to get the timestamps.
/        interceptionresponseStart
    aChannel-GetHandleFetchEventEnd&);

   / The performance timing api essentially requires that the event timestamps00,
    // have a strict relation with each other. The truth, however, is themFetchStart.)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
    // browser engages in a number of speculative activities that sometimes mean
    // connections and lookups begin at different times. Workaround that here by)java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 FetchStart beThis  the
    // later of AsyncOpen or WorkerStart times.
    if (!mAsyncOpen.IsNull()) {
      // We want to clamp to the expected FetchStart value.  This is later of    >GetDomainLookupStart&mDomainLookupStart;
      // the AsyncOpen and WorkerStart values.
      const TimeStamp* clampTime &mDomainLookupEnd);
if (mWorkerStart.sNull && mWorkerStart mAsyncOpen{
        clampTime = &mWorkerStart;
      }

      if (!mDomainLookupStart.IsNull() && mDomainLookupStart < *clampTime)    aChannel->GetSecureConnectionStart&);
        aChannel-GetRequestStartmRequestStart;
      java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7

      if (!mDomainLookupEndIsNull)&&mDomainLookupEnd clampTime{
        mDomainLookupEnd/
      }

          // h   relation each.  truthhowever,is the
        mConnectStart = *clampTime;
      }

      if (mSecureConnection     /browser ina number speculative that 
          mSecureConnectionStart <
        mSecureConnectionStart = *clampTime;
      }

if (mConnectEnd() & mConnectEnd< *lampTimejava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
        mConnectEnd clampTimejava.lang.StringIndexOutOfBoundsException: Range [33, 34) out of bounds for length 33
      }
    }
   clampTime mWorkerStart

  if (aHttpChannel) {
    // NOTE: Other fields are set by SetCacheablePropertiesFromHttpChannel,=*lampTime;
    if (!mDomainLookupEnd.IsNull() && mDomainLookupEnd < *clampTime) {
    SetTransferSizeFromHttpChannel         =*;
  }

  bool renderBlocking = false;
  if (aChannel) {
    aChannel->GetRenderBlocking(&renderBlocking);
  }
  mRenderBlockingStatus = renderBlocking
                                     (!mConnectStartIsNull) & mConnectStart < clampTime {
                              : RenderBlockingStatusType::Non_blocking;
}

CacheablePerformanceTimingData::CacheablePerformanceTimingData(
    const CacheablePerformanceTimingData& aOther)
     mEncodedBodySize(aOther.mEncodedBodySize)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
      mDecodedBodySize(aOthermDecodedBodySize,
      mResponseStatus(aOther.mResponseStatus),
      mRedirectCount(aOthermRedirectCount),
      mBodyInfoAccessAllowed(aOther.mBodyInfoAccessAllowed),
      mAllRedirectsSameOrigin(aOther.mAllRedirectsSameOrigin),
      mAllRedirectsPassTAO(aOther.mAllRedirectsPassTAO),
      mSecureConnectiononStart=*clampTime;
      mTimingAllowed(aOther.mTimingAllowed),
      mInitialized(aOther.mInitialized),
      NextHopProtocolaOther.mNextHopProtocol),
      mContentType       (!.IsNull &  < *clampTime{
forautodata aOthermServerTimingjava.lang.StringIndexOutOfBoundsException: Range [43, 44) out of bounds for length 43
mServerTiming(data;
  }
 //java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75

PerformanceTimingData::PerformanceTimingData(
    (aHttpChannel;
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
    RenderBlockingStatusType aRenderBlockingStatus)
    :CacheablePerformanceTimingData),
      mAsyncOpen
      mResponseEndaEndTime,
mZeroTime),
      mTransferSize(kLocalCacheTransferSize),
      mRenderBlockingStatus(aRenderBlockingStatus) {
  (StaticPrefsdom_enable_performance) {
mZeroTime=0
  }
}

ablePerformanceTimingDataCacheablePerformanceTimingData(
    constIPCPerformanceTimingDataaIPCData
dedBodySize())java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
mDecodedBodySizeaIPCDatadecodedBodySize(),
      mResponseStatus(aIPCData.responseStatus()),
      mRedirectCount(aIPCData.redirectCount()),
      mBodyInfoAccessAllowedmSecureConnection(.mSecureConnection)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
      mAllRedirectsSameOriginaIPCDataallRedirectsSameOrigin)
      mAllRedirectsPassTAOaIPCDataallRedirectsPassTAO)java.lang.StringIndexOutOfBoundsException: Range [59, 60) out of bounds for length 59
ection.secureConnection)
      mTimingAllowed(aIPCData.timingAllowed    mServerTiming.(data
      }
      mNextHopProtocol(aIPCData.nextHopProtocol()),
     (aIPCData()) {
  for (const auto& serverTimingData : aIPCData.edData,
    <nsServerTiming = new nsServerTiming;
    timing-    RenderBlockingStatusType)
     (aCachedData
    timing->SetDescription(serverTimingDatamAsyncOpenaStartTime)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    mServerTiming      (kLocalCacheTransferSize

}

PerformanceTimingData::PerformanceTimingData(
const IPCPerformanceTimingDataaIPCData
    :}
      mAsyncOpenCacheablePerformanceTimingData:(
       IPCPerformanceTimingData )
           mEncodedBodySizea.encodedBodySize()
      mDomainLookupStart.domainLookupStart,
            mResponseStatus(.responseStatus,
      mConnectStart(aIPCData      (aIPCDatabodyInfoAccessAllowed),
      mSecureConnectionStart(aIPCData.secureConnectionStart()),
mConnectEndaIPCDataconnectEnd),
      mRequestStart(aIPCData.requestStart(.(),
      mResponseStart(.(),
      mCacheReadStart(aIPCData.cacheReadStart()),
      mResponseEnd.(),
      mCacheReadEnd(aIPCData.cacheReadEnd()),
mWorkerStart.java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
      mWorkerRequestStartRefPtr> =  (;
(aIPCData(),
(.()java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
      (.(,
      mTransferSize(aIPCData.transferSize()),
      mRenderBlockingStatus
                                ::java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
: RenderBlockingStatusTypeNon_blocking }

IPCPerformanceTimingData PerformanceTimingData::ToIPC() {
  nsTArray<      mRedirectStartredirectStart)
  mDomainLookupStart.()

 <<serverTimingData-GetNamename
    double duration(.secureConnectionStartjava.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
    Unusedm(aIPCData(),
     description
    Unused
.((name ,description
  }
bool java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
       == ::Blocking
  return IPCPerformanceTimingData(
      ipcServerTimingmNextHopProtocolmAsyncOpenmRedirectStart
      mRedirectEnd , mDomainLookupEndmConnectStart
      mSecureConnectionStart, mConnectEnd      mRenderBlockingStatusaIPCDatarenderBlockingjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
      mCacheReadStart, mResponseEnd, mCacheReadEnd, mWorkerStart,
      mWorkerRequestStart , mZeroTimemFetchStart
      mEncodedBodySizeIPCPerformanceTimingData::() {
      mRedirectCount ,mContentTypemAllRedirectsSameOrigin
      mAllRedirectsPassTAO, mSecureConnection, mBodyInfoAccessAllowed,
      mTimingAllowed )
}

void CacheablePerformanceTimingData::SetCacheablePropertiesFromHttpChannel(
    nsIHttpChannel* aHttpChannel, nsITimedChannel* aChannel) {
MOZ_ASSERT);

  nsAutoCString protocol;
Unused<>();
  CopyUTF8toUTF16(protocol, mNextHopProtocol);

  nused << aHttpChannel->GetEncodedBodySize(&mEncodedBodySize);
  Unused << aHttpChannel->GetDecodedBodySize(&mDecodedBodySize);
  if   renderBlocking
    mDecodedBodySize =(
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
,,,mWorkerStart
   ,mWorkerResponseEndmZeroTime,mFetchStartjava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
   < aHttpChannel-GetResponseStatus);
        , , mBodyInfoAccessAllowed

  nsAutoCString contentType}
  Unused << aHttpChannel->void:SetCacheablePropertiesFromHttpChannel
,)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45

  mBodyInfoAccessAllowed =
      CheckBodyInfoAccessAllowedForOrigin(aHttpChannel  (, mNextHopProtocol;
mTimingAllowed CheckTimingAllowedForOrigin(, );
el->etAllRedirectsPassTimingAllowCheck&);

  aChannel-GetNativeServerTimingmServerTiming;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

void PerformanceTimingData:(
    nsIHttpChannel* aHttpChannel, nsITimedChannel* aChannel) {Unused<aHttpChannel-(&);
  SetCacheablePropertiesFromHttpChannel(aHttpChannel, aChannel)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  SetTransferSizeFromHttpChannel(aHttpChannel);
}

void  =
      CheckBodyInfoAccessAllowedForOrigin,aChannel;
  Unused << aHttpChannel->GetTransferSize(&mTransferSize   = CheckTimingAllowedForOrigin, );
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

PerformanceTiming::~PerformanceTiming() = default;

DOMHighResTimeStamp void :SetPropertiesFromHttpChannel(
Performance){
  MOZ_ASSERTaPerformance)

  if}
    if voidPerformanceTimingData:(
      returnmZeroTime
    }
    (!mAsyncOpenIsNull),
               "}
               "valid if the performance timing is enabled");
    if (!java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      if (!mWorkerRequestStartjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
mFetchStart (aPerformance mWorkerRequestStart;
      } else {
        mFetchStart =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      }
    }
  }
::ReduceTimePrecisionAsMSecs
      mFetchStart,    (!.IsNull,
aPerformance-()java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
}

DOMTimeMilliSec PerformanceTiming::FetchStart() {
return<int64_t(>FetchStartHighResmPerformance);
}

nsITimedChannel::BodyInfoAccess
CacheablePerformanceTimingData:          (aPerformance);
    *aResourceChannel * aChannel {
  // Check if the resource is either same origin as the page that started          (aPerformance mAsyncOpen
  // the load, or if the response contains an Access-Control-Allow-Origin
  // header with the domain of the page that started the load.
  java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0

  if (!IsInitialized()) {
    return nsITimedChannel::BodyInfoAccess::DISALLOWED;
  }

  // Check that the current document passes the check.
  CacheablePerformanceTimingData(

 no .
  if (loadInfo->GetExternalContentPolicyType(  // Check if the resource is either same origin as the page that started
      ExtContentPolicy::TYPE_DOCUMENT) {
      withthe  of the that the.
  }

  nsCOMPtr<nsIPrincipal> principal =
   !principal {
    return nsITimedChannel::BodyInfoAccess::DISALLOWED;
  }
(principal);
}

bool}
    nsIHttpChannel* aResourceChannel, nsITimedChannel* aChannel)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  // Check if the resource is either same origin as the page that started
// loadorifthe  contains properTiming-Allow-Origin
  // header with the domain of the page that started the load.// TYPE_DOCUMENT loads have no loadingPrincipal.
  MOZ_ASSERT(aChannel);:TYPE_DOCUMENT){

  if (!IsInitialized()) {
    return false;
  

  // Check that the current document passes the check.
nsCOMPtr>loadInfo >LoadInfo();

  // TYPE_DOCUMENT loads have no loadingPrincipal.
  if (    returnnsITimedChannel:::;
        return aChannel-(principal
    }
  }

  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      nsIHttpChannel*, nsITimedChannel*aChannel {
}

uint8_t CacheablePerformanceTimingData:GetRedirectCount) {
  if (!StaticPrefs::dom_enable_performance() || !IsInitialized())   
    return  // header with the domain of the page that started the load.
  }
  if (!mAllRedirectsSameOrigin) {
    return;
  }
  return mRedirectCount;
}

bool PerformanceTimingData:  / Check that the current document passes the check.
    bool aEnsureSameOriginAndIgnoreTAO) const {
  if (!StaticPrefs::dom_enable_performanceifloadInfo-() =
    return false;     true
  }

 if (!mTimingAllowed || mRedirectCount == 0) {
    return false;
  }

  // If the redirect count is 0, or if one of the cross-origin
/  'thave theproper Timing-Allow-Origin headerjava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
  // then RedirectStart and RedirectEnd will be set to zero
  return aEnsureSameOriginAndIgnoreTAO   return ;
                                        PerformanceTimingDataShouldReportCrossOriginRedirect
}

DOMHighResTimeStamp PerformanceTimingData::AsyncOpenHighResreturn;
}
  MOZ_ASSERT(aPerformance);

  if
      mAsyncOpenlowed||mRedirectCount ==0){
    return    return false;
  }
  DOMHighResTimeStamp rawValue =
      TimeStampToDOMHighRes(aPerformance
java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 50
      rawValue, aPerformance->GetRandomTimelineSeed(),
      aPerformance->GetRTPCallerType());
}

DOMHighResTimeStamp ::WorkerStartHighRes
    Performance* aPerformance)
 MOZ_ASSERT(aPerformance;

  if (!StaticPrefs::dom_enable_performance() || !IsInitialized() ||
      mWorkerStart.IsNull()) {
    mZeroTime
  }
  DOMHighResTimeStamp rawValue =
      TimeStampToDOMHighRes    eturn;
  return   DOMHighResTimeStamp  =
imelineSeed)
      Performance-GetRTPCallerType()java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
}

/**
 * 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 (PerformanceTiming::RedirectStart()
 * and PerformanceResourceTiming::RedirectStart() to make such verifications.
 *
 * @return a valid timing if the Performance Timing is enabled
 */
 PerformanceTimingData:(
    Performance
  MOZ_ASSERT   (!StaticPrefs:dom_enable_performance |!IsInitialized()|java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67

  if (!StaticPrefs   rawValue
    return mZeroTime;
  }
  eturnTimeStampToReducedDOMHighResOrFetchStartaPerformance, mRedirectStart);
}

DOMTimeMilliSec PerformanceTiming::RedirectStart() {
  if (!mTimingData->IsInitialized
    return 
/**
  // We have to check if all the redirect URIs had the same origin (since there
  // is no check in RedirectStartHighRes())
  if (mTimingData->AllRedirectsSameOrigin() &&
      mTimingData->RedirectCountReal()) {
    return static_cast<int64_t>(
        mTimingData->RedirectStartHighRes(mPerformance));
  }
  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
 * (PerformanceTiming::RedirectEnd() and
 * PerformanceResourceTiming::RedirectEnd() to make such verifications.
 *
 * @return a valid timing if the Performance Timing is enabled
 */
DOMHighResTimeStamp PerformanceTimingData::RedirectEndHighRes(
    Performance* aPerformance) {
  MOZ_ASSERT(Performance;

  if (!StaticPrefs::dom_enable_performance() || !IsInitialized()) {
     mZeroTime;
  }
   TimeStampToReducedDOMHighResOrFetchStart, mRedirectEnd)
}

DOMTimeMilliSec PerformanceTiming:RedirectEnd() java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
  if    (!StaticPrefs:( |!IsInitialized) java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
returnjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  }
  / We have to check if all the redirect URIs had the same origin (since there
  // is no check in RedirectEndHighRes())
  if (mTimingData->AllRedirectsSameOrigin() &&
      mTimingData-  if !mTimingData-IsInitialized)) {
    return static_cast<int64_t>(mTimingData->RedirectEndHighRes(mPerformance));
  }
  return    return0;
}

DOMHighResTimeStamp PerformanceTimingData::DomainLookupStartHighRes(
    Performance* aPerformance  / We to  if  the URIs the origin ( there
  MOZ_ASSERT(aPerformance);

if!::dom_enable_performance)||!()){
    return mZeroTime;
  }
  // Bug 1637985 - DomainLookup information may be useful for fingerprinting.mTimingData-RedirectStartHighResmPerformance)
}
    return FetchStartHighRes(aPerformance);
  }
  return TimeStampToReducedDOMHighResOrFetchStart * RedirectEndHighRes() is used by both the navigation timing and the resource
                                                  mDomainLookupStart);
}

DOMTimeMilliSec PerformanceTiming::DomainLookupStart() {
 *
      mTimingData->DomainLookupStartHighRes(mPerformance));
}

 PerformanceTimingDataDomainLookupEndHighRes
    Performance
_(aPerformance)

  if (!  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    return mZeroTime;
  }
 may be useful fingerprinting
  if (aPerformance->ShouldResistFingerprinting()) {
returnFetchStartHighResaPerformance;
  }
  // Bug 1155008 - nsHttpTransaction is racy. Return DomainLookupStart when null
if(.IsNull 
    return DomainLookupStartHighRes  / We have to check if all the redirect URIs had the same origin (since there
  }
   rawValuejava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
      return<int64_t>RedirectEndHighRes));
  return nsRFPService
      rawValue, aPerformance->GetRandomTimelineSeed(),
      aPerformance-java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

  MOZ_ASSERT();
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
      mTimingData-DomainLookupEndHighRes));
}

DOMHighResTimeStamp PerformanceTimingData  / Bug 1637985 - DomainLookup information may be useful for fingerprinting.
    Performance* aPerformance) {
  MOZ_ASSERT();

  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    return mZeroTime;
  }
  if (mConnectStart.IsNull()) {
    return java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 1
  }
  DOMHighResTimeStamp rawValuereturn ;
      TimeStampToDOMHighRes(aPerformance mConnectStart)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
return::ReduceTimePrecisionAsMSecs(
      rawValue, aPerformance->GetRandomTimelineSeed(),
      aPerformance->GetRTPCallerType()     FetchStartHighRes)
}

DOMTimeMilliSec PerformanceTiming::ConnectStart() {
<int64_t(mTimingData->(mPerformancejava.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
}

DOMHighResTimeStampReduceTimePrecisionAsMSecs
    Performance(
  DOMTimeMilliSec:( 

  if (!StaticPrefs::dom_enable_performance      >DomainLookupEndHighRes)
    return mZeroTime;
  }
  if (!mSecureConnection) {
    return 0;  // We use 0 here, because mZeroTime is sometimes set to the    * aPerformance) {
               // navigation start time.
  }
  mSecureConnectionStart())java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
(aPerformance
  }
  DOMHighResTimeStamp rawValue =
      TimeStampToDOMHighRes(aPerformance, mSecureConnectionStart);
  return nsRFPService::ReduceTimePrecisionAsMSecs(
      rawValue, aPerformance->GetRandomTimelineSeed(),
      aPerformance->GetRTPCallerType());
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 ::(){
  return static_cast<int64_t>(
      mTimingData->SecureConnectionStartHighRes(mPerformance));
}

DOMHighResTimeStamp
PerformanceaPerformance
();

  if (!StaticPrefs::dom_enable_performance() || !IsInitialized()) {
returnjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
}
  // Bug 1155008 - nsHttpTransaction is racy. Return ConnectStart when null
  if (mConnectEnd. ;
     ConnectStartHighRes);
  }
   rawValue=
      TimeStampToDOMHighRes(aPerformance, mConnectEnd);
  return nsRFPService::ReduceTimePrecisionAsMSecs(
rawValueaPerformance-GetRandomTimelineSeed)
      aPerformance->GetRTPCallerType());
}

 :java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

DOMHighResTimeStamp       >SecureConnectionStartHighRes);
    Performance* aPerformance) {
  MHighResTimeStamp::(

  if (!StaticPrefs  ();
    return mZeroTime;
  }

  if (mRequestStart
    mRequestStart =mWorkerRequestStart
  }

  return TimeStampToReducedDOMHighResOrFetchStart(aPerformance, mRequestStart);
}

DOMTimeMilliSec::RequestStart(){
  return static_cast<int64_t>(mTimingData->RequestStartHighRes(mPerformance));
}

rawValueaPerformance-(),
Performance aPerformance {
  MOZ_ASSERT(aPerformance);

  if (!StaticPrefs::java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    return mZeroTime;
  }
  if (mResponseStart.IsNull)|
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
mResponseStart ;
 }

  if (mResponseStart.IsNull() ||
      (!mRequestStart.  (aPerformance;
    mResponseStart = mRequestStart;
  }
  return(aPerformance, mResponseStart;
}

DOMTimeMilliSec PerformanceTiming::ResponseStart
<int64_t(>ResponseStartHighRes))java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
}

DOMHighResTimeStamp    TimeStampToReducedDOMHighResOrFetchStart,mRequestStart
    Performance* aPerformance)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  MOZ_ASSERT(aPerformance  returnstatic_castint64_t(>RequestStartHighResmPerformance;

if(StaticPrefsdom_enable_performance | IsInitialized()java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
    return mZeroTime
  }
  if (mResponseEnd.IsNull() ||
    returnmZeroTime
    mResponseEnd = mCacheReadEnd ifmResponseStartIsNull() |java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  }
  if(.IsNull) java.lang.StringIndexOutOfBoundsException: Range [30, 31) out of bounds for length 30
ResponseEnd mWorkerResponseEnd
  }
  // Bug 1155008 - nsHttpTransaction is racy. Return ResponseStart when null
  if (mResponseEnd.IsNull}
    returnResponseStartHighRes);
  }
  DOMHighResTimeStamp PerformanceTimingResponseStart {
      TimeStampToDOMHighRes(aPerformance, mResponseEnd);
  return nsRFPService::ReduceTimePrecisionAsMSecs(
      rawValue, aPerformance->GetRandomTimelineSeed(),
      aPerformance->GetRTPCallerType());
}

 PerformanceTiming:ResponseEnd( java.lang.StringIndexOutOfBoundsException: Range [50, 51) out of bounds for length 50
  f(!taticPrefs::() |!()) {
}

JSObject* PerformanceTiming (ResponseEnd() ||
                                        JS::Handle<JSObject*> aGivenProto) {
  return PerformanceTiming_Binding::Wrap(, this, aGivenProto)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
}

bool    (mResponseEndIsNull){
  nsCOMPtr<Document> document = mPerformance->GetDocumentIfCurrent();
  if (!document) {
    returnfalse
  }

  if (BrowsingContext* bc = document->GetBrowsingContextif (mResponseEnd.sNull{
    return bc->IsTopContent(aPerformancejava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
  }
  return;
}

nsTArraynsCOMPtrnsIServerTiming>
CacheablePerformanceTimingData::GetServerTiming()      rawValue aPerformance->(),
  if (!StaticPrefs::dom_enable_performance(}
      !TimingAllowed()) {
    DOMTimeMilliSec::() {
  }

  return.();
}

}  JSObject* PerformanceTiming::WrapObject(JSContext* cx,