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