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