dom/performance/PerformanceTiming.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef mozilla_dom_PerformanceTiming_h
   8 #define mozilla_dom_PerformanceTiming_h
   9
  10 #include "mozilla/Attributes.h"
  11 #include "mozilla/BasePrincipal.h"
  12 #include "mozilla/StaticPrefs_dom.h"
  13 #include "nsContentUtils.h"
  14 #include "nsDOMNavigationTiming.h"
  15 #include "nsRFPService.h"
  16 #include "nsWrapperCache.h"
  17 #include "CacheablePerformanceTimingData.h"
  18 #include "Performance.h"
  19 #include "nsITimedChannel.h"
  20 #include "mozilla/dom/PerformanceTimingTypes.h"
  21 #include "mozilla/ipc/IPDLParamTraits.h"
  22 #include "ipc/IPCMessageUtils.h"
  23 #include "ipc/IPCMessageUtilsSpecializations.h"
  24 #include "mozilla/net/nsServerTiming.h"
  25
  26 class nsIHttpChannel;
  27
  28 namespace mozilla::dom {
  29
  30 class PerformanceTiming;
  31 enum class RenderBlockingStatusType : uint8_t;
  32
  33 class PerformanceTimingData final : public CacheablePerformanceTimingData {
  34   friend class PerformanceTiming;
  35   friend struct mozilla::ipc::IPDLParamTraits<
  36       mozilla::dom::PerformanceTimingData>;
  37
  38   // https://w3c.github.io/resource-timing/#dom-performanceresourcetiming-transfersize
  39   // The transferSize getter steps are to perform the following steps:
  40   //   1. If this's cache mode is "local", then return 0.
  41   static constexpr uint64_t kLocalCacheTransferSize = 0;
  42
  43  public:
  44   PerformanceTimingData() = default;  // For deserialization
  45   // This can return null.
  46   static PerformanceTimingData* Create(nsITimedChannel* aChannel,
  47                                        nsIHttpChannel* aHttpChannel,
  48                                        DOMHighResTimeStamp aZeroTime,
  49                                        nsAString& aInitiatorType,
  50                                        nsAString& aEntryName);
  51
  52   PerformanceTimingData(nsITimedChannel* aChannel, nsIHttpChannel* aHttpChannel,
  53                         DOMHighResTimeStamp aZeroTime);
  54
  55   static PerformanceTimingData* Create(
  56       const CacheablePerformanceTimingData& aCachedData,
  57       DOMHighResTimeStamp aZeroTime, TimeStamp aStartTime, TimeStamp aEndTime,
  58       RenderBlockingStatusType aRenderBlockingStatus);
  59
  60  private:
  61   PerformanceTimingData(const CacheablePerformanceTimingData& aCachedData,
  62                         DOMHighResTimeStamp aZeroTime, TimeStamp aStartTime,
  63                         TimeStamp aEndTime,
  64                         RenderBlockingStatusType aRenderBlockingStatus);
  65
  66  public:
  67   explicit PerformanceTimingData(const IPCPerformanceTimingData& aIPCData);
  68
  69   IPCPerformanceTimingData ToIPC();
  70
  71   void SetPropertiesFromHttpChannel(nsIHttpChannel* aHttpChannel,
  72                                     nsITimedChannel* aChannel);
  73
  74  private:
  75   void SetTransferSizeFromHttpChannel(nsIHttpChannel* aHttpChannel);
  76
  77  public:
  78   uint64_t TransferSize() const { return mTransferSize; }
  79
  80   /**
  81    * @param   aStamp
  82    *          The TimeStamp recorded for a specific event. This TimeStamp can
  83    *          be null.
  84    * @return  the duration of an event with a given TimeStamp, relative to the
  85    *          navigationStart TimeStamp (the moment the user landed on the
  86    *          page), if the given TimeStamp is valid. Otherwise, it will return
  87    *          the FetchStart timing value.
  88    */
  89   inline DOMHighResTimeStamp TimeStampToReducedDOMHighResOrFetchStart(
  90       Performance* aPerformance, TimeStamp aStamp) {
  91     MOZ_ASSERT(aPerformance);
  92
  93     if (aStamp.IsNull()) {
  94       return FetchStartHighRes(aPerformance);
  95     }
  96
  97     DOMHighResTimeStamp rawTimestamp =
  98         TimeStampToDOMHighRes(aPerformance, aStamp);
  99
 100     return nsRFPService::ReduceTimePrecisionAsMSecs(
 101         rawTimestamp, aPerformance->GetRandomTimelineSeed(),
 102         aPerformance->GetRTPCallerType());
 103   }
 104
 105   /**
 106    * The nsITimedChannel records an absolute timestamp for each event.
 107    * The nsDOMNavigationTiming will record the moment when the user landed on
 108    * the page. This is a window.performance unique timestamp, so it can be used
 109    * for all the events (navigation timing and resource timing events).
 110    *
 111    * The algorithm operates in 2 steps:
 112    * 1. The first step is to subtract the two timestamps: the argument (the
 113    * event's timestamp) and the navigation start timestamp. This will result in
 114    * a relative timestamp of the event (relative to the navigation start -
 115    * window.performance.timing.navigationStart).
 116    * 2. The second step is to add any required offset (the mZeroTime). For now,
 117    * this offset value is either 0 (for the resource timing), or equal to
 118    * "performance.navigationStart" (for navigation timing).
 119    * For the resource timing, mZeroTime is set to 0, causing the result to be a
 120    * relative time.
 121    * For the navigation timing, mZeroTime is set to
 122    * "performance.navigationStart" causing the result be an absolute time.
 123    *
 124    * @param   aStamp
 125    *          The TimeStamp recorded for a specific event. This TimeStamp can't
 126    *          be null.
 127    * @return  number of milliseconds value as one of:
 128    * - relative to the navigation start time, time the user has landed on the
 129    *   page
 130    * - an absolute wall clock time since the unix epoch
 131    */
 132   inline DOMHighResTimeStamp TimeStampToDOMHighRes(Performance* aPerformance,
 133                                                    TimeStamp aStamp) const {
 134     MOZ_ASSERT(aPerformance);
 135     MOZ_ASSERT(!aStamp.IsNull());
 136
 137     TimeDuration duration = aStamp - aPerformance->CreationTimeStamp();
 138     return duration.ToMilliseconds() + mZeroTime;
 139   }
 140
 141   // The last channel's AsyncOpen time.  This may occur before the FetchStart
 142   // in some cases.
 143   DOMHighResTimeStamp AsyncOpenHighRes(Performance* aPerformance);
 144
 145   // High resolution (used by resource timing)
 146   DOMHighResTimeStamp WorkerStartHighRes(Performance* aPerformance);
 147   DOMHighResTimeStamp FetchStartHighRes(Performance* aPerformance);
 148   DOMHighResTimeStamp RedirectStartHighRes(Performance* aPerformance);
 149   DOMHighResTimeStamp RedirectEndHighRes(Performance* aPerformance);
 150   DOMHighResTimeStamp DomainLookupStartHighRes(Performance* aPerformance);
 151   DOMHighResTimeStamp DomainLookupEndHighRes(Performance* aPerformance);
 152   DOMHighResTimeStamp ConnectStartHighRes(Performance* aPerformance);
 153   DOMHighResTimeStamp SecureConnectionStartHighRes(Performance* aPerformance);
 154   DOMHighResTimeStamp ConnectEndHighRes(Performance* aPerformance);
 155   DOMHighResTimeStamp RequestStartHighRes(Performance* aPerformance);
 156   DOMHighResTimeStamp ResponseStartHighRes(Performance* aPerformance);
 157   DOMHighResTimeStamp ResponseEndHighRes(Performance* aPerformance);
 158
 159   DOMHighResTimeStamp ZeroTime() const { return mZeroTime; }
 160
 161   // If this is false the values of redirectStart/End will be 0 This is false if
 162   // no redirects occured, or if any of the responses failed the
 163   // timing-allow-origin check in HttpBaseChannel::TimingAllowCheck
 164   //
 165   // If aEnsureSameOriginAndIgnoreTAO is false, it checks if all redirects pass
 166   // TAO. When it is true, it checks if all redirects are same-origin and
 167   // ignores the result of TAO.
 168   bool ShouldReportCrossOriginRedirect(
 169       bool aEnsureSameOriginAndIgnoreTAO) const;
 170
 171   RenderBlockingStatusType RenderBlockingStatus() const {
 172     return mRenderBlockingStatus;
 173   }
 174
 175  private:
 176   TimeStamp mAsyncOpen;
 177   TimeStamp mRedirectStart;
 178   TimeStamp mRedirectEnd;
 179   TimeStamp mDomainLookupStart;
 180   TimeStamp mDomainLookupEnd;
 181   TimeStamp mConnectStart;
 182   TimeStamp mSecureConnectionStart;
 183   TimeStamp mConnectEnd;
 184   TimeStamp mRequestStart;
 185   TimeStamp mResponseStart;
 186   TimeStamp mCacheReadStart;
 187   TimeStamp mResponseEnd;
 188   TimeStamp mCacheReadEnd;
 189
 190   // ServiceWorker interception timing information
 191   TimeStamp mWorkerStart;
 192   TimeStamp mWorkerRequestStart;
 193   TimeStamp mWorkerResponseEnd;
 194
 195   // This is an offset that will be added to each timing ([ms] resolution).
 196   // There are only 2 possible values: (1) logicaly equal to navigationStart
 197   // TimeStamp (results are absolute timstamps - wallclock); (2) "0" (results
 198   // are relative to the navigation start).
 199   DOMHighResTimeStamp mZeroTime = 0;
 200
 201   DOMHighResTimeStamp mFetchStart = 0;
 202
 203   uint64_t mTransferSize = 0;
 204
 205   RenderBlockingStatusType mRenderBlockingStatus;
 206 };
 207
 208 // Script "performance.timing" object
 209 class PerformanceTiming final : public nsWrapperCache {
 210  public:
 211   /**
 212    * @param   aPerformance
 213    *          The performance object (the JS parent).
 214    *          This will allow access to "window.performance.timing" attribute
 215    * for the navigation timing (can't be null).
 216    * @param   aChannel
 217    *          An nsITimedChannel used to gather all the networking timings by
 218    * both the navigation timing and the resource timing (can't be null).
 219    * @param   aHttpChannel
 220    *          An nsIHttpChannel (the resource's http channel).
 221    *          This will be used by the resource timing cross-domain check
 222    *          algorithm.
 223    *          Argument is null for the navigation timing (navigation timing uses
 224    *          another algorithm for the cross-domain redirects).
 225    * @param   aZeroTime
 226    *          The offset that will be added to the timestamp of each event. This
 227    *          argument should be equal to performance.navigationStart for
 228    *          navigation timing and "0" for the resource timing.
 229    */
 230   PerformanceTiming(Performance* aPerformance, nsITimedChannel* aChannel,
 231                     nsIHttpChannel* aHttpChannel,
 232                     DOMHighResTimeStamp aZeroTime);
 233   NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(PerformanceTiming)
 234   NS_DECL_CYCLE_COLLECTION_NATIVE_WRAPPERCACHE_CLASS(PerformanceTiming)
 235
 236   nsDOMNavigationTiming* GetDOMTiming() const {
 237     return mPerformance->GetDOMTiming();
 238   }
 239
 240   Performance* GetParentObject() const { return mPerformance; }
 241
 242   virtual JSObject* WrapObject(JSContext* cx,
 243                                JS::Handle<JSObject*> aGivenProto) override;
 244
 245   // PerformanceNavigation WebIDL methods
 246   DOMTimeMilliSec NavigationStart() const {
 247     if (!StaticPrefs::dom_enable_performance()) {
 248       return 0;
 249     }
 250     return nsRFPService::ReduceTimePrecisionAsMSecs(
 251         GetDOMTiming()->GetNavigationStart(),
 252         mPerformance->GetRandomTimelineSeed(),
 253         mPerformance->GetRTPCallerType());
 254   }
 255
 256   DOMTimeMilliSec UnloadEventStart() {
 257     if (!StaticPrefs::dom_enable_performance()) {
 258       return 0;
 259     }
 260     return nsRFPService::ReduceTimePrecisionAsMSecs(
 261         GetDOMTiming()->GetUnloadEventStart(),
 262         mPerformance->GetRandomTimelineSeed(),
 263         mPerformance->GetRTPCallerType());
 264   }
 265
 266   DOMTimeMilliSec UnloadEventEnd() {
 267     if (!StaticPrefs::dom_enable_performance()) {
 268       return 0;
 269     }
 270     return nsRFPService::ReduceTimePrecisionAsMSecs(
 271         GetDOMTiming()->GetUnloadEventEnd(),
 272         mPerformance->GetRandomTimelineSeed(),
 273         mPerformance->GetRTPCallerType());
 274   }
 275
 276   // Low resolution (used by navigation timing)
 277   DOMTimeMilliSec FetchStart();
 278   DOMTimeMilliSec RedirectStart();
 279   DOMTimeMilliSec RedirectEnd();
 280   DOMTimeMilliSec DomainLookupStart();
 281   DOMTimeMilliSec DomainLookupEnd();
 282   DOMTimeMilliSec ConnectStart();
 283   DOMTimeMilliSec SecureConnectionStart();
 284   DOMTimeMilliSec ConnectEnd();
 285   DOMTimeMilliSec RequestStart();
 286   DOMTimeMilliSec ResponseStart();
 287   DOMTimeMilliSec ResponseEnd();
 288
 289   DOMTimeMilliSec DomLoading() {
 290     if (!StaticPrefs::dom_enable_performance()) {
 291       return 0;
 292     }
 293     return nsRFPService::ReduceTimePrecisionAsMSecs(
 294         GetDOMTiming()->GetDomLoading(), mPerformance->GetRandomTimelineSeed(),
 295         mPerformance->GetRTPCallerType());
 296   }
 297
 298   DOMTimeMilliSec DomInteractive() const {
 299     if (!StaticPrefs::dom_enable_performance()) {
 300       return 0;
 301     }
 302     return nsRFPService::ReduceTimePrecisionAsMSecs(
 303         GetDOMTiming()->GetDomInteractive(),
 304         mPerformance->GetRandomTimelineSeed(),
 305         mPerformance->GetRTPCallerType());
 306   }
 307
 308   DOMTimeMilliSec DomContentLoadedEventStart() const {
 309     if (!StaticPrefs::dom_enable_performance()) {
 310       return 0;
 311     }
 312     return nsRFPService::ReduceTimePrecisionAsMSecs(
 313         GetDOMTiming()->GetDomContentLoadedEventStart(),
 314         mPerformance->GetRandomTimelineSeed(),
 315         mPerformance->GetRTPCallerType());
 316   }
 317
 318   DOMTimeMilliSec DomContentLoadedEventEnd() const {
 319     if (!StaticPrefs::dom_enable_performance()) {
 320       return 0;
 321     }
 322     return nsRFPService::ReduceTimePrecisionAsMSecs(
 323         GetDOMTiming()->GetDomContentLoadedEventEnd(),
 324         mPerformance->GetRandomTimelineSeed(),
 325         mPerformance->GetRTPCallerType());
 326   }
 327
 328   DOMTimeMilliSec DomComplete() const {
 329     if (!StaticPrefs::dom_enable_performance()) {
 330       return 0;
 331     }
 332     return nsRFPService::ReduceTimePrecisionAsMSecs(
 333         GetDOMTiming()->GetDomComplete(), mPerformance->GetRandomTimelineSeed(),
 334         mPerformance->GetRTPCallerType());
 335   }
 336
 337   DOMTimeMilliSec LoadEventStart() const {
 338     if (!StaticPrefs::dom_enable_performance()) {
 339       return 0;
 340     }
 341     return nsRFPService::ReduceTimePrecisionAsMSecs(
 342         GetDOMTiming()->GetLoadEventStart(),
 343         mPerformance->GetRandomTimelineSeed(),
 344         mPerformance->GetRTPCallerType());
 345   }
 346
 347   DOMTimeMilliSec LoadEventEnd() const {
 348     if (!StaticPrefs::dom_enable_performance()) {
 349       return 0;
 350     }
 351     return nsRFPService::ReduceTimePrecisionAsMSecs(
 352         GetDOMTiming()->GetLoadEventEnd(),
 353         mPerformance->GetRandomTimelineSeed(),
 354         mPerformance->GetRTPCallerType());
 355   }
 356
 357   DOMTimeMilliSec TimeToNonBlankPaint() const {
 358     if (!StaticPrefs::dom_enable_performance()) {
 359       return 0;
 360     }
 361     return nsRFPService::ReduceTimePrecisionAsMSecs(
 362         GetDOMTiming()->GetTimeToNonBlankPaint(),
 363         mPerformance->GetRandomTimelineSeed(),
 364         mPerformance->GetRTPCallerType());
 365   }
 366
 367   DOMTimeMilliSec TimeToContentfulPaint() const {
 368     if (!StaticPrefs::dom_enable_performance()) {
 369       return 0;
 370     }
 371     return nsRFPService::ReduceTimePrecisionAsMSecs(
 372         GetDOMTiming()->GetTimeToContentfulComposite(),
 373         mPerformance->GetRandomTimelineSeed(),
 374         mPerformance->GetRTPCallerType());
 375   }
 376
 377   DOMTimeMilliSec TimeToFirstInteractive() const {
 378     if (!StaticPrefs::dom_enable_performance()) {
 379       return 0;
 380     }
 381     return nsRFPService::ReduceTimePrecisionAsMSecs(
 382         GetDOMTiming()->GetTimeToTTFI(), mPerformance->GetRandomTimelineSeed(),
 383         mPerformance->GetRTPCallerType());
 384   }
 385
 386   PerformanceTimingData* Data() const { return mTimingData.get(); }
 387
 388  private:
 389   ~PerformanceTiming();
 390
 391   bool IsTopLevelContentDocument() const;
 392
 393   RefPtr<Performance> mPerformance;
 394
 395   UniquePtr<PerformanceTimingData> mTimingData;
 396 };
 397
 398 }  // namespace mozilla::dom
 399
 400 namespace mozilla::ipc {
 401
 402 template <>
 403 struct IPDLParamTraits<mozilla::dom::PerformanceTimingData> {
 404   using paramType = mozilla::dom::PerformanceTimingData;
 405   static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
 406                     const paramType& aParam) {
 407     WriteIPDLParam(aWriter, aActor, aParam.mServerTiming);
 408     WriteIPDLParam(aWriter, aActor, aParam.mNextHopProtocol);
 409     WriteIPDLParam(aWriter, aActor, aParam.mAsyncOpen);
 410     WriteIPDLParam(aWriter, aActor, aParam.mRedirectStart);
 411     WriteIPDLParam(aWriter, aActor, aParam.mRedirectEnd);
 412     WriteIPDLParam(aWriter, aActor, aParam.mDomainLookupStart);
 413     WriteIPDLParam(aWriter, aActor, aParam.mDomainLookupEnd);
 414     WriteIPDLParam(aWriter, aActor, aParam.mConnectStart);
 415     WriteIPDLParam(aWriter, aActor, aParam.mSecureConnectionStart);
 416     WriteIPDLParam(aWriter, aActor, aParam.mConnectEnd);
 417     WriteIPDLParam(aWriter, aActor, aParam.mRequestStart);
 418     WriteIPDLParam(aWriter, aActor, aParam.mResponseStart);
 419     WriteIPDLParam(aWriter, aActor, aParam.mCacheReadStart);
 420     WriteIPDLParam(aWriter, aActor, aParam.mResponseEnd);
 421     WriteIPDLParam(aWriter, aActor, aParam.mCacheReadEnd);
 422     WriteIPDLParam(aWriter, aActor, aParam.mWorkerStart);
 423     WriteIPDLParam(aWriter, aActor, aParam.mWorkerRequestStart);
 424     WriteIPDLParam(aWriter, aActor, aParam.mWorkerResponseEnd);
 425     WriteIPDLParam(aWriter, aActor, aParam.mZeroTime);
 426     WriteIPDLParam(aWriter, aActor, aParam.mFetchStart);
 427     WriteIPDLParam(aWriter, aActor, aParam.mEncodedBodySize);
 428     WriteIPDLParam(aWriter, aActor, aParam.mTransferSize);
 429     WriteIPDLParam(aWriter, aActor, aParam.mDecodedBodySize);
 430     WriteIPDLParam(aWriter, aActor, aParam.mResponseStatus);
 431     WriteIPDLParam(aWriter, aActor, aParam.mRedirectCount);
 432     WriteIPDLParam(aWriter, aActor, aParam.mContentType);
 433     WriteIPDLParam(aWriter, aActor, aParam.mAllRedirectsSameOrigin);
 434     WriteIPDLParam(aWriter, aActor, aParam.mAllRedirectsPassTAO);
 435     WriteIPDLParam(aWriter, aActor, aParam.mSecureConnection);
 436     WriteIPDLParam(aWriter, aActor, aParam.mBodyInfoAccessAllowed);
 437     WriteIPDLParam(aWriter, aActor, aParam.mTimingAllowed);
 438     WriteIPDLParam(aWriter, aActor, aParam.mInitialized);
 439   }
 440
 441   static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
 442                    paramType* aResult) {
 443     if (!ReadIPDLParam(aReader, aActor, &aResult->mServerTiming)) {
 444       return false;
 445     }
 446     if (!ReadIPDLParam(aReader, aActor, &aResult->mNextHopProtocol)) {
 447       return false;
 448     }
 449     if (!ReadIPDLParam(aReader, aActor, &aResult->mAsyncOpen)) {
 450       return false;
 451     }
 452     if (!ReadIPDLParam(aReader, aActor, &aResult->mRedirectStart)) {
 453       return false;
 454     }
 455     if (!ReadIPDLParam(aReader, aActor, &aResult->mRedirectEnd)) {
 456       return false;
 457     }
 458     if (!ReadIPDLParam(aReader, aActor, &aResult->mDomainLookupStart)) {
 459       return false;
 460     }
 461     if (!ReadIPDLParam(aReader, aActor, &aResult->mDomainLookupEnd)) {
 462       return false;
 463     }
 464     if (!ReadIPDLParam(aReader, aActor, &aResult->mConnectStart)) {
 465       return false;
 466     }
 467     if (!ReadIPDLParam(aReader, aActor, &aResult->mSecureConnectionStart)) {
 468       return false;
 469     }
 470     if (!ReadIPDLParam(aReader, aActor, &aResult->mConnectEnd)) {
 471       return false;
 472     }
 473     if (!ReadIPDLParam(aReader, aActor, &aResult->mRequestStart)) {
 474       return false;
 475     }
 476     if (!ReadIPDLParam(aReader, aActor, &aResult->mResponseStart)) {
 477       return false;
 478     }
 479     if (!ReadIPDLParam(aReader, aActor, &aResult->mCacheReadStart)) {
 480       return false;
 481     }
 482     if (!ReadIPDLParam(aReader, aActor, &aResult->mResponseEnd)) {
 483       return false;
 484     }
 485     if (!ReadIPDLParam(aReader, aActor, &aResult->mCacheReadEnd)) {
 486       return false;
 487     }
 488     if (!ReadIPDLParam(aReader, aActor, &aResult->mWorkerStart)) {
 489       return false;
 490     }
 491     if (!ReadIPDLParam(aReader, aActor, &aResult->mWorkerRequestStart)) {
 492       return false;
 493     }
 494     if (!ReadIPDLParam(aReader, aActor, &aResult->mWorkerResponseEnd)) {
 495       return false;
 496     }
 497     if (!ReadIPDLParam(aReader, aActor, &aResult->mZeroTime)) {
 498       return false;
 499     }
 500     if (!ReadIPDLParam(aReader, aActor, &aResult->mFetchStart)) {
 501       return false;
 502     }
 503     if (!ReadIPDLParam(aReader, aActor, &aResult->mEncodedBodySize)) {
 504       return false;
 505     }
 506     if (!ReadIPDLParam(aReader, aActor, &aResult->mTransferSize)) {
 507       return false;
 508     }
 509     if (!ReadIPDLParam(aReader, aActor, &aResult->mDecodedBodySize)) {
 510       return false;
 511     }
 512     if (!ReadIPDLParam(aReader, aActor, &aResult->mResponseStatus)) {
 513       return false;
 514     }
 515     if (!ReadIPDLParam(aReader, aActor, &aResult->mRedirectCount)) {
 516       return false;
 517     }
 518     if (!ReadIPDLParam(aReader, aActor, &aResult->mContentType)) {
 519       return false;
 520     }
 521     if (!ReadIPDLParam(aReader, aActor, &aResult->mAllRedirectsSameOrigin)) {
 522       return false;
 523     }
 524     if (!ReadIPDLParam(aReader, aActor, &aResult->mAllRedirectsPassTAO)) {
 525       return false;
 526     }
 527     if (!ReadIPDLParam(aReader, aActor, &aResult->mSecureConnection)) {
 528       return false;
 529     }
 530     if (!ReadIPDLParam(aReader, aActor, &aResult->mBodyInfoAccessAllowed)) {
 531       return false;
 532     }
 533     if (!ReadIPDLParam(aReader, aActor, &aResult->mTimingAllowed)) {
 534       return false;
 535     }
 536     if (!ReadIPDLParam(aReader, aActor, &aResult->mInitialized)) {
 537       return false;
 538     }
 539     return true;
 540   }
 541 };
 542
 543 template <>
 544 struct IPDLParamTraits<nsIServerTiming*> {
 545   static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
 546                     nsIServerTiming* aParam) {
 547     nsAutoCString name;
 548     Unused << aParam->GetName(name);
 549     double duration = 0;
 550     Unused << aParam->GetDuration(&duration);
 551     nsAutoCString description;
 552     Unused << aParam->GetDescription(description);
 553     WriteIPDLParam(aWriter, aActor, name);
 554     WriteIPDLParam(aWriter, aActor, duration);
 555     WriteIPDLParam(aWriter, aActor, description);
 556   }
 557
 558   static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
 559                    RefPtr<nsIServerTiming>* aResult) {
 560     nsAutoCString name;
 561     double duration;
 562     nsAutoCString description;
 563     if (!ReadIPDLParam(aReader, aActor, &name)) {
 564       return false;
 565     }
 566     if (!ReadIPDLParam(aReader, aActor, &duration)) {
 567       return false;
 568     }
 569     if (!ReadIPDLParam(aReader, aActor, &description)) {
 570       return false;
 571     }
 572
 573     RefPtr<nsServerTiming> timing = new nsServerTiming();
 574     timing->SetName(name);
 575     timing->SetDuration(duration);
 576     timing->SetDescription(description);
 577     *aResult = timing.forget();
 578     return true;
 579   }
 580 };
 581
 582 }  // namespace mozilla::ipc
 583
 584 #endif  // mozilla_dom_PerformanceTiming_h