dom/base/nsDOMNavigationTiming.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 nsDOMNavigationTiming_h___
   8 #define nsDOMNavigationTiming_h___
   9
  10 #include "nsCOMPtr.h"
  11 #include "nsCOMArray.h"
  12 #include "mozilla/WeakPtr.h"
  13 #include "mozilla/RelativeTimeline.h"
  14 #include "mozilla/TimeStamp.h"
  15 #include "nsITimer.h"
  16
  17 class nsDocShell;
  18 class nsIURI;
  19
  20 using DOMTimeMilliSec = unsigned long long;
  21 using DOMHighResTimeStamp = double;
  22
  23 class PickleIterator;
  24 namespace IPC {
  25 class Message;
  26 class MessageReader;
  27 class MessageWriter;
  28 }  // namespace IPC
  29 namespace mozilla::ipc {
  30 class IProtocol;
  31 template <typename>
  32 struct IPDLParamTraits;
  33 }  // namespace mozilla::ipc
  34
  35 class nsDOMNavigationTiming final : public mozilla::RelativeTimeline {
  36  public:
  37   enum Type {
  38     TYPE_NAVIGATE = 0,
  39     TYPE_RELOAD = 1,
  40     TYPE_BACK_FORWARD = 2,
  41     TYPE_RESERVED = 255,
  42   };
  43
  44   explicit nsDOMNavigationTiming(nsDocShell* aDocShell);
  45
  46   NS_INLINE_DECL_REFCOUNTING(nsDOMNavigationTiming)
  47
  48   Type GetType() const { return mNavigationType; }
  49
  50   inline DOMHighResTimeStamp GetNavigationStartHighRes() const {
  51     return mNavigationStartHighRes;
  52   }
  53
  54   DOMTimeMilliSec GetNavigationStart() const {
  55     return static_cast<int64_t>(GetNavigationStartHighRes());
  56   }
  57
  58   mozilla::TimeStamp GetNavigationStartTimeStamp() const {
  59     return mNavigationStart;
  60   }
  61
  62   mozilla::TimeStamp GetLoadEventStartTimeStamp() const {
  63     return mLoadEventStart;
  64   }
  65
  66   mozilla::TimeStamp GetDOMContentLoadedEventStartTimeStamp() const {
  67     return mDOMContentLoadedEventStart;
  68   }
  69
  70   mozilla::TimeStamp GetFirstContentfulCompositeTimeStamp() const {
  71     return mContentfulComposite;
  72   }
  73
  74   DOMTimeMilliSec GetUnloadEventStart() {
  75     return TimeStampToDOM(GetUnloadEventStartTimeStamp());
  76   }
  77
  78   DOMTimeMilliSec GetUnloadEventEnd() {
  79     return TimeStampToDOM(GetUnloadEventEndTimeStamp());
  80   }
  81
  82   DOMTimeMilliSec GetDomLoading() const { return TimeStampToDOM(mDOMLoading); }
  83   DOMTimeMilliSec GetDomInteractive() const {
  84     return TimeStampToDOM(mDOMInteractive);
  85   }
  86   DOMTimeMilliSec GetDomContentLoadedEventStart() const {
  87     return TimeStampToDOM(mDOMContentLoadedEventStart);
  88   }
  89   DOMTimeMilliSec GetDomContentLoadedEventEnd() const {
  90     return TimeStampToDOM(mDOMContentLoadedEventEnd);
  91   }
  92   DOMTimeMilliSec GetDomComplete() const {
  93     return TimeStampToDOM(mDOMComplete);
  94   }
  95   DOMTimeMilliSec GetLoadEventStart() const {
  96     return TimeStampToDOM(mLoadEventStart);
  97   }
  98   DOMTimeMilliSec GetLoadEventEnd() const {
  99     return TimeStampToDOM(mLoadEventEnd);
 100   }
 101   DOMTimeMilliSec GetTimeToNonBlankPaint() const {
 102     return TimeStampToDOM(mNonBlankPaint);
 103   }
 104   DOMTimeMilliSec GetTimeToContentfulComposite() const {
 105     return TimeStampToDOM(mContentfulComposite);
 106   }
 107   DOMTimeMilliSec GetTimeToTTFI() const { return TimeStampToDOM(mTTFI); }
 108   DOMTimeMilliSec GetTimeToDOMContentFlushed() const {
 109     return TimeStampToDOM(mDOMContentFlushed);
 110   }
 111
 112   DOMHighResTimeStamp GetUnloadEventStartHighRes() {
 113     mozilla::TimeStamp stamp = GetUnloadEventStartTimeStamp();
 114     if (stamp.IsNull()) {
 115       return 0;
 116     }
 117     return TimeStampToDOMHighRes(stamp);
 118   }
 119   DOMHighResTimeStamp GetUnloadEventEndHighRes() {
 120     mozilla::TimeStamp stamp = GetUnloadEventEndTimeStamp();
 121     if (stamp.IsNull()) {
 122       return 0;
 123     }
 124     return TimeStampToDOMHighRes(stamp);
 125   }
 126   DOMHighResTimeStamp GetDomInteractiveHighRes() const {
 127     return TimeStampToDOMHighRes(mDOMInteractive);
 128   }
 129   DOMHighResTimeStamp GetDomContentLoadedEventStartHighRes() const {
 130     return TimeStampToDOMHighRes(mDOMContentLoadedEventStart);
 131   }
 132   DOMHighResTimeStamp GetDomContentLoadedEventEndHighRes() const {
 133     return TimeStampToDOMHighRes(mDOMContentLoadedEventEnd);
 134   }
 135   DOMHighResTimeStamp GetDomCompleteHighRes() const {
 136     return TimeStampToDOMHighRes(mDOMComplete);
 137   }
 138   DOMHighResTimeStamp GetLoadEventStartHighRes() const {
 139     return TimeStampToDOMHighRes(mLoadEventStart);
 140   }
 141   DOMHighResTimeStamp GetLoadEventEndHighRes() const {
 142     return TimeStampToDOMHighRes(mLoadEventEnd);
 143   }
 144
 145   enum class DocShellState : uint8_t { eActive, eInactive };
 146
 147   void NotifyNavigationStart(DocShellState aDocShellState);
 148   void NotifyFetchStart(nsIURI* aURI, Type aNavigationType);
 149   // A restoration occurs when the document is loaded from the
 150   // bfcache. This method sets the appropriate parameters of the
 151   // navigation timing object in this case.
 152   void NotifyRestoreStart();
 153   void NotifyBeforeUnload();
 154   void NotifyUnloadAccepted(nsIURI* aOldURI);
 155   void NotifyUnloadEventStart();
 156   void NotifyUnloadEventEnd();
 157   void NotifyLoadEventStart();
 158   void NotifyLoadEventEnd();
 159
 160   // Document changes state to 'loading' before connecting to timing
 161   void SetDOMLoadingTimeStamp(nsIURI* aURI, mozilla::TimeStamp aValue);
 162   void NotifyDOMLoading(nsIURI* aURI);
 163   void NotifyDOMInteractive(nsIURI* aURI);
 164   void NotifyDOMComplete(nsIURI* aURI);
 165   void NotifyDOMContentLoadedStart(nsIURI* aURI);
 166   void NotifyDOMContentLoadedEnd(nsIURI* aURI);
 167
 168   static void TTITimeoutCallback(nsITimer* aTimer, void* aClosure);
 169   void TTITimeout(nsITimer* aTimer);
 170
 171   void NotifyLongTask(mozilla::TimeStamp aWhen);
 172   void NotifyNonBlankPaintForRootContentDocument();
 173   void NotifyContentfulCompositeForRootContentDocument(
 174       const mozilla::TimeStamp& aCompositeEndTime);
 175   void NotifyDOMContentFlushedForRootContentDocument();
 176   void NotifyDocShellStateChanged(DocShellState aDocShellState);
 177
 178   DOMTimeMilliSec TimeStampToDOM(mozilla::TimeStamp aStamp) const;
 179
 180   inline DOMHighResTimeStamp TimeStampToDOMHighRes(
 181       mozilla::TimeStamp aStamp) const {
 182     if (aStamp.IsNull()) {
 183       return 0;
 184     }
 185     mozilla::TimeDuration duration = aStamp - mNavigationStart;
 186     return duration.ToMilliseconds();
 187   }
 188
 189   // Called by the DocumentLoadListener before sending the timing information
 190   // to the new content process.
 191   void Anonymize(nsIURI* aFinalURI);
 192
 193   inline already_AddRefed<nsDOMNavigationTiming> CloneNavigationTime(
 194       nsDocShell* aDocShell) const {
 195     RefPtr<nsDOMNavigationTiming> timing = new nsDOMNavigationTiming(aDocShell);
 196     timing->mNavigationStartHighRes = mNavigationStartHighRes;
 197     timing->mNavigationStart = mNavigationStart;
 198     return timing.forget();
 199   }
 200
 201   bool DocShellHasBeenActiveSinceNavigationStart() {
 202     return mDocShellHasBeenActiveSinceNavigationStart;
 203   }
 204
 205   mozilla::TimeStamp LoadEventEnd() { return mLoadEventEnd; }
 206
 207  private:
 208   friend class nsDocShell;
 209   nsDOMNavigationTiming(nsDocShell* aDocShell, nsDOMNavigationTiming* aOther);
 210   nsDOMNavigationTiming(const nsDOMNavigationTiming&) = delete;
 211   ~nsDOMNavigationTiming();
 212
 213   void Clear();
 214
 215   mozilla::TimeStamp GetUnloadEventStartTimeStamp() const;
 216   mozilla::TimeStamp GetUnloadEventEndTimeStamp() const;
 217
 218   bool IsTopLevelContentDocumentInContentProcess() const;
 219
 220   // Should those be amended, the IPC serializer should be updated
 221   // accordingly.
 222   mozilla::WeakPtr<nsDocShell> mDocShell;
 223
 224   nsCOMPtr<nsIURI> mUnloadedURI;
 225   nsCOMPtr<nsIURI> mLoadedURI;
 226   nsCOMPtr<nsITimer> mTTITimer;
 227
 228   Type mNavigationType;
 229   DOMHighResTimeStamp mNavigationStartHighRes;
 230   mozilla::TimeStamp mNavigationStart;
 231   mozilla::TimeStamp mNonBlankPaint;
 232   mozilla::TimeStamp mContentfulComposite;
 233   mozilla::TimeStamp mDOMContentFlushed;
 234
 235   mozilla::TimeStamp mBeforeUnloadStart;
 236   mozilla::TimeStamp mUnloadStart;
 237   mozilla::TimeStamp mUnloadEnd;
 238   mozilla::TimeStamp mLoadEventStart;
 239   mozilla::TimeStamp mLoadEventEnd;
 240
 241   mozilla::TimeStamp mDOMLoading;
 242   mozilla::TimeStamp mDOMInteractive;
 243   mozilla::TimeStamp mDOMContentLoadedEventStart;
 244   mozilla::TimeStamp mDOMContentLoadedEventEnd;
 245   mozilla::TimeStamp mDOMComplete;
 246
 247   mozilla::TimeStamp mTTFI;
 248
 249   bool mDocShellHasBeenActiveSinceNavigationStart;
 250
 251   friend struct mozilla::ipc::IPDLParamTraits<nsDOMNavigationTiming*>;
 252 };
 253
 254 // IPDL serializer. Please be aware of the caveats in sending across
 255 // the information and the potential resulting data leakage.
 256 // For now, this serializer is to only be used under a very narrowed scope
 257 // so that only the starting times are ever set.
 258 namespace mozilla::ipc {
 259 template <>
 260 struct IPDLParamTraits<nsDOMNavigationTiming*> {
 261   static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
 262                     nsDOMNavigationTiming* aParam);
 263   static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
 264                    RefPtr<nsDOMNavigationTiming>* aResult);
 265 };
 266
 267 }  // namespace mozilla::ipc
 268
 269 #endif /* nsDOMNavigationTiming_h___ */