Recompute percentage based @viewport on resize.

Source/core/css/resolver/ViewportStyleResolver.cpp

 /*
  * Copyright (C) 2012-2013 Intel Corporation. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above
  *    copyright notice, this list of conditions and the following
  *    disclaimer.
@@ skipping 66 matching lines @@
 {
     if (!m_document || !m_propertySet)
         return;
 
     ViewportArguments arguments(ViewportArguments::CSSDeviceAdaptation);
 
     arguments.userZoom = getViewportArgumentValue(CSSPropertyUserZoom);
     arguments.zoom = getViewportArgumentValue(CSSPropertyZoom);
     arguments.minZoom = getViewportArgumentValue(CSSPropertyMinZoom);
     arguments.maxZoom = getViewportArgumentValue(CSSPropertyMaxZoom);
-    arguments.minWidth = getViewportArgumentValue(CSSPropertyMinWidth);
-    arguments.maxWidth = getViewportArgumentValue(CSSPropertyMaxWidth);
-    arguments.minHeight = getViewportArgumentValue(CSSPropertyMinHeight);
-    arguments.maxHeight = getViewportArgumentValue(CSSPropertyMaxHeight);
+    arguments.minWidth = getViewportLengthValue(CSSPropertyMinWidth);
+    arguments.maxWidth = getViewportLengthValue(CSSPropertyMaxWidth);
+    arguments.minHeight = getViewportLengthValue(CSSPropertyMinHeight);
+    arguments.maxHeight = getViewportLengthValue(CSSPropertyMaxHeight);
     arguments.orientation = getViewportArgumentValue(CSSPropertyOrientation);
 
     m_document->setViewportArguments(arguments);
     m_document->updateViewportArguments();
 
     m_propertySet = 0;
 }
 
 float ViewportStyleResolver::getViewportArgumentValue(CSSPropertyID id) const
 {
@@ skipping 13 matching lines @@
 
     if (primitiveValue->isNumber() || primitiveValue->isPx())
         return primitiveValue->getFloatValue();
 
     if (primitiveValue->isFontRelativeLength())
         return primitiveValue->getFloatValue() * m_document->renderStyle()->fontDescription().computedSize();
 
     if (primitiveValue->isPercentage()) {
         float percentValue = primitiveValue->getFloatValue() / 100.0f;
         switch (id) {
-        case CSSPropertyMaxHeight:
-        case CSSPropertyMinHeight:
-            return percentValue * m_document->initialViewportSize().height();
-        case CSSPropertyMaxWidth:
-        case CSSPropertyMinWidth:
-            return percentValue * m_document->initialViewportSize().width();
         case CSSPropertyMaxZoom:
         case CSSPropertyMinZoom:
         case CSSPropertyZoom:
             return percentValue;
         default:
             ASSERT_NOT_REACHED();
             break;
         }
     }
 
     switch (primitiveValue->getValueID()) {
     case CSSValueAuto:
         return defaultValue;
     case CSSValueLandscape:
         return ViewportArguments::ValueLandscape;
     case CSSValuePortrait:
         return ViewportArguments::ValuePortrait;
     case CSSValueZoom:
         return defaultValue;
     case CSSValueInternalExtendToZoom:
         return ViewportArguments::ValueExtendToZoom;
     case CSSValueFixed:
         return 0;
     default:
         return defaultValue;
     }
 }
 
+Length ViewportStyleResolver::getViewportLengthValue(CSSPropertyID id) const
+{
+    ASSERT(id == CSSPropertyMaxHeight
+        || id == CSSPropertyMinHeight
+        || id == CSSPropertyMaxWidth
+        || id == CSSPropertyMinWidth);
+
+    RefPtr<CSSValue> value = m_propertySet->getPropertyCSSValue(id);
+    if (!value)
+        return Length(); // auto
+
+    ASSERT(value->isPrimitiveValue());
+
+    CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value.get());
+
+    if (primitiveValue->isLength())
+        return primitiveValue->computeLength<Length>(m_document->renderStyle(), m_document->renderStyle());
+
+    if (primitiveValue->isViewportPercentageLength())
+        return primitiveValue->viewportPercentageLength();
+
+    if (primitiveValue->isPercentage())
+        return Length(primitiveValue->getFloatValue(), Percent);
+
+    switch (primitiveValue->getValueID()) {
+    case CSSValueInternalExtendToZoom:
+        return Length(ExtendToZoom);
+    default:

[apavlov, 2013/08/07 09:25:54]

Is there any particular idea behind putting "default:" in the middle, between
two cases?

[rune, 2013/08/07 10:06:15]

Just to avoid an extra "return Length();" statement and have the assert for the
default case. There should have been a "// Fall through." comment there too.
Should I add an extra "return Length()" instead?

[apavlov, 2013/08/07 10:12:10]

Well, this doesn't look like code where two cases are [partially] semantically
equivalent and can be handled with a fallthrough. Instead, "return Length()" for
the default case is your best-effort approach to dealing with an error, right?
You might as well choose to return something different (a 0 length,
ExtendToZoom, or something else), so this should stand out as a separate return
statement to avoid readers' confusion.

[rune, 2013/08/07 11:30:04]

Chose 0px in patch set 3.

+        ASSERT_NOT_REACHED();
+    case CSSValueAuto:
+        return Length();
+    }
+}
+
 } // namespace WebCore