Change float-->double in CanvasRenderingContext2D.idl

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

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 
 #include "modules/canvas2d/CanvasRenderingContext2DState.h"
 
 #include "core/css/CSSFontSelector.h"
 #include "core/css/resolver/FilterOperationResolver.h"
@@ skipping 169 matching lines @@
 }
 
 DEFINE_TRACE(CanvasRenderingContext2DState)
 {
     visitor->trace(m_strokeStyle);
     visitor->trace(m_fillStyle);
     visitor->trace(m_filterValue);
     CSSFontSelectorClient::trace(visitor);
 }
 
-void CanvasRenderingContext2DState::setLineDashOffset(float offset)
+void CanvasRenderingContext2DState::setLineDashOffset(double offset)
 {
     m_lineDashOffset = offset;
     m_lineDashDirty = true;
 }
 
-void CanvasRenderingContext2DState::setLineDash(const Vector<float>& dash)
+void CanvasRenderingContext2DState::setLineDash(const Vector<double>& dash)
 {
     m_lineDash = dash;
     // Spec requires the concatenation of two copies the dash list when the
     // number of elements is odd
     if (dash.size() % 2)
         m_lineDash.appendVector(dash);
 
     m_lineDashDirty = true;
 }
 
-static bool hasANonZeroElement(const Vector<float>& lineDash)
+static bool hasANonZeroElement(const Vector<double>& lineDash)
 {
     for (size_t i = 0; i < lineDash.size(); i++) {
-        if (lineDash[i] != 0.0f)
+        if (lineDash[i] != 0.0)
             return true;
     }
     return false;
 }
 
 void CanvasRenderingContext2DState::updateLineDash() const
 {
     if (!m_lineDashDirty)
         return;
 
     if (!hasANonZeroElement(m_lineDash)) {
         m_strokePaint.setPathEffect(0);
     } else {
-        RefPtr<SkPathEffect> dashPathEffect = adoptRef(SkDashPathEffect::Create(m_lineDash.data(), m_lineDash.size(), m_lineDashOffset));
+        Vector<float> lineDash(m_lineDash.size());
+        std::copy(m_lineDash.begin(), m_lineDash.end(), lineDash.begin());
+        RefPtr<SkPathEffect> dashPathEffect = adoptRef(SkDashPathEffect::Create(lineDash.data(), lineDash.size(), m_lineDashOffset));
         m_strokePaint.setPathEffect(dashPathEffect.get());
     }
 
     m_lineDashDirty = false;
 }
 
 void CanvasRenderingContext2DState::setStrokeStyle(CanvasStyle* style)
 {
     m_strokeStyle = style;
     m_strokeStyleDirty = true;
@@ skipping 59 matching lines @@
     m_strokePaint.setAntiAlias(shouldAntialias);
     m_imagePaint.setAntiAlias(shouldAntialias);
 }
 
 bool CanvasRenderingContext2DState::shouldAntialias() const
 {
     ASSERT(m_fillPaint.isAntiAlias() == m_strokePaint.isAntiAlias() && m_fillPaint.isAntiAlias() == m_imagePaint.isAntiAlias());
     return m_fillPaint.isAntiAlias();
 }
 
-void CanvasRenderingContext2DState::setGlobalAlpha(float alpha)
+void CanvasRenderingContext2DState::setGlobalAlpha(double alpha)
 {
     m_globalAlpha = alpha;
     m_strokeStyleDirty = true;
     m_fillStyleDirty = true;
     int imageAlpha = clampedAlphaForBlending(alpha);
     m_imagePaint.setAlpha(imageAlpha > 255 ? 255 : imageAlpha);
 }
 
 void CanvasRenderingContext2DState::clipPath(const SkPath& path, AntiAliasingMode antiAliasingMode)
 {
@@ skipping 46 matching lines @@
         // Must set font in case the filter uses any font-relative units (em, ex)
         filterStyle->setFont(font);
 
         StyleResolverState resolverState(styleResolutionHost->document(), styleResolutionHost, filterStyle.get());
         resolverState.setStyle(filterStyle);
 
         // TODO(junov): crbug.com/502877 Feed m_fillStyle and m_strokeStyle into FillPaint and
         // StrokePaint respectively for filters that reference SVG.
         StyleBuilder::applyProperty(CSSPropertyWebkitFilter, resolverState, m_filterValue.get());
         RefPtrWillBeRawPtr<FilterEffectBuilder> filterEffectBuilder = FilterEffectBuilder::create();
-        const float effectiveZoom = 1.0f; // Deliberately ignore zoom on the canvas element
+        const double effectiveZoom = 1.0; // Deliberately ignore zoom on the canvas element
         filterEffectBuilder->build(styleResolutionHost, filterStyle->filter(), effectiveZoom);
 
         SkiaImageFilterBuilder imageFilterBuilder;
         RefPtrWillBeRawPtr<FilterEffect> lastEffect = filterEffectBuilder->lastEffect();
         m_resolvedFilter = imageFilterBuilder.build(lastEffect.get(), ColorSpaceDeviceRGB);
     }
 
     return m_resolvedFilter.get();
 }
 
@@ skipping 23 matching lines @@
         drawLooperBuilder->addShadow(m_shadowOffset, m_shadowBlur, m_shadowColor, DrawLooperBuilder::ShadowIgnoresTransforms, DrawLooperBuilder::ShadowRespectsAlpha);
         drawLooperBuilder->addUnmodifiedContent();
         m_shadowAndForegroundDrawLooper = drawLooperBuilder->detachDrawLooper();
     }
     return m_shadowAndForegroundDrawLooper.get();
 }
 
 SkImageFilter* CanvasRenderingContext2DState::shadowOnlyImageFilter() const
 {
     if (!m_shadowOnlyImageFilter) {
-        float sigma = skBlurRadiusToSigma(m_shadowBlur);
+        double sigma = skBlurRadiusToSigma(m_shadowBlur);
         m_shadowOnlyImageFilter = adoptRef(SkDropShadowImageFilter::Create(m_shadowOffset.width(), m_shadowOffset.height(), sigma, sigma, m_shadowColor, SkDropShadowImageFilter::kDrawShadowOnly_ShadowMode));
     }
     return m_shadowOnlyImageFilter.get();
 }
 
 SkImageFilter* CanvasRenderingContext2DState::shadowAndForegroundImageFilter() const
 {
     if (!m_shadowAndForegroundImageFilter) {
-        float sigma = skBlurRadiusToSigma(m_shadowBlur);
+        double sigma = skBlurRadiusToSigma(m_shadowBlur);
         m_shadowAndForegroundImageFilter = adoptRef(SkDropShadowImageFilter::Create(m_shadowOffset.width(), m_shadowOffset.height(), sigma, sigma, m_shadowColor, SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode));
     }
     return m_shadowAndForegroundImageFilter.get();
 }
 
 void CanvasRenderingContext2DState::shadowParameterChanged()
 {
     m_shadowOnlyDrawLooper.clear();
     m_shadowAndForegroundDrawLooper.clear();
     m_shadowOnlyImageFilter.clear();
     m_shadowAndForegroundImageFilter.clear();
 }
 
-void CanvasRenderingContext2DState::setShadowOffsetX(float x)
+void CanvasRenderingContext2DState::setShadowOffsetX(double x)
 {
     m_shadowOffset.setWidth(x);
     shadowParameterChanged();
 }
 
-void CanvasRenderingContext2DState::setShadowOffsetY(float y)
+void CanvasRenderingContext2DState::setShadowOffsetY(double y)
 {
     m_shadowOffset.setHeight(y);
     shadowParameterChanged();
 }
 
-void CanvasRenderingContext2DState::setShadowBlur(float shadowBlur)
+void CanvasRenderingContext2DState::setShadowBlur(double shadowBlur)
 {
     m_shadowBlur = shadowBlur;
     shadowParameterChanged();
 }
 
 void CanvasRenderingContext2DState::setShadowColor(SkColor shadowColor)
 {
     m_shadowColor = shadowColor;
     shadowParameterChanged();
 }
@@ skipping 131 matching lines @@
         paint->setLooper(0);
         paint->setImageFilter(shadowAndForegroundImageFilter());
         return paint;
     }
     paint->setLooper(shadowAndForegroundDrawLooper());
     paint->setImageFilter(0);
     return paint;
 }
 
 } // blink