dom/base/ResponsiveImageSelector.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "mozilla/dom/ResponsiveImageSelector.h"
   7 #include "nsIURI.h"
   8 #include "nsIDocument.h"
   9 #include "nsContentUtils.h"
  10 #include "nsPresContext.h"
  11 #include "nsNetUtil.h"
  12
  13 #include "nsCSSParser.h"
  14 #include "nsCSSProps.h"
  15 #include "nsIMediaList.h"
  16 #include "nsRuleNode.h"
  17 #include "nsRuleData.h"
  18
  19 using namespace mozilla;
  20 using namespace mozilla::dom;
  21
  22 namespace mozilla {
  23 namespace dom {
  24
  25 NS_IMPL_CYCLE_COLLECTION(ResponsiveImageSelector, mContent)
  26
  27 NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(ResponsiveImageSelector, AddRef)
  28 NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(ResponsiveImageSelector, Release)
  29
  30 static bool
  31 ParseInteger(const nsAString& aString, int32_t& aInt)
  32 {
  33   nsContentUtils::ParseHTMLIntegerResultFlags parseResult;
  34   aInt = nsContentUtils::ParseHTMLInteger(aString, &parseResult);
  35   return !(parseResult &
  36            ( nsContentUtils::eParseHTMLInteger_Error |
  37              nsContentUtils::eParseHTMLInteger_DidNotConsumeAllInput |
  38              nsContentUtils::eParseHTMLInteger_IsPercent ));
  39 }
  40
  41 ResponsiveImageSelector::ResponsiveImageSelector(nsIContent *aContent)
  42   : mContent(aContent),
  43     mBestCandidateIndex(-1)
  44 {
  45 }
  46
  47 ResponsiveImageSelector::~ResponsiveImageSelector()
  48 {}
  49
  50 // http://www.whatwg.org/specs/web-apps/current-work/#processing-the-image-candidates
  51 bool
  52 ResponsiveImageSelector::SetCandidatesFromSourceSet(const nsAString & aSrcSet)
  53 {
  54   nsIDocument* doc = mContent ? mContent->OwnerDoc() : nullptr;
  55   nsCOMPtr<nsIURI> docBaseURI = mContent ? mContent->GetBaseURI() : nullptr;
  56
  57   if (!mContent || !doc || !docBaseURI) {
  58     MOZ_ASSERT(false,
  59                "Should not be parsing SourceSet without a content and document");
  60     return false;
  61   }
  62
  63   // Preserve the default source if we have one, it has a separate setter.
  64   uint32_t prevNumCandidates = mCandidates.Length();
  65   nsCOMPtr<nsIURI> defaultURL;
  66   if (prevNumCandidates && (mCandidates[prevNumCandidates - 1].Type() ==
  67                             ResponsiveImageCandidate::eCandidateType_Default)) {
  68     defaultURL = mCandidates[prevNumCandidates - 1].URL();
  69   }
  70
  71   mCandidates.Clear();
  72
  73   nsAString::const_iterator iter, end;
  74   aSrcSet.BeginReading(iter);
  75   aSrcSet.EndReading(end);
  76
  77   // Read URL / descriptor pairs
  78   while (iter != end) {
  79     nsAString::const_iterator url, desc;
  80
  81     // Skip whitespace
  82     for (; iter != end && nsContentUtils::IsHTMLWhitespace(*iter); ++iter);
  83
  84     if (iter == end) {
  85       break;
  86     }
  87
  88     url = iter;
  89
  90     // Find end of url
  91     for (;iter != end && !nsContentUtils::IsHTMLWhitespace(*iter); ++iter);
  92
  93     desc = iter;
  94
  95     // Find end of descriptor
  96     for (; iter != end && *iter != char16_t(','); ++iter);
  97     const nsDependentSubstring &descriptor = Substring(desc, iter);
  98
  99     nsresult rv;
 100     nsCOMPtr<nsIURI> candidateURL;
 101     rv = nsContentUtils::NewURIWithDocumentCharset(getter_AddRefs(candidateURL),
 102                                                    Substring(url, desc),
 103                                                    doc,
 104                                                    docBaseURI);
 105     if (NS_SUCCEEDED(rv) && candidateURL) {
 106       NS_TryToSetImmutable(candidateURL);
 107       ResponsiveImageCandidate candidate;
 108       if (candidate.SetParamaterFromDescriptor(descriptor)) {
 109         candidate.SetURL(candidateURL);
 110         AppendCandidateIfUnique(candidate);
 111       }
 112     }
 113
 114     // Advance past comma
 115     if (iter != end) {
 116       ++iter;
 117     }
 118   }
 119
 120   bool parsedCandidates = mCandidates.Length() > 0;
 121
 122   // Re-add default to end of list
 123   if (defaultURL) {
 124     AppendDefaultCandidate(defaultURL);
 125   }
 126
 127   return parsedCandidates;
 128 }
 129
 130 nsresult
 131 ResponsiveImageSelector::SetDefaultSource(const nsAString & aSpec)
 132 {
 133   nsIDocument* doc = mContent ? mContent->OwnerDoc() : nullptr;
 134   nsCOMPtr<nsIURI> docBaseURI = mContent ? mContent->GetBaseURI() : nullptr;
 135
 136   if (!mContent || !doc || !docBaseURI) {
 137     MOZ_ASSERT(false,
 138                "Should not be calling this without a content and document");
 139     return NS_ERROR_UNEXPECTED;
 140   }
 141
 142   if (aSpec.IsEmpty()) {
 143     SetDefaultSource(nullptr);
 144     return NS_OK;
 145   }
 146
 147   nsresult rv;
 148   nsCOMPtr<nsIURI> candidateURL;
 149   rv = nsContentUtils::NewURIWithDocumentCharset(getter_AddRefs(candidateURL),
 150                                                  aSpec, doc, docBaseURI);
 151   NS_ENSURE_SUCCESS(rv, rv);
 152
 153   SetDefaultSource(candidateURL);
 154   return NS_OK;
 155 }
 156
 157 uint32_t
 158 ResponsiveImageSelector::NumCandidates(bool aIncludeDefault)
 159 {
 160   uint32_t candidates = mCandidates.Length();
 161
 162   // If present, the default candidate is the last item
 163   if (!aIncludeDefault && candidates &&
 164       (mCandidates[candidates - 1].Type() ==
 165        ResponsiveImageCandidate::eCandidateType_Default)) {
 166     candidates--;
 167   }
 168
 169   return candidates;
 170 }
 171
 172 void
 173 ResponsiveImageSelector::SetDefaultSource(nsIURI *aURL)
 174 {
 175   // Check if the last element of our candidates is a default
 176   int32_t candidates = mCandidates.Length();
 177   if (candidates && (mCandidates[candidates - 1].Type() ==
 178                      ResponsiveImageCandidate::eCandidateType_Default)) {
 179     mCandidates.RemoveElementAt(candidates - 1);
 180     if (mBestCandidateIndex == candidates - 1) {
 181       mBestCandidateIndex = -1;
 182     }
 183   }
 184
 185   // Add new default if set
 186   if (aURL) {
 187     AppendDefaultCandidate(aURL);
 188   }
 189 }
 190
 191 bool
 192 ResponsiveImageSelector::SetSizesFromDescriptor(const nsAString & aSizes)
 193 {
 194   mSizeQueries.Clear();
 195   mSizeValues.Clear();
 196   mBestCandidateIndex = -1;
 197
 198   nsCSSParser cssParser;
 199
 200   if (!cssParser.ParseSourceSizeList(aSizes, nullptr, 0,
 201                                      mSizeQueries, mSizeValues, true)) {
 202     return false;
 203   }
 204
 205   return mSizeQueries.Length() > 0;
 206 }
 207
 208 void
 209 ResponsiveImageSelector::AppendCandidateIfUnique(const ResponsiveImageCandidate & aCandidate)
 210 {
 211   int numCandidates = mCandidates.Length();
 212
 213   // With the exception of Default, which should not be added until we are done
 214   // building the list, the spec forbids mixing width and explicit density
 215   // selectors in the same set.
 216   if (numCandidates && mCandidates[0].Type() != aCandidate.Type()) {
 217     return;
 218   }
 219
 220   // Discard candidates with identical parameters, they will never match
 221   for (int i = 0; i < numCandidates; i++) {
 222     if (mCandidates[i].HasSameParameter(aCandidate)) {
 223       return;
 224     }
 225   }
 226
 227   mBestCandidateIndex = -1;
 228   mCandidates.AppendElement(aCandidate);
 229 }
 230
 231 void
 232 ResponsiveImageSelector::AppendDefaultCandidate(nsIURI *aURL)
 233 {
 234   NS_ENSURE_TRUE(aURL, /* void */);
 235
 236   ResponsiveImageCandidate defaultCandidate;
 237   defaultCandidate.SetParameterDefault();
 238   defaultCandidate.SetURL(aURL);
 239   // We don't use MaybeAppend since we want to keep this even if it can never
 240   // match, as it may if the source set changes.
 241   mBestCandidateIndex = -1;
 242   mCandidates.AppendElement(defaultCandidate);
 243 }
 244
 245 already_AddRefed<nsIURI>
 246 ResponsiveImageSelector::GetSelectedImageURL()
 247 {
 248   int bestIndex = GetBestCandidateIndex();
 249   if (bestIndex < 0) {
 250     return nullptr;
 251   }
 252
 253   nsCOMPtr<nsIURI> bestURL = mCandidates[bestIndex].URL();
 254   MOZ_ASSERT(bestURL, "Shouldn't have candidates with no URL in the array");
 255   return bestURL.forget();
 256 }
 257
 258 double
 259 ResponsiveImageSelector::GetSelectedImageDensity()
 260 {
 261   int bestIndex = GetBestCandidateIndex();
 262   if (bestIndex < 0) {
 263     return 1.0;
 264   }
 265
 266   return mCandidates[bestIndex].Density(this);
 267 }
 268
 269 bool
 270 ResponsiveImageSelector::SelectImage(bool aReselect)
 271 {
 272   if (!aReselect && mBestCandidateIndex != -1) {
 273     // Already have selection
 274     return false;
 275   }
 276
 277   int oldBest = mBestCandidateIndex;
 278   mBestCandidateIndex = -1;
 279   return GetBestCandidateIndex() != oldBest;
 280 }
 281
 282 int
 283 ResponsiveImageSelector::GetBestCandidateIndex()
 284 {
 285   if (mBestCandidateIndex != -1) {
 286     return mBestCandidateIndex;
 287   }
 288
 289   int numCandidates = mCandidates.Length();
 290   if (!numCandidates) {
 291     return -1;
 292   }
 293
 294   nsIDocument* doc = mContent ? mContent->OwnerDoc() : nullptr;
 295   nsIPresShell *shell = doc ? doc->GetShell() : nullptr;
 296   nsPresContext *pctx = shell ? shell->GetPresContext() : nullptr;
 297
 298   if (!pctx) {
 299     MOZ_ASSERT(false, "Unable to find document prescontext");
 300     return -1;
 301   }
 302
 303   double displayDensity = pctx->CSSPixelsToDevPixels(1.0f);
 304
 305   // Per spec, "In a UA-specific manner, choose one image source"
 306   // - For now, select the lowest density greater than displayDensity, otherwise
 307   //   the greatest density available
 308
 309   // If the list contains computed width candidates, compute the current
 310   // effective image width. Note that we currently disallow both computed and
 311   // static density candidates in the same selector, so checking the first
 312   // candidate is sufficient.
 313   int32_t computedWidth = -1;
 314   if (numCandidates && mCandidates[0].IsComputedFromWidth()) {
 315     DebugOnly<bool> computeResult = \
 316       ComputeFinalWidthForCurrentViewport(&computedWidth);
 317     MOZ_ASSERT(computeResult,
 318                "Computed candidates not allowed without sizes data");
 319
 320     // If we have a default candidate in the list, don't consider it when using
 321     // computed widths. (It has a static 1.0 density that is inapplicable to a
 322     // sized-image)
 323     if (numCandidates > 1 && mCandidates[numCandidates - 1].Type() ==
 324         ResponsiveImageCandidate::eCandidateType_Default) {
 325       numCandidates--;
 326     }
 327   }
 328
 329   int bestIndex = -1;
 330   double bestDensity = -1.0;
 331   for (int i = 0; i < numCandidates; i++) {
 332     double candidateDensity = \
 333       (computedWidth == -1) ? mCandidates[i].Density(this)
 334                             : mCandidates[i].Density(computedWidth);
 335     // - If bestIndex is below display density, pick anything larger.
 336     // - Otherwise, prefer if less dense than bestDensity but still above
 337     //   displayDensity.
 338     if (bestIndex == -1 ||
 339         (bestDensity < displayDensity && candidateDensity > bestDensity) ||
 340         (candidateDensity >= displayDensity && candidateDensity < bestDensity)) {
 341       bestIndex = i;
 342       bestDensity = candidateDensity;
 343     }
 344   }
 345
 346   MOZ_ASSERT(bestIndex >= 0 && bestIndex < numCandidates);
 347   mBestCandidateIndex = bestIndex;
 348   return bestIndex;
 349 }
 350
 351 bool
 352 ResponsiveImageSelector::ComputeFinalWidthForCurrentViewport(int32_t *aWidth)
 353 {
 354   unsigned int numSizes = mSizeQueries.Length();
 355   nsIDocument* doc = mContent ? mContent->OwnerDoc() : nullptr;
 356   nsIPresShell *presShell = doc ? doc->GetShell() : nullptr;
 357   nsPresContext *pctx = presShell ? presShell->GetPresContext() : nullptr;
 358
 359   if (!pctx) {
 360     MOZ_ASSERT(false, "Unable to find presContext for this content");
 361     return false;
 362   }
 363
 364   MOZ_ASSERT(numSizes == mSizeValues.Length(),
 365              "mSizeValues length differs from mSizeQueries");
 366
 367   unsigned int i;
 368   for (i = 0; i < numSizes; i++) {
 369     if (mSizeQueries[i]->Matches(pctx, nullptr)) {
 370       break;
 371     }
 372   }
 373
 374   nscoord effectiveWidth;
 375   if (i == numSizes) {
 376     // No match defaults to 100% viewport
 377     nsCSSValue defaultWidth(100.0f, eCSSUnit_ViewportWidth);
 378     effectiveWidth = nsRuleNode::CalcLengthWithInitialFont(pctx,
 379                                                            defaultWidth);
 380   } else {
 381     effectiveWidth = nsRuleNode::CalcLengthWithInitialFont(pctx,
 382                                                            mSizeValues[i]);
 383   }
 384
 385   MOZ_ASSERT(effectiveWidth >= 0);
 386   *aWidth = nsPresContext::AppUnitsToIntCSSPixels(std::max(effectiveWidth, 0));
 387   return true;
 388 }
 389
 390 ResponsiveImageCandidate::ResponsiveImageCandidate()
 391 {
 392   mType = eCandidateType_Invalid;
 393   mValue.mDensity = 1.0;
 394 }
 395
 396 ResponsiveImageCandidate::ResponsiveImageCandidate(nsIURI *aURL,
 397                                                    double aDensity)
 398   : mURL(aURL)
 399 {
 400   mType = eCandidateType_Density;
 401   mValue.mDensity = aDensity;
 402 }
 403
 404
 405 void
 406 ResponsiveImageCandidate::SetURL(nsIURI *aURL)
 407 {
 408   mURL = aURL;
 409 }
 410
 411 void
 412 ResponsiveImageCandidate::SetParameterAsComputedWidth(int32_t aWidth)
 413 {
 414   mType = eCandidateType_ComputedFromWidth;
 415   mValue.mWidth = aWidth;
 416 }
 417
 418 void
 419 ResponsiveImageCandidate::SetParameterDefault()
 420 {
 421   MOZ_ASSERT(mType == eCandidateType_Invalid, "double setting candidate type");
 422
 423   mType = eCandidateType_Default;
 424   // mValue shouldn't actually be used for this type, but set it to default
 425   // anyway
 426   mValue.mDensity = 1.0;
 427 }
 428
 429 void
 430 ResponsiveImageCandidate::SetParameterAsDensity(double aDensity)
 431 {
 432   MOZ_ASSERT(mType == eCandidateType_Invalid, "double setting candidate type");
 433
 434   mType = eCandidateType_Density;
 435   mValue.mDensity = aDensity;
 436 }
 437
 438 bool
 439 ResponsiveImageCandidate::SetParamaterFromDescriptor(const nsAString & aDescriptor)
 440 {
 441   // Valid input values must be positive, using -1 for not-set
 442   double density = -1.0;
 443   int32_t width = -1;
 444
 445   nsAString::const_iterator iter, end;
 446   aDescriptor.BeginReading(iter);
 447   aDescriptor.EndReading(end);
 448
 449   // Parse descriptor list
 450   // We currently only support a single density descriptor of the form:
 451   //   <floating-point number>x
 452   // Silently ignore other descriptors in the list for forward-compat
 453   while (iter != end) {
 454     // Skip initial whitespace
 455     for (; iter != end && nsContentUtils::IsHTMLWhitespace(*iter); ++iter);
 456     if (iter == end) {
 457       break;
 458     }
 459
 460     // Find end of type
 461     nsAString::const_iterator start = iter;
 462     for (; iter != end && !nsContentUtils::IsHTMLWhitespace(*iter); ++iter);
 463
 464     if (start == iter) {
 465       // Empty descriptor
 466       break;
 467     }
 468
 469     // Iter is at end of descriptor, type is single character previous to that.
 470     // Safe because we just verified that iter > start
 471     --iter;
 472     nsAString::const_iterator type(iter);
 473     ++iter;
 474
 475     const nsDependentSubstring& valStr = Substring(start, type);
 476     if (*type == char16_t('w')) {
 477       int32_t possibleWidth;
 478       if (width == -1 && density == -1.0) {
 479         if (ParseInteger(valStr, possibleWidth) && possibleWidth > 0) {
 480           width = possibleWidth;
 481         }
 482       } else {
 483         return false;
 484       }
 485     } else if (*type == char16_t('x')) {
 486       if (width == -1 && density == -1.0) {
 487         nsresult rv;
 488         double possibleDensity = PromiseFlatString(valStr).ToDouble(&rv);
 489         if (NS_SUCCEEDED(rv) && possibleDensity > 0.0) {
 490           density = possibleDensity;
 491         }
 492       } else {
 493         return false;
 494       }
 495     }
 496   }
 497
 498   if (width != -1) {
 499     SetParameterAsComputedWidth(width);
 500   } else if (density != -1.0) {
 501     SetParameterAsDensity(density);
 502   } else {
 503     // No valid descriptors -> 1.0 density
 504     SetParameterAsDensity(1.0);
 505   }
 506
 507   return true;
 508 }
 509
 510 bool
 511 ResponsiveImageCandidate::HasSameParameter(const ResponsiveImageCandidate & aOther) const
 512 {
 513   if (aOther.mType != mType) {
 514     return false;
 515   }
 516
 517   if (mType == eCandidateType_Default) {
 518     return true;
 519   }
 520
 521   if (mType == eCandidateType_Density) {
 522     return aOther.mValue.mDensity == mValue.mDensity;
 523   }
 524
 525   if (mType == eCandidateType_Invalid) {
 526     MOZ_ASSERT(false, "Comparing invalid candidates?");
 527     return true;
 528   } else if (mType == eCandidateType_ComputedFromWidth) {
 529     return aOther.mValue.mWidth == mValue.mWidth;
 530   }
 531
 532   MOZ_ASSERT(false, "Somebody forgot to check for all uses of this enum");
 533   return false;
 534 }
 535
 536 already_AddRefed<nsIURI>
 537 ResponsiveImageCandidate::URL() const
 538 {
 539   nsCOMPtr<nsIURI> url = mURL;
 540   return url.forget();
 541 }
 542
 543 double
 544 ResponsiveImageCandidate::Density(ResponsiveImageSelector *aSelector) const
 545 {
 546   if (mType == eCandidateType_ComputedFromWidth) {
 547     int32_t width;
 548     if (!aSelector->ComputeFinalWidthForCurrentViewport(&width)) {
 549       return 1.0;
 550     }
 551     return Density(width);
 552   }
 553
 554   // Other types don't need matching width
 555   MOZ_ASSERT(mType == eCandidateType_Default || mType == eCandidateType_Density,
 556              "unhandled candidate type");
 557   return Density(-1);
 558 }
 559
 560 double
 561 ResponsiveImageCandidate::Density(int32_t aMatchingWidth) const
 562 {
 563   if (mType == eCandidateType_Invalid) {
 564     MOZ_ASSERT(false, "Getting density for uninitialized candidate");
 565     return 1.0;
 566   }
 567
 568   if (mType == eCandidateType_Default) {
 569     return 1.0;
 570   }
 571
 572   if (mType == eCandidateType_Density) {
 573     return mValue.mDensity;
 574   } else if (mType == eCandidateType_ComputedFromWidth) {
 575     if (aMatchingWidth <= 0) {
 576       MOZ_ASSERT(false, "0 or negative matching width is invalid per spec");
 577       return 1.0;
 578     }
 579     double density = double(mValue.mWidth) / double(aMatchingWidth);
 580     MOZ_ASSERT(density > 0.0);
 581     return density;
 582   }
 583
 584   MOZ_ASSERT(false, "Unknown candidate type");
 585   return 1.0;
 586 }
 587
 588 bool
 589 ResponsiveImageCandidate::IsComputedFromWidth() const
 590 {
 591   if (mType == eCandidateType_ComputedFromWidth) {
 592     return true;
 593   }
 594
 595   MOZ_ASSERT(mType == eCandidateType_Default || mType == eCandidateType_Density,
 596              "Unknown candidate type");
 597   return false;
 598 }
 599
 600 } // namespace dom
 601 } // namespace mozilla