Reconstrain zoom value to the [min-zoom, max-zoom] range before it used

third_party/WebKit/Source/core/dom/ViewportDescription.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2011 Apple Inc. All rights
  * reserved.
  * Copyright (C) 2008 Torch Mobile Inc. All rights reserved.
  * (http://www.torchmobile.com/)
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
@@ skipping 101 matching lines @@
   float resultMaxHeight =
       resolveViewportLength(maxHeight, initialViewportSize, Vertical);
   float resultMinHeight =
       resolveViewportLength(minHeight, initialViewportSize, Vertical);
 
   float resultZoom = zoom;
   float resultMinZoom = minZoom;
   float resultMaxZoom = maxZoom;
   bool resultUserZoom = userZoom;
 
-  // 1. Resolve min-zoom and max-zoom values.
+  // Resolve min-zoom and max-zoom values.
   if (resultMinZoom != ViewportDescription::ValueAuto &&
       resultMaxZoom != ViewportDescription::ValueAuto)
     resultMaxZoom = std::max(resultMinZoom, resultMaxZoom);
 
-  // 2. Constrain zoom value to the [min-zoom, max-zoom] range.
+  // Constrain zoom value to the [min-zoom, max-zoom] range.
   if (resultZoom != ViewportDescription::ValueAuto)
     resultZoom = compareIgnoringAuto(
         resultMinZoom, compareIgnoringAuto(resultMaxZoom, resultZoom, std::min),
         std::max);
 
   float extendZoom = compareIgnoringAuto(resultZoom, resultMaxZoom, std::min);
 
-  // 3. Resolve non-"auto" lengths to pixel lengths.
+  // Resolve non-"auto" lengths to pixel lengths.
   if (extendZoom == ViewportDescription::ValueAuto) {
     if (resultMaxWidth == ViewportDescription::ValueExtendToZoom)
       resultMaxWidth = ViewportDescription::ValueAuto;
 
     if (resultMaxHeight == ViewportDescription::ValueExtendToZoom)
       resultMaxHeight = ViewportDescription::ValueAuto;
 
     if (resultMinWidth == ViewportDescription::ValueExtendToZoom)
       resultMinWidth = resultMaxWidth;
 
@@ skipping 11 matching lines @@
 
     if (resultMinWidth == ViewportDescription::ValueExtendToZoom)
       resultMinWidth =
           compareIgnoringAuto(extendWidth, resultMaxWidth, std::max);
 
     if (resultMinHeight == ViewportDescription::ValueExtendToZoom)
       resultMinHeight =
           compareIgnoringAuto(extendHeight, resultMaxHeight, std::max);
   }
 
-  // 4. Resolve initial width from min/max descriptors.
+  // Resolve initial width from min/max descriptors.
   if (resultMinWidth != ViewportDescription::ValueAuto ||
       resultMaxWidth != ViewportDescription::ValueAuto)
     resultWidth = compareIgnoringAuto(
         resultMinWidth,
         compareIgnoringAuto(resultMaxWidth, initialViewportSize.width(),
                             std::min),
         std::max);
 
-  // 5. Resolve initial height from min/max descriptors.
+  // Resolve initial height from min/max descriptors.
   if (resultMinHeight != ViewportDescription::ValueAuto ||
       resultMaxHeight != ViewportDescription::ValueAuto)
     resultHeight = compareIgnoringAuto(
         resultMinHeight,
         compareIgnoringAuto(resultMaxHeight, initialViewportSize.height(),
                             std::min),
         std::max);
 
-  // 6-7. Resolve width value.
+  // Resolve width value.
   if (resultWidth == ViewportDescription::ValueAuto) {
     if (resultHeight == ViewportDescription::ValueAuto ||
         !initialViewportSize.height())
       resultWidth = initialViewportSize.width();
     else
       resultWidth = resultHeight * (initialViewportSize.width() /
                                     initialViewportSize.height());
   }
 
-  // 8. Resolve height value.
+  // Resolve height value.
   if (resultHeight == ViewportDescription::ValueAuto) {
     if (!initialViewportSize.width())
       resultHeight = initialViewportSize.height();
     else
       resultHeight = resultWidth * initialViewportSize.height() /
                      initialViewportSize.width();
   }
 
   // Resolve initial-scale value.
   if (resultZoom == ViewportDescription::ValueAuto) {
     if (resultWidth != ViewportDescription::ValueAuto && resultWidth > 0)
       resultZoom = initialViewportSize.width() / resultWidth;
     if (resultHeight != ViewportDescription::ValueAuto && resultHeight > 0) {
       // if 'auto', the initial-scale will be negative here and thus ignored.
       resultZoom = std::max<float>(resultZoom,
                                    initialViewportSize.height() / resultHeight);
     }
+
+    // Reconstrain zoom value to the [min-zoom, max-zoom] range. It will reset
+    // below, if it is ValueAuto here.

[rune, 2016/10/31 22:24:24]

I didn't understand the second sentence: "It will reset below ...". Maybe just
drop it?

+    resultZoom = compareIgnoringAuto(
+        resultMinZoom, compareIgnoringAuto(resultMaxZoom, resultZoom, std::min),
+        std::max);
   }
 
   // If user-scalable = no, lock the min/max scale to the computed initial
   // scale.
   if (!resultUserZoom)
     resultMinZoom = resultMaxZoom = resultZoom;
 
   // Only set initialScale to a value if it was explicitly set.
   if (zoom == ViewportDescription::ValueAuto)
     resultZoom = ViewportDescription::ValueAuto;
@@ skipping 69 matching lines @@
     metaTagTypeHistogram.count(MobileOptimizedMeta);
   }
 #endif
 }
 
 bool ViewportDescription::matchesHeuristicsForGpuRasterization() const {
   return isSpecifiedByAuthor();
 }
 
 }  // namespace blink