Get rid of getCTM/setCTM pair in Font::paintGlyphsVertical

Source/platform/fonts/Font.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2003, 2006, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (c) 2007, 2008, 2010 Google Inc. All rights reserved.
  *
  * 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
@@ skipping 21 matching lines @@
 #include "platform/fonts/Character.h"
 #include "platform/fonts/FontCache.h"
 #include "platform/fonts/FontFallbackList.h"
 #include "platform/fonts/GlyphBuffer.h"
 #include "platform/fonts/GlyphPageTreeNode.h"
 #include "platform/fonts/SimpleFontData.h"
 #include "platform/fonts/shaping/HarfBuzzShaper.h"
 #include "platform/fonts/shaping/SimpleShaper.h"
 #include "platform/geometry/FloatRect.h"
 #include "platform/graphics/GraphicsContext.h"
+#include "platform/graphics/GraphicsContextStateSaver.h"
 #include "platform/text/TextRun.h"
 #include "wtf/MainThread.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/unicode/CharacterNames.h"
 #include "wtf/unicode/Unicode.h"
 
 using namespace WTF;
 using namespace Unicode;
 
 namespace blink {
@@ skipping 742 matching lines @@
 {
     const OpenTypeVerticalData* verticalData = font->verticalData();
 
     SkAutoSTMalloc<32, SkPoint> storage(numGlyphs);
     SkPoint* pos = storage.get();
 
     // Bend over backwards to preserve legacy rounding.
     float initialAdvance = glyphBuffer.xOffsetAt(from);
     FloatPoint adjustedPoint(point.x() + initialAdvance, point.y());
 
-    AffineTransform savedMatrix = gc->getCTM();
+    GraphicsContextStateSaver stateSaver(*gc);
     gc->concatCTM(AffineTransform(0, -1, 1, 0, adjustedPoint.x(), adjustedPoint.y()));
     gc->concatCTM(AffineTransform(1, 0, 0, 1, -adjustedPoint.x(), -adjustedPoint.y()));
 
     const unsigned kMaxBufferLength = 256;
     Vector<FloatPoint, kMaxBufferLength> translations;
 
     const FontMetrics& metrics = font->fontMetrics();
     float verticalOriginX = adjustedPoint.x() + metrics.floatAscent() - metrics.floatAscent(IdeographicBaseline);
 
     unsigned glyphIndex = 0;
     while (glyphIndex < numGlyphs) {
         unsigned chunkLength = std::min(kMaxBufferLength, numGlyphs - glyphIndex);
 
         const Glyph* glyphs = glyphBuffer.glyphs(from + glyphIndex);
 
         translations.resize(chunkLength);
         verticalData->getVerticalTranslationsForGlyphs(font, glyphs, chunkLength,
             reinterpret_cast<float*>(&translations[0]));
 
         for (unsigned i = 0; i < chunkLength; ++i, ++glyphIndex) {
             SkScalar x = verticalOriginX + lroundf(translations[i].x());
             SkScalar y = adjustedPoint.y() - SkIntToScalar(
                 -lroundf(glyphBuffer.xOffsetAt(from + glyphIndex) - initialAdvance - translations[i].y()));
             pos[i].set(x, y);
         }
         paintGlyphs(gc, font, glyphs, chunkLength, pos, textRect);
     }
-
-    gc->setCTM(savedMatrix);
 }
 
 void Font::drawGlyphs(GraphicsContext* gc, const SimpleFontData* font,
     const GlyphBuffer& glyphBuffer, unsigned from, unsigned numGlyphs,
     const FloatPoint& point, const FloatRect& textRect) const
 {
     ASSERT(glyphBuffer.size() >= from + numGlyphs);
 
     if (font->platformData().orientation() == Vertical && font->verticalData()) {
         paintGlyphsVertical(gc, font, glyphBuffer, from, numGlyphs, point, textRect);
@@ skipping 215 matching lines @@
                 if (delta <= 0)
                     break;
             }
         }
     }
 
     return offset;
 }
 
 } // namespace blink