Change float-->double in CanvasRenderingContext2D.idl

third_party/WebKit/Source/modules/canvas2d/CanvasRenderingContext2D.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2008, 2010 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008 Dirk Schulze <krit@webkit.org>
  * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. All rights reserved.
  * Copyright (C) 2012, 2013 Intel Corporation. All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
  *
@@ skipping 64 matching lines @@
 #include "wtf/text/StringBuilder.h"
 
 namespace blink {
 
 static const char defaultFont[] = "10px sans-serif";
 static const char inherit[] = "inherit";
 static const char rtl[] = "rtl";
 static const char ltr[] = "ltr";
 static const double TryRestoreContextInterval = 0.5;
 static const unsigned MaxTryRestoreContextAttempts = 4;
-static const float cDeviceScaleFactor = 1.0f; // Canvas is device independent
+static const double cDeviceScaleFactor = 1.0; // Canvas is device independent
 
 static bool contextLostRestoredEventsEnabled()
 {
     return RuntimeEnabledFeatures::experimentalCanvasFeaturesEnabled();
 }
 
 // Drawing methods need to use this instead of SkAutoCanvasRestore in case overdraw
 // detection substitutes the recording canvas (to discard overdrawn draw calls).
 class CanvasRenderingContext2DAutoRestoreSkCanvas {
     STACK_ALLOCATED();
@@ skipping 345 matching lines @@
         if (canvasPattern->pattern()->isTextureBacked())
             canvas()->disableDeferral();
         canvasStyle = CanvasStyle::createFromPattern(canvasPattern);
     }
 
     ASSERT(canvasStyle);
     modifiableState().setFillStyle(canvasStyle);
     modifiableState().setUnparsedFillColor(colorString);
 }
 
-float CanvasRenderingContext2D::lineWidth() const
+double CanvasRenderingContext2D::lineWidth() const
 {
     return state().lineWidth();
 }
 
-void CanvasRenderingContext2D::setLineWidth(float width)
+void CanvasRenderingContext2D::setLineWidth(double width)
 {
     if (!std::isfinite(width) || width <= 0)
         return;
     if (state().lineWidth() == width)
         return;
     modifiableState().setLineWidth(width);
 }
 
 String CanvasRenderingContext2D::lineCap() const
 {
@@ skipping 18 matching lines @@
 void CanvasRenderingContext2D::setLineJoin(const String& s)
 {
     LineJoin join;
     if (!parseLineJoin(s, join))
         return;
     if (state().lineJoin() == join)
         return;
     modifiableState().setLineJoin(join);
 }
 
-float CanvasRenderingContext2D::miterLimit() const
+double CanvasRenderingContext2D::miterLimit() const
 {
     return state().miterLimit();
 }
 
-void CanvasRenderingContext2D::setMiterLimit(float limit)
+void CanvasRenderingContext2D::setMiterLimit(double limit)
 {
     if (!std::isfinite(limit) || limit <= 0)
         return;
     if (state().miterLimit() == limit)
         return;
     modifiableState().setMiterLimit(limit);
 }
 
-float CanvasRenderingContext2D::shadowOffsetX() const
+double CanvasRenderingContext2D::shadowOffsetX() const
 {
     return state().shadowOffset().width();
 }
 
-void CanvasRenderingContext2D::setShadowOffsetX(float x)
+void CanvasRenderingContext2D::setShadowOffsetX(double x)
 {
     if (!std::isfinite(x))
         return;
     if (state().shadowOffset().width() == x)
         return;
     modifiableState().setShadowOffsetX(x);
 }
 
-float CanvasRenderingContext2D::shadowOffsetY() const
+double CanvasRenderingContext2D::shadowOffsetY() const
 {
     return state().shadowOffset().height();
 }
 
-void CanvasRenderingContext2D::setShadowOffsetY(float y)
+void CanvasRenderingContext2D::setShadowOffsetY(double y)
 {
     if (!std::isfinite(y))
         return;
     if (state().shadowOffset().height() == y)
         return;
     modifiableState().setShadowOffsetY(y);
 }
 
-float CanvasRenderingContext2D::shadowBlur() const
+double CanvasRenderingContext2D::shadowBlur() const
 {
     return state().shadowBlur();
 }
 
-void CanvasRenderingContext2D::setShadowBlur(float blur)
+void CanvasRenderingContext2D::setShadowBlur(double blur)
 {
     if (!std::isfinite(blur) || blur < 0)
         return;
     if (state().shadowBlur() == blur)
         return;
     modifiableState().setShadowBlur(blur);
 }
 
 String CanvasRenderingContext2D::shadowColor() const
 {
     return Color(state().shadowColor()).serialized();
 }
 
 void CanvasRenderingContext2D::setShadowColor(const String& colorString)
 {
     Color color;
     if (!parseColorOrCurrentColor(color, colorString, canvas()))
         return;
     if (state().shadowColor() == color)
         return;
     modifiableState().setShadowColor(color.rgb());
 }
 
-const Vector<float>& CanvasRenderingContext2D::getLineDash() const
+const Vector<double>& CanvasRenderingContext2D::getLineDash() const
 {
     return state().lineDash();
 }
 
-static bool lineDashSequenceIsValid(const Vector<float>& dash)
+static bool lineDashSequenceIsValid(const Vector<double>& dash)
 {
     for (size_t i = 0; i < dash.size(); i++) {
         if (!std::isfinite(dash[i]) || dash[i] < 0)
             return false;
     }
     return true;
 }
 
-void CanvasRenderingContext2D::setLineDash(const Vector<float>& dash)
+void CanvasRenderingContext2D::setLineDash(const Vector<double>& dash)
 {
     if (!lineDashSequenceIsValid(dash))
         return;
     modifiableState().setLineDash(dash);
 }
 
-float CanvasRenderingContext2D::lineDashOffset() const
+double CanvasRenderingContext2D::lineDashOffset() const
 {
     return state().lineDashOffset();
 }
 
-void CanvasRenderingContext2D::setLineDashOffset(float offset)
+void CanvasRenderingContext2D::setLineDashOffset(double offset)
 {
     if (!std::isfinite(offset) || state().lineDashOffset() == offset)
         return;
     modifiableState().setLineDashOffset(offset);
 }
 
-float CanvasRenderingContext2D::globalAlpha() const
+double CanvasRenderingContext2D::globalAlpha() const
 {
     return state().globalAlpha();
 }
 
-void CanvasRenderingContext2D::setGlobalAlpha(float alpha)
+void CanvasRenderingContext2D::setGlobalAlpha(double alpha)
 {
     if (!(alpha >= 0 && alpha <= 1))
         return;
     if (state().globalAlpha() == alpha)
         return;
     modifiableState().setGlobalAlpha(alpha);
 }
 
 bool CanvasRenderingContext2D::shouldAntialias() const
 {
@@ skipping 46 matching lines @@
     return SVGMatrixTearOff::create(state().transform());
 }
 
 void CanvasRenderingContext2D::setCurrentTransform(PassRefPtrWillBeRawPtr<SVGMatrixTearOff> passMatrixTearOff)
 {
     RefPtrWillBeRawPtr<SVGMatrixTearOff> matrixTearOff = passMatrixTearOff;
     const AffineTransform& transform = matrixTearOff->value();
     setTransform(transform.a(), transform.b(), transform.c(), transform.d(), transform.e(), transform.f());
 }
 
-void CanvasRenderingContext2D::scale(float sx, float sy)
+void CanvasRenderingContext2D::scale(double sx, double sy)
 {
     SkCanvas* c = drawingCanvas();
     if (!c)
         return;
 
     if (!std::isfinite(sx) || !std::isfinite(sy))
         return;
 
     AffineTransform newTransform = state().transform();
     newTransform.scaleNonUniform(sx, sy);
     if (state().transform() == newTransform)
         return;
 
     modifiableState().setTransform(newTransform);
     if (!state().isTransformInvertible())
         return;
 
     c->scale(sx, sy);
     m_path.transform(AffineTransform().scaleNonUniform(1.0 / sx, 1.0 / sy));
 }
 
-void CanvasRenderingContext2D::rotate(float angleInRadians)
+void CanvasRenderingContext2D::rotate(double angleInRadians)
 {
     SkCanvas* c = drawingCanvas();
     if (!c)
         return;
 
     if (!std::isfinite(angleInRadians))
         return;
 
     AffineTransform newTransform = state().transform();
     newTransform.rotateRadians(angleInRadians);
     if (state().transform() == newTransform)
         return;
 
     modifiableState().setTransform(newTransform);
     if (!state().isTransformInvertible())
         return;
-    c->rotate(angleInRadians * (180.0f / piFloat));
+    c->rotate(angleInRadians * (180.0 / piFloat));
     m_path.transform(AffineTransform().rotateRadians(-angleInRadians));
 }
 
-void CanvasRenderingContext2D::translate(float tx, float ty)
+void CanvasRenderingContext2D::translate(double tx, double ty)
 {
     SkCanvas* c = drawingCanvas();
     if (!c)
         return;
     if (!state().isTransformInvertible())
         return;
 
     if (!std::isfinite(tx) || !std::isfinite(ty))
         return;
 
     AffineTransform newTransform = state().transform();
     newTransform.translate(tx, ty);
     if (state().transform() == newTransform)
         return;
 
     modifiableState().setTransform(newTransform);
     if (!state().isTransformInvertible())
         return;
     c->translate(tx, ty);
     m_path.transform(AffineTransform().translate(-tx, -ty));
 }
 
-void CanvasRenderingContext2D::transform(float m11, float m12, float m21, float m22, float dx, float dy)
+void CanvasRenderingContext2D::transform(double m11, double m12, double m21, double m22, double dx, double dy)
 {
     SkCanvas* c = drawingCanvas();
     if (!c)
         return;
 
     if (!std::isfinite(m11) || !std::isfinite(m21) || !std::isfinite(dx) || !std::isfinite(m12) || !std::isfinite(m22) || !std::isfinite(dy))
         return;
 
     AffineTransform transform(m11, m12, m21, m22, dx, dy);
     AffineTransform newTransform = state().transform() * transform;
@@ skipping 24 matching lines @@
     // resetTransform() resolves the non-invertible CTM state.
     modifiableState().resetTransform();
     c->setMatrix(affineTransformToSkMatrix(canvas()->baseTransform()));
 
     if (invertibleCTM)
         m_path.transform(ctm);
     // When else, do nothing because all transform methods didn't update m_path when CTM became non-invertible.
     // It means that resetTransform() restores m_path just before CTM became non-invertible.
 }
 
-void CanvasRenderingContext2D::setTransform(float m11, float m12, float m21, float m22, float dx, float dy)
+void CanvasRenderingContext2D::setTransform(double m11, double m12, double m21, double m22, double dx, double dy)
 {
     SkCanvas* c = drawingCanvas();
     if (!c)
         return;
 
     if (!std::isfinite(m11) || !std::isfinite(m21) || !std::isfinite(dx) || !std::isfinite(m12) || !std::isfinite(m22) || !std::isfinite(dy))
         return;
 
     resetTransform();
     transform(m11, m12, m21, m22, dx, dy);
 }
 
 void CanvasRenderingContext2D::beginPath()
 {
     m_path.clear();
 }
 
-static bool validateRectForCanvas(float& x, float& y, float& width, float& height)
+static bool validateRectForCanvas(double& x, double& y, double& width, double& height)
 {
     if (!std::isfinite(x) || !std::isfinite(y) || !std::isfinite(width) || !std::isfinite(height))
         return false;
 
     if (!width && !height)
         return false;
 
     if (width < 0) {
         width = -width;
         x -= width;
@@ skipping 167 matching lines @@
 void CanvasRenderingContext2D::stroke()
 {
     drawPathInternal(m_path, CanvasRenderingContext2DState::StrokePaintType);
 }
 
 void CanvasRenderingContext2D::stroke(Path2D* domPath)
 {
     drawPathInternal(domPath->path(), CanvasRenderingContext2DState::StrokePaintType);
 }
 
-void CanvasRenderingContext2D::fillRect(float x, float y, float width, float height)
+void CanvasRenderingContext2D::fillRect(double x, double y, double width, double height)
 {
     if (!validateRectForCanvas(x, y, width, height))
         return;
 
     if (!drawingCanvas())
         return;
 
     SkRect rect = SkRect::MakeXYWH(x, y, width, height);
     draw(
         [&rect, this](SkCanvas* c, const SkPaint* paint) // draw lambda
@@ skipping 14 matching lines @@
         SkPath path;
         path.moveTo(rect.x(), rect.y());
         path.lineTo(rect.maxX(), rect.maxY());
         path.close();
         canvas->drawPath(path, *paint);
         return;
     }
     canvas->drawRect(rect, *paint);
 }
 
-void CanvasRenderingContext2D::strokeRect(float x, float y, float width, float height)
+void CanvasRenderingContext2D::strokeRect(double x, double y, double width, double height)
 {
     if (!validateRectForCanvas(x, y, width, height))
         return;
 
     if (!drawingCanvas())
         return;
 
     SkRect rect = SkRect::MakeXYWH(x, y, width, height);
     FloatRect bounds = rect;
     inflateStrokeRect(bounds);
@@ skipping 30 matching lines @@
 void CanvasRenderingContext2D::clip(const String& windingRuleString)
 {
     clipInternal(m_path, windingRuleString);
 }
 
 void CanvasRenderingContext2D::clip(Path2D* domPath, const String& windingRuleString)
 {
     clipInternal(domPath->path(), windingRuleString);
 }
 
-bool CanvasRenderingContext2D::isPointInPath(const float x, const float y, const String& windingRuleString)
+bool CanvasRenderingContext2D::isPointInPath(const double x, const double y, const String& windingRuleString)
 {
     return isPointInPathInternal(m_path, x, y, windingRuleString);
 }
 
-bool CanvasRenderingContext2D::isPointInPath(Path2D* domPath, const float x, const float y, const String& windingRuleString)
+bool CanvasRenderingContext2D::isPointInPath(Path2D* domPath, const double x, const double y, const String& windingRuleString)
 {
     return isPointInPathInternal(domPath->path(), x, y, windingRuleString);
 }
 
-bool CanvasRenderingContext2D::isPointInPathInternal(const Path& path, const float x, const float y, const String& windingRuleString)
+bool CanvasRenderingContext2D::isPointInPathInternal(const Path& path, const double x, const double y, const String& windingRuleString)
 {
     SkCanvas* c = drawingCanvas();
     if (!c)
         return false;
     if (!state().isTransformInvertible())
         return false;
 
     FloatPoint point(x, y);
     if (!std::isfinite(point.x()) || !std::isfinite(point.y()))
         return false;
     AffineTransform ctm = state().transform();
     FloatPoint transformedPoint = ctm.inverse().mapPoint(point);
 
     return path.contains(transformedPoint, SkFillTypeToWindRule(parseWinding(windingRuleString)));
 }
 
-bool CanvasRenderingContext2D::isPointInStroke(const float x, const float y)
+bool CanvasRenderingContext2D::isPointInStroke(const double x, const double y)
 {
     return isPointInStrokeInternal(m_path, x, y);
 }
 
-bool CanvasRenderingContext2D::isPointInStroke(Path2D* domPath, const float x, const float y)
+bool CanvasRenderingContext2D::isPointInStroke(Path2D* domPath, const double x, const double y)
 {
     return isPointInStrokeInternal(domPath->path(), x, y);
 }
 
-bool CanvasRenderingContext2D::isPointInStrokeInternal(const Path& path, const float x, const float y)
+bool CanvasRenderingContext2D::isPointInStrokeInternal(const Path& path, const double x, const double y)
 {
     SkCanvas* c = drawingCanvas();
     if (!c)
         return false;
     if (!state().isTransformInvertible())
         return false;
 
     FloatPoint point(x, y);
     if (!std::isfinite(point.x()) || !std::isfinite(point.y()))
         return false;
     AffineTransform ctm = state().transform();
     FloatPoint transformedPoint = ctm.inverse().mapPoint(point);
 
     StrokeData strokeData;
     strokeData.setThickness(state().lineWidth());
     strokeData.setLineCap(state().lineCap());
     strokeData.setLineJoin(state().lineJoin());
     strokeData.setMiterLimit(state().miterLimit());
-    strokeData.setLineDash(state().lineDash(), state().lineDashOffset());
+    Vector<float> lineDash(state().lineDash().size());
+    std::copy(state().lineDash().begin(), state().lineDash().end(), lineDash.begin());
+    strokeData.setLineDash(lineDash, state().lineDashOffset());
     return path.strokeContains(transformedPoint, strokeData);
 }
 
 void CanvasRenderingContext2D::scrollPathIntoView()
 {
     scrollPathIntoViewInternal(m_path);
 }
 
 void CanvasRenderingContext2D::scrollPathIntoView(Path2D* path2d)
 {
@@ skipping 22 matching lines @@
     IntRect canvasRect = layoutBox->absoluteContentBox();
     pathRect.move(canvasRect.x(), canvasRect.y());
 
     renderer->scrollRectToVisible(
         pathRect, ScrollAlignment::alignCenterAlways, ScrollAlignment::alignTopAlways);
 
     // TODO: should implement "inform the user" that the caret and/or
     // selection the specified rectangle of the canvas. See http://crbug.com/357987
 }
 
-void CanvasRenderingContext2D::clearRect(float x, float y, float width, float height)
+void CanvasRenderingContext2D::clearRect(double x, double y, double width, double height)
 {
     if (!validateRectForCanvas(x, y, width, height))
         return;
 
     SkCanvas* c = drawingCanvas();
     if (!c)
         return;
     if (!state().isTransformInvertible())
         return;
 
@@ skipping 58 matching lines @@
     if (value.isHTMLVideoElement())
         return value.getAsHTMLVideoElement().get();
     if (value.isHTMLCanvasElement())
         return value.getAsHTMLCanvasElement().get();
     if (value.isImageBitmap())
         return value.getAsImageBitmap().get();
     ASSERT_NOT_REACHED();
     return nullptr;
 }
 
-void CanvasRenderingContext2D::drawImage(const CanvasImageSourceUnion& imageSource, float x, float y, ExceptionState& exceptionState)
+void CanvasRenderingContext2D::drawImage(const CanvasImageSourceUnion& imageSource, double x, double y, ExceptionState& exceptionState)
 {
     CanvasImageSource* imageSourceInternal = toImageSourceInternal(imageSource);
     FloatSize sourceRectSize = imageSourceInternal->elementSize();
     FloatSize destRectSize = imageSourceInternal->defaultDestinationSize();
     drawImage(imageSourceInternal, 0, 0, sourceRectSize.width(), sourceRectSize.height(), x, y, destRectSize.width(), destRectSize.height(), exceptionState);
 }
 
 void CanvasRenderingContext2D::drawImage(const CanvasImageSourceUnion& imageSource,
-    float x, float y, float width, float height, ExceptionState& exceptionState)
+    double x, double y, double width, double height, ExceptionState& exceptionState)
 {
     CanvasImageSource* imageSourceInternal = toImageSourceInternal(imageSource);
     FloatSize sourceRectSize = imageSourceInternal->elementSize();
     drawImage(imageSourceInternal, 0, 0, sourceRectSize.width(), sourceRectSize.height(), x, y, width, height, exceptionState);
 }
 
 void CanvasRenderingContext2D::drawImage(const CanvasImageSourceUnion& imageSource,
-    float sx, float sy, float sw, float sh,
-    float dx, float dy, float dw, float dh, ExceptionState& exceptionState)
+    double sx, double sy, double sw, double sh,
+    double dx, double dy, double dw, double dh, ExceptionState& exceptionState)
 {
     CanvasImageSource* imageSourceInternal = toImageSourceInternal(imageSource);
     drawImage(imageSourceInternal, sx, sy, sw, sh, dx, dy, dw, dh, exceptionState);
 }
 
 bool CanvasRenderingContext2D::shouldDrawImageAntialiased(const FloatRect& destRect) const
 {
     if (!shouldAntialias())
         return false;
     SkCanvas* c = drawingCanvas();
@@ skipping 71 matching lines @@
         return true;
     if (imageSource->isCanvasElement()) {
         HTMLCanvasElement* canvas = static_cast<HTMLCanvasElement*>(imageSource);
         if (canvas->isAnimated2D())
             return true;
     }
     return false;
 }
 
 void CanvasRenderingContext2D::drawImage(CanvasImageSource* imageSource,
-    float sx, float sy, float sw, float sh,
-    float dx, float dy, float dw, float dh, ExceptionState& exceptionState)
+    double sx, double sy, double sw, double sh,
+    double dx, double dy, double dw, double dh, ExceptionState& exceptionState)
 {
     if (!drawingCanvas())
         return;
 
     RefPtr<Image> image;
     SourceImageStatus sourceImageStatus = InvalidSourceImageStatus;
     if (!imageSource->isVideoElement()) {
         AccelerationHint hint = canvas()->buffer()->isAccelerated() ? PreferAcceleration : PreferNoAcceleration;
         image = imageSource->getSourceImageForCanvas(&sourceImageStatus, hint);
         if (sourceImageStatus == UndecodableSourceImageStatus)
@@ skipping 71 matching lines @@
         c->clear(m_hasAlpha ? SK_ColorTRANSPARENT : SK_ColorBLACK);
 }
 
 bool CanvasRenderingContext2D::rectContainsTransformedRect(const FloatRect& rect, const SkIRect& transformedRect) const
 {
     FloatQuad quad(rect);
     FloatQuad transformedQuad(FloatRect(transformedRect.x(), transformedRect.y(), transformedRect.width(), transformedRect.height()));
     return state().transform().mapQuad(quad).containsQuad(transformedQuad);
 }
 
-CanvasGradient* CanvasRenderingContext2D::createLinearGradient(float x0, float y0, float x1, float y1)
+CanvasGradient* CanvasRenderingContext2D::createLinearGradient(double x0, double y0, double x1, double y1)
 {
     CanvasGradient* gradient = CanvasGradient::create(FloatPoint(x0, y0), FloatPoint(x1, y1));
     return gradient;
 }
 
-CanvasGradient* CanvasRenderingContext2D::createRadialGradient(float x0, float y0, float r0, float x1, float y1, float r1, ExceptionState& exceptionState)
+CanvasGradient* CanvasRenderingContext2D::createRadialGradient(double x0, double y0, double r0, double x1, double y1, double r1, ExceptionState& exceptionState)
 {
     if (r0 < 0 || r1 < 0) {
         exceptionState.throwDOMException(IndexSizeError, String::format("The %s provided is less than 0.", r0 < 0 ? "r0" : "r1"));
         return nullptr;
     }
 
     CanvasGradient* gradient = CanvasGradient::create(FloatPoint(x0, y0), r0, FloatPoint(x1, y1), r1);
     return gradient;
 }
 
@@ skipping 81 matching lines @@
     if (isContextLost())
         return nullptr;
     return canvas()->drawingCanvas();
 }
 
 ImageData* CanvasRenderingContext2D::createImageData(ImageData* imageData) const
 {
     return ImageData::create(imageData->size());
 }
 
-ImageData* CanvasRenderingContext2D::createImageData(float sw, float sh, ExceptionState& exceptionState) const
+ImageData* CanvasRenderingContext2D::createImageData(double sw, double sh, ExceptionState& exceptionState) const
 {
     if (!sw || !sh) {
         exceptionState.throwDOMException(IndexSizeError, String::format("The source %s is 0.", sw ? "height" : "width"));
         return nullptr;
     }
 
     FloatSize logicalSize(fabs(sw), fabs(sh));
     if (!logicalSize.isExpressibleAsIntSize())
         return nullptr;
 
     IntSize size = expandedIntSize(logicalSize);
     if (size.width() < 1)
         size.setWidth(1);
     if (size.height() < 1)
         size.setHeight(1);
 
     return ImageData::create(size);
 }
 
-ImageData* CanvasRenderingContext2D::getImageData(float sx, float sy, float sw, float sh, ExceptionState& exceptionState) const
+ImageData* CanvasRenderingContext2D::getImageData(double sx, double sy, double sw, double sh, ExceptionState& exceptionState) const
 {
     if (!canvas()->originClean())
         exceptionState.throwSecurityError("The canvas has been tainted by cross-origin data.");
     else if (!sw || !sh)
         exceptionState.throwDOMException(IndexSizeError, String::format("The source %s is 0.", sw ? "height" : "width"));
 
     if (exceptionState.hadException())
         return nullptr;
 
     if (sw < 0) {
@@ skipping 21 matching lines @@
     WTF::ArrayBufferContents contents;
     if (!buffer->getImageData(Unmultiplied, imageDataRect, contents))
         return nullptr;
 
     RefPtr<DOMArrayBuffer> arrayBuffer = DOMArrayBuffer::create(contents);
     return ImageData::create(
         imageDataRect.size(),
         DOMUint8ClampedArray::create(arrayBuffer, 0, arrayBuffer->byteLength()));
 }
 
-void CanvasRenderingContext2D::putImageData(ImageData* data, float dx, float dy, ExceptionState& exceptionState)
+void CanvasRenderingContext2D::putImageData(ImageData* data, double dx, double dy, ExceptionState& exceptionState)
 {
     putImageData(data, dx, dy, 0, 0, data->width(), data->height(), exceptionState);
 }
 
-void CanvasRenderingContext2D::putImageData(ImageData* data, float dx, float dy, float dirtyX, float dirtyY, float dirtyWidth, float dirtyHeight, ExceptionState& exceptionState)
+void CanvasRenderingContext2D::putImageData(ImageData* data, double dx, double dy, double dirtyX, double dirtyY, double dirtyWidth, double dirtyHeight, ExceptionState& exceptionState)
 {
     if (data->data()->bufferBase()->isNeutered()) {
         exceptionState.throwDOMException(InvalidStateError, "The source data has been neutered.");
         return;
     }
     ImageBuffer* buffer = canvas()->buffer();
     if (!buffer)
         return;
 
     if (dirtyWidth < 0) {
@@ skipping 225 matching lines @@
         direction = CanvasRenderingContext2DState::DirectionLTR;
     else
         return;
 
     if (state().direction() == direction)
         return;
 
     modifiableState().setDirection(direction);
 }
 
-void CanvasRenderingContext2D::fillText(const String& text, float x, float y)
+void CanvasRenderingContext2D::fillText(const String& text, double x, double y)
 {
     drawTextInternal(text, x, y, CanvasRenderingContext2DState::FillPaintType);
 }
 
-void CanvasRenderingContext2D::fillText(const String& text, float x, float y, float maxWidth)
+void CanvasRenderingContext2D::fillText(const String& text, double x, double y, double maxWidth)
 {
     drawTextInternal(text, x, y, CanvasRenderingContext2DState::FillPaintType, &maxWidth);
 }
 
-void CanvasRenderingContext2D::strokeText(const String& text, float x, float y)
+void CanvasRenderingContext2D::strokeText(const String& text, double x, double y)
 {
     drawTextInternal(text, x, y, CanvasRenderingContext2DState::StrokePaintType);
 }
 
-void CanvasRenderingContext2D::strokeText(const String& text, float x, float y, float maxWidth)
+void CanvasRenderingContext2D::strokeText(const String& text, double x, double y, double maxWidth)
 {
     drawTextInternal(text, x, y, CanvasRenderingContext2DState::StrokePaintType, &maxWidth);
 }
 
 TextMetrics* CanvasRenderingContext2D::measureText(const String& text)
 {
     TextMetrics* metrics = TextMetrics::create();
 
     // The style resolution required for rendering text is not available in frame-less documents.
     if (!canvas()->document().frame())
@@ skipping 31 matching lines @@
     //        between the EM box's top and bottom and the font's ascend and descend
     metrics->setEmHeightAscent(0);
     metrics->setEmHeightDescent(0);
 
     metrics->setHangingBaseline(-0.8f * ascent + baselineY);
     metrics->setAlphabeticBaseline(baselineY);
     metrics->setIdeographicBaseline(descent + baselineY);
     return metrics;
 }
 
-void CanvasRenderingContext2D::drawTextInternal(const String& text, float x, float y, CanvasRenderingContext2DState::PaintType paintType, float* maxWidth)
+void CanvasRenderingContext2D::drawTextInternal(const String& text, double x, double y, CanvasRenderingContext2DState::PaintType paintType, double* maxWidth)
 {
     // The style resolution required for rendering text is not available in frame-less documents.
     if (!canvas()->document().frame())
         return;
 
     // accessFont needs the style to be up to date, but updating style can cause script to run,
     // (e.g. due to autofocus) which can free the canvas (set size to 0, for example), so update
     // style before grabbing the drawingCanvas.
     canvas()->document().updateLayoutTreeForNodeIfNeeded(canvas());
 
@@ skipping 13 matching lines @@
 
     const ComputedStyle* computedStyle = 0;
     TextDirection direction = toTextDirection(state().direction(), canvas(), &computedStyle);
     bool isRTL = direction == RTL;
     bool override = computedStyle ? isOverride(computedStyle->unicodeBidi()) : false;
 
     TextRun textRun(text, 0, 0, TextRun::AllowTrailingExpansion, direction, override);
     textRun.setNormalizeSpace(true);
     // Draw the item text at the correct point.
     FloatPoint location(x, y + getFontBaseline(fontMetrics));
-    float fontWidth = font.width(textRun);
+    double fontWidth = font.width(textRun);
 
     bool useMaxWidth = (maxWidth && *maxWidth < fontWidth);
-    float width = useMaxWidth ? *maxWidth : fontWidth;
+    double width = useMaxWidth ? *maxWidth : fontWidth;
 
     TextAlign align = state().textAlign();
     if (align == StartTextAlign)
         align = isRTL ? RightTextAlign : LeftTextAlign;
     else if (align == EndTextAlign)
         align = isRTL ? LeftTextAlign : RightTextAlign;
 
     switch (align) {
     case CenterTextAlign:
         location.setX(location.x() - width / 2);
@@ skipping 33 matching lines @@
             return false;
         },
         textRunPaintInfo.bounds, paintType);
 }
 
 void CanvasRenderingContext2D::inflateStrokeRect(FloatRect& rect) const
 {
     // Fast approximation of the stroke's bounding rect.
     // This yields a slightly oversized rect but is very fast
     // compared to Path::strokeBoundingRect().
-    static const float root2 = sqrtf(2);
-    float delta = state().lineWidth() / 2;
+    static const double root2 = sqrtf(2);
+    double delta = state().lineWidth() / 2;
     if (state().lineJoin() == MiterJoin)
         delta *= state().miterLimit();
     else if (state().lineCap() == SquareCap)
         delta *= root2;
 
     rect.inflate(delta);
 }
 
 const Font& CanvasRenderingContext2D::accessFont()
 {
@@ skipping 287 matching lines @@
         if (imageType == CanvasRenderingContext2DState::NonOpaqueImage)
             return;
         if (alpha < 0xFF)
             return;
     }
 
     canvas()->buffer()->willOverwriteCanvas();
 }
 
 } // namespace blink