Implement canvas2d direction attribute

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 65 matching lines @@
 static const char defaultFontFamily[] = "sans-serif";
 static const char defaultFont[] = "10px sans-serif";
 static const double TryRestoreContextInterval = 0.5;
 static const unsigned MaxTryRestoreContextAttempts = 4;
 
 static bool contextLostRestoredEventsEnabled()
 {
     return RuntimeEnabledFeatures::experimentalCanvasFeaturesEnabled();
 }
 
+static inline TextDirection inheritedDirection(HTMLCanvasElement& canvasElement)
+{
+    canvasElement.document().updateRenderTreeIfNeeded();
+    RenderStyle* computedStyle = canvasElement.computedStyle();
+    return computedStyle ? computedStyle->direction() : LTR;
+}
+
 CanvasRenderingContext2D::CanvasRenderingContext2D(HTMLCanvasElement* canvas, const Canvas2DContextAttributes* attrs, bool usesCSSCompatibilityParseMode)
     : CanvasRenderingContext(canvas)
     , m_usesCSSCompatibilityParseMode(usesCSSCompatibilityParseMode)
     , m_hasAlpha(!attrs || attrs->alpha())
     , m_isContextLost(false)
     , m_contextRestorable(true)
     , m_storageMode(!attrs ? PersistentStorage : attrs->parsedStorage())
     , m_tryRestoreContextAttemptCount(0)
     , m_dispatchContextLostEventTimer(this, &CanvasRenderingContext2D::dispatchContextLostEvent)
     , m_dispatchContextRestoredEventTimer(this, &CanvasRenderingContext2D::dispatchContextRestoredEvent)
     , m_tryRestoreContextEventTimer(this, &CanvasRenderingContext2D::tryRestoreContextEvent)
 {
-    m_stateStack.append(adoptPtrWillBeNoop(new State()));
+    m_stateStack.append(adoptPtrWillBeNoop(new State(inheritedDirection(*canvas))));
     ScriptWrappable::init(this);
 }
 
 void CanvasRenderingContext2D::unwindStateStack()
 {
     if (size_t stackSize = m_stateStack.size()) {
         if (GraphicsContext* context = canvas()->existingDrawingContext()) {
             while (--stackSize)
                 context->restore();
         }
@@ skipping 114 matching lines @@
         RefPtrWillBeRawPtr<Event> event(Event::create(EventTypeNames::contextrestored));
         canvas()->dispatchEvent(event);
     }
 }
 
 void CanvasRenderingContext2D::reset()
 {
     validateStateStack();
     unwindStateStack();
     m_stateStack.resize(1);
-    m_stateStack.first() = adoptPtrWillBeNoop(new State());
+    m_stateStack.first() = adoptPtrWillBeNoop(new State(inheritedDirection(*canvas())));
     m_path.clear();
     validateStateStack();
 }
 
 // Important: Several of these properties are also stored in GraphicsContext's
 // StrokeData. The default values that StrokeData uses may not the same values
 // that the canvas 2d spec specifies. Make sure to sync the initial state of the
 // GraphicsContext in HTMLCanvasElement::createImageBuffer()!
-CanvasRenderingContext2D::State::State()
+CanvasRenderingContext2D::State::State(TextDirection direction)
     : m_unrealizedSaveCount(0)
     , m_strokeStyle(CanvasStyle::createFromRGBA(Color::black))
     , m_fillStyle(CanvasStyle::createFromRGBA(Color::black))
     , m_lineWidth(1)
     , m_lineCap(ButtCap)
     , m_lineJoin(MiterJoin)
     , m_miterLimit(10)
     , m_shadowBlur(0)
     , m_shadowColor(Color::transparent)
     , m_globalAlpha(1)
     , m_globalComposite(CompositeSourceOver)
     , m_globalBlend(blink::WebBlendModeNormal)
     , m_invertibleCTM(true)
     , m_lineDashOffset(0)
     , m_imageSmoothingEnabled(true)
     , m_textAlign(StartTextAlign)
     , m_textBaseline(AlphabeticTextBaseline)
+    , m_direction(direction)
     , m_unparsedFont(defaultFont)
     , m_realizedFont(false)
     , m_hasClip(false)
 {
 }
 
 CanvasRenderingContext2D::State::State(const State& other)
     : CSSFontSelectorClient()
     , m_unrealizedSaveCount(other.m_unrealizedSaveCount)
     , m_unparsedStrokeColor(other.m_unparsedStrokeColor)
     , m_unparsedFillColor(other.m_unparsedFillColor)
     , m_strokeStyle(other.m_strokeStyle)
     , m_fillStyle(other.m_fillStyle)
     , m_lineWidth(other.m_lineWidth)
     , m_lineCap(other.m_lineCap)
     , m_lineJoin(other.m_lineJoin)
     , m_miterLimit(other.m_miterLimit)
     , m_shadowOffset(other.m_shadowOffset)
     , m_shadowBlur(other.m_shadowBlur)
     , m_shadowColor(other.m_shadowColor)
     , m_globalAlpha(other.m_globalAlpha)
     , m_globalComposite(other.m_globalComposite)
     , m_globalBlend(other.m_globalBlend)
     , m_transform(other.m_transform)
     , m_invertibleCTM(other.m_invertibleCTM)
     , m_lineDashOffset(other.m_lineDashOffset)
     , m_imageSmoothingEnabled(other.m_imageSmoothingEnabled)
     , m_textAlign(other.m_textAlign)
     , m_textBaseline(other.m_textBaseline)
+    , m_direction(other.m_direction)
     , m_unparsedFont(other.m_unparsedFont)
     , m_font(other.m_font)
     , m_realizedFont(other.m_realizedFont)
     , m_hasClip(other.m_hasClip)
 {
     if (m_realizedFont)
         static_cast<CSSFontSelector*>(m_font.fontSelector())->registerForInvalidationCallbacks(this);
 }
 
 CanvasRenderingContext2D::State& CanvasRenderingContext2D::State::operator=(const State& other)
@@ skipping 19 matching lines @@
     m_shadowBlur = other.m_shadowBlur;
     m_shadowColor = other.m_shadowColor;
     m_globalAlpha = other.m_globalAlpha;
     m_globalComposite = other.m_globalComposite;
     m_globalBlend = other.m_globalBlend;
     m_transform = other.m_transform;
     m_invertibleCTM = other.m_invertibleCTM;
     m_imageSmoothingEnabled = other.m_imageSmoothingEnabled;
     m_textAlign = other.m_textAlign;
     m_textBaseline = other.m_textBaseline;
+    m_direction = other.m_direction;
     m_unparsedFont = other.m_unparsedFont;
     m_font = other.m_font;
     m_realizedFont = other.m_realizedFont;
     m_hasClip = other.m_hasClip;
 
     if (m_realizedFont)
         static_cast<CSSFontSelector*>(m_font.fontSelector())->registerForInvalidationCallbacks(this);
 
     return *this;
 }
@@ skipping 1671 matching lines @@
 {
     TextBaseline baseline;
     if (!parseTextBaseline(s, baseline))
         return;
     if (state().m_textBaseline == baseline)
         return;
     realizeSaves();
     modifiableState().m_textBaseline = baseline;
 }
 
+String CanvasRenderingContext2D::direction() const
+{
+    return state().m_direction == RTL ? "rtl" : "ltr";
+}
+
+void CanvasRenderingContext2D::setDirection(const String& directionString)
+{
+    TextDirection direction;
+    if (directionString == "inherit")
+        direction = inheritedDirection(*canvas());

[esprehn, 2014/08/19 17:46:53]

This is now how inheritance is supposed to work, it's supposed to be live, so
that if the parent value changes then it changes here too. The getter needs to
resolve inherit into the correct value when reading, not when here in the
setter.

+    else if (directionString == "rtl")
+        direction = RTL;
+    else if (directionString == "ltr")
+        direction = LTR;
+    else
+        return;
+
+    realizeSaves();
+    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)
 {
     drawTextInternal(text, x, y, true, maxWidth, true);
 }
 
@@ skipping 107 matching lines @@
 
     FontCachePurgePreventer fontCachePurgePreventer;
 
     const Font& font = accessFont();
     const FontMetrics& fontMetrics = font.fontMetrics();
     String normalizedText = normalizeSpaces(text);
 
     // FIXME: Need to turn off font smoothing.
 
     RenderStyle* computedStyle = canvas()->computedStyle();
-    TextDirection direction = computedStyle ? computedStyle->direction() : LTR;
-    bool isRTL = direction == RTL;
+    bool isRTL = state().m_direction == RTL;
     bool override = computedStyle ? isOverride(computedStyle->unicodeBidi()) : false;
 
-    TextRun textRun(normalizedText, 0, 0, TextRun::AllowTrailingExpansion, direction, override, true);
+    TextRun textRun(normalizedText, 0, 0, TextRun::AllowTrailingExpansion, state().m_direction, override, true);
     // Draw the item text at the correct point.
     FloatPoint location(x, y + getFontBaseline(fontMetrics));
 
-    float fontWidth = font.width(TextRun(normalizedText, 0, 0, TextRun::AllowTrailingExpansion, direction, override));
+    float fontWidth = font.width(TextRun(normalizedText, 0, 0, TextRun::AllowTrailingExpansion, state().m_direction, override));
 
     useMaxWidth = (useMaxWidth && maxWidth < fontWidth);
     float width = useMaxWidth ? maxWidth : fontWidth;
 
     TextAlign align = state().m_textAlign;
     if (align == StartTextAlign)
         align = isRTL ? RightTextAlign : LeftTextAlign;
     else if (align == EndTextAlign)
         align = isRTL ? LeftTextAlign : RightTextAlign;
 
@@ skipping 279 matching lines @@
 
 unsigned CanvasRenderingContext2D::hitRegionsCount() const
 {
     if (m_hitRegionManager)
         return m_hitRegionManager->getHitRegionsCount();
 
     return 0;
 }
 
 } // namespace blink