tor-browser

ResponsiveImageSelector.cpp (21100B)

---

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* 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 "mozilla/dom/ResponsiveImageSelector.h"

#include "mozilla/PresShell.h"
#include "mozilla/PresShellInlines.h"
#include "mozilla/ServoStyleSetInlines.h"
#include "mozilla/dom/Document.h"
#include "mozilla/dom/DocumentInlines.h"
#include "nsCSSProps.h"
#include "nsContentUtils.h"
#include "nsIURI.h"
#include "nsPresContext.h"

using namespace mozilla;
using namespace mozilla::dom;

namespace mozilla::dom {

NS_IMPL_CYCLE_COLLECTION(ResponsiveImageSelector, mOwnerNode)

static bool ParseInteger(const nsAString& aString, int32_t& aInt) {
 nsContentUtils::ParseHTMLIntegerResultFlags parseResult;
 aInt = nsContentUtils::ParseHTMLInteger(aString, &parseResult);
 return !(parseResult &
          (nsContentUtils::eParseHTMLInteger_Error |
           nsContentUtils::eParseHTMLInteger_DidNotConsumeAllInput |
           nsContentUtils::eParseHTMLInteger_NonStandard));
}

ResponsiveImageSelector::ResponsiveImageSelector(nsIContent* aContent)
   : mOwnerNode(aContent), mSelectedCandidateIndex(-1) {}

ResponsiveImageSelector::ResponsiveImageSelector(dom::Document* aDocument)
   : mOwnerNode(aDocument), mSelectedCandidateIndex(-1) {}

ResponsiveImageSelector::~ResponsiveImageSelector() = default;

void ResponsiveImageSelector::ParseSourceSet(
   const nsAString& aSrcSet,
   FunctionRef<void(ResponsiveImageCandidate&&)> aCallback) {
 nsAString::const_iterator iter, end;
 aSrcSet.BeginReading(iter);
 aSrcSet.EndReading(end);

 // Read URL / descriptor pairs
 while (iter != end) {
   nsAString::const_iterator url, urlEnd, descriptor;

   // Skip whitespace and commas.
   // Extra commas at this point are a non-fatal syntax error.
   for (; iter != end &&
          (nsContentUtils::IsHTMLWhitespace(*iter) || *iter == char16_t(','));
        ++iter);

   if (iter == end) {
     break;
   }

   url = iter;

   // Find end of url
   for (; iter != end && !nsContentUtils::IsHTMLWhitespace(*iter); ++iter);

   // Omit trailing commas from URL.
   // Multiple commas are a non-fatal error.
   while (iter != url) {
     if (*(--iter) != char16_t(',')) {
       iter++;
       break;
     }
   }

   const nsDependentSubstring& urlStr = Substring(url, iter);

   MOZ_ASSERT(url != iter, "Shouldn't have empty URL at this point");

   ResponsiveImageCandidate candidate;
   if (candidate.ConsumeDescriptors(iter, end)) {
     candidate.SetURLSpec(urlStr);
     aCallback(std::move(candidate));
   }
 }
}

// http://www.whatwg.org/specs/web-apps/current-work/#processing-the-image-candidates
bool ResponsiveImageSelector::SetCandidatesFromSourceSet(
   const nsAString& aSrcSet, nsIPrincipal* aTriggeringPrincipal) {
 ClearSelectedCandidate();

 if (!mOwnerNode || !mOwnerNode->GetBaseURI()) {
   MOZ_ASSERT(false, "Should not be parsing SourceSet without a document");
   return false;
 }

 mCandidates.Clear();

 auto eachCandidate = [&](ResponsiveImageCandidate&& aCandidate) {
   aCandidate.SetTriggeringPrincipal(
       nsContentUtils::GetAttrTriggeringPrincipal(
           Content(), aCandidate.URLString(), aTriggeringPrincipal));
   AppendCandidateIfUnique(std::move(aCandidate));
 };

 ParseSourceSet(aSrcSet, eachCandidate);

 bool parsedCandidates = !mCandidates.IsEmpty();

 // Re-add default to end of list
 MaybeAppendDefaultCandidate();

 return parsedCandidates;
}

uint32_t ResponsiveImageSelector::NumCandidates(bool aIncludeDefault) {
 uint32_t candidates = mCandidates.Length();

 // If present, the default candidate is the last item
 if (!aIncludeDefault && candidates && mCandidates.LastElement().IsDefault()) {
   candidates--;
 }

 return candidates;
}

nsIContent* ResponsiveImageSelector::Content() {
 return mOwnerNode->IsContent() ? mOwnerNode->AsContent() : nullptr;
}

dom::Document* ResponsiveImageSelector::Document() {
 return mOwnerNode->OwnerDoc();
}

void ResponsiveImageSelector::ClearDefaultSource() {
 ClearSelectedCandidate();
 // Check if the last element of our candidates is a default
 if (!mCandidates.IsEmpty() && mCandidates.LastElement().IsDefault()) {
   mCandidates.RemoveLastElement();
 }
}

void ResponsiveImageSelector::SetDefaultSource(nsIURI* aURI,
                                              nsIPrincipal* aPrincipal) {
 ClearDefaultSource();
 mDefaultSourceTriggeringPrincipal = aPrincipal;
 mDefaultSourceURL = VoidString();
 if (aURI) {
   nsAutoCString spec;
   aURI->GetSpec(spec);
   CopyUTF8toUTF16(spec, mDefaultSourceURL);
 }
 MaybeAppendDefaultCandidate();
}

void ResponsiveImageSelector::SetDefaultSource(const nsAString& aURLString,
                                              nsIPrincipal* aPrincipal) {
 ClearDefaultSource();
 mDefaultSourceTriggeringPrincipal = aPrincipal;
 mDefaultSourceURL = aURLString;
 MaybeAppendDefaultCandidate();
}

void ResponsiveImageSelector::ClearSelectedCandidate() {
 mSelectedCandidateIndex = -1;
 mSelectedCandidateURL = nullptr;
}

bool ResponsiveImageSelector::SetSizesFromDescriptor(const nsAString& aSizes) {
 ClearSelectedCandidate();

 NS_ConvertUTF16toUTF8 sizes(aSizes);
 mServoSourceSizeList.reset(Servo_SourceSizeList_Parse(&sizes));
 return !!mServoSourceSizeList;
}

void ResponsiveImageSelector::AppendCandidateIfUnique(
   ResponsiveImageCandidate&& aCandidate) {
 int numCandidates = mCandidates.Length();

 // With the exception of Default, which should not be added until we are done
 // building the list.
 if (aCandidate.IsDefault()) {
   return;
 }

 // Discard candidates with identical parameters, they will never match
 for (int i = 0; i < numCandidates; i++) {
   if (mCandidates[i].HasSameParameter(aCandidate)) {
     return;
   }
 }

 mCandidates.AppendElement(std::move(aCandidate));
}

void ResponsiveImageSelector::MaybeAppendDefaultCandidate() {
 if (mDefaultSourceURL.IsEmpty()) {
   return;
 }

 int numCandidates = mCandidates.Length();

 // https://html.spec.whatwg.org/multipage/embedded-content.html#update-the-source-set
 // step 4.1.3:
 // If child has a src attribute whose value is not the empty string and source
 // set does not contain an image source with a density descriptor value of 1,
 // and no image source with a width descriptor, append child's src attribute
 // value to source set.
 for (int i = 0; i < numCandidates; i++) {
   if (mCandidates[i].IsComputedFromWidth()) {
     return;
   } else if (mCandidates[i].Density(this) == 1.0) {
     return;
   }
 }

 ResponsiveImageCandidate defaultCandidate;
 defaultCandidate.SetParameterDefault();
 defaultCandidate.SetURLSpec(mDefaultSourceURL);
 defaultCandidate.SetTriggeringPrincipal(mDefaultSourceTriggeringPrincipal);
 // We don't use MaybeAppend since we want to keep this even if it can never
 // match, as it may if the source set changes.
 mCandidates.AppendElement(std::move(defaultCandidate));
}

already_AddRefed<nsIURI> ResponsiveImageSelector::GetSelectedImageURL() {
 SelectImage();

 nsCOMPtr<nsIURI> url = mSelectedCandidateURL;
 return url.forget();
}

bool ResponsiveImageSelector::GetSelectedImageURLSpec(nsAString& aResult) {
 SelectImage();

 if (mSelectedCandidateIndex == -1) {
   return false;
 }

 aResult.Assign(mCandidates[mSelectedCandidateIndex].URLString());
 return true;
}

double ResponsiveImageSelector::GetSelectedImageDensity() {
 int bestIndex = GetSelectedCandidateIndex();
 if (bestIndex < 0) {
   return 1.0;
 }

 return mCandidates[bestIndex].Density(this);
}

nsIPrincipal* ResponsiveImageSelector::GetSelectedImageTriggeringPrincipal() {
 int bestIndex = GetSelectedCandidateIndex();
 if (bestIndex < 0) {
   return nullptr;
 }

 return mCandidates[bestIndex].TriggeringPrincipal();
}

bool ResponsiveImageSelector::SelectImage(bool aReselect) {
 if (!aReselect && mSelectedCandidateIndex != -1) {
   // Already have selection
   return false;
 }

 int oldBest = mSelectedCandidateIndex;
 ClearSelectedCandidate();

 int numCandidates = mCandidates.Length();
 if (!numCandidates) {
   return oldBest != -1;
 }

 dom::Document* doc = Document();
 nsPresContext* pctx = doc->GetPresContext();
 nsCOMPtr<nsIURI> baseURI = mOwnerNode->GetBaseURI();

 if (!pctx || !baseURI) {
   return oldBest != -1;
 }

 double displayDensity = pctx->CSSPixelsToDevPixels(1.0f);
 double overrideDPPX = pctx->GetOverrideDPPX();

 if (overrideDPPX > 0) {
   displayDensity = overrideDPPX;
 }
 if (doc->ShouldResistFingerprinting(RFPTarget::WindowDevicePixelRatio)) {
   displayDensity = nsRFPService::GetDevicePixelRatioAtZoom(1);
 }

 // Per spec, "In a UA-specific manner, choose one image source"
 // - For now, select the lowest density greater than displayDensity, otherwise
 //   the greatest density available

 // If the list contains computed width candidates, compute the current
 // effective image width.
 double computedWidth = -1;
 for (int i = 0; i < numCandidates; i++) {
   if (mCandidates[i].IsComputedFromWidth()) {
     DebugOnly<bool> computeResult =
         ComputeFinalWidthForCurrentViewport(&computedWidth);
     MOZ_ASSERT(computeResult,
                "Computed candidates not allowed without sizes data");
     break;
   }
 }

 int bestIndex = -1;
 double bestDensity = -1.0;
 for (int i = 0; i < numCandidates; i++) {
   double candidateDensity = (computedWidth == -1)
                                 ? mCandidates[i].Density(this)
                                 : mCandidates[i].Density(computedWidth);
   // - If bestIndex is below display density, pick anything larger.
   // - Otherwise, prefer if less dense than bestDensity but still above
   //   displayDensity.
   if (bestIndex == -1 ||
       (bestDensity < displayDensity && candidateDensity > bestDensity) ||
       (candidateDensity >= displayDensity &&
        candidateDensity < bestDensity)) {
     bestIndex = i;
     bestDensity = candidateDensity;
   }
 }

 MOZ_ASSERT(bestIndex >= 0 && bestIndex < numCandidates);

 // Resolve URL
 nsresult rv;
 const nsAString& urlStr = mCandidates[bestIndex].URLString();
 nsCOMPtr<nsIURI> candidateURL;
 rv = nsContentUtils::NewURIWithDocumentCharset(getter_AddRefs(candidateURL),
                                                urlStr, doc, baseURI);

 mSelectedCandidateURL = NS_SUCCEEDED(rv) ? candidateURL : nullptr;
 mSelectedCandidateIndex = bestIndex;

 return mSelectedCandidateIndex != oldBest;
}

int ResponsiveImageSelector::GetSelectedCandidateIndex() {
 SelectImage();

 return mSelectedCandidateIndex;
}

bool ResponsiveImageSelector::ComputeFinalWidthForCurrentViewport(
   double* aWidth) {
 dom::Document* doc = Document();
 PresShell* presShell = doc->GetPresShell();
 nsPresContext* pctx = presShell ? presShell->GetPresContext() : nullptr;

 if (!pctx) {
   return false;
 }
 nscoord effectiveWidth =
     presShell->StyleSet()->EvaluateSourceSizeList(mServoSourceSizeList.get());

 *aWidth =
     nsPresContext::AppUnitsToDoubleCSSPixels(std::max(effectiveWidth, 0));
 return true;
}

ResponsiveImageCandidate::ResponsiveImageCandidate() {
 mType = CandidateType::Invalid;
 mValue.mDensity = 1.0;
}

void ResponsiveImageCandidate::SetURLSpec(const nsAString& aURLString) {
 mURLString = aURLString;
}

void ResponsiveImageCandidate::SetTriggeringPrincipal(
   nsIPrincipal* aPrincipal) {
 mTriggeringPrincipal = aPrincipal;
}

void ResponsiveImageCandidate::SetParameterAsComputedWidth(int32_t aWidth) {
 mType = CandidateType::ComputedFromWidth;
 mValue.mWidth = aWidth;
}

void ResponsiveImageCandidate::SetParameterDefault() {
 MOZ_ASSERT(!IsValid(), "double setting candidate type");

 mType = CandidateType::Default;
 // mValue shouldn't actually be used for this type, but set it to default
 // anyway
 mValue.mDensity = 1.0;
}

void ResponsiveImageCandidate::SetParameterInvalid() {
 mType = CandidateType::Invalid;
 // mValue shouldn't actually be used for this type, but set it to default
 // anyway
 mValue.mDensity = 1.0;
}

void ResponsiveImageCandidate::SetParameterAsDensity(double aDensity) {
 MOZ_ASSERT(!IsValid(), "double setting candidate type");

 mType = CandidateType::Density;
 mValue.mDensity = aDensity;
}

// Represents all supported descriptors for a ResponsiveImageCandidate, though
// there is no candidate type that uses all of these. This should generally
// match the mValue union of ResponsiveImageCandidate.
struct ResponsiveImageDescriptors {
 ResponsiveImageDescriptors() : mInvalid(false) {};

 Maybe<double> mDensity;
 Maybe<int32_t> mWidth;
 // We don't support "h" descriptors yet and they are not spec'd, but the
 // current spec does specify that they can be silently ignored (whereas
 // entirely unknown descriptors cause us to invalidate the candidate)
 //
 // If we ever start honoring them we should serialize them in
 // AppendDescriptors.
 Maybe<int32_t> mFutureCompatHeight;
 // If this descriptor set is bogus, e.g. a value was added twice (and thus
 // dropped) or an unknown descriptor was added.
 bool mInvalid;

 void AddDescriptor(const nsAString& aDescriptor);
 bool Valid();
 // Use the current set of descriptors to configure a candidate
 void FillCandidate(ResponsiveImageCandidate& aCandidate);
};

// Try to parse a single descriptor from a string. If value already set or
// unknown, sets invalid flag.
// This corresponds to the descriptor "Descriptor parser" step in:
// https://html.spec.whatwg.org/#parse-a-srcset-attribute
void ResponsiveImageDescriptors::AddDescriptor(const nsAString& aDescriptor) {
 if (aDescriptor.IsEmpty()) {
   return;
 }

 // All currently supported descriptors end with an identifying character.
 nsAString::const_iterator descStart, descType;
 aDescriptor.BeginReading(descStart);
 aDescriptor.EndReading(descType);
 descType--;
 const nsDependentSubstring& valueStr = Substring(descStart, descType);
 if (*descType == char16_t('w')) {
   int32_t possibleWidth;
   // If the value is not a valid non-negative integer, it doesn't match this
   // descriptor, fall through.
   if (ParseInteger(valueStr, possibleWidth) && possibleWidth >= 0) {
     if (possibleWidth != 0 && mWidth.isNothing() && mDensity.isNothing()) {
       mWidth.emplace(possibleWidth);
     } else {
       // Valid width descriptor, but width or density were already seen, sizes
       // support isn't enabled, or it parsed to 0, which is an error per spec
       mInvalid = true;
     }

     return;
   }
 } else if (*descType == char16_t('h')) {
   int32_t possibleHeight;
   // If the value is not a valid non-negative integer, it doesn't match this
   // descriptor, fall through.
   if (ParseInteger(valueStr, possibleHeight) && possibleHeight >= 0) {
     if (possibleHeight != 0 && mFutureCompatHeight.isNothing() &&
         mDensity.isNothing()) {
       mFutureCompatHeight.emplace(possibleHeight);
     } else {
       // Valid height descriptor, but height or density were already seen, or
       // it parsed to zero, which is an error per spec
       mInvalid = true;
     }

     return;
   }
 } else if (*descType == char16_t('x')) {
   // If the value is not a valid floating point number, it doesn't match this
   // descriptor, fall through.
   if (auto possibleDensity =
           nsContentUtils::ParseHTMLFloatingPointNumber(valueStr)) {
     if (*possibleDensity >= 0.0 && mWidth.isNothing() &&
         mDensity.isNothing() && mFutureCompatHeight.isNothing()) {
       mDensity = possibleDensity;
     } else {
       // Valid density descriptor, but height or width or density were already
       // seen, or it parsed to less than zero, which is an error per spec
       mInvalid = true;
     }

     return;
   }
 }

 // Matched no known descriptor, mark this descriptor set invalid
 mInvalid = true;
}

bool ResponsiveImageDescriptors::Valid() {
 return !mInvalid && !(mFutureCompatHeight.isSome() && mWidth.isNothing());
}

void ResponsiveImageDescriptors::FillCandidate(
   ResponsiveImageCandidate& aCandidate) {
 if (!Valid()) {
   aCandidate.SetParameterInvalid();
 } else if (mWidth.isSome()) {
   MOZ_ASSERT(mDensity.isNothing());  // Shouldn't be valid

   aCandidate.SetParameterAsComputedWidth(*mWidth);
 } else if (mDensity.isSome()) {
   MOZ_ASSERT(mWidth.isNothing());  // Shouldn't be valid

   aCandidate.SetParameterAsDensity(*mDensity);
 } else {
   // A valid set of descriptors with no density nor width (e.g. an empty set)
   // becomes 1.0 density, per spec
   aCandidate.SetParameterAsDensity(1.0);
 }
}

bool ResponsiveImageCandidate::ConsumeDescriptors(
   nsAString::const_iterator& aIter,
   const nsAString::const_iterator& aIterEnd) {
 nsAString::const_iterator& iter = aIter;
 const nsAString::const_iterator& end = aIterEnd;

 bool inParens = false;

 ResponsiveImageDescriptors descriptors;

 // Parse descriptor list.
 // This corresponds to the descriptor parsing loop from:
 // https://html.spec.whatwg.org/#parse-a-srcset-attribute

 // Skip initial whitespace
 for (; iter != end && nsContentUtils::IsHTMLWhitespace(*iter); ++iter);

 nsAString::const_iterator currentDescriptor = iter;

 for (;; iter++) {
   if (iter == end) {
     descriptors.AddDescriptor(Substring(currentDescriptor, iter));
     break;
   } else if (inParens) {
     if (*iter == char16_t(')')) {
       inParens = false;
     }
   } else {
     if (*iter == char16_t(',')) {
       // End of descriptors, flush current descriptor and advance past comma
       // before breaking
       descriptors.AddDescriptor(Substring(currentDescriptor, iter));
       iter++;
       break;
     }
     if (nsContentUtils::IsHTMLWhitespace(*iter)) {
       // End of current descriptor, consume it, skip spaces
       // ("After descriptor" state in spec) before continuing
       descriptors.AddDescriptor(Substring(currentDescriptor, iter));
       for (; iter != end && nsContentUtils::IsHTMLWhitespace(*iter); ++iter);
       if (iter == end) {
         break;
       }
       currentDescriptor = iter;
       // Leave one whitespace so the loop advances to this position next
       // iteration
       iter--;
     } else if (*iter == char16_t('(')) {
       inParens = true;
     }
   }
 }

 descriptors.FillCandidate(*this);

 return IsValid();
}

bool ResponsiveImageCandidate::HasSameParameter(
   const ResponsiveImageCandidate& aOther) const {
 if (aOther.mType != mType) {
   return false;
 }

 if (mType == CandidateType::Default) {
   return true;
 }

 if (mType == CandidateType::Density) {
   return aOther.mValue.mDensity == mValue.mDensity;
 }

 if (mType == CandidateType::Invalid) {
   MOZ_ASSERT_UNREACHABLE("Comparing invalid candidates?");
   return true;
 }

 if (mType == CandidateType::ComputedFromWidth) {
   return aOther.mValue.mWidth == mValue.mWidth;
 }

 MOZ_ASSERT(false, "Somebody forgot to check for all uses of this enum");
 return false;
}

double ResponsiveImageCandidate::Density(
   ResponsiveImageSelector* aSelector) const {
 if (mType == CandidateType::ComputedFromWidth) {
   double width;
   if (!aSelector->ComputeFinalWidthForCurrentViewport(&width)) {
     return 1.0;
   }
   return Density(width);
 }

 // Other types don't need matching width
 MOZ_ASSERT(mType == CandidateType::Default || mType == CandidateType::Density,
            "unhandled candidate type");
 return Density(-1);
}

void ResponsiveImageCandidate::AppendDescriptors(
   nsAString& aDescriptors) const {
 MOZ_ASSERT(IsValid());
 switch (mType) {
   case CandidateType::Default:
   case CandidateType::Invalid:
     return;
   case CandidateType::ComputedFromWidth:
     aDescriptors.Append(' ');
     aDescriptors.AppendInt(mValue.mWidth);
     aDescriptors.Append('w');
     return;
   case CandidateType::Density:
     aDescriptors.Append(' ');
     aDescriptors.AppendFloat(mValue.mDensity);
     aDescriptors.Append('x');
     return;
 }
}

double ResponsiveImageCandidate::Density(double aMatchingWidth) const {
 if (mType == CandidateType::Invalid) {
   MOZ_ASSERT(false, "Getting density for uninitialized candidate");
   return 1.0;
 }

 if (mType == CandidateType::Default) {
   return 1.0;
 }

 if (mType == CandidateType::Density) {
   return mValue.mDensity;
 }
 if (mType == CandidateType::ComputedFromWidth) {
   if (aMatchingWidth < 0) {
     MOZ_ASSERT(
         false,
         "Don't expect to have a negative matching width at this point");
     return 1.0;
   }
   double density = double(mValue.mWidth) / aMatchingWidth;
   MOZ_ASSERT(density > 0.0);
   return density;
 }

 MOZ_ASSERT(false, "Unknown candidate type");
 return 1.0;
}

}  // namespace mozilla::dom