c45dc19cc99cdf2d8259fe738ffcf2d7493abeee
[WebKit-https.git] / Source / WebCore / platform / graphics / cg / GraphicsContextCG.cpp
1 /*
2  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
3  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
25  */
26
27 #include "config.h"
28 #include "GraphicsContextCG.h"
29
30 #include "AffineTransform.h"
31 #include "CoreGraphicsSPI.h"
32 #include "FloatConversion.h"
33 #include "GraphicsContextPlatformPrivateCG.h"
34 #include "ImageBuffer.h"
35 #include "ImageOrientation.h"
36 #include "Path.h"
37 #include "Pattern.h"
38 #include "ShadowBlur.h"
39 #include "SubimageCacheWithTimer.h"
40 #include "Timer.h"
41 #include "URL.h"
42 #include <wtf/MathExtras.h>
43 #include <wtf/RetainPtr.h>
44
45 #if PLATFORM(COCOA)
46 #include "WebCoreSystemInterface.h"
47 #endif
48
49 #if PLATFORM(WIN)
50 #include <WebKitSystemInterface/WebKitSystemInterface.h>
51 #endif
52
53 // FIXME: The following using declaration should be in <wtf/HashFunctions.h>.
54 using WTF::pairIntHash;
55
56 // FIXME: The following using declaration should be in <wtf/HashTraits.h>.
57 using WTF::GenericHashTraits;
58
59 namespace WebCore {
60
61 static void setCGFillColor(CGContextRef context, const Color& color)
62 {
63     CGContextSetFillColorWithColor(context, cachedCGColor(color));
64 }
65
66 static void setCGStrokeColor(CGContextRef context, const Color& color)
67 {
68     CGContextSetStrokeColorWithColor(context, cachedCGColor(color));
69 }
70
71 // FIXME: This should be removed soon.
72 CGColorSpaceRef deviceRGBColorSpaceRef()
73 {
74     static CGColorSpaceRef deviceSpace = CGColorSpaceCreateDeviceRGB();
75     return deviceSpace;
76 }
77
78 CGColorSpaceRef sRGBColorSpaceRef()
79 {
80     static CGColorSpaceRef sRGBSpace = CGColorSpaceCreateWithName(kCGColorSpaceSRGB);
81 #if PLATFORM(WIN)
82     // Out-of-date CG installations will not honor kCGColorSpaceSRGB. This logic avoids
83     // causing a crash under those conditions. Since the default color space in Windows
84     // is sRGB, this all works out nicely.
85     if (!sRGBSpace)
86         sRGBSpace = deviceRGBColorSpaceRef();
87 #endif // PLATFORM(WIN)
88     return sRGBSpace;
89 }
90
91 #if PLATFORM(WIN)
92 CGColorSpaceRef linearRGBColorSpaceRef()
93 {
94     // FIXME: Windows should be able to use linear sRGB, this is tracked by http://webkit.org/b/80000.
95     return deviceRGBColorSpaceRef();
96 }
97 #endif
98
99 static InterpolationQuality convertInterpolationQuality(CGInterpolationQuality quality)
100 {
101     switch (quality) {
102     case kCGInterpolationDefault:
103         return InterpolationDefault;
104     case kCGInterpolationNone:
105         return InterpolationNone;
106     case kCGInterpolationLow:
107         return InterpolationLow;
108     case kCGInterpolationMedium:
109         return InterpolationMedium;
110     case kCGInterpolationHigh:
111         return InterpolationHigh;
112     }
113     return InterpolationDefault;
114 }
115
116 void GraphicsContext::platformInit(CGContextRef cgContext)
117 {
118     if (!cgContext)
119         return;
120
121     m_data = new GraphicsContextPlatformPrivate(cgContext);
122     // Make sure the context starts in sync with our state.
123     setPlatformFillColor(fillColor());
124     setPlatformStrokeColor(strokeColor());
125     setPlatformStrokeThickness(strokeThickness());
126     m_state.imageInterpolationQuality = convertInterpolationQuality(CGContextGetInterpolationQuality(platformContext()));
127 }
128
129 void GraphicsContext::platformDestroy()
130 {
131     delete m_data;
132 }
133
134 CGContextRef GraphicsContext::platformContext() const
135 {
136     ASSERT(!paintingDisabled());
137     ASSERT(m_data->m_cgContext);
138     return m_data->m_cgContext.get();
139 }
140
141 void GraphicsContext::savePlatformState()
142 {
143     ASSERT(!paintingDisabled());
144     // Note: Do not use this function within this class implementation, since we want to avoid the extra
145     // save of the secondary context (in GraphicsContextPlatformPrivateCG.h).
146     CGContextSaveGState(platformContext());
147     m_data->save();
148 }
149
150 void GraphicsContext::restorePlatformState()
151 {
152     ASSERT(!paintingDisabled());
153     // Note: Do not use this function within this class implementation, since we want to avoid the extra
154     // restore of the secondary context (in GraphicsContextPlatformPrivateCG.h).
155     CGContextRestoreGState(platformContext());
156     m_data->restore();
157     m_data->m_userToDeviceTransformKnownToBeIdentity = false;
158 }
159
160 void GraphicsContext::drawNativeImage(PassNativeImagePtr imagePtr, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, CompositeOperator op, BlendMode blendMode, ImageOrientation orientation)
161 {
162     if (paintingDisabled())
163         return;
164
165     RetainPtr<CGImageRef> image(imagePtr);
166
167     float currHeight = orientation.usesWidthAsHeight() ? CGImageGetWidth(image.get()) : CGImageGetHeight(image.get());
168     if (currHeight <= srcRect.y())
169         return;
170
171     CGContextRef context = platformContext();
172     CGContextStateSaver stateSaver(context);
173
174 #if PLATFORM(IOS)
175     // Anti-aliasing is on by default on the iPhone. Need to turn it off when drawing images.
176     CGContextSetShouldAntialias(context, false);
177 #endif
178
179     bool shouldUseSubimage = false;
180
181     // If the source rect is a subportion of the image, then we compute an inflated destination rect that will hold the entire image
182     // and then set a clip to the portion that we want to display.
183     FloatRect adjustedDestRect = destRect;
184
185     if (srcRect.size() != imageSize) {
186         CGInterpolationQuality interpolationQuality = CGContextGetInterpolationQuality(context);
187         // When the image is scaled using high-quality interpolation, we create a temporary CGImage
188         // containing only the portion we want to display. We need to do this because high-quality
189         // interpolation smoothes sharp edges, causing pixels from outside the source rect to bleed
190         // into the destination rect. See <rdar://problem/6112909>.
191         shouldUseSubimage = (interpolationQuality != kCGInterpolationNone) && (srcRect.size() != destRect.size() || !getCTM().isIdentityOrTranslationOrFlipped());
192         float xScale = srcRect.width() / destRect.width();
193         float yScale = srcRect.height() / destRect.height();
194         if (shouldUseSubimage) {
195             FloatRect subimageRect = srcRect;
196             float leftPadding = srcRect.x() - floorf(srcRect.x());
197             float topPadding = srcRect.y() - floorf(srcRect.y());
198
199             subimageRect.move(-leftPadding, -topPadding);
200             adjustedDestRect.move(-leftPadding / xScale, -topPadding / yScale);
201
202             subimageRect.setWidth(ceilf(subimageRect.width() + leftPadding));
203             adjustedDestRect.setWidth(subimageRect.width() / xScale);
204
205             subimageRect.setHeight(ceilf(subimageRect.height() + topPadding));
206             adjustedDestRect.setHeight(subimageRect.height() / yScale);
207
208 #if CACHE_SUBIMAGES
209             image = subimageCache().getSubimage(image.get(), subimageRect);
210 #else
211             image = adoptCF(CGImageCreateWithImageInRect(image.get(), subimageRect));
212 #endif
213             if (currHeight < srcRect.maxY()) {
214                 ASSERT(CGImageGetHeight(image.get()) == currHeight - CGRectIntegral(srcRect).origin.y);
215                 adjustedDestRect.setHeight(CGImageGetHeight(image.get()) / yScale);
216             }
217         } else {
218             adjustedDestRect.setLocation(FloatPoint(destRect.x() - srcRect.x() / xScale, destRect.y() - srcRect.y() / yScale));
219             adjustedDestRect.setSize(FloatSize(imageSize.width() / xScale, imageSize.height() / yScale));
220         }
221
222         if (!destRect.contains(adjustedDestRect))
223             CGContextClipToRect(context, destRect);
224     }
225
226     // If the image is only partially loaded, then shrink the destination rect that we're drawing into accordingly.
227     if (!shouldUseSubimage && currHeight < imageSize.height())
228         adjustedDestRect.setHeight(adjustedDestRect.height() * currHeight / imageSize.height());
229
230 #if PLATFORM(IOS)
231     // Align to pixel boundaries
232     adjustedDestRect = roundToDevicePixels(adjustedDestRect);
233 #endif
234
235     setPlatformCompositeOperation(op, blendMode);
236
237     // ImageOrientation expects the origin to be at (0, 0)
238     CGContextTranslateCTM(context, adjustedDestRect.x(), adjustedDestRect.y());
239     adjustedDestRect.setLocation(FloatPoint());
240
241     if (orientation != DefaultImageOrientation) {
242         CGContextConcatCTM(context, orientation.transformFromDefault(adjustedDestRect.size()));
243         if (orientation.usesWidthAsHeight()) {
244             // The destination rect will have it's width and height already reversed for the orientation of
245             // the image, as it was needed for page layout, so we need to reverse it back here.
246             adjustedDestRect = FloatRect(adjustedDestRect.x(), adjustedDestRect.y(), adjustedDestRect.height(), adjustedDestRect.width());
247         }
248     }
249     
250     // Flip the coords.
251     CGContextTranslateCTM(context, 0, adjustedDestRect.height());
252     CGContextScaleCTM(context, 1, -1);
253
254     // Draw the image.
255     CGContextDrawImage(context, adjustedDestRect, image.get());
256 }
257
258 static void drawPatternCallback(void* info, CGContextRef context)
259 {
260     CGImageRef image = (CGImageRef)info;
261     CGFloat height = CGImageGetHeight(image);
262 #if PLATFORM(IOS)
263     CGContextScaleCTM(context, 1, -1);
264     CGContextTranslateCTM(context, 0, -height);
265 #endif
266     CGContextDrawImage(context, GraphicsContext(context).roundToDevicePixels(FloatRect(0, 0, CGImageGetWidth(image), height)), image);
267 }
268
269 static void patternReleaseCallback(void* info)
270 {
271     auto image = static_cast<CGImageRef>(info);
272     callOnMainThread([image] {
273         CGImageRelease(image);
274     });
275 }
276
277 void GraphicsContext::drawPattern(Image& image, const FloatRect& tileRect, const AffineTransform& patternTransform, const FloatPoint& phase, const FloatSize& spacing, CompositeOperator op, const FloatRect& destRect, BlendMode blendMode)
278 {
279     if (paintingDisabled() || !patternTransform.isInvertible())
280         return;
281
282     CGContextRef context = platformContext();
283     CGContextStateSaver stateSaver(context);
284     CGContextClipToRect(context, destRect);
285
286     setPlatformCompositeOperation(op, blendMode);
287
288     CGContextTranslateCTM(context, destRect.x(), destRect.y() + destRect.height());
289     CGContextScaleCTM(context, 1, -1);
290     
291     // Compute the scaled tile size.
292     float scaledTileHeight = tileRect.height() * narrowPrecisionToFloat(patternTransform.d());
293     
294     // We have to adjust the phase to deal with the fact we're in Cartesian space now (with the bottom left corner of destRect being
295     // the origin).
296     float adjustedX = phase.x() - destRect.x() + tileRect.x() * narrowPrecisionToFloat(patternTransform.a()); // We translated the context so that destRect.x() is the origin, so subtract it out.
297     float adjustedY = destRect.height() - (phase.y() - destRect.y() + tileRect.y() * narrowPrecisionToFloat(patternTransform.d()) + scaledTileHeight);
298
299     CGImageRef tileImage = image.nativeImageForCurrentFrame();
300     float h = CGImageGetHeight(tileImage);
301
302     RetainPtr<CGImageRef> subImage;
303 #if PLATFORM(IOS)
304     FloatSize imageSize = image.originalSize();
305 #else
306     FloatSize imageSize = image.size();
307 #endif
308     if (tileRect.size() == imageSize)
309         subImage = tileImage;
310     else {
311         // Copying a sub-image out of a partially-decoded image stops the decoding of the original image. It should never happen
312         // because sub-images are only used for border-image, which only renders when the image is fully decoded.
313         ASSERT(h == image.height());
314         subImage = adoptCF(CGImageCreateWithImageInRect(tileImage, tileRect));
315     }
316
317     // If we need to paint gaps between tiles because we have a partially loaded image or non-zero spacing,
318     // fall back to the less efficient CGPattern-based mechanism.
319     float scaledTileWidth = tileRect.width() * narrowPrecisionToFloat(patternTransform.a());
320     float w = CGImageGetWidth(tileImage);
321     if (w == image.size().width() && h == image.size().height() && !spacing.width() && !spacing.height()) {
322         // FIXME: CG seems to snap the images to integral sizes. When we care (e.g. with border-image-repeat: round),
323         // we should tile all but the last, and stetch the last image to fit.
324         CGContextDrawTiledImage(context, FloatRect(adjustedX, adjustedY, scaledTileWidth, scaledTileHeight), subImage.get());
325     } else {
326         static const CGPatternCallbacks patternCallbacks = { 0, drawPatternCallback, patternReleaseCallback };
327         CGAffineTransform matrix = CGAffineTransformMake(narrowPrecisionToCGFloat(patternTransform.a()), 0, 0, narrowPrecisionToCGFloat(patternTransform.d()), adjustedX, adjustedY);
328         matrix = CGAffineTransformConcat(matrix, CGContextGetCTM(context));
329         // The top of a partially-decoded image is drawn at the bottom of the tile. Map it to the top.
330         matrix = CGAffineTransformTranslate(matrix, 0, image.size().height() - h);
331 #if PLATFORM(IOS)
332         matrix = CGAffineTransformScale(matrix, 1, -1);
333         matrix = CGAffineTransformTranslate(matrix, 0, -h);
334 #endif
335         CGImageRef platformImage = CGImageRetain(subImage.get());
336         RetainPtr<CGPatternRef> pattern = adoptCF(CGPatternCreate(platformImage, CGRectMake(0, 0, tileRect.width(), tileRect.height()), matrix,
337             tileRect.width() + spacing.width() * (1 / narrowPrecisionToFloat(patternTransform.a())),
338             tileRect.height() + spacing.height() * (1 / narrowPrecisionToFloat(patternTransform.d())),
339             kCGPatternTilingConstantSpacing, true, &patternCallbacks));
340         
341         if (!pattern)
342             return;
343
344         RetainPtr<CGColorSpaceRef> patternSpace = adoptCF(CGColorSpaceCreatePattern(nullptr));
345
346         CGFloat alpha = 1;
347         RetainPtr<CGColorRef> color = adoptCF(CGColorCreateWithPattern(patternSpace.get(), pattern.get(), &alpha));
348         CGContextSetFillColorSpace(context, patternSpace.get());
349
350         CGContextSetBaseCTM(context, CGAffineTransformIdentity);
351         CGContextSetPatternPhase(context, CGSizeZero);
352
353         CGContextSetFillColorWithColor(context, color.get());
354         CGContextFillRect(context, CGContextGetClipBoundingBox(context)); // FIXME: we know the clip; we set it above.
355     }
356 }
357
358 void GraphicsContext::clipToImageBuffer(ImageBuffer& buffer, const FloatRect& destRect)
359 {
360     if (paintingDisabled())
361         return;
362
363     FloatSize bufferDestinationSize = buffer.sizeForDestinationSize(destRect.size());
364     RetainPtr<CGImageRef> image = buffer.copyNativeImage(DontCopyBackingStore);
365
366     CGContextRef context = platformContext();
367     // FIXME: This image needs to be grayscale to be used as an alpha mask here.
368     CGContextTranslateCTM(context, destRect.x(), destRect.y() + bufferDestinationSize.height());
369     CGContextScaleCTM(context, 1, -1);
370     CGContextClipToRect(context, FloatRect(FloatPoint(0, bufferDestinationSize.height() - destRect.height()), destRect.size()));
371     CGContextClipToMask(context, FloatRect(FloatPoint(), bufferDestinationSize), image.get());
372     CGContextScaleCTM(context, 1, -1);
373     CGContextTranslateCTM(context, -destRect.x(), -destRect.y() - destRect.height());
374 }
375
376 // Draws a filled rectangle with a stroked border.
377 void GraphicsContext::drawRect(const FloatRect& rect, float borderThickness)
378 {
379     if (paintingDisabled())
380         return;
381
382     // FIXME: this function does not handle patterns and gradients like drawPath does, it probably should.
383     ASSERT(!rect.isEmpty());
384
385     CGContextRef context = platformContext();
386
387     CGContextFillRect(context, rect);
388
389     if (strokeStyle() != NoStroke) {
390         // We do a fill of four rects to simulate the stroke of a border.
391         Color oldFillColor = fillColor();
392         if (oldFillColor != strokeColor())
393             setCGFillColor(context, strokeColor());
394         CGRect rects[4] = {
395             FloatRect(rect.x(), rect.y(), rect.width(), borderThickness),
396             FloatRect(rect.x(), rect.maxY() - borderThickness, rect.width(), borderThickness),
397             FloatRect(rect.x(), rect.y() + borderThickness, borderThickness, rect.height() - 2 * borderThickness),
398             FloatRect(rect.maxX() - borderThickness, rect.y() + borderThickness, borderThickness, rect.height() - 2 * borderThickness)
399         };
400         CGContextFillRects(context, rects, 4);
401         if (oldFillColor != strokeColor())
402             setCGFillColor(context, oldFillColor);
403     }
404 }
405
406 // This is only used to draw borders.
407 void GraphicsContext::drawLine(const FloatPoint& point1, const FloatPoint& point2)
408 {
409     if (paintingDisabled())
410         return;
411
412     if (strokeStyle() == NoStroke)
413         return;
414
415     float thickness = strokeThickness();
416     bool isVerticalLine = (point1.x() + thickness == point2.x());
417     float strokeWidth = isVerticalLine ? point2.y() - point1.y() : point2.x() - point1.x();
418     if (!thickness || !strokeWidth)
419         return;
420
421     CGContextRef context = platformContext();
422
423     StrokeStyle strokeStyle = this->strokeStyle();
424     float cornerWidth = 0;
425     bool drawsDashedLine = strokeStyle == DottedStroke || strokeStyle == DashedStroke;
426
427     CGContextStateSaver stateSaver(context, drawsDashedLine);
428     if (drawsDashedLine) {
429         // Figure out end points to ensure we always paint corners.
430         cornerWidth = strokeStyle == DottedStroke ? thickness : std::min(2 * thickness, std::max(thickness, strokeWidth / 3));
431         setCGFillColor(context, strokeColor());
432         if (isVerticalLine) {
433             CGContextFillRect(context, FloatRect(point1.x(), point1.y(), thickness, cornerWidth));
434             CGContextFillRect(context, FloatRect(point1.x(), point2.y() - cornerWidth, thickness, cornerWidth));
435         } else {
436             CGContextFillRect(context, FloatRect(point1.x(), point1.y(), cornerWidth, thickness));
437             CGContextFillRect(context, FloatRect(point2.x() - cornerWidth, point1.y(), cornerWidth, thickness));
438         }
439         strokeWidth -= 2 * cornerWidth;
440         float patternWidth = strokeStyle == DottedStroke ? thickness : std::min(3 * thickness, std::max(thickness, strokeWidth / 3));
441         // Check if corner drawing sufficiently covers the line.
442         if (strokeWidth <= patternWidth + 1)
443             return;
444
445         // Pattern starts with full fill and ends with the empty fill.
446         // 1. Let's start with the empty phase after the corner.
447         // 2. Check if we've got odd or even number of patterns and whether they fully cover the line.
448         // 3. In case of even number of patterns and/or remainder, move the pattern start position
449         // so that the pattern is balanced between the corners.
450         float patternOffset = patternWidth;
451         int numberOfSegments = floorf(strokeWidth / patternWidth);
452         bool oddNumberOfSegments = numberOfSegments % 2;
453         float remainder = strokeWidth - (numberOfSegments * patternWidth);
454         if (oddNumberOfSegments && remainder)
455             patternOffset -= remainder / 2;
456         else if (!oddNumberOfSegments) {
457             if (remainder)
458                 patternOffset += patternOffset - (patternWidth + remainder)  / 2;
459             else
460                 patternOffset += patternWidth  / 2;
461         }
462         const CGFloat dashedLine[2] = { static_cast<CGFloat>(patternWidth), static_cast<CGFloat>(patternWidth) };
463         CGContextSetLineDash(context, patternOffset, dashedLine, 2);
464     }
465
466     FloatPoint p1 = point1;
467     FloatPoint p2 = point2;
468     // Center line and cut off corners for pattern patining.
469     if (isVerticalLine) {
470         float centerOffset = (p2.x() - p1.x()) / 2;
471         p1.move(centerOffset, cornerWidth);
472         p2.move(-centerOffset, -cornerWidth);
473     } else {
474         float centerOffset = (p2.y() - p1.y()) / 2;
475         p1.move(cornerWidth, centerOffset);
476         p2.move(-cornerWidth, -centerOffset);
477     }
478
479     if (shouldAntialias()) {
480 #if PLATFORM(IOS)
481         // Force antialiasing on for line patterns as they don't look good with it turned off (<rdar://problem/5459772>).
482         CGContextSetShouldAntialias(context, strokeStyle == DottedStroke || strokeStyle == DashedStroke);
483 #else
484         CGContextSetShouldAntialias(context, false);
485 #endif
486     }
487     CGContextBeginPath(context);
488     CGContextMoveToPoint(context, p1.x(), p1.y());
489     CGContextAddLineToPoint(context, p2.x(), p2.y());
490     CGContextStrokePath(context);
491     if (shouldAntialias())
492         CGContextSetShouldAntialias(context, true);
493 }
494
495 void GraphicsContext::drawEllipse(const FloatRect& rect)
496 {
497     if (paintingDisabled())
498         return;
499
500     Path path;
501     path.addEllipse(rect);
502     drawPath(path);
503 }
504
505 static void addConvexPolygonToPath(Path& path, size_t numberOfPoints, const FloatPoint* points)
506 {
507     ASSERT(numberOfPoints > 0);
508
509     path.moveTo(points[0]);
510     for (size_t i = 1; i < numberOfPoints; ++i)
511         path.addLineTo(points[i]);
512     path.closeSubpath();
513 }
514
515 void GraphicsContext::drawConvexPolygon(size_t numberOfPoints, const FloatPoint* points, bool antialiased)
516 {
517     if (paintingDisabled())
518         return;
519
520     if (numberOfPoints <= 1)
521         return;
522
523     CGContextRef context = platformContext();
524
525     if (antialiased != shouldAntialias())
526         CGContextSetShouldAntialias(context, antialiased);
527
528     Path path;
529     addConvexPolygonToPath(path, numberOfPoints, points);
530     drawPath(path);
531
532     if (antialiased != shouldAntialias())
533         CGContextSetShouldAntialias(context, shouldAntialias());
534 }
535
536 void GraphicsContext::clipConvexPolygon(size_t numberOfPoints, const FloatPoint* points, bool antialias)
537 {
538     if (paintingDisabled())
539         return;
540
541     if (numberOfPoints <= 1)
542         return;
543
544     CGContextRef context = platformContext();
545
546     if (antialias != shouldAntialias())
547         CGContextSetShouldAntialias(context, antialias);
548
549     Path path;
550     addConvexPolygonToPath(path, numberOfPoints, points);
551     clipPath(path, RULE_NONZERO);
552
553     if (antialias != shouldAntialias())
554         CGContextSetShouldAntialias(context, shouldAntialias());
555 }
556
557 void GraphicsContext::applyStrokePattern()
558 {
559     if (paintingDisabled())
560         return;
561
562     CGContextRef cgContext = platformContext();
563     AffineTransform userToBaseCTM = AffineTransform(getUserToBaseCTM(cgContext));
564
565     RetainPtr<CGPatternRef> platformPattern = adoptCF(m_state.strokePattern->createPlatformPattern(userToBaseCTM));
566     if (!platformPattern)
567         return;
568
569     RetainPtr<CGColorSpaceRef> patternSpace = adoptCF(CGColorSpaceCreatePattern(0));
570     CGContextSetStrokeColorSpace(cgContext, patternSpace.get());
571
572     const CGFloat patternAlpha = 1;
573     CGContextSetStrokePattern(cgContext, platformPattern.get(), &patternAlpha);
574 }
575
576 void GraphicsContext::applyFillPattern()
577 {
578     if (paintingDisabled())
579         return;
580
581     CGContextRef cgContext = platformContext();
582     AffineTransform userToBaseCTM = AffineTransform(getUserToBaseCTM(cgContext));
583
584     RetainPtr<CGPatternRef> platformPattern = adoptCF(m_state.fillPattern->createPlatformPattern(userToBaseCTM));
585     if (!platformPattern)
586         return;
587
588     RetainPtr<CGColorSpaceRef> patternSpace = adoptCF(CGColorSpaceCreatePattern(nullptr));
589     CGContextSetFillColorSpace(cgContext, patternSpace.get());
590
591     const CGFloat patternAlpha = 1;
592     CGContextSetFillPattern(cgContext, platformPattern.get(), &patternAlpha);
593 }
594
595 static inline bool calculateDrawingMode(const GraphicsContextState& state, CGPathDrawingMode& mode)
596 {
597     bool shouldFill = state.fillPattern || state.fillColor.alpha();
598     bool shouldStroke = state.strokePattern || (state.strokeStyle != NoStroke && state.strokeColor.alpha());
599     bool useEOFill = state.fillRule == RULE_EVENODD;
600
601     if (shouldFill) {
602         if (shouldStroke) {
603             if (useEOFill)
604                 mode = kCGPathEOFillStroke;
605             else
606                 mode = kCGPathFillStroke;
607         } else { // fill, no stroke
608             if (useEOFill)
609                 mode = kCGPathEOFill;
610             else
611                 mode = kCGPathFill;
612         }
613     } else {
614         // Setting mode to kCGPathStroke even if shouldStroke is false. In that case, we return false and mode will not be used,
615         // but the compiler will not complain about an uninitialized variable.
616         mode = kCGPathStroke;
617     }
618
619     return shouldFill || shouldStroke;
620 }
621
622 void GraphicsContext::drawPath(const Path& path)
623 {
624     if (paintingDisabled() || path.isEmpty())
625         return;
626
627     CGContextRef context = platformContext();
628     const GraphicsContextState& state = m_state;
629
630     if (state.fillGradient || state.strokeGradient) {
631         // We don't have any optimized way to fill & stroke a path using gradients
632         // FIXME: Be smarter about this.
633         fillPath(path);
634         strokePath(path);
635         return;
636     }
637
638     CGContextBeginPath(context);
639     CGContextAddPath(context, path.platformPath());
640
641     if (state.fillPattern)
642         applyFillPattern();
643     if (state.strokePattern)
644         applyStrokePattern();
645
646     CGPathDrawingMode drawingMode;
647     if (calculateDrawingMode(state, drawingMode))
648         CGContextDrawPath(context, drawingMode);
649 }
650
651 static inline void fillPathWithFillRule(CGContextRef context, WindRule fillRule)
652 {
653     if (fillRule == RULE_EVENODD)
654         CGContextEOFillPath(context);
655     else
656         CGContextFillPath(context);
657 }
658
659 void GraphicsContext::fillPath(const Path& path)
660 {
661     if (paintingDisabled() || path.isEmpty())
662         return;
663
664     CGContextRef context = platformContext();
665
666     if (m_state.fillGradient) {
667         if (hasShadow()) {
668             FloatRect rect = path.fastBoundingRect();
669             FloatSize layerSize = getCTM().mapSize(rect.size());
670
671             CGLayerRef layer = CGLayerCreateWithContext(context, layerSize, 0);
672             CGContextRef layerContext = CGLayerGetContext(layer);
673
674             CGContextScaleCTM(layerContext, layerSize.width() / rect.width(), layerSize.height() / rect.height());
675             CGContextTranslateCTM(layerContext, -rect.x(), -rect.y());
676             CGContextBeginPath(layerContext);
677             CGContextAddPath(layerContext, path.platformPath());
678             CGContextConcatCTM(layerContext, m_state.fillGradient->gradientSpaceTransform());
679
680             if (fillRule() == RULE_EVENODD)
681                 CGContextEOClip(layerContext);
682             else
683                 CGContextClip(layerContext);
684
685             m_state.fillGradient->paint(layerContext);
686             CGContextDrawLayerInRect(context, rect, layer);
687             CGLayerRelease(layer);
688         } else {
689             CGContextBeginPath(context);
690             CGContextAddPath(context, path.platformPath());
691             CGContextStateSaver stateSaver(context);
692             CGContextConcatCTM(context, m_state.fillGradient->gradientSpaceTransform());
693
694             if (fillRule() == RULE_EVENODD)
695                 CGContextEOClip(context);
696             else
697                 CGContextClip(context);
698
699             m_state.fillGradient->paint(this);
700         }
701
702         return;
703     }
704
705     CGContextBeginPath(context);
706     CGContextAddPath(context, path.platformPath());
707
708     if (m_state.fillPattern)
709         applyFillPattern();
710     fillPathWithFillRule(context, fillRule());
711 }
712
713 void GraphicsContext::strokePath(const Path& path)
714 {
715     if (paintingDisabled() || path.isEmpty())
716         return;
717
718     CGContextRef context = platformContext();
719
720     CGContextBeginPath(context);
721     CGContextAddPath(context, path.platformPath());
722
723     if (m_state.strokeGradient) {
724         if (hasShadow()) {
725             FloatRect rect = path.fastBoundingRect();
726             float lineWidth = strokeThickness();
727             float doubleLineWidth = lineWidth * 2;
728             float adjustedWidth = ceilf(rect.width() + doubleLineWidth);
729             float adjustedHeight = ceilf(rect.height() + doubleLineWidth);
730
731             FloatSize layerSize = getCTM().mapSize(FloatSize(adjustedWidth, adjustedHeight));
732
733             CGLayerRef layer = CGLayerCreateWithContext(context, layerSize, 0);
734             CGContextRef layerContext = CGLayerGetContext(layer);
735             CGContextSetLineWidth(layerContext, lineWidth);
736
737             // Compensate for the line width, otherwise the layer's top-left corner would be
738             // aligned with the rect's top-left corner. This would result in leaving pixels out of
739             // the layer on the left and top sides.
740             float translationX = lineWidth - rect.x();
741             float translationY = lineWidth - rect.y();
742             CGContextScaleCTM(layerContext, layerSize.width() / adjustedWidth, layerSize.height() / adjustedHeight);
743             CGContextTranslateCTM(layerContext, translationX, translationY);
744
745             CGContextAddPath(layerContext, path.platformPath());
746             CGContextReplacePathWithStrokedPath(layerContext);
747             CGContextClip(layerContext);
748             CGContextConcatCTM(layerContext, m_state.strokeGradient->gradientSpaceTransform());
749             m_state.strokeGradient->paint(layerContext);
750
751             float destinationX = roundf(rect.x() - lineWidth);
752             float destinationY = roundf(rect.y() - lineWidth);
753             CGContextDrawLayerInRect(context, CGRectMake(destinationX, destinationY, adjustedWidth, adjustedHeight), layer);
754             CGLayerRelease(layer);
755         } else {
756             CGContextStateSaver stateSaver(context);
757             CGContextReplacePathWithStrokedPath(context);
758             CGContextClip(context);
759             CGContextConcatCTM(context, m_state.strokeGradient->gradientSpaceTransform());
760             m_state.strokeGradient->paint(this);
761         }
762         return;
763     }
764
765     if (m_state.strokePattern)
766         applyStrokePattern();
767     CGContextStrokePath(context);
768 }
769
770 void GraphicsContext::fillRect(const FloatRect& rect)
771 {
772     if (paintingDisabled())
773         return;
774
775     CGContextRef context = platformContext();
776
777     if (m_state.fillGradient) {
778         CGContextStateSaver stateSaver(context);
779         if (hasShadow()) {
780             FloatSize layerSize = getCTM().mapSize(rect.size());
781
782             CGLayerRef layer = CGLayerCreateWithContext(context, layerSize, 0);
783             CGContextRef layerContext = CGLayerGetContext(layer);
784
785             CGContextScaleCTM(layerContext, layerSize.width() / rect.width(), layerSize.height() / rect.height());
786             CGContextTranslateCTM(layerContext, -rect.x(), -rect.y());
787             CGContextAddRect(layerContext, rect);
788             CGContextClip(layerContext);
789
790             CGContextConcatCTM(layerContext, m_state.fillGradient->gradientSpaceTransform());
791             m_state.fillGradient->paint(layerContext);
792             CGContextDrawLayerInRect(context, rect, layer);
793             CGLayerRelease(layer);
794         } else {
795             CGContextClipToRect(context, rect);
796             CGContextConcatCTM(context, m_state.fillGradient->gradientSpaceTransform());
797             m_state.fillGradient->paint(this);
798         }
799         return;
800     }
801
802     if (m_state.fillPattern)
803         applyFillPattern();
804
805     bool drawOwnShadow = !isAcceleratedContext() && hasBlurredShadow() && !m_state.shadowsIgnoreTransforms; // Don't use ShadowBlur for canvas yet.
806     CGContextStateSaver stateSaver(context, drawOwnShadow);
807     if (drawOwnShadow) {
808         // Turn off CG shadows.
809         CGContextSetShadowWithColor(platformContext(), CGSizeZero, 0, 0);
810
811         ShadowBlur contextShadow(m_state);
812         contextShadow.drawRectShadow(*this, FloatRoundedRect(rect));
813     }
814
815     CGContextFillRect(context, rect);
816 }
817
818 void GraphicsContext::fillRect(const FloatRect& rect, const Color& color)
819 {
820     if (paintingDisabled())
821         return;
822
823     CGContextRef context = platformContext();
824     Color oldFillColor = fillColor();
825
826     if (oldFillColor != color)
827         setCGFillColor(context, color);
828
829     bool drawOwnShadow = !isAcceleratedContext() && hasBlurredShadow() && !m_state.shadowsIgnoreTransforms; // Don't use ShadowBlur for canvas yet.
830     CGContextStateSaver stateSaver(context, drawOwnShadow);
831     if (drawOwnShadow) {
832         // Turn off CG shadows.
833         CGContextSetShadowWithColor(platformContext(), CGSizeZero, 0, 0);
834
835         ShadowBlur contextShadow(m_state);
836         contextShadow.drawRectShadow(*this, FloatRoundedRect(rect));
837     }
838
839     CGContextFillRect(context, rect);
840     
841     if (drawOwnShadow)
842         stateSaver.restore();
843
844     if (oldFillColor != color)
845         setCGFillColor(context, oldFillColor);
846 }
847
848 void GraphicsContext::platformFillRoundedRect(const FloatRoundedRect& rect, const Color& color)
849 {
850     if (paintingDisabled())
851         return;
852
853     CGContextRef context = platformContext();
854     Color oldFillColor = fillColor();
855
856     if (oldFillColor != color)
857         setCGFillColor(context, color);
858
859     bool drawOwnShadow = !isAcceleratedContext() && hasBlurredShadow() && !m_state.shadowsIgnoreTransforms; // Don't use ShadowBlur for canvas yet.
860     CGContextStateSaver stateSaver(context, drawOwnShadow);
861     if (drawOwnShadow) {
862         // Turn off CG shadows.
863         CGContextSetShadowWithColor(platformContext(), CGSizeZero, 0, 0);
864
865         ShadowBlur contextShadow(m_state);
866         contextShadow.drawRectShadow(*this, rect);
867     }
868
869     const FloatRect& r = rect.rect();
870     const FloatRoundedRect::Radii& radii = rect.radii();
871     bool equalWidths = (radii.topLeft().width() == radii.topRight().width() && radii.topRight().width() == radii.bottomLeft().width() && radii.bottomLeft().width() == radii.bottomRight().width());
872     bool equalHeights = (radii.topLeft().height() == radii.bottomLeft().height() && radii.bottomLeft().height() == radii.topRight().height() && radii.topRight().height() == radii.bottomRight().height());
873     bool hasCustomFill = m_state.fillGradient || m_state.fillPattern;
874     if (!hasCustomFill && equalWidths && equalHeights && radii.topLeft().width() * 2 == r.width() && radii.topLeft().height() * 2 == r.height())
875         CGContextFillEllipseInRect(context, r);
876     else {
877         Path path;
878         path.addRoundedRect(rect);
879         fillPath(path);
880     }
881
882     if (drawOwnShadow)
883         stateSaver.restore();
884
885     if (oldFillColor != color)
886         setCGFillColor(context, oldFillColor);
887 }
888
889 void GraphicsContext::fillRectWithRoundedHole(const FloatRect& rect, const FloatRoundedRect& roundedHoleRect, const Color& color)
890 {
891     if (paintingDisabled())
892         return;
893
894     CGContextRef context = platformContext();
895
896     Path path;
897     path.addRect(rect);
898
899     if (!roundedHoleRect.radii().isZero())
900         path.addRoundedRect(roundedHoleRect);
901     else
902         path.addRect(roundedHoleRect.rect());
903
904     WindRule oldFillRule = fillRule();
905     Color oldFillColor = fillColor();
906     
907     setFillRule(RULE_EVENODD);
908     setFillColor(color);
909
910     // fillRectWithRoundedHole() assumes that the edges of rect are clipped out, so we only care about shadows cast around inside the hole.
911     bool drawOwnShadow = !isAcceleratedContext() && hasBlurredShadow() && !m_state.shadowsIgnoreTransforms;
912     CGContextStateSaver stateSaver(context, drawOwnShadow);
913     if (drawOwnShadow) {
914         // Turn off CG shadows.
915         CGContextSetShadowWithColor(platformContext(), CGSizeZero, 0, 0);
916
917         ShadowBlur contextShadow(m_state);
918         contextShadow.drawInsetShadow(*this, rect, roundedHoleRect);
919     }
920
921     fillPath(path);
922
923     if (drawOwnShadow)
924         stateSaver.restore();
925     
926     setFillRule(oldFillRule);
927     setFillColor(oldFillColor);
928 }
929
930 void GraphicsContext::clip(const FloatRect& rect)
931 {
932     if (paintingDisabled())
933         return;
934
935     CGContextClipToRect(platformContext(), rect);
936     m_data->clip(rect);
937 }
938
939 void GraphicsContext::clipOut(const FloatRect& rect)
940 {
941     if (paintingDisabled())
942         return;
943
944     // FIXME: Using CGRectInfinite is much faster than getting the clip bounding box. However, due
945     // to <rdar://problem/12584492>, CGRectInfinite can't be used with an accelerated context that
946     // has certain transforms that aren't just a translation or a scale. And due to <rdar://problem/14634453>
947     // we cannot use it in for a printing context either.
948     const AffineTransform& ctm = getCTM();
949     bool canUseCGRectInfinite = !wkCGContextIsPDFContext(platformContext()) && (!isAcceleratedContext() || (!ctm.b() && !ctm.c()));
950     CGRect rects[2] = { canUseCGRectInfinite ? CGRectInfinite : CGContextGetClipBoundingBox(platformContext()), rect };
951     CGContextBeginPath(platformContext());
952     CGContextAddRects(platformContext(), rects, 2);
953     CGContextEOClip(platformContext());
954 }
955
956 void GraphicsContext::clipPath(const Path& path, WindRule clipRule)
957 {
958     if (paintingDisabled())
959         return;
960
961     CGContextRef context = platformContext();
962     if (path.isEmpty())
963         CGContextClipToRect(context, CGRectZero);
964     else {
965         CGContextBeginPath(platformContext());
966         CGContextAddPath(platformContext(), path.platformPath());
967
968         if (clipRule == RULE_EVENODD)
969             CGContextEOClip(context);
970         else
971             CGContextClip(context);
972     }
973     
974     m_data->clip(path);
975 }
976
977 IntRect GraphicsContext::clipBounds() const
978 {
979     if (paintingDisabled())
980         return IntRect();
981
982     return enclosingIntRect(CGContextGetClipBoundingBox(platformContext()));
983 }
984
985 void GraphicsContext::beginPlatformTransparencyLayer(float opacity)
986 {
987     if (paintingDisabled())
988         return;
989
990     save();
991
992     CGContextRef context = platformContext();
993     CGContextSetAlpha(context, opacity);
994     CGContextBeginTransparencyLayer(context, 0);
995     m_data->m_userToDeviceTransformKnownToBeIdentity = false;
996 }
997
998 void GraphicsContext::endPlatformTransparencyLayer()
999 {
1000     if (paintingDisabled())
1001         return;
1002     CGContextRef context = platformContext();
1003     CGContextEndTransparencyLayer(context);
1004
1005     restore();
1006 }
1007
1008 bool GraphicsContext::supportsTransparencyLayers()
1009 {
1010     return true;
1011 }
1012
1013 static void applyShadowOffsetWorkaroundIfNeeded(const GraphicsContext& context, CGFloat& xOffset, CGFloat& yOffset)
1014 {
1015 #if PLATFORM(IOS)
1016     UNUSED_PARAM(context);
1017     UNUSED_PARAM(xOffset);
1018     UNUSED_PARAM(yOffset);
1019 #else
1020     if (context.isAcceleratedContext())
1021         return;
1022
1023     if (wkCGContextDrawsWithCorrectShadowOffsets(context.platformContext()))
1024         return;
1025
1026     // Work around <rdar://problem/5539388> by ensuring that the offsets will get truncated
1027     // to the desired integer. Also see: <rdar://problem/10056277>
1028     static const CGFloat extraShadowOffset = narrowPrecisionToCGFloat(1.0 / 128);
1029     if (xOffset > 0)
1030         xOffset += extraShadowOffset;
1031     else if (xOffset < 0)
1032         xOffset -= extraShadowOffset;
1033
1034     if (yOffset > 0)
1035         yOffset += extraShadowOffset;
1036     else if (yOffset < 0)
1037         yOffset -= extraShadowOffset;
1038 #endif
1039 }
1040
1041 void GraphicsContext::setPlatformShadow(const FloatSize& offset, float blur, const Color& color)
1042 {
1043     if (paintingDisabled())
1044         return;
1045     
1046     // FIXME: we could avoid the shadow setup cost when we know we'll render the shadow ourselves.
1047
1048     CGFloat xOffset = offset.width();
1049     CGFloat yOffset = offset.height();
1050     CGFloat blurRadius = blur;
1051     CGContextRef context = platformContext();
1052
1053     if (!m_state.shadowsIgnoreTransforms) {
1054         CGAffineTransform userToBaseCTM = getUserToBaseCTM(context);
1055
1056         CGFloat A = userToBaseCTM.a * userToBaseCTM.a + userToBaseCTM.b * userToBaseCTM.b;
1057         CGFloat B = userToBaseCTM.a * userToBaseCTM.c + userToBaseCTM.b * userToBaseCTM.d;
1058         CGFloat C = B;
1059         CGFloat D = userToBaseCTM.c * userToBaseCTM.c + userToBaseCTM.d * userToBaseCTM.d;
1060
1061         CGFloat smallEigenvalue = narrowPrecisionToCGFloat(sqrt(0.5 * ((A + D) - sqrt(4 * B * C + (A - D) * (A - D)))));
1062
1063         blurRadius = blur * smallEigenvalue;
1064
1065         CGSize offsetInBaseSpace = CGSizeApplyAffineTransform(offset, userToBaseCTM);
1066
1067         xOffset = offsetInBaseSpace.width;
1068         yOffset = offsetInBaseSpace.height;
1069     }
1070
1071     // Extreme "blur" values can make text drawing crash or take crazy long times, so clamp
1072     blurRadius = std::min(blurRadius, narrowPrecisionToCGFloat(1000.0));
1073
1074     applyShadowOffsetWorkaroundIfNeeded(*this, xOffset, yOffset);
1075
1076     // Check for an invalid color, as this means that the color was not set for the shadow
1077     // and we should therefore just use the default shadow color.
1078     if (!color.isValid())
1079         CGContextSetShadow(context, CGSizeMake(xOffset, yOffset), blurRadius);
1080     else
1081         CGContextSetShadowWithColor(context, CGSizeMake(xOffset, yOffset), blurRadius, cachedCGColor(color));
1082 }
1083
1084 void GraphicsContext::clearPlatformShadow()
1085 {
1086     if (paintingDisabled())
1087         return;
1088     CGContextSetShadowWithColor(platformContext(), CGSizeZero, 0, 0);
1089 }
1090
1091 void GraphicsContext::setMiterLimit(float limit)
1092 {
1093     if (paintingDisabled())
1094         return;
1095     CGContextSetMiterLimit(platformContext(), limit);
1096 }
1097
1098 void GraphicsContext::clearRect(const FloatRect& r)
1099 {
1100     if (paintingDisabled())
1101         return;
1102     CGContextClearRect(platformContext(), r);
1103 }
1104
1105 void GraphicsContext::strokeRect(const FloatRect& rect, float lineWidth)
1106 {
1107     if (paintingDisabled())
1108         return;
1109
1110     CGContextRef context = platformContext();
1111
1112     if (m_state.strokeGradient) {
1113         if (hasShadow()) {
1114             const float doubleLineWidth = lineWidth * 2;
1115             float adjustedWidth = ceilf(rect.width() + doubleLineWidth);
1116             float adjustedHeight = ceilf(rect.height() + doubleLineWidth);
1117             FloatSize layerSize = getCTM().mapSize(FloatSize(adjustedWidth, adjustedHeight));
1118
1119             CGLayerRef layer = CGLayerCreateWithContext(context, layerSize, 0);
1120
1121             CGContextRef layerContext = CGLayerGetContext(layer);
1122             m_state.strokeThickness = lineWidth;
1123             CGContextSetLineWidth(layerContext, lineWidth);
1124
1125             // Compensate for the line width, otherwise the layer's top-left corner would be
1126             // aligned with the rect's top-left corner. This would result in leaving pixels out of
1127             // the layer on the left and top sides.
1128             const float translationX = lineWidth - rect.x();
1129             const float translationY = lineWidth - rect.y();
1130             CGContextScaleCTM(layerContext, layerSize.width() / adjustedWidth, layerSize.height() / adjustedHeight);
1131             CGContextTranslateCTM(layerContext, translationX, translationY);
1132
1133             CGContextAddRect(layerContext, rect);
1134             CGContextReplacePathWithStrokedPath(layerContext);
1135             CGContextClip(layerContext);
1136             CGContextConcatCTM(layerContext, m_state.strokeGradient->gradientSpaceTransform());
1137             m_state.strokeGradient->paint(layerContext);
1138
1139             const float destinationX = roundf(rect.x() - lineWidth);
1140             const float destinationY = roundf(rect.y() - lineWidth);
1141             CGContextDrawLayerInRect(context, CGRectMake(destinationX, destinationY, adjustedWidth, adjustedHeight), layer);
1142             CGLayerRelease(layer);
1143         } else {
1144             CGContextStateSaver stateSaver(context);
1145             setStrokeThickness(lineWidth);
1146             CGContextAddRect(context, rect);
1147             CGContextReplacePathWithStrokedPath(context);
1148             CGContextClip(context);
1149             CGContextConcatCTM(context, m_state.strokeGradient->gradientSpaceTransform());
1150             m_state.strokeGradient->paint(this);
1151         }
1152         return;
1153     }
1154
1155     if (m_state.strokePattern)
1156         applyStrokePattern();
1157
1158     // Using CGContextAddRect and CGContextStrokePath to stroke rect rather than
1159     // convenience functions (CGContextStrokeRect/CGContextStrokeRectWithWidth).
1160     // The convenience functions currently (in at least OSX 10.9.4) fail to
1161     // apply some attributes of the graphics state in certain cases
1162     // (as identified in https://bugs.webkit.org/show_bug.cgi?id=132948)
1163     CGContextStateSaver stateSaver(context);
1164     setStrokeThickness(lineWidth);
1165
1166     CGContextAddRect(context, rect);
1167     CGContextStrokePath(context);
1168 }
1169
1170 void GraphicsContext::setLineCap(LineCap cap)
1171 {
1172     if (paintingDisabled())
1173         return;
1174     switch (cap) {
1175     case ButtCap:
1176         CGContextSetLineCap(platformContext(), kCGLineCapButt);
1177         break;
1178     case RoundCap:
1179         CGContextSetLineCap(platformContext(), kCGLineCapRound);
1180         break;
1181     case SquareCap:
1182         CGContextSetLineCap(platformContext(), kCGLineCapSquare);
1183         break;
1184     }
1185 }
1186
1187 void GraphicsContext::setLineDash(const DashArray& dashes, float dashOffset)
1188 {
1189     if (paintingDisabled())
1190         return;
1191
1192     if (dashOffset < 0) {
1193         float length = 0;
1194         for (size_t i = 0; i < dashes.size(); ++i)
1195             length += static_cast<float>(dashes[i]);
1196         if (length)
1197             dashOffset = fmod(dashOffset, length) + length;
1198     }
1199     CGContextSetLineDash(platformContext(), dashOffset, dashes.data(), dashes.size());
1200 }
1201
1202 void GraphicsContext::setLineJoin(LineJoin join)
1203 {
1204     if (paintingDisabled())
1205         return;
1206     switch (join) {
1207     case MiterJoin:
1208         CGContextSetLineJoin(platformContext(), kCGLineJoinMiter);
1209         break;
1210     case RoundJoin:
1211         CGContextSetLineJoin(platformContext(), kCGLineJoinRound);
1212         break;
1213     case BevelJoin:
1214         CGContextSetLineJoin(platformContext(), kCGLineJoinBevel);
1215         break;
1216     }
1217 }
1218
1219 void GraphicsContext::canvasClip(const Path& path, WindRule fillRule)
1220 {
1221     clipPath(path, fillRule);
1222 }
1223
1224 void GraphicsContext::clipOut(const Path& path)
1225 {
1226     if (paintingDisabled())
1227         return;
1228
1229     CGContextBeginPath(platformContext());
1230     CGContextAddRect(platformContext(), CGContextGetClipBoundingBox(platformContext()));
1231     if (!path.isEmpty())
1232         CGContextAddPath(platformContext(), path.platformPath());
1233     CGContextEOClip(platformContext());
1234 }
1235
1236 void GraphicsContext::scale(const FloatSize& size)
1237 {
1238     if (paintingDisabled())
1239         return;
1240     CGContextScaleCTM(platformContext(), size.width(), size.height());
1241     m_data->scale(size);
1242     m_data->m_userToDeviceTransformKnownToBeIdentity = false;
1243 }
1244
1245 void GraphicsContext::rotate(float angle)
1246 {
1247     if (paintingDisabled())
1248         return;
1249     CGContextRotateCTM(platformContext(), angle);
1250     m_data->rotate(angle);
1251     m_data->m_userToDeviceTransformKnownToBeIdentity = false;
1252 }
1253
1254 void GraphicsContext::translate(float x, float y)
1255 {
1256     if (paintingDisabled())
1257         return;
1258     CGContextTranslateCTM(platformContext(), x, y);
1259     m_data->translate(x, y);
1260     m_data->m_userToDeviceTransformKnownToBeIdentity = false;
1261 }
1262
1263 void GraphicsContext::concatCTM(const AffineTransform& transform)
1264 {
1265     if (paintingDisabled())
1266         return;
1267     CGContextConcatCTM(platformContext(), transform);
1268     m_data->concatCTM(transform);
1269     m_data->m_userToDeviceTransformKnownToBeIdentity = false;
1270 }
1271
1272 void GraphicsContext::setCTM(const AffineTransform& transform)
1273 {
1274     if (paintingDisabled())
1275         return;
1276     CGContextSetCTM(platformContext(), transform);
1277     m_data->setCTM(transform);
1278     m_data->m_userToDeviceTransformKnownToBeIdentity = false;
1279 }
1280
1281 AffineTransform GraphicsContext::getCTM(IncludeDeviceScale includeScale) const
1282 {
1283     if (paintingDisabled())
1284         return AffineTransform();
1285
1286     // The CTM usually includes the deviceScaleFactor except in WebKit 1 when the
1287     // content is non-composited, since the scale factor is integrated at a lower
1288     // level. To guarantee the deviceScale is included, we can use this CG API.
1289     if (includeScale == DefinitelyIncludeDeviceScale)
1290         return CGContextGetUserSpaceToDeviceSpaceTransform(platformContext());
1291
1292     return CGContextGetCTM(platformContext());
1293 }
1294
1295 FloatRect GraphicsContext::roundToDevicePixels(const FloatRect& rect, RoundingMode roundingMode)
1296 {
1297     if (paintingDisabled())
1298         return rect;
1299
1300     // It is not enough just to round to pixels in device space. The rotation part of the
1301     // affine transform matrix to device space can mess with this conversion if we have a
1302     // rotating image like the hands of the world clock widget. We just need the scale, so
1303     // we get the affine transform matrix and extract the scale.
1304
1305     if (m_data->m_userToDeviceTransformKnownToBeIdentity)
1306         return roundedIntRect(rect);
1307
1308     CGAffineTransform deviceMatrix = CGContextGetUserSpaceToDeviceSpaceTransform(platformContext());
1309     if (CGAffineTransformIsIdentity(deviceMatrix)) {
1310         m_data->m_userToDeviceTransformKnownToBeIdentity = true;
1311         return roundedIntRect(rect);
1312     }
1313
1314     float deviceScaleX = sqrtf(deviceMatrix.a * deviceMatrix.a + deviceMatrix.b * deviceMatrix.b);
1315     float deviceScaleY = sqrtf(deviceMatrix.c * deviceMatrix.c + deviceMatrix.d * deviceMatrix.d);
1316
1317     CGPoint deviceOrigin = CGPointMake(rect.x() * deviceScaleX, rect.y() * deviceScaleY);
1318     CGPoint deviceLowerRight = CGPointMake((rect.x() + rect.width()) * deviceScaleX,
1319         (rect.y() + rect.height()) * deviceScaleY);
1320
1321     deviceOrigin.x = roundf(deviceOrigin.x);
1322     deviceOrigin.y = roundf(deviceOrigin.y);
1323     if (roundingMode == RoundAllSides) {
1324         deviceLowerRight.x = roundf(deviceLowerRight.x);
1325         deviceLowerRight.y = roundf(deviceLowerRight.y);
1326     } else {
1327         deviceLowerRight.x = deviceOrigin.x + roundf(rect.width() * deviceScaleX);
1328         deviceLowerRight.y = deviceOrigin.y + roundf(rect.height() * deviceScaleY);
1329     }
1330
1331     // Don't let the height or width round to 0 unless either was originally 0
1332     if (deviceOrigin.y == deviceLowerRight.y && rect.height())
1333         deviceLowerRight.y += 1;
1334     if (deviceOrigin.x == deviceLowerRight.x && rect.width())
1335         deviceLowerRight.x += 1;
1336
1337     FloatPoint roundedOrigin = FloatPoint(deviceOrigin.x / deviceScaleX, deviceOrigin.y / deviceScaleY);
1338     FloatPoint roundedLowerRight = FloatPoint(deviceLowerRight.x / deviceScaleX, deviceLowerRight.y / deviceScaleY);
1339     return FloatRect(roundedOrigin, roundedLowerRight - roundedOrigin);
1340 }
1341
1342 void GraphicsContext::drawLineForText(const FloatPoint& point, float width, bool printing, bool doubleLines)
1343 {
1344     DashArray widths;
1345     widths.append(width);
1346     widths.append(0);
1347     drawLinesForText(point, widths, printing, doubleLines);
1348 }
1349
1350 void GraphicsContext::drawLinesForText(const FloatPoint& point, const DashArray& widths, bool printing, bool doubleLines)
1351 {
1352     if (paintingDisabled())
1353         return;
1354
1355     if (!widths.size())
1356         return;
1357
1358     Color localStrokeColor(strokeColor());
1359
1360     FloatRect bounds = computeLineBoundsAndAntialiasingModeForText(point, widths.last(), printing, localStrokeColor);
1361     bool fillColorIsNotEqualToStrokeColor = fillColor() != localStrokeColor;
1362     
1363     Vector<CGRect, 4> dashBounds;
1364     ASSERT(!(widths.size() % 2));
1365     dashBounds.reserveInitialCapacity(dashBounds.size() / 2);
1366     for (size_t i = 0; i < widths.size(); i += 2)
1367         dashBounds.append(CGRectMake(bounds.x() + widths[i], bounds.y(), widths[i+1] - widths[i], bounds.height()));
1368
1369     if (doubleLines) {
1370         // The space between double underlines is equal to the height of the underline
1371         for (size_t i = 0; i < widths.size(); i += 2)
1372             dashBounds.append(CGRectMake(bounds.x() + widths[i], bounds.y() + 2 * bounds.height(), widths[i+1] - widths[i], bounds.height()));
1373     }
1374
1375     if (fillColorIsNotEqualToStrokeColor)
1376         setCGFillColor(platformContext(), localStrokeColor);
1377
1378     CGContextFillRects(platformContext(), dashBounds.data(), dashBounds.size());
1379
1380     if (fillColorIsNotEqualToStrokeColor)
1381         setCGFillColor(platformContext(), fillColor());
1382 }
1383
1384 void GraphicsContext::setURLForRect(const URL& link, const IntRect& destRect)
1385 {
1386 #if !PLATFORM(IOS)
1387     if (paintingDisabled())
1388         return;
1389
1390     RetainPtr<CFURLRef> urlRef = link.createCFURL();
1391     if (!urlRef)
1392         return;
1393
1394     CGContextRef context = platformContext();
1395
1396     // Get the bounding box to handle clipping.
1397     CGRect box = CGContextGetClipBoundingBox(context);
1398
1399     IntRect intBox((int)box.origin.x, (int)box.origin.y, (int)box.size.width, (int)box.size.height);
1400     IntRect rect = destRect;
1401     rect.intersect(intBox);
1402
1403     CGPDFContextSetURLForRect(context, urlRef.get(),
1404         CGRectApplyAffineTransform(rect, CGContextGetCTM(context)));
1405 #else
1406     UNUSED_PARAM(link);
1407     UNUSED_PARAM(destRect);
1408 #endif
1409 }
1410
1411 void GraphicsContext::setPlatformImageInterpolationQuality(InterpolationQuality mode)
1412 {
1413     ASSERT(!paintingDisabled());
1414
1415     CGInterpolationQuality quality = kCGInterpolationDefault;
1416     switch (mode) {
1417     case InterpolationDefault:
1418         quality = kCGInterpolationDefault;
1419         break;
1420     case InterpolationNone:
1421         quality = kCGInterpolationNone;
1422         break;
1423     case InterpolationLow:
1424         quality = kCGInterpolationLow;
1425         break;
1426     case InterpolationMedium:
1427         quality = kCGInterpolationMedium;
1428         break;
1429     case InterpolationHigh:
1430         quality = kCGInterpolationHigh;
1431         break;
1432     }
1433     CGContextSetInterpolationQuality(platformContext(), quality);
1434 }
1435
1436 void GraphicsContext::setIsCALayerContext(bool isLayerContext)
1437 {
1438     if (paintingDisabled())
1439         return;
1440
1441     if (isLayerContext)
1442         m_data->m_contextFlags |= IsLayerCGContext;
1443     else
1444         m_data->m_contextFlags &= ~IsLayerCGContext;
1445 }
1446
1447 bool GraphicsContext::isCALayerContext() const
1448 {
1449     if (paintingDisabled())
1450         return false;
1451
1452     return m_data->m_contextFlags & IsLayerCGContext;
1453 }
1454
1455 void GraphicsContext::setIsAcceleratedContext(bool isAccelerated)
1456 {
1457     if (paintingDisabled())
1458         return;
1459
1460     if (isAccelerated)
1461         m_data->m_contextFlags |= IsAcceleratedCGContext;
1462     else
1463         m_data->m_contextFlags &= ~IsAcceleratedCGContext;
1464 }
1465
1466 bool GraphicsContext::isAcceleratedContext() const
1467 {
1468     if (paintingDisabled())
1469         return false;
1470
1471     return m_data->m_contextFlags & IsAcceleratedCGContext;
1472 }
1473
1474 void GraphicsContext::setPlatformTextDrawingMode(TextDrawingModeFlags mode)
1475 {
1476     if (paintingDisabled())
1477         return;
1478
1479     CGContextRef context = platformContext();
1480     switch (mode) {
1481     case TextModeFill:
1482         CGContextSetTextDrawingMode(context, kCGTextFill);
1483         break;
1484     case TextModeStroke:
1485         CGContextSetTextDrawingMode(context, kCGTextStroke);
1486         break;
1487     case TextModeFill | TextModeStroke:
1488         CGContextSetTextDrawingMode(context, kCGTextFillStroke);
1489         break;
1490     default:
1491         break;
1492     }
1493 }
1494
1495 void GraphicsContext::setPlatformStrokeColor(const Color& color)
1496 {
1497     if (paintingDisabled())
1498         return;
1499     setCGStrokeColor(platformContext(), color);
1500 }
1501
1502 void GraphicsContext::setPlatformStrokeThickness(float thickness)
1503 {
1504     if (paintingDisabled())
1505         return;
1506     CGContextSetLineWidth(platformContext(), std::max(thickness, 0.f));
1507 }
1508
1509 void GraphicsContext::setPlatformFillColor(const Color& color)
1510 {
1511     if (paintingDisabled())
1512         return;
1513     setCGFillColor(platformContext(), color);
1514 }
1515
1516 void GraphicsContext::setPlatformShouldAntialias(bool enable)
1517 {
1518     if (paintingDisabled())
1519         return;
1520     CGContextSetShouldAntialias(platformContext(), enable);
1521 }
1522
1523 void GraphicsContext::setPlatformShouldSmoothFonts(bool enable)
1524 {
1525     if (paintingDisabled())
1526         return;
1527     CGContextSetShouldSmoothFonts(platformContext(), enable);
1528 }
1529
1530 void GraphicsContext::setPlatformAlpha(float alpha)
1531 {
1532     if (paintingDisabled())
1533         return;
1534     CGContextSetAlpha(platformContext(), alpha);
1535 }
1536
1537 void GraphicsContext::setPlatformCompositeOperation(CompositeOperator mode, BlendMode blendMode)
1538 {
1539     if (paintingDisabled())
1540         return;
1541
1542     CGBlendMode target = kCGBlendModeNormal;
1543     if (blendMode != BlendModeNormal) {
1544         switch (blendMode) {
1545         case BlendModeMultiply:
1546             target = kCGBlendModeMultiply;
1547             break;
1548         case BlendModeScreen:
1549             target = kCGBlendModeScreen;
1550             break;
1551         case BlendModeOverlay:
1552             target = kCGBlendModeOverlay;
1553             break;
1554         case BlendModeDarken:
1555             target = kCGBlendModeDarken;
1556             break;
1557         case BlendModeLighten:
1558             target = kCGBlendModeLighten;
1559             break;
1560         case BlendModeColorDodge:
1561             target = kCGBlendModeColorDodge;
1562             break;
1563         case BlendModeColorBurn:
1564             target = kCGBlendModeColorBurn;
1565             break;
1566         case BlendModeHardLight:
1567             target = kCGBlendModeHardLight;
1568             break;
1569         case BlendModeSoftLight:
1570             target = kCGBlendModeSoftLight;
1571             break;
1572         case BlendModeDifference:
1573             target = kCGBlendModeDifference;
1574             break;
1575         case BlendModeExclusion:
1576             target = kCGBlendModeExclusion;
1577             break;
1578         case BlendModeHue:
1579             target = kCGBlendModeHue;
1580             break;
1581         case BlendModeSaturation:
1582             target = kCGBlendModeSaturation;
1583             break;
1584         case BlendModeColor:
1585             target = kCGBlendModeColor;
1586             break;
1587         case BlendModeLuminosity:
1588             target = kCGBlendModeLuminosity;
1589             break;
1590         case BlendModePlusDarker:
1591             target = kCGBlendModePlusDarker;
1592             break;
1593         case BlendModePlusLighter:
1594             target = kCGBlendModePlusLighter;
1595             break;
1596         default:
1597             break;
1598         }
1599     } else {
1600         switch (mode) {
1601         case CompositeClear:
1602             target = kCGBlendModeClear;
1603             break;
1604         case CompositeCopy:
1605             target = kCGBlendModeCopy;
1606             break;
1607         case CompositeSourceOver:
1608             // kCGBlendModeNormal
1609             break;
1610         case CompositeSourceIn:
1611             target = kCGBlendModeSourceIn;
1612             break;
1613         case CompositeSourceOut:
1614             target = kCGBlendModeSourceOut;
1615             break;
1616         case CompositeSourceAtop:
1617             target = kCGBlendModeSourceAtop;
1618             break;
1619         case CompositeDestinationOver:
1620             target = kCGBlendModeDestinationOver;
1621             break;
1622         case CompositeDestinationIn:
1623             target = kCGBlendModeDestinationIn;
1624             break;
1625         case CompositeDestinationOut:
1626             target = kCGBlendModeDestinationOut;
1627             break;
1628         case CompositeDestinationAtop:
1629             target = kCGBlendModeDestinationAtop;
1630             break;
1631         case CompositeXOR:
1632             target = kCGBlendModeXOR;
1633             break;
1634         case CompositePlusDarker:
1635             target = kCGBlendModePlusDarker;
1636             break;
1637         case CompositePlusLighter:
1638             target = kCGBlendModePlusLighter;
1639             break;
1640         case CompositeDifference:
1641             target = kCGBlendModeDifference;
1642             break;
1643         }
1644     }
1645     CGContextSetBlendMode(platformContext(), target);
1646 }
1647
1648 void GraphicsContext::platformApplyDeviceScaleFactor(float deviceScaleFactor)
1649 {
1650     if (paintingDisabled())
1651         return;
1652
1653     // CoreGraphics expects the base CTM of a HiDPI context to have the scale factor applied to it.
1654     // Failing to change the base level CTM will cause certain CG features, such as focus rings,
1655     // to draw with a scale factor of 1 rather than the actual scale factor.
1656     CGContextSetBaseCTM(platformContext(), CGAffineTransformScale(CGContextGetBaseCTM(platformContext()), deviceScaleFactor, deviceScaleFactor));
1657 }
1658
1659 void GraphicsContext::platformFillEllipse(const FloatRect& ellipse)
1660 {
1661     if (paintingDisabled())
1662         return;
1663
1664     // CGContextFillEllipseInRect only supports solid colors.
1665     if (m_state.fillGradient || m_state.fillPattern) {
1666         fillEllipseAsPath(ellipse);
1667         return;
1668     }
1669
1670     CGContextRef context = platformContext();
1671     CGContextFillEllipseInRect(context, ellipse);
1672 }
1673
1674 void GraphicsContext::platformStrokeEllipse(const FloatRect& ellipse)
1675 {
1676     if (paintingDisabled())
1677         return;
1678
1679     // CGContextStrokeEllipseInRect only supports solid colors.
1680     if (m_state.strokeGradient || m_state.strokePattern) {
1681         strokeEllipseAsPath(ellipse);
1682         return;
1683     }
1684
1685     CGContextRef context = platformContext();
1686     CGContextStrokeEllipseInRect(context, ellipse);
1687 }
1688
1689 }