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