Use C++11 features in core/html

Source/core/html/canvas/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 189 matching lines @@
 
 void CanvasRenderingContext2D::tryRestoreContextEvent(Timer<CanvasRenderingContext2D>* timer)
 {
     if (!m_isContextLost) {
         // Canvas was already restored (possibly thanks to a resize), so stop trying.
         m_tryRestoreContextEventTimer.stop();
         return;
     }
     if (canvas()->hasImageBuffer() && canvas()->buffer()->restoreSurface()) {
         m_tryRestoreContextEventTimer.stop();
-        dispatchContextRestoredEvent(0);
+        dispatchContextRestoredEvent(nullptr);
     }
 
     if (++m_tryRestoreContextAttemptCount > MaxTryRestoreContextAttempts)
         canvas()->discardImageBuffer();
 
     if (!canvas()->hasImageBuffer()) {
         // final attempt: allocate a brand new image buffer instead of restoring
         timer->stop();
         if (canvas()->buffer())
-            dispatchContextRestoredEvent(0);
+            dispatchContextRestoredEvent(nullptr);
     }
 }
 
 void CanvasRenderingContext2D::dispatchContextRestoredEvent(Timer<CanvasRenderingContext2D>*)
 {
     if (!m_isContextLost)
         return;
     reset();
     m_isContextLost = false;
     if (contextLostRestoredEventsEnabled()) {
@@ skipping 329 matching lines @@
 {
     return state().m_shadowOffset.width();
 }
 
 void CanvasRenderingContext2D::setShadowOffsetX(float x)
 {
     if (!std::isfinite(x))
         return;
     if (state().m_shadowOffset.width() == x)
         return;
-    realizeSaves(0);
+    realizeSaves(nullptr);
     modifiableState().m_shadowOffset.setWidth(x);
     applyShadow();
 }
 
 float CanvasRenderingContext2D::shadowOffsetY() const
 {
     return state().m_shadowOffset.height();
 }
 
 void CanvasRenderingContext2D::setShadowOffsetY(float y)
 {
     if (!std::isfinite(y))
         return;
     if (state().m_shadowOffset.height() == y)
         return;
-    realizeSaves(0);
+    realizeSaves(nullptr);
     modifiableState().m_shadowOffset.setHeight(y);
     applyShadow();
 }
 
 float CanvasRenderingContext2D::shadowBlur() const
 {
     return state().m_shadowBlur;
 }
 
 void CanvasRenderingContext2D::setShadowBlur(float blur)
 {
     if (!std::isfinite(blur) || blur < 0)
         return;
     if (state().m_shadowBlur == blur)
         return;
-    realizeSaves(0);
+    realizeSaves(nullptr);
     modifiableState().m_shadowBlur = blur;
     applyShadow();
 }
 
 String CanvasRenderingContext2D::shadowColor() const
 {
     return Color(state().m_shadowColor).serialized();
 }
 
 void CanvasRenderingContext2D::setShadowColor(const String& color)
 {
     RGBA32 rgba;
     if (!parseColorOrCurrentColor(rgba, color, canvas()))
         return;
     if (state().m_shadowColor == rgba)
         return;
-    realizeSaves(0);
+    realizeSaves(nullptr);
     modifiableState().m_shadowColor = rgba;
     applyShadow();
 }
 
 const Vector<float>& CanvasRenderingContext2D::getLineDash() const
 {
     return state().m_lineDash;
 }
 
 static bool lineDashSequenceIsValid(const Vector<float>& 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)
 {
     if (!lineDashSequenceIsValid(dash))
         return;
 
-    realizeSaves(0);
+    realizeSaves(nullptr);
     modifiableState().m_lineDash = dash;
     // Spec requires the concatenation of two copies the dash list when the
     // number of elements is odd
     if (dash.size() % 2)
         modifiableState().m_lineDash.appendVector(dash);
 
     applyLineDash();
 }
 
 float CanvasRenderingContext2D::lineDashOffset() const
 {
     return state().m_lineDashOffset;
 }
 
 void CanvasRenderingContext2D::setLineDashOffset(float offset)
 {
     if (!std::isfinite(offset) || state().m_lineDashOffset == offset)
         return;
 
-    realizeSaves(0);
+    realizeSaves(nullptr);
     modifiableState().m_lineDashOffset = offset;
     applyLineDash();
 }
 
 void CanvasRenderingContext2D::applyLineDash() const
 {
     GraphicsContext* c = drawingContext();
     if (!c)
         return;
     DashArray convertedLineDash(state().m_lineDash.size());
@@ skipping 200 matching lines @@
         return;
 
     resetTransform();
     transform(m11, m12, m21, m22, dx, dy);
 }
 
 void CanvasRenderingContext2D::setStrokeColor(const String& color)
 {
     if (color == state().m_unparsedStrokeColor)
         return;
-    realizeSaves(0);
+    realizeSaves(nullptr);
     setStrokeStyle(CanvasStyle::createFromString(color));
     modifiableState().m_unparsedStrokeColor = color;
 }
 
 void CanvasRenderingContext2D::setStrokeColor(float grayLevel)
 {
     if (state().m_strokeStyle && state().m_strokeStyle->isEquivalentRGBA(grayLevel, grayLevel, grayLevel, 1.0f))
         return;
     setStrokeStyle(CanvasStyle::createFromGrayLevelWithAlpha(grayLevel, 1.0f));
 }
@@ skipping 21 matching lines @@
 {
     if (state().m_strokeStyle && state().m_strokeStyle->isEquivalentCMYKA(c, m, y, k, a))
         return;
     setStrokeStyle(CanvasStyle::createFromCMYKAChannels(c, m, y, k, a));
 }
 
 void CanvasRenderingContext2D::setFillColor(const String& color)
 {
     if (color == state().m_unparsedFillColor)
         return;
-    realizeSaves(0);
+    realizeSaves(nullptr);
     setFillStyle(CanvasStyle::createFromString(color));
     modifiableState().m_unparsedFillColor = color;
 }
 
 void CanvasRenderingContext2D::setFillColor(float grayLevel)
 {
     if (state().m_fillStyle && state().m_fillStyle->isEquivalentRGBA(grayLevel, grayLevel, grayLevel, 1.0f))
         return;
     setFillStyle(CanvasStyle::createFromGrayLevelWithAlpha(grayLevel, 1.0f));
 }
@@ skipping 484 matching lines @@
 void CanvasRenderingContext2D::clearShadow()
 {
     setShadow(FloatSize(), 0, Color::transparent);
 }
 
 void CanvasRenderingContext2D::setShadow(const FloatSize& offset, float blur, RGBA32 color)
 {
     if (state().m_shadowOffset == offset && state().m_shadowBlur == blur && state().m_shadowColor == color)
         return;
     bool wasDrawingShadows = shouldDrawShadows();
-    realizeSaves(0);
+    realizeSaves(nullptr);
     modifiableState().m_shadowOffset = offset;
     modifiableState().m_shadowBlur = blur;
     modifiableState().m_shadowColor = color;
     if (!wasDrawingShadows && !shouldDrawShadows())
         return;
     applyShadow();
 }
 
 void CanvasRenderingContext2D::applyShadow(ShadowMode shadowMode)
 {
@@ skipping 310 matching lines @@
 {
     if (dirtyRect.isEmpty())
         return;
 
     canvas()->didDraw(dirtyRect);
 }
 
 GraphicsContext* CanvasRenderingContext2D::drawingContext() const
 {
     if (isContextLost())
-        return 0;
+        return nullptr;
     return canvas()->drawingContext();
 }
 
 static PassRefPtrWillBeRawPtr<ImageData> createEmptyImageData(const IntSize& size)
 {
     if (RefPtrWillBeRawPtr<ImageData> data = ImageData::create(size)) {
         data->data()->zeroFill();
         return data.release();
     }
 
@@ skipping 166 matching lines @@
 
     String fontValue = parsedStyle->getPropertyValue(CSSPropertyFont);
 
     // According to http://lists.w3.org/Archives/Public/public-html/2009Jul/0947.html,
     // the "inherit" and "initial" values must be ignored.
     if (fontValue == "inherit" || fontValue == "initial")
         return;
 
     // The parse succeeded.
     String newFontSafeCopy(newFont); // Create a string copy since newFont can be deleted inside realizeSaves.
-    realizeSaves(0);
+    realizeSaves(nullptr);
     modifiableState().m_unparsedFont = newFontSafeCopy;
 
     // Map the <canvas> font into the text style. If the font uses keywords like larger/smaller, these will work
     // relative to the canvas.
     RefPtr<RenderStyle> newStyle = RenderStyle::create();
     canvas()->document().updateRenderTreeIfNeeded();
     if (RenderStyle* computedStyle = canvas()->computedStyle()) {
         FontDescription elementFontDescription(computedStyle->fontDescription());
         // Reset the computed size to avoid inheriting the zoom factor from the <canvas> element.
         elementFontDescription.setComputedSize(elementFontDescription.specifiedSize());
@@ skipping 40 matching lines @@
     return textAlignName(state().m_textAlign);
 }
 
 void CanvasRenderingContext2D::setTextAlign(const String& s)
 {
     TextAlign align;
     if (!parseTextAlign(s, align))
         return;
     if (state().m_textAlign == align)
         return;
-    realizeSaves(0);
+    realizeSaves(nullptr);
     modifiableState().m_textAlign = align;
 }
 
 String CanvasRenderingContext2D::textBaseline() const
 {
     return textBaselineName(state().m_textBaseline);
 }
 
 void CanvasRenderingContext2D::setTextBaseline(const String& s)
 {
     TextBaseline baseline;
     if (!parseTextBaseline(s, baseline))
         return;
     if (state().m_textBaseline == baseline)
         return;
-    realizeSaves(0);
+    realizeSaves(nullptr);
     modifiableState().m_textBaseline = baseline;
 }
 
 inline TextDirection CanvasRenderingContext2D::toTextDirection(Direction direction, RenderStyle** computedStyle) const
 {
     RenderStyle* style = (computedStyle || direction == DirectionInherit) ? canvas()->computedStyle() : nullptr;
     if (computedStyle)
         *computedStyle = style;
     switch (direction) {
     case DirectionInherit:
@@ skipping 22 matching lines @@
     else if (directionString == rtl)
         direction = DirectionRTL;
     else if (directionString == ltr)
         direction = DirectionLTR;
     else
         return;
 
     if (state().m_direction == direction)
         return;
 
-    realizeSaves(0);
+    realizeSaves(nullptr);
     modifiableState().m_direction = direction;
 }
 
 void CanvasRenderingContext2D::fillText(const String& text, float x, float y)
 {
     drawTextInternal(text, x, y, true);
 }
 
 void CanvasRenderingContext2D::fillText(const String& text, float x, float y, float maxWidth)
 {
@@ skipping 356 matching lines @@
 {
     if (m_hitRegionManager)
         m_hitRegionManager->removeAllHitRegions();
 }
 
 HitRegion* CanvasRenderingContext2D::hitRegionAtPoint(const LayoutPoint& point)
 {
     if (m_hitRegionManager)
         return m_hitRegionManager->getHitRegionAtPoint(point);
 
-    return 0;
+    return nullptr;
 }
 
 unsigned CanvasRenderingContext2D::hitRegionsCount() const
 {
     if (m_hitRegionManager)
         return m_hitRegionManager->getHitRegionsCount();
 
     return 0;
 }
 
 } // namespace blink