Source/WebCore/dom/ViewportArguments.cpp - platform/external/webkit - Git at Google

 /*
  * 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)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  *
  */

 #include "config.h"
 #include "ViewportArguments.h"

 #include "Chrome.h"
 #include "Console.h"
 #include "DOMWindow.h"
 #include "Document.h"
 #include "Frame.h"
 #include "IntSize.h"
 #include "Page.h"
 #include "PlatformString.h"
 #include "ScriptableDocumentParser.h"

 using namespace std;

 namespace WebCore {

 ViewportAttributes computeViewportAttributes(ViewportArguments args, int desktopWidth, int deviceWidth, int deviceHeight, int deviceDPI, IntSize visibleViewport)
 {
     ViewportAttributes result;

     float availableWidth = visibleViewport.width();
     float availableHeight = visibleViewport.height();

     ASSERT(availableWidth > 0 && availableHeight > 0);

     switch (int(args.targetDensityDpi)) {
     case ViewportArguments::ValueDeviceDPI:
         args.targetDensityDpi = deviceDPI;
         break;
     case ViewportArguments::ValueLowDPI:
         args.targetDensityDpi = 120;
         break;
     case ViewportArguments::ValueAuto:
     case ViewportArguments::ValueMediumDPI:
         args.targetDensityDpi = 160;
         break;
     case ViewportArguments::ValueHighDPI:
         args.targetDensityDpi = 240;
         break;
     }

     result.devicePixelRatio = float(deviceDPI / args.targetDensityDpi);

     // Resolve non-'auto' width and height to pixel values.
     if (result.devicePixelRatio != 1.0) {
         availableWidth /= result.devicePixelRatio;
         availableHeight /= result.devicePixelRatio;
         deviceWidth /= result.devicePixelRatio;
         deviceHeight /= result.devicePixelRatio;
     }

     switch (int(args.width)) {
     case ViewportArguments::ValueDesktopWidth:
         args.width = desktopWidth;
         break;
     case ViewportArguments::ValueDeviceWidth:
         args.width = deviceWidth;
         break;
     case ViewportArguments::ValueDeviceHeight:
         args.width = deviceHeight;
         break;
     }

     switch (int(args.height)) {
     case ViewportArguments::ValueDesktopWidth:
         args.height = desktopWidth;
         break;
     case ViewportArguments::ValueDeviceWidth:
         args.height = deviceWidth;
         break;
     case ViewportArguments::ValueDeviceHeight:
         args.height = deviceHeight;
         break;
     }

     // Clamp values to range defined by spec and resolve minimum-scale and maximum-scale values
     if (args.width != ViewportArguments::ValueAuto)
         args.width = min(float(10000), max(args.width, float(1)));
     if (args.height != ViewportArguments::ValueAuto)
         args.height = min(float(10000), max(args.height, float(1)));

     if (args.initialScale != ViewportArguments::ValueAuto)
         args.initialScale = min(float(10), max(args.initialScale, float(0.1)));
     if (args.minimumScale != ViewportArguments::ValueAuto)
         args.minimumScale = min(float(10), max(args.minimumScale, float(0.1)));
     if (args.maximumScale != ViewportArguments::ValueAuto)
         args.maximumScale = min(float(10), max(args.maximumScale, float(0.1)));

     // Resolve minimum-scale and maximum-scale values according to spec.
     if (args.minimumScale == ViewportArguments::ValueAuto)
         result.minimumScale = float(0.25);
     else
         result.minimumScale = args.minimumScale;

     if (args.maximumScale == ViewportArguments::ValueAuto) {
         result.maximumScale = float(5.0);
         result.minimumScale = min(float(5.0), result.minimumScale);
     } else
         result.maximumScale = args.maximumScale;
     result.maximumScale = max(result.minimumScale, result.maximumScale);

     // Resolve initial-scale value.
     result.initialScale = args.initialScale;
     if (result.initialScale == ViewportArguments::ValueAuto) {
         result.initialScale = availableWidth / desktopWidth;
         if (args.width != ViewportArguments::ValueAuto)
             result.initialScale = availableWidth / args.width;
         if (args.height != ViewportArguments::ValueAuto) {
             // if 'auto', the initial-scale will be negative here and thus ignored.
             result.initialScale = max(result.initialScale, availableHeight / args.height);
         }
     }

     // Constrain initial-scale value to minimum-scale/maximum-scale range.
     result.initialScale = min(result.maximumScale, max(result.minimumScale, result.initialScale));

     // Resolve width value.
     float width;
     if (args.width != ViewportArguments::ValueAuto)
         width = args.width;
     else {
         if (args.initialScale == ViewportArguments::ValueAuto)
             width = desktopWidth;
         else if (args.height != ViewportArguments::ValueAuto)
             width = args.height * (availableWidth / availableHeight);
         else
             width = availableWidth / result.initialScale;
     }

     // Resolve height value.
     float height;
     if (args.height != ViewportArguments::ValueAuto)
         height = args.height;
     else
         height = width * availableHeight / availableWidth;

     // Extend width and height to fill the visual viewport for the resolved initial-scale.
     width = max(width, availableWidth / result.initialScale);
     height = max(height, availableHeight / result.initialScale);
     result.layoutSize.setWidth(width);
     result.layoutSize.setHeight(height);

     // Update minimum scale factor, to never allow zooming out more than viewport
     result.minimumScale = max(result.minimumScale, max(availableWidth / width, availableHeight / height));

     result.userScalable = args.userScalable;
     // Make maximum and minimum scale equal to the initial scale if user is not allowed to zoom in/out.
     if (!args.userScalable)
         result.maximumScale = result.minimumScale = result.initialScale;

     return result;
 }

 static float numericPrefix(const String& keyString, const String& valueString, Document* document, bool* ok)
 {
     // If a prefix of property-value can be converted to a number using strtod,
     // the value will be that number. The remainder of the string is ignored.
     // So when String::toFloat says there is an error, it may be a false positive,
     // and we should check if the valueString prefix was a number.

     bool didReadNumber;
     float value = valueString.toFloat(ok, &didReadNumber);
     if (!*ok) {
         if (!didReadNumber) {
             ASSERT(!value);
             reportViewportWarning(document, UnrecognizedViewportArgumentValueError, valueString, keyString);
             return value;
         }
         *ok = true;
         reportViewportWarning(document, TruncatedViewportArgumentValueError, valueString, keyString);
     }
     return value;
 }

 static float findSizeValue(const String& keyString, const String& valueString, Document* document)
 {
     // 1) Non-negative number values are translated to px lengths.
     // 2) Negative number values are translated to auto.
     // 3) device-width and device-height are used as keywords.
     // 4) Other keywords and unknown values translate to 0.0.

     if (equalIgnoringCase(valueString, "desktop-width"))
         return ViewportArguments::ValueDesktopWidth;
     if (equalIgnoringCase(valueString, "device-width"))
         return ViewportArguments::ValueDeviceWidth;
     if (equalIgnoringCase(valueString, "device-height"))
         return ViewportArguments::ValueDeviceHeight;

     bool ok;
     float value = numericPrefix(keyString, valueString, document, &ok);
     if (!ok)
         return float(0.0);

     if (value < 0)
         return ViewportArguments::ValueAuto;

     return value;
 }

 static float findScaleValue(const String& keyString, const String& valueString, Document* document)
 {
     // 1) Non-negative number values are translated to <number> values.
     // 2) Negative number values are translated to auto.
     // 3) yes is translated to 1.0.
     // 4) device-width and device-height are translated to 10.0.
     // 5) no and unknown values are translated to 0.0

     if (equalIgnoringCase(valueString, "yes"))
         return float(1.0);
     if (equalIgnoringCase(valueString, "no"))
         return float(0.0);
     if (equalIgnoringCase(valueString, "desktop-width"))
         return float(10.0);
     if (equalIgnoringCase(valueString, "device-width"))
         return float(10.0);
     if (equalIgnoringCase(valueString, "device-height"))
         return float(10.0);

     bool ok;
     float value = numericPrefix(keyString, valueString, document, &ok);
     if (!ok)
         return float(0.0);

     if (value < 0)
         return ViewportArguments::ValueAuto;

     if (value > 10.0)
         reportViewportWarning(document, MaximumScaleTooLargeError, String(), String());

     return value;
 }

 static float findUserScalableValue(const String& keyString, const String& valueString, Document* document)
 {
     // yes and no are used as keywords.
     // Numbers >= 1, numbers <= -1, device-width and device-height are mapped to yes.
     // Numbers in the range <-1, 1>, and unknown values, are mapped to no.

     if (equalIgnoringCase(valueString, "yes"))
         return 1;
     if (equalIgnoringCase(valueString, "no"))
         return 0;
     if (equalIgnoringCase(valueString, "desktop-width"))
         return 1;
     if (equalIgnoringCase(valueString, "device-width"))
         return 1;
     if (equalIgnoringCase(valueString, "device-height"))
         return 1;

     bool ok;
     float value = numericPrefix(keyString, valueString, document, &ok);
     if (!ok)
         return 0;

     if (fabs(value) < 1)
         return 0;

     return 1;
 }

 static float findTargetDensityDPIValue(const String& keyString, const String& valueString, Document* document)
 {
     if (equalIgnoringCase(valueString, "device-dpi"))
         return ViewportArguments::ValueDeviceDPI;
     if (equalIgnoringCase(valueString, "low-dpi"))
         return ViewportArguments::ValueLowDPI;
     if (equalIgnoringCase(valueString, "medium-dpi"))
         return ViewportArguments::ValueMediumDPI;
     if (equalIgnoringCase(valueString, "high-dpi"))
         return ViewportArguments::ValueHighDPI;

     bool ok;
     float value = numericPrefix(keyString, valueString, document, &ok);
     if (!ok)
         return ViewportArguments::ValueAuto;

      if (value < 70 || value > 400) {
         reportViewportWarning(document, TargetDensityDpiTooSmallOrLargeError, String(), String());
         return ViewportArguments::ValueAuto;
     }

     return value;
 }

 void setViewportFeature(const String& keyString, const String& valueString, Document* document, void* data)
 {
     ViewportArguments* arguments = static_cast<ViewportArguments*>(data);

     if (keyString == "width")
         arguments->width = findSizeValue(keyString, valueString, document);
     else if (keyString == "height")
         arguments->height = findSizeValue(keyString, valueString, document);
     else if (keyString == "initial-scale")
         arguments->initialScale = findScaleValue(keyString, valueString, document);
     else if (keyString == "minimum-scale")
         arguments->minimumScale = findScaleValue(keyString, valueString, document);
     else if (keyString == "maximum-scale")
         arguments->maximumScale = findScaleValue(keyString, valueString, document);
     else if (keyString == "user-scalable")
         arguments->userScalable = findUserScalableValue(keyString, valueString, document);
     else if (keyString == "target-densitydpi")
         arguments->targetDensityDpi = findTargetDensityDPIValue(keyString, valueString, document);
     else
         reportViewportWarning(document, UnrecognizedViewportArgumentKeyError, keyString, String());
 }

 static const char* viewportErrorMessageTemplate(ViewportErrorCode errorCode)
 {
     static const char* const errors[] = {
         "Viewport argument key \"%replacement1\" not recognized and ignored.",
         "Viewport argument value \"%replacement1\" for key \"%replacement2\" not recognized. Content ignored.",
         "Viewport argument value \"%replacement1\" for key \"%replacement2\" was truncated to its numeric prefix.",
         "Viewport maximum-scale cannot be larger than 10.0. The maximum-scale will be set to 10.0.",
         "Viewport target-densitydpi has to take a number between 70 and 400 as a valid target dpi, try using \"device-dpi\", \"low-dpi\", \"medium-dpi\" or \"high-dpi\" instead for future compatibility."
     };

     return errors[errorCode];
 }

 static MessageLevel viewportErrorMessageLevel(ViewportErrorCode errorCode)
 {
     switch (errorCode) {
     case TruncatedViewportArgumentValueError:
     case TargetDensityDpiTooSmallOrLargeError:
         return TipMessageLevel;
     case UnrecognizedViewportArgumentKeyError:
     case UnrecognizedViewportArgumentValueError:
     case MaximumScaleTooLargeError:
         return ErrorMessageLevel;
     }

     ASSERT_NOT_REACHED();
     return ErrorMessageLevel;
 }

 // FIXME: Why is this different from SVGDocumentExtensions parserLineNumber?
 // FIXME: Callers should probably use ScriptController::eventHandlerLineNumber()
 static int parserLineNumber(Document* document)
 {
     if (!document)
         return 0;
     ScriptableDocumentParser* parser = document->scriptableDocumentParser();
     if (!parser)
         return 0;
     return parser->lineNumber() + 1;
 }

 void reportViewportWarning(Document* document, ViewportErrorCode errorCode, const String& replacement1, const String& replacement2)
 {
     Frame* frame = document->frame();
     if (!frame)
         return;

     String message = viewportErrorMessageTemplate(errorCode);
     if (!replacement1.isNull())
         message.replace("%replacement1", replacement1);
     if (!replacement2.isNull())
         message.replace("%replacement2", replacement2);

     frame->domWindow()->console()->addMessage(HTMLMessageSource, LogMessageType, viewportErrorMessageLevel(errorCode), message, parserLineNumber(document), document->url().string());
 }

 } // namespace WebCore
	/*
	* 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)
	*
	* This library is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Library General Public
	* License as published by the Free Software Foundation; either
	* version 2 of the License, or (at your option) any later version.
	*
	* This library is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Library General Public License for more details.
	*
	* You should have received a copy of the GNU Library General Public License
	* along with this library; see the file COPYING.LIB. If not, write to
	* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
	* Boston, MA 02110-1301, USA.
	*
	*/

	#include "config.h"
	#include "ViewportArguments.h"

	#include "Chrome.h"
	#include "Console.h"
	#include "DOMWindow.h"
	#include "Document.h"
	#include "Frame.h"
	#include "IntSize.h"
	#include "Page.h"
	#include "PlatformString.h"
	#include "ScriptableDocumentParser.h"

	using namespace std;

	namespace WebCore {

	ViewportAttributes computeViewportAttributes(ViewportArguments args, int desktopWidth, int deviceWidth, int deviceHeight, int deviceDPI, IntSize visibleViewport)
	{
	ViewportAttributes result;

	float availableWidth = visibleViewport.width();
	float availableHeight = visibleViewport.height();

	ASSERT(availableWidth > 0 && availableHeight > 0);

	switch (int(args.targetDensityDpi)) {
	case ViewportArguments::ValueDeviceDPI:
	args.targetDensityDpi = deviceDPI;
	break;
	case ViewportArguments::ValueLowDPI:
	args.targetDensityDpi = 120;
	break;
	case ViewportArguments::ValueAuto:
	case ViewportArguments::ValueMediumDPI:
	args.targetDensityDpi = 160;
	break;
	case ViewportArguments::ValueHighDPI:
	args.targetDensityDpi = 240;
	break;
	}

	result.devicePixelRatio = float(deviceDPI / args.targetDensityDpi);

	// Resolve non-'auto' width and height to pixel values.
	if (result.devicePixelRatio != 1.0) {
	availableWidth /= result.devicePixelRatio;
	availableHeight /= result.devicePixelRatio;
	deviceWidth /= result.devicePixelRatio;
	deviceHeight /= result.devicePixelRatio;
	}

	switch (int(args.width)) {
	case ViewportArguments::ValueDesktopWidth:
	args.width = desktopWidth;
	break;
	case ViewportArguments::ValueDeviceWidth:
	args.width = deviceWidth;
	break;
	case ViewportArguments::ValueDeviceHeight:
	args.width = deviceHeight;
	break;
	}

	switch (int(args.height)) {
	case ViewportArguments::ValueDesktopWidth:
	args.height = desktopWidth;
	break;
	case ViewportArguments::ValueDeviceWidth:
	args.height = deviceWidth;
	break;
	case ViewportArguments::ValueDeviceHeight:
	args.height = deviceHeight;
	break;
	}

	// Clamp values to range defined by spec and resolve minimum-scale and maximum-scale values
	if (args.width != ViewportArguments::ValueAuto)
	args.width = min(float(10000), max(args.width, float(1)));
	if (args.height != ViewportArguments::ValueAuto)
	args.height = min(float(10000), max(args.height, float(1)));

	if (args.initialScale != ViewportArguments::ValueAuto)
	args.initialScale = min(float(10), max(args.initialScale, float(0.1)));
	if (args.minimumScale != ViewportArguments::ValueAuto)
	args.minimumScale = min(float(10), max(args.minimumScale, float(0.1)));
	if (args.maximumScale != ViewportArguments::ValueAuto)
	args.maximumScale = min(float(10), max(args.maximumScale, float(0.1)));

	// Resolve minimum-scale and maximum-scale values according to spec.
	if (args.minimumScale == ViewportArguments::ValueAuto)
	result.minimumScale = float(0.25);
	else
	result.minimumScale = args.minimumScale;

	if (args.maximumScale == ViewportArguments::ValueAuto) {
	result.maximumScale = float(5.0);
	result.minimumScale = min(float(5.0), result.minimumScale);
	} else
	result.maximumScale = args.maximumScale;
	result.maximumScale = max(result.minimumScale, result.maximumScale);

	// Resolve initial-scale value.
	result.initialScale = args.initialScale;
	if (result.initialScale == ViewportArguments::ValueAuto) {
	result.initialScale = availableWidth / desktopWidth;
	if (args.width != ViewportArguments::ValueAuto)
	result.initialScale = availableWidth / args.width;
	if (args.height != ViewportArguments::ValueAuto) {
	// if 'auto', the initial-scale will be negative here and thus ignored.
	result.initialScale = max(result.initialScale, availableHeight / args.height);
	}
	}

	// Constrain initial-scale value to minimum-scale/maximum-scale range.
	result.initialScale = min(result.maximumScale, max(result.minimumScale, result.initialScale));

	// Resolve width value.
	float width;
	if (args.width != ViewportArguments::ValueAuto)
	width = args.width;
	else {
	if (args.initialScale == ViewportArguments::ValueAuto)
	width = desktopWidth;
	else if (args.height != ViewportArguments::ValueAuto)
	width = args.height * (availableWidth / availableHeight);
	else
	width = availableWidth / result.initialScale;
	}

	// Resolve height value.
	float height;
	if (args.height != ViewportArguments::ValueAuto)
	height = args.height;
	else
	height = width * availableHeight / availableWidth;

	// Extend width and height to fill the visual viewport for the resolved initial-scale.
	width = max(width, availableWidth / result.initialScale);
	height = max(height, availableHeight / result.initialScale);
	result.layoutSize.setWidth(width);
	result.layoutSize.setHeight(height);

	// Update minimum scale factor, to never allow zooming out more than viewport
	result.minimumScale = max(result.minimumScale, max(availableWidth / width, availableHeight / height));

	result.userScalable = args.userScalable;
	// Make maximum and minimum scale equal to the initial scale if user is not allowed to zoom in/out.
	if (!args.userScalable)
	result.maximumScale = result.minimumScale = result.initialScale;

	return result;
	}

	static float numericPrefix(const String& keyString, const String& valueString, Document* document, bool* ok)
	{
	// If a prefix of property-value can be converted to a number using strtod,
	// the value will be that number. The remainder of the string is ignored.
	// So when String::toFloat says there is an error, it may be a false positive,
	// and we should check if the valueString prefix was a number.

	bool didReadNumber;
	float value = valueString.toFloat(ok, &didReadNumber);
	if (!*ok) {
	if (!didReadNumber) {
	ASSERT(!value);
	reportViewportWarning(document, UnrecognizedViewportArgumentValueError, valueString, keyString);
	return value;
	}
	*ok = true;
	reportViewportWarning(document, TruncatedViewportArgumentValueError, valueString, keyString);
	}
	return value;
	}

	static float findSizeValue(const String& keyString, const String& valueString, Document* document)
	{
	// 1) Non-negative number values are translated to px lengths.
	// 2) Negative number values are translated to auto.
	// 3) device-width and device-height are used as keywords.
	// 4) Other keywords and unknown values translate to 0.0.

	if (equalIgnoringCase(valueString, "desktop-width"))
	return ViewportArguments::ValueDesktopWidth;
	if (equalIgnoringCase(valueString, "device-width"))
	return ViewportArguments::ValueDeviceWidth;
	if (equalIgnoringCase(valueString, "device-height"))
	return ViewportArguments::ValueDeviceHeight;

	bool ok;
	float value = numericPrefix(keyString, valueString, document, &ok);
	if (!ok)
	return float(0.0);

	if (value < 0)
	return ViewportArguments::ValueAuto;

	return value;
	}

	static float findScaleValue(const String& keyString, const String& valueString, Document* document)
	{
	// 1) Non-negative number values are translated to <number> values.
	// 2) Negative number values are translated to auto.
	// 3) yes is translated to 1.0.
	// 4) device-width and device-height are translated to 10.0.
	// 5) no and unknown values are translated to 0.0

	if (equalIgnoringCase(valueString, "yes"))
	return float(1.0);
	if (equalIgnoringCase(valueString, "no"))
	return float(0.0);
	if (equalIgnoringCase(valueString, "desktop-width"))
	return float(10.0);
	if (equalIgnoringCase(valueString, "device-width"))
	return float(10.0);
	if (equalIgnoringCase(valueString, "device-height"))
	return float(10.0);

	bool ok;
	float value = numericPrefix(keyString, valueString, document, &ok);
	if (!ok)
	return float(0.0);

	if (value < 0)
	return ViewportArguments::ValueAuto;

	if (value > 10.0)
	reportViewportWarning(document, MaximumScaleTooLargeError, String(), String());

	return value;
	}

	static float findUserScalableValue(const String& keyString, const String& valueString, Document* document)
	{
	// yes and no are used as keywords.
	// Numbers >= 1, numbers <= -1, device-width and device-height are mapped to yes.
	// Numbers in the range <-1, 1>, and unknown values, are mapped to no.

	if (equalIgnoringCase(valueString, "yes"))
	return 1;
	if (equalIgnoringCase(valueString, "no"))
	return 0;
	if (equalIgnoringCase(valueString, "desktop-width"))
	return 1;
	if (equalIgnoringCase(valueString, "device-width"))
	return 1;
	if (equalIgnoringCase(valueString, "device-height"))
	return 1;

	bool ok;
	float value = numericPrefix(keyString, valueString, document, &ok);
	if (!ok)
	return 0;

	if (fabs(value) < 1)
	return 0;

	return 1;
	}

	static float findTargetDensityDPIValue(const String& keyString, const String& valueString, Document* document)
	{
	if (equalIgnoringCase(valueString, "device-dpi"))
	return ViewportArguments::ValueDeviceDPI;
	if (equalIgnoringCase(valueString, "low-dpi"))
	return ViewportArguments::ValueLowDPI;
	if (equalIgnoringCase(valueString, "medium-dpi"))
	return ViewportArguments::ValueMediumDPI;
	if (equalIgnoringCase(valueString, "high-dpi"))
	return ViewportArguments::ValueHighDPI;

	bool ok;
	float value = numericPrefix(keyString, valueString, document, &ok);
	if (!ok)
	return ViewportArguments::ValueAuto;

	if (value < 70 \|\| value > 400) {
	reportViewportWarning(document, TargetDensityDpiTooSmallOrLargeError, String(), String());
	return ViewportArguments::ValueAuto;
	}

	return value;
	}

	void setViewportFeature(const String& keyString, const String& valueString, Document* document, void* data)
	{
	ViewportArguments* arguments = static_cast<ViewportArguments*>(data);

	if (keyString == "width")
	arguments->width = findSizeValue(keyString, valueString, document);
	else if (keyString == "height")
	arguments->height = findSizeValue(keyString, valueString, document);
	else if (keyString == "initial-scale")
	arguments->initialScale = findScaleValue(keyString, valueString, document);
	else if (keyString == "minimum-scale")
	arguments->minimumScale = findScaleValue(keyString, valueString, document);
	else if (keyString == "maximum-scale")
	arguments->maximumScale = findScaleValue(keyString, valueString, document);
	else if (keyString == "user-scalable")
	arguments->userScalable = findUserScalableValue(keyString, valueString, document);
	else if (keyString == "target-densitydpi")
	arguments->targetDensityDpi = findTargetDensityDPIValue(keyString, valueString, document);
	else
	reportViewportWarning(document, UnrecognizedViewportArgumentKeyError, keyString, String());
	}

	static const char* viewportErrorMessageTemplate(ViewportErrorCode errorCode)
	{
	static const char* const errors[] = {
	"Viewport argument key \"%replacement1\" not recognized and ignored.",
	"Viewport argument value \"%replacement1\" for key \"%replacement2\" not recognized. Content ignored.",
	"Viewport argument value \"%replacement1\" for key \"%replacement2\" was truncated to its numeric prefix.",
	"Viewport maximum-scale cannot be larger than 10.0. The maximum-scale will be set to 10.0.",
	"Viewport target-densitydpi has to take a number between 70 and 400 as a valid target dpi, try using \"device-dpi\", \"low-dpi\", \"medium-dpi\" or \"high-dpi\" instead for future compatibility."
	};

	return errors[errorCode];
	}

	static MessageLevel viewportErrorMessageLevel(ViewportErrorCode errorCode)
	{
	switch (errorCode) {
	case TruncatedViewportArgumentValueError:
	case TargetDensityDpiTooSmallOrLargeError:
	return TipMessageLevel;
	case UnrecognizedViewportArgumentKeyError:
	case UnrecognizedViewportArgumentValueError:
	case MaximumScaleTooLargeError:
	return ErrorMessageLevel;
	}

	ASSERT_NOT_REACHED();
	return ErrorMessageLevel;
	}

	// FIXME: Why is this different from SVGDocumentExtensions parserLineNumber?
	// FIXME: Callers should probably use ScriptController::eventHandlerLineNumber()
	static int parserLineNumber(Document* document)
	{
	if (!document)
	return 0;
	ScriptableDocumentParser* parser = document->scriptableDocumentParser();
	if (!parser)
	return 0;
	return parser->lineNumber() + 1;
	}

	void reportViewportWarning(Document* document, ViewportErrorCode errorCode, const String& replacement1, const String& replacement2)
	{
	Frame* frame = document->frame();
	if (!frame)
	return;

	String message = viewportErrorMessageTemplate(errorCode);
	if (!replacement1.isNull())
	message.replace("%replacement1", replacement1);
	if (!replacement2.isNull())
	message.replace("%replacement2", replacement2);

	frame->domWindow()->console()->addMessage(HTMLMessageSource, LogMessageType, viewportErrorMessageLevel(errorCode), message, parserLineNumber(document), document->url().string());
	}

	} // namespace WebCore