dom/base/ResizeObserver.h

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim:set ts=2 sw=2 sts=2 et cindent: */
   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_ResizeObserver_h
   8 #define mozilla_dom_ResizeObserver_h
   9
  10 #include "gfxPoint.h"
  11 #include "js/TypeDecls.h"
  12 #include "mozilla/AppUnits.h"
  13 #include "mozilla/Attributes.h"
  14 #include "mozilla/LinkedList.h"
  15 #include "mozilla/WritingModes.h"
  16 #include "mozilla/dom/DOMRect.h"
  17 #include "mozilla/dom/BindingDeclarations.h"
  18 #include "mozilla/dom/ResizeObserverBinding.h"
  19 #include "nsCoord.h"
  20 #include "nsCycleCollectionParticipant.h"
  21 #include "nsRefPtrHashtable.h"
  22 #include "nsTArray.h"
  23 #include "nsWrapperCache.h"
  24
  25 // XXX Avoid including this here by moving function bodies to the cpp file
  26 #include "nsPIDOMWindow.h"
  27
  28 namespace mozilla {
  29 class ErrorResult;
  30
  31 namespace dom {
  32
  33 class Element;
  34
  35 // The logical size in pixels.
  36 // Note: if LogicalPixelSize have usages other than ResizeObserver in the
  37 // future, it might be better to change LogicalSize into a template class, and
  38 // use it to implement LogicalPixelSize.
  39 class LogicalPixelSize {
  40  public:
  41   LogicalPixelSize() = default;
  42   LogicalPixelSize(WritingMode aWM, const gfx::Size& aSize) {
  43     mSize = aSize;
  44     if (aWM.IsVertical()) {
  45       std::swap(mSize.width, mSize.height);
  46     }
  47   }
  48
  49   gfx::Size PhysicalSize(WritingMode aWM) const {
  50     if (!aWM.IsVertical()) {
  51       return mSize;
  52     }
  53     gfx::Size result(mSize);
  54     std::swap(result.width, result.height);
  55     return result;
  56   }
  57
  58   bool operator==(const LogicalPixelSize& aOther) const {
  59     return mSize == aOther.mSize;
  60   }
  61   bool operator!=(const LogicalPixelSize& aOther) const {
  62     return !(*this == aOther);
  63   }
  64
  65   float ISize() const { return mSize.width; }
  66   float BSize() const { return mSize.height; }
  67   float& ISize() { return mSize.width; }
  68   float& BSize() { return mSize.height; }
  69
  70  private:
  71   // |mSize.width| represents inline-size and |mSize.height| represents
  72   // block-size.
  73   gfx::Size mSize;
  74 };
  75
  76 // For the internal implementation in ResizeObserver. Normally, this is owned by
  77 // ResizeObserver.
  78 class ResizeObservation final : public LinkedListElement<ResizeObservation> {
  79  public:
  80   NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(ResizeObservation)
  81   NS_DECL_CYCLE_COLLECTION_NATIVE_CLASS(ResizeObservation)
  82
  83   ResizeObservation(Element&, ResizeObserver&, ResizeObserverBoxOptions);
  84
  85   Element* Target() const { return mTarget; }
  86
  87   ResizeObserverBoxOptions BoxOptions() const { return mObservedBox; }
  88
  89   /**
  90    * Returns whether the observed target element size differs from the saved
  91    * mLastReportedSize.
  92    */
  93   bool IsActive() const;
  94
  95   /**
  96    * Update current mLastReportedSize to aSize.
  97    */
  98   void UpdateLastReportedSize(const nsTArray<LogicalPixelSize>& aSize);
  99
 100   enum class RemoveFromObserver : bool { No, Yes };
 101   void Unlink(RemoveFromObserver);
 102
 103  protected:
 104   ~ResizeObservation() { Unlink(RemoveFromObserver::No); };
 105
 106   nsCOMPtr<Element> mTarget;
 107
 108   // Weak, observer always outlives us.
 109   ResizeObserver* mObserver;
 110
 111   const ResizeObserverBoxOptions mObservedBox;
 112
 113   // The latest recorded of observed target.
 114   // This will be CSS pixels for border-box/content-box, or device pixels for
 115   // device-pixel-content-box.
 116   AutoTArray<LogicalPixelSize, 1> mLastReportedSize;
 117 };
 118
 119 /**
 120  * ResizeObserver interfaces and algorithms are based on
 121  * https://drafts.csswg.org/resize-observer/#api
 122  */
 123 class ResizeObserver final : public nsISupports, public nsWrapperCache {
 124
 125  public:
 126   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
 127   NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(ResizeObserver)
 128
 129   ResizeObserver(nsCOMPtr<nsPIDOMWindowInner>&& aOwner, Document* aDocument,
 130                  ResizeObserverCallback& aCb)
 131       : mOwner(std::move(aOwner)), mDocument(aDocument), mCallback(&aCb) {
 132     MOZ_ASSERT(mOwner, "Need a non-null owner window");
 133     MOZ_ASSERT(mDocument, "Need a non-null doc");
 134     MOZ_ASSERT(mDocument == mOwner->GetExtantDoc());
 135   }
 136
 137   nsISupports* GetParentObject() const { return mOwner; }
 138
 139   JSObject* WrapObject(JSContext* aCx,
 140                        JS::Handle<JSObject*> aGivenProto) override {
 141     return ResizeObserver_Binding::Wrap(aCx, this, aGivenProto);
 142   }
 143
 144   static already_AddRefed<ResizeObserver> Constructor(
 145       const GlobalObject& aGlobal, ResizeObserverCallback& aCb,
 146       ErrorResult& aRv);
 147
 148   void Observe(Element&, const ResizeObserverOptions&);
 149   void Unobserve(Element&);
 150
 151   void Disconnect();
 152
 153   /**
 154    * Gather all observations which have an observed target with size changed
 155    * since last BroadcastActiveObservations() in this ResizeObserver.
 156    * An observation will be skipped if the depth of its observed target is less
 157    * or equal than aDepth. All gathered observations will be added to
 158    * mActiveTargets.
 159    */
 160   void GatherActiveObservations(uint32_t aDepth);
 161
 162   /**
 163    * Returns whether this ResizeObserver has any active observations
 164    * since last GatherActiveObservations().
 165    */
 166   bool HasActiveObservations() const { return !mActiveTargets.IsEmpty(); }
 167
 168   /**
 169    * Returns whether this ResizeObserver has any skipped observations
 170    * since last GatherActiveObservations().
 171    */
 172   bool HasSkippedObservations() const { return mHasSkippedTargets; }
 173
 174   /**
 175    * Invoke the callback function in JavaScript for all active observations
 176    * and pass the sequence of ResizeObserverEntry so JavaScript can access them.
 177    * The active observations' mLastReportedSize fields will be updated, and
 178    * mActiveTargets will be cleared. It also returns the shallowest depth of
 179    * elements from active observations or numeric_limits<uint32_t>::max() if
 180    * there are not any active observations.
 181    */
 182   MOZ_CAN_RUN_SCRIPT uint32_t BroadcastActiveObservations();
 183
 184   /**
 185    * Returns |aTarget|'s size in the form of gfx::Size (in pixels).
 186    * If the target is an SVG that does not participate in CSS layout,
 187    * its width and height are determined from bounding box. Otherwise, the
 188    * relevant box is determined according to the |aBox| parameter.
 189    *
 190    * If dom.resize_observer.support_fragments is enabled, or if
 191    * |aForceFragmentHandling| is true then the function reports the size of all
 192    * fragments, and not just the first one.
 193    *
 194    * https://www.w3.org/TR/resize-observer-1/#calculate-box-size
 195    */
 196   static AutoTArray<LogicalPixelSize, 1> CalculateBoxSize(
 197       Element* aTarget, ResizeObserverBoxOptions aBox,
 198       bool aForceFragmentHandling = false);
 199
 200  protected:
 201   ~ResizeObserver() { Disconnect(); }
 202
 203   nsCOMPtr<nsPIDOMWindowInner> mOwner;
 204   // The window's document at the time of ResizeObserver creation.
 205   RefPtr<Document> mDocument;
 206   RefPtr<ResizeObserverCallback> mCallback;
 207   nsTArray<RefPtr<ResizeObservation>> mActiveTargets;
 208   // The spec uses a list to store the skipped targets. However, it seems what
 209   // we want is to check if there are any skipped targets (i.e. existence).
 210   // Therefore, we use a boolean value to represent the existence of skipped
 211   // targets.
 212   bool mHasSkippedTargets = false;
 213
 214   // Combination of HashTable and LinkedList so we can iterate through
 215   // the elements of HashTable in order of insertion time, so we can deliver
 216   // observations in the correct order
 217   // FIXME: it will be nice if we have our own data structure for this in the
 218   // future, and mObservationMap should be considered the "owning" storage for
 219   // the observations, so it'd be better to drop mObservationList later.
 220   nsRefPtrHashtable<nsPtrHashKey<Element>, ResizeObservation> mObservationMap;
 221   LinkedList<ResizeObservation> mObservationList;
 222 };
 223
 224 /**
 225  * ResizeObserverEntry is the entry that contains the information for observed
 226  * elements. This object is the one that's visible to JavaScript in callback
 227  * function that is fired by ResizeObserver.
 228  */
 229 class ResizeObserverEntry final : public nsISupports, public nsWrapperCache {
 230  public:
 231   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
 232   NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(ResizeObserverEntry)
 233
 234   ResizeObserverEntry(
 235       nsISupports* aOwner, Element& aTarget,
 236       const nsTArray<LogicalPixelSize>& aBorderBoxSize,
 237       const nsTArray<LogicalPixelSize>& aContentBoxSize,
 238       const nsTArray<LogicalPixelSize>& aDevicePixelContentBoxSize)
 239       : mOwner(aOwner), mTarget(&aTarget) {
 240     MOZ_ASSERT(mOwner, "Need a non-null owner");
 241     MOZ_ASSERT(mTarget, "Need a non-null target element");
 242
 243     SetBorderBoxSize(aBorderBoxSize);
 244     SetContentRectAndSize(aContentBoxSize);
 245     SetDevicePixelContentSize(aDevicePixelContentBoxSize);
 246   }
 247
 248   nsISupports* GetParentObject() const { return mOwner; }
 249
 250   JSObject* WrapObject(JSContext* aCx,
 251                        JS::Handle<JSObject*> aGivenProto) override {
 252     return ResizeObserverEntry_Binding::Wrap(aCx, this, aGivenProto);
 253   }
 254
 255   Element* Target() const { return mTarget; }
 256
 257   /**
 258    * Returns the DOMRectReadOnly of target's content rect so it can be
 259    * accessed from JavaScript in callback function of ResizeObserver.
 260    */
 261   DOMRectReadOnly* ContentRect() const { return mContentRect; }
 262
 263   /**
 264    * Returns target's logical border-box size, content-box size, and
 265    * device-pixel-content-box as an array of ResizeObserverSize.
 266    */
 267   void GetBorderBoxSize(nsTArray<RefPtr<ResizeObserverSize>>& aRetVal) const;
 268   void GetContentBoxSize(nsTArray<RefPtr<ResizeObserverSize>>& aRetVal) const;
 269   void GetDevicePixelContentBoxSize(
 270       nsTArray<RefPtr<ResizeObserverSize>>& aRetVal) const;
 271
 272  private:
 273   ~ResizeObserverEntry() = default;
 274
 275   // Set borderBoxSize.
 276   void SetBorderBoxSize(const nsTArray<LogicalPixelSize>& aSize);
 277   // Set contentRect and contentBoxSize.
 278   void SetContentRectAndSize(const nsTArray<LogicalPixelSize>& aSize);
 279   // Set devicePixelContentBoxSize.
 280   void SetDevicePixelContentSize(const nsTArray<LogicalPixelSize>& aSize);
 281
 282   nsCOMPtr<nsISupports> mOwner;
 283   nsCOMPtr<Element> mTarget;
 284
 285   RefPtr<DOMRectReadOnly> mContentRect;
 286   AutoTArray<RefPtr<ResizeObserverSize>, 1> mBorderBoxSize;
 287   AutoTArray<RefPtr<ResizeObserverSize>, 1> mContentBoxSize;
 288   AutoTArray<RefPtr<ResizeObserverSize>, 1> mDevicePixelContentBoxSize;
 289 };
 290
 291 class ResizeObserverSize final : public nsISupports, public nsWrapperCache {
 292  public:
 293   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
 294   NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(ResizeObserverSize)
 295
 296   ResizeObserverSize(nsISupports* aOwner, const LogicalPixelSize& aSize)
 297       : mOwner(aOwner), mSize(aSize) {
 298     MOZ_ASSERT(mOwner, "Need a non-null owner");
 299   }
 300
 301   nsISupports* GetParentObject() const { return mOwner; }
 302
 303   JSObject* WrapObject(JSContext* aCx,
 304                        JS::Handle<JSObject*> aGivenProto) override {
 305     return ResizeObserverSize_Binding::Wrap(aCx, this, aGivenProto);
 306   }
 307
 308   float InlineSize() const { return mSize.ISize(); }
 309   float BlockSize() const { return mSize.BSize(); }
 310
 311  protected:
 312   ~ResizeObserverSize() = default;
 313
 314   nsCOMPtr<nsISupports> mOwner;
 315   // The logical size value:
 316   // 1. content-box/border-box: in CSS pixels.
 317   // 2. device-pixel-content-box: in device pixels.
 318   const LogicalPixelSize mSize;
 319 };
 320
 321 }  // namespace dom
 322 }  // namespace mozilla
 323
 324 #endif  // mozilla_dom_ResizeObserver_h