dom/html/HTMLDNSPrefetch.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_HTMLDNSPrefetch_h___
   8 #define mozilla_dom_HTMLDNSPrefetch_h___
   9
  10 #include "nsCOMPtr.h"
  11 #include "nsIRequest.h"
  12 #include "nsString.h"
  13
  14 class nsITimer;
  15 class nsIURI;
  16 namespace mozilla {
  17
  18 class OriginAttributes;
  19
  20 namespace net {
  21 class NeckoParent;
  22 }  // namespace net
  23
  24 namespace dom {
  25 class Document;
  26 class Element;
  27
  28 class SupportsDNSPrefetch;
  29
  30 class HTMLDNSPrefetch {
  31  public:
  32   // The required aDocument parameter is the context requesting the prefetch -
  33   // under certain circumstances (e.g. headers, or security context) associated
  34   // with the context the prefetch will not be performed.
  35   static bool IsAllowed(Document* aDocument);
  36
  37   static nsresult Initialize();
  38   static nsresult Shutdown();
  39
  40   // Call one of the Prefetch* methods to start the lookup.
  41   //
  42   // The URI versions will defer DNS lookup until pageload is
  43   // complete, while the string versions submit the lookup to
  44   // the DNS system immediately. The URI version is somewhat lighter
  45   // weight, but its request is also more likely to be dropped due to a
  46   // full queue and it may only be used from the main thread.
  47   //
  48   // If you are planning to use the methods with the OriginAttributes param, be
  49   // sure that you pass a partitioned one. See StoragePrincipalHelper.h to know
  50   // more.
  51
  52   enum class Priority {
  53     Low,
  54     Medium,
  55     High,
  56   };
  57   static nsresult Prefetch(SupportsDNSPrefetch&, Element&, Priority);
  58   static nsresult Prefetch(
  59       const nsAString& host, bool isHttps,
  60       const OriginAttributes& aPartitionedPrincipalOriginAttributes,
  61       nsIRequest::TRRMode aTRRMode, Priority);
  62   static nsresult CancelPrefetch(
  63       const nsAString& host, bool isHttps,
  64       const OriginAttributes& aPartitionedPrincipalOriginAttributes,
  65       nsIRequest::TRRMode aTRRMode, Priority, nsresult aReason);
  66   static nsresult CancelPrefetch(SupportsDNSPrefetch&, Element&, Priority,
  67                                  nsresult aReason);
  68   static void ElementDestroyed(Element&, SupportsDNSPrefetch&);
  69
  70  private:
  71   static uint32_t PriorityToDNSServiceFlags(Priority);
  72
  73   static nsresult Prefetch(
  74       const nsAString& host, bool isHttps,
  75       const OriginAttributes& aPartitionedPrincipalOriginAttributes,
  76       uint32_t flags);
  77   static nsresult CancelPrefetch(
  78       const nsAString& hostname, bool isHttps,
  79       const OriginAttributes& aPartitionedPrincipalOriginAttributes,
  80       uint32_t flags, nsresult aReason);
  81
  82   friend class net::NeckoParent;
  83 };
  84
  85 // Elements that support DNS prefetch are expected to subclass this.
  86 class SupportsDNSPrefetch {
  87  public:
  88   bool IsInDNSPrefetch() { return mInDNSPrefetch; }
  89   void SetIsInDNSPrefetch() { mInDNSPrefetch = true; }
  90   void ClearIsInDNSPrefetch() { mInDNSPrefetch = false; }
  91
  92   void DNSPrefetchRequestStarted() {
  93     mDNSPrefetchDeferred = false;
  94     mDNSPrefetchRequested = true;
  95   }
  96
  97   void DNSPrefetchRequestDeferred() {
  98     mDNSPrefetchDeferred = true;
  99     mDNSPrefetchRequested = false;
 100   }
 101
 102   bool IsDNSPrefetchRequestDeferred() const { return mDNSPrefetchDeferred; }
 103
 104   // This could be a virtual function or something like that, but that would
 105   // cause our subclasses to grow by two pointers, rather than just 1 byte at
 106   // most.
 107   nsIURI* GetURIForDNSPrefetch(Element& aOwner);
 108
 109  protected:
 110   SupportsDNSPrefetch()
 111       : mInDNSPrefetch(false),
 112         mDNSPrefetchRequested(false),
 113         mDNSPrefetchDeferred(false),
 114         mDestroyedCalled(false) {}
 115
 116   void CancelDNSPrefetch(Element&);
 117   void TryDNSPrefetch(Element&);
 118
 119   // This MUST be called on the destructor of the Element subclass.
 120   // Our own destructor ensures that.
 121   void Destroyed(Element& aOwner) {
 122     MOZ_DIAGNOSTIC_ASSERT(!mDestroyedCalled,
 123                           "Multiple calls to SupportsDNSPrefetch::Destroyed?");
 124     mDestroyedCalled = true;
 125     if (mInDNSPrefetch) {
 126       HTMLDNSPrefetch::ElementDestroyed(aOwner, *this);
 127     }
 128   }
 129
 130   ~SupportsDNSPrefetch() {
 131     MOZ_DIAGNOSTIC_ASSERT(mDestroyedCalled,
 132                           "Need to call SupportsDNSPrefetch::Destroyed "
 133                           "from the owner element");
 134   }
 135
 136  private:
 137   bool mInDNSPrefetch : 1;
 138   bool mDNSPrefetchRequested : 1;
 139   bool mDNSPrefetchDeferred : 1;
 140   bool mDestroyedCalled : 1;
 141 };
 142
 143 }  // namespace dom
 144 }  // namespace mozilla
 145
 146 #endif