Add display-list drawing hooks to platform-specific GraphicsContext files
[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 static void addConvexPolygonToPath(Path& path, size_t numberOfPoints, const FloatPoint* points)
536 {
537     ASSERT(numberOfPoints > 0);
538
539     path.moveTo(points[0]);
540     for (size_t i = 1; i < numberOfPoints; ++i)
541         path.addLineTo(points[i]);
542     path.closeSubpath();
543 }
544
545 void GraphicsContext::drawConvexPolygon(size_t numberOfPoints, const FloatPoint* points, bool antialiased)
546 {
547     if (paintingDisabled())
548         return;
549
550     if (numberOfPoints <= 1)
551         return;
552
553     if (isRecording()) {
554         m_displayListRecorder->drawConvexPolygon(numberOfPoints, points, antialiased);
555         return;
556     }
557
558     CGContextRef context = platformContext();
559
560     if (antialiased != shouldAntialias())
561         CGContextSetShouldAntialias(context, antialiased);
562
563     Path path;
564     addConvexPolygonToPath(path, numberOfPoints, points);
565     drawPath(path);
566
567     if (antialiased != shouldAntialias())
568         CGContextSetShouldAntialias(context, shouldAntialias());
569 }
570
571 void GraphicsContext::clipConvexPolygon(size_t numberOfPoints, const FloatPoint* points, bool antialias)
572 {
573     if (paintingDisabled())
574         return;
575
576     if (numberOfPoints <= 1)
577         return;
578
579     if (isRecording()) {
580         m_displayListRecorder->clipConvexPolygon(numberOfPoints, points, antialias);
581         return;
582     }
583
584     CGContextRef context = platformContext();
585
586     if (antialias != shouldAntialias())
587         CGContextSetShouldAntialias(context, antialias);
588
589     Path path;
590     addConvexPolygonToPath(path, numberOfPoints, points);
591     clipPath(path, RULE_NONZERO);
592
593     if (antialias != shouldAntialias())
594         CGContextSetShouldAntialias(context, shouldAntialias());
595 }
596
597 void GraphicsContext::applyStrokePattern()
598 {
599     if (paintingDisabled())
600         return;
601
602     if (isRecording()) {
603         m_displayListRecorder->applyStrokePattern();
604         return;
605     }
606
607     CGContextRef cgContext = platformContext();
608     AffineTransform userToBaseCTM = AffineTransform(getUserToBaseCTM(cgContext));
609
610     RetainPtr<CGPatternRef> platformPattern = adoptCF(m_state.strokePattern->createPlatformPattern(userToBaseCTM));
611     if (!platformPattern)
612         return;
613
614     RetainPtr<CGColorSpaceRef> patternSpace = adoptCF(CGColorSpaceCreatePattern(0));
615     CGContextSetStrokeColorSpace(cgContext, patternSpace.get());
616
617     const CGFloat patternAlpha = 1;
618     CGContextSetStrokePattern(cgContext, platformPattern.get(), &patternAlpha);
619 }
620
621 void GraphicsContext::applyFillPattern()
622 {
623     if (paintingDisabled())
624         return;
625
626     if (isRecording()) {
627         m_displayListRecorder->applyFillPattern();
628         return;
629     }
630
631     CGContextRef cgContext = platformContext();
632     AffineTransform userToBaseCTM = AffineTransform(getUserToBaseCTM(cgContext));
633
634     RetainPtr<CGPatternRef> platformPattern = adoptCF(m_state.fillPattern->createPlatformPattern(userToBaseCTM));
635     if (!platformPattern)
636         return;
637
638     RetainPtr<CGColorSpaceRef> patternSpace = adoptCF(CGColorSpaceCreatePattern(nullptr));
639     CGContextSetFillColorSpace(cgContext, patternSpace.get());
640
641     const CGFloat patternAlpha = 1;
642     CGContextSetFillPattern(cgContext, platformPattern.get(), &patternAlpha);
643 }
644
645 static inline bool calculateDrawingMode(const GraphicsContextState& state, CGPathDrawingMode& mode)
646 {
647     bool shouldFill = state.fillPattern || state.fillColor.alpha();
648     bool shouldStroke = state.strokePattern || (state.strokeStyle != NoStroke && state.strokeColor.alpha());
649     bool useEOFill = state.fillRule == RULE_EVENODD;
650
651     if (shouldFill) {
652         if (shouldStroke) {
653             if (useEOFill)
654                 mode = kCGPathEOFillStroke;
655             else
656                 mode = kCGPathFillStroke;
657         } else { // fill, no stroke
658             if (useEOFill)
659                 mode = kCGPathEOFill;
660             else
661                 mode = kCGPathFill;
662         }
663     } else {
664         // Setting mode to kCGPathStroke even if shouldStroke is false. In that case, we return false and mode will not be used,
665         // but the compiler will not complain about an uninitialized variable.
666         mode = kCGPathStroke;
667     }
668
669     return shouldFill || shouldStroke;
670 }
671
672 void GraphicsContext::drawPath(const Path& path)
673 {
674     if (paintingDisabled() || path.isEmpty())
675         return;
676
677     if (isRecording()) {
678         m_displayListRecorder->drawPath(path);
679         return;
680     }
681
682     CGContextRef context = platformContext();
683     const GraphicsContextState& state = m_state;
684
685     if (state.fillGradient || state.strokeGradient) {
686         // We don't have any optimized way to fill & stroke a path using gradients
687         // FIXME: Be smarter about this.
688         fillPath(path);
689         strokePath(path);
690         return;
691     }
692
693     CGContextBeginPath(context);
694     CGContextAddPath(context, path.platformPath());
695
696     if (state.fillPattern)
697         applyFillPattern();
698     if (state.strokePattern)
699         applyStrokePattern();
700
701     CGPathDrawingMode drawingMode;
702     if (calculateDrawingMode(state, drawingMode))
703         CGContextDrawPath(context, drawingMode);
704 }
705
706 static inline void fillPathWithFillRule(CGContextRef context, WindRule fillRule)
707 {
708     if (fillRule == RULE_EVENODD)
709         CGContextEOFillPath(context);
710     else
711         CGContextFillPath(context);
712 }
713
714 void GraphicsContext::fillPath(const Path& path)
715 {
716     if (paintingDisabled() || path.isEmpty())
717         return;
718
719     if (isRecording()) {
720         m_displayListRecorder->fillPath(path);
721         return;
722     }
723
724     CGContextRef context = platformContext();
725
726     if (m_state.fillGradient) {
727         if (hasShadow()) {
728             FloatRect rect = path.fastBoundingRect();
729             FloatSize layerSize = getCTM().mapSize(rect.size());
730
731             CGLayerRef layer = CGLayerCreateWithContext(context, layerSize, 0);
732             CGContextRef layerContext = CGLayerGetContext(layer);
733
734             CGContextScaleCTM(layerContext, layerSize.width() / rect.width(), layerSize.height() / rect.height());
735             CGContextTranslateCTM(layerContext, -rect.x(), -rect.y());
736             CGContextBeginPath(layerContext);
737             CGContextAddPath(layerContext, path.platformPath());
738             CGContextConcatCTM(layerContext, m_state.fillGradient->gradientSpaceTransform());
739
740             if (fillRule() == RULE_EVENODD)
741                 CGContextEOClip(layerContext);
742             else
743                 CGContextClip(layerContext);
744
745             m_state.fillGradient->paint(layerContext);
746             CGContextDrawLayerInRect(context, rect, layer);
747             CGLayerRelease(layer);
748         } else {
749             CGContextBeginPath(context);
750             CGContextAddPath(context, path.platformPath());
751             CGContextStateSaver stateSaver(context);
752             CGContextConcatCTM(context, m_state.fillGradient->gradientSpaceTransform());
753
754             if (fillRule() == RULE_EVENODD)
755                 CGContextEOClip(context);
756             else
757                 CGContextClip(context);
758
759             m_state.fillGradient->paint(this);
760         }
761
762         return;
763     }
764
765     CGContextBeginPath(context);
766     CGContextAddPath(context, path.platformPath());
767
768     if (m_state.fillPattern)
769         applyFillPattern();
770     fillPathWithFillRule(context, fillRule());
771 }
772
773 void GraphicsContext::strokePath(const Path& path)
774 {
775     if (paintingDisabled() || path.isEmpty())
776         return;
777
778     if (isRecording()) {
779         m_displayListRecorder->strokePath(path);
780         return;
781     }
782
783     CGContextRef context = platformContext();
784
785     CGContextBeginPath(context);
786     CGContextAddPath(context, path.platformPath());
787
788     if (m_state.strokeGradient) {
789         if (hasShadow()) {
790             FloatRect rect = path.fastBoundingRect();
791             float lineWidth = strokeThickness();
792             float doubleLineWidth = lineWidth * 2;
793             float adjustedWidth = ceilf(rect.width() + doubleLineWidth);
794             float adjustedHeight = ceilf(rect.height() + doubleLineWidth);
795
796             FloatSize layerSize = getCTM().mapSize(FloatSize(adjustedWidth, adjustedHeight));
797
798             CGLayerRef layer = CGLayerCreateWithContext(context, layerSize, 0);
799             CGContextRef layerContext = CGLayerGetContext(layer);
800             CGContextSetLineWidth(layerContext, lineWidth);
801
802             // Compensate for the line width, otherwise the layer's top-left corner would be
803             // aligned with the rect's top-left corner. This would result in leaving pixels out of
804             // the layer on the left and top sides.
805             float translationX = lineWidth - rect.x();
806             float translationY = lineWidth - rect.y();
807             CGContextScaleCTM(layerContext, layerSize.width() / adjustedWidth, layerSize.height() / adjustedHeight);
808             CGContextTranslateCTM(layerContext, translationX, translationY);
809
810             CGContextAddPath(layerContext, path.platformPath());
811             CGContextReplacePathWithStrokedPath(layerContext);
812             CGContextClip(layerContext);
813             CGContextConcatCTM(layerContext, m_state.strokeGradient->gradientSpaceTransform());
814             m_state.strokeGradient->paint(layerContext);
815
816             float destinationX = roundf(rect.x() - lineWidth);
817             float destinationY = roundf(rect.y() - lineWidth);
818             CGContextDrawLayerInRect(context, CGRectMake(destinationX, destinationY, adjustedWidth, adjustedHeight), layer);
819             CGLayerRelease(layer);
820         } else {
821             CGContextStateSaver stateSaver(context);
822             CGContextReplacePathWithStrokedPath(context);
823             CGContextClip(context);
824             CGContextConcatCTM(context, m_state.strokeGradient->gradientSpaceTransform());
825             m_state.strokeGradient->paint(this);
826         }
827         return;
828     }
829
830     if (m_state.strokePattern)
831         applyStrokePattern();
832     CGContextStrokePath(context);
833 }
834
835 void GraphicsContext::fillRect(const FloatRect& rect)
836 {
837     if (paintingDisabled())
838         return;
839
840     if (isRecording()) {
841         m_displayListRecorder->fillRect(rect);
842         return;
843     }
844
845     CGContextRef context = platformContext();
846
847     if (m_state.fillGradient) {
848         CGContextStateSaver stateSaver(context);
849         if (hasShadow()) {
850             FloatSize layerSize = getCTM().mapSize(rect.size());
851
852             CGLayerRef layer = CGLayerCreateWithContext(context, layerSize, 0);
853             CGContextRef layerContext = CGLayerGetContext(layer);
854
855             CGContextScaleCTM(layerContext, layerSize.width() / rect.width(), layerSize.height() / rect.height());
856             CGContextTranslateCTM(layerContext, -rect.x(), -rect.y());
857             CGContextAddRect(layerContext, rect);
858             CGContextClip(layerContext);
859
860             CGContextConcatCTM(layerContext, m_state.fillGradient->gradientSpaceTransform());
861             m_state.fillGradient->paint(layerContext);
862             CGContextDrawLayerInRect(context, rect, layer);
863             CGLayerRelease(layer);
864         } else {
865             CGContextClipToRect(context, rect);
866             CGContextConcatCTM(context, m_state.fillGradient->gradientSpaceTransform());
867             m_state.fillGradient->paint(this);
868         }
869         return;
870     }
871
872     if (m_state.fillPattern)
873         applyFillPattern();
874
875     bool drawOwnShadow = !isAcceleratedContext() && hasBlurredShadow() && !m_state.shadowsIgnoreTransforms; // Don't use ShadowBlur for canvas yet.
876     CGContextStateSaver stateSaver(context, drawOwnShadow);
877     if (drawOwnShadow) {
878         // Turn off CG shadows.
879         CGContextSetShadowWithColor(platformContext(), CGSizeZero, 0, 0);
880
881         ShadowBlur contextShadow(m_state);
882         contextShadow.drawRectShadow(*this, FloatRoundedRect(rect));
883     }
884
885     CGContextFillRect(context, rect);
886 }
887
888 void GraphicsContext::fillRect(const FloatRect& rect, const Color& color)
889 {
890     if (paintingDisabled())
891         return;
892
893     if (isRecording()) {
894         m_displayListRecorder->fillRect(rect, color);
895         return;
896     }
897
898     CGContextRef context = platformContext();
899     Color oldFillColor = fillColor();
900
901     if (oldFillColor != color)
902         setCGFillColor(context, color);
903
904     bool drawOwnShadow = !isAcceleratedContext() && hasBlurredShadow() && !m_state.shadowsIgnoreTransforms; // Don't use ShadowBlur for canvas yet.
905     CGContextStateSaver stateSaver(context, drawOwnShadow);
906     if (drawOwnShadow) {
907         // Turn off CG shadows.
908         CGContextSetShadowWithColor(platformContext(), CGSizeZero, 0, 0);
909
910         ShadowBlur contextShadow(m_state);
911         contextShadow.drawRectShadow(*this, FloatRoundedRect(rect));
912     }
913
914     CGContextFillRect(context, rect);
915     
916     if (drawOwnShadow)
917         stateSaver.restore();
918
919     if (oldFillColor != color)
920         setCGFillColor(context, oldFillColor);
921 }
922
923 void GraphicsContext::platformFillRoundedRect(const FloatRoundedRect& rect, const Color& color)
924 {
925     if (paintingDisabled())
926         return;
927     
928     ASSERT(!isRecording());
929
930     CGContextRef context = platformContext();
931     Color oldFillColor = fillColor();
932
933     if (oldFillColor != color)
934         setCGFillColor(context, color);
935
936     bool drawOwnShadow = !isAcceleratedContext() && hasBlurredShadow() && !m_state.shadowsIgnoreTransforms; // Don't use ShadowBlur for canvas yet.
937     CGContextStateSaver stateSaver(context, drawOwnShadow);
938     if (drawOwnShadow) {
939         // Turn off CG shadows.
940         CGContextSetShadowWithColor(platformContext(), CGSizeZero, 0, 0);
941
942         ShadowBlur contextShadow(m_state);
943         contextShadow.drawRectShadow(*this, rect);
944     }
945
946     const FloatRect& r = rect.rect();
947     const FloatRoundedRect::Radii& radii = rect.radii();
948     bool equalWidths = (radii.topLeft().width() == radii.topRight().width() && radii.topRight().width() == radii.bottomLeft().width() && radii.bottomLeft().width() == radii.bottomRight().width());
949     bool equalHeights = (radii.topLeft().height() == radii.bottomLeft().height() && radii.bottomLeft().height() == radii.topRight().height() && radii.topRight().height() == radii.bottomRight().height());
950     bool hasCustomFill = m_state.fillGradient || m_state.fillPattern;
951     if (!hasCustomFill && equalWidths && equalHeights && radii.topLeft().width() * 2 == r.width() && radii.topLeft().height() * 2 == r.height())
952         CGContextFillEllipseInRect(context, r);
953     else {
954         Path path;
955         path.addRoundedRect(rect);
956         fillPath(path);
957     }
958
959     if (drawOwnShadow)
960         stateSaver.restore();
961
962     if (oldFillColor != color)
963         setCGFillColor(context, oldFillColor);
964 }
965
966 void GraphicsContext::fillRectWithRoundedHole(const FloatRect& rect, const FloatRoundedRect& roundedHoleRect, const Color& color)
967 {
968     if (paintingDisabled())
969         return;
970
971     if (isRecording()) {
972         m_displayListRecorder->fillRectWithRoundedHole(rect, roundedHoleRect, color);
973         return;
974     }
975
976     CGContextRef context = platformContext();
977
978     Path path;
979     path.addRect(rect);
980
981     if (!roundedHoleRect.radii().isZero())
982         path.addRoundedRect(roundedHoleRect);
983     else
984         path.addRect(roundedHoleRect.rect());
985
986     WindRule oldFillRule = fillRule();
987     Color oldFillColor = fillColor();
988     
989     setFillRule(RULE_EVENODD);
990     setFillColor(color);
991
992     // fillRectWithRoundedHole() assumes that the edges of rect are clipped out, so we only care about shadows cast around inside the hole.
993     bool drawOwnShadow = !isAcceleratedContext() && hasBlurredShadow() && !m_state.shadowsIgnoreTransforms;
994     CGContextStateSaver stateSaver(context, drawOwnShadow);
995     if (drawOwnShadow) {
996         // Turn off CG shadows.
997         CGContextSetShadowWithColor(platformContext(), CGSizeZero, 0, 0);
998
999         ShadowBlur contextShadow(m_state);
1000         contextShadow.drawInsetShadow(*this, rect, roundedHoleRect);
1001     }
1002
1003     fillPath(path);
1004
1005     if (drawOwnShadow)
1006         stateSaver.restore();
1007     
1008     setFillRule(oldFillRule);
1009     setFillColor(oldFillColor);
1010 }
1011
1012 void GraphicsContext::clip(const FloatRect& rect)
1013 {
1014     if (paintingDisabled())
1015         return;
1016
1017     if (isRecording()) {
1018         m_displayListRecorder->clip(rect);
1019         return;
1020     }
1021
1022     CGContextClipToRect(platformContext(), rect);
1023     m_data->clip(rect);
1024 }
1025
1026 void GraphicsContext::clipOut(const FloatRect& rect)
1027 {
1028     if (paintingDisabled())
1029         return;
1030
1031     if (isRecording()) {
1032         m_displayListRecorder->clipOut(rect);
1033         return;
1034     }
1035
1036     // FIXME: Using CGRectInfinite is much faster than getting the clip bounding box. However, due
1037     // to <rdar://problem/12584492>, CGRectInfinite can't be used with an accelerated context that
1038     // has certain transforms that aren't just a translation or a scale. And due to <rdar://problem/14634453>
1039     // we cannot use it in for a printing context either.
1040     const AffineTransform& ctm = getCTM();
1041     bool canUseCGRectInfinite = !wkCGContextIsPDFContext(platformContext()) && (!isAcceleratedContext() || (!ctm.b() && !ctm.c()));
1042     CGRect rects[2] = { canUseCGRectInfinite ? CGRectInfinite : CGContextGetClipBoundingBox(platformContext()), rect };
1043     CGContextBeginPath(platformContext());
1044     CGContextAddRects(platformContext(), rects, 2);
1045     CGContextEOClip(platformContext());
1046 }
1047
1048 void GraphicsContext::clipOut(const Path& path)
1049 {
1050     if (paintingDisabled())
1051         return;
1052
1053     if (isRecording()) {
1054         m_displayListRecorder->clipOut(path);
1055         return;
1056     }
1057
1058     CGContextBeginPath(platformContext());
1059     CGContextAddRect(platformContext(), CGContextGetClipBoundingBox(platformContext()));
1060     if (!path.isEmpty())
1061         CGContextAddPath(platformContext(), path.platformPath());
1062     CGContextEOClip(platformContext());
1063 }
1064
1065 void GraphicsContext::clipPath(const Path& path, WindRule clipRule)
1066 {
1067     if (paintingDisabled())
1068         return;
1069
1070     if (isRecording()) {
1071         m_displayListRecorder->clipPath(path, clipRule);
1072         return;
1073     }
1074
1075     CGContextRef context = platformContext();
1076     if (path.isEmpty())
1077         CGContextClipToRect(context, CGRectZero);
1078     else {
1079         CGContextBeginPath(platformContext());
1080         CGContextAddPath(platformContext(), path.platformPath());
1081
1082         if (clipRule == RULE_EVENODD)
1083             CGContextEOClip(context);
1084         else
1085             CGContextClip(context);
1086     }
1087     
1088     m_data->clip(path);
1089 }
1090
1091 IntRect GraphicsContext::clipBounds() const
1092 {
1093     if (paintingDisabled())
1094         return IntRect();
1095
1096     if (isRecording()) {
1097         WTFLogAlways("Getting the clip bounds not yet supported with display lists");
1098         return IntRect(-2048, -2048, 4096, 4096); // FIXME: display lists.
1099     }
1100
1101
1102     return enclosingIntRect(CGContextGetClipBoundingBox(platformContext()));
1103 }
1104
1105 void GraphicsContext::beginPlatformTransparencyLayer(float opacity)
1106 {
1107     if (paintingDisabled())
1108         return;
1109
1110     ASSERT(!isRecording());
1111
1112     save();
1113
1114     CGContextRef context = platformContext();
1115     CGContextSetAlpha(context, opacity);
1116     CGContextBeginTransparencyLayer(context, 0);
1117     m_data->m_userToDeviceTransformKnownToBeIdentity = false;
1118 }
1119
1120 void GraphicsContext::endPlatformTransparencyLayer()
1121 {
1122     if (paintingDisabled())
1123         return;
1124
1125     ASSERT(!isRecording());
1126
1127     CGContextRef context = platformContext();
1128     CGContextEndTransparencyLayer(context);
1129
1130     restore();
1131 }
1132
1133 bool GraphicsContext::supportsTransparencyLayers()
1134 {
1135     return true;
1136 }
1137
1138 static void applyShadowOffsetWorkaroundIfNeeded(const GraphicsContext& context, CGFloat& xOffset, CGFloat& yOffset)
1139 {
1140 #if PLATFORM(IOS)
1141     UNUSED_PARAM(context);
1142     UNUSED_PARAM(xOffset);
1143     UNUSED_PARAM(yOffset);
1144 #else
1145     if (context.isAcceleratedContext())
1146         return;
1147
1148     if (wkCGContextDrawsWithCorrectShadowOffsets(context.platformContext()))
1149         return;
1150
1151     // Work around <rdar://problem/5539388> by ensuring that the offsets will get truncated
1152     // to the desired integer. Also see: <rdar://problem/10056277>
1153     static const CGFloat extraShadowOffset = narrowPrecisionToCGFloat(1.0 / 128);
1154     if (xOffset > 0)
1155         xOffset += extraShadowOffset;
1156     else if (xOffset < 0)
1157         xOffset -= extraShadowOffset;
1158
1159     if (yOffset > 0)
1160         yOffset += extraShadowOffset;
1161     else if (yOffset < 0)
1162         yOffset -= extraShadowOffset;
1163 #endif
1164 }
1165
1166 void GraphicsContext::setPlatformShadow(const FloatSize& offset, float blur, const Color& color)
1167 {
1168     if (paintingDisabled())
1169         return;
1170
1171     ASSERT(!isRecording());
1172     
1173     // FIXME: we could avoid the shadow setup cost when we know we'll render the shadow ourselves.
1174
1175     CGFloat xOffset = offset.width();
1176     CGFloat yOffset = offset.height();
1177     CGFloat blurRadius = blur;
1178     CGContextRef context = platformContext();
1179
1180     if (!m_state.shadowsIgnoreTransforms) {
1181         CGAffineTransform userToBaseCTM = getUserToBaseCTM(context);
1182
1183         CGFloat A = userToBaseCTM.a * userToBaseCTM.a + userToBaseCTM.b * userToBaseCTM.b;
1184         CGFloat B = userToBaseCTM.a * userToBaseCTM.c + userToBaseCTM.b * userToBaseCTM.d;
1185         CGFloat C = B;
1186         CGFloat D = userToBaseCTM.c * userToBaseCTM.c + userToBaseCTM.d * userToBaseCTM.d;
1187
1188         CGFloat smallEigenvalue = narrowPrecisionToCGFloat(sqrt(0.5 * ((A + D) - sqrt(4 * B * C + (A - D) * (A - D)))));
1189
1190         blurRadius = blur * smallEigenvalue;
1191
1192         CGSize offsetInBaseSpace = CGSizeApplyAffineTransform(offset, userToBaseCTM);
1193
1194         xOffset = offsetInBaseSpace.width;
1195         yOffset = offsetInBaseSpace.height;
1196     }
1197
1198     // Extreme "blur" values can make text drawing crash or take crazy long times, so clamp
1199     blurRadius = std::min(blurRadius, narrowPrecisionToCGFloat(1000.0));
1200
1201     applyShadowOffsetWorkaroundIfNeeded(*this, xOffset, yOffset);
1202
1203     // Check for an invalid color, as this means that the color was not set for the shadow
1204     // and we should therefore just use the default shadow color.
1205     if (!color.isValid())
1206         CGContextSetShadow(context, CGSizeMake(xOffset, yOffset), blurRadius);
1207     else
1208         CGContextSetShadowWithColor(context, CGSizeMake(xOffset, yOffset), blurRadius, cachedCGColor(color));
1209 }
1210
1211 void GraphicsContext::clearPlatformShadow()
1212 {
1213     if (paintingDisabled())
1214         return;
1215     CGContextSetShadowWithColor(platformContext(), CGSizeZero, 0, 0);
1216 }
1217
1218 void GraphicsContext::setMiterLimit(float limit)
1219 {
1220     if (paintingDisabled())
1221         return;
1222
1223     if (isRecording()) {
1224         // Maybe this should be part of the state.
1225         m_displayListRecorder->setMiterLimit(limit);
1226         return;
1227     }
1228
1229     CGContextSetMiterLimit(platformContext(), limit);
1230 }
1231
1232 void GraphicsContext::clearRect(const FloatRect& r)
1233 {
1234     if (paintingDisabled())
1235         return;
1236
1237     if (isRecording()) {
1238         m_displayListRecorder->clearRect(r);
1239         return;
1240     }
1241
1242     CGContextClearRect(platformContext(), r);
1243 }
1244
1245 void GraphicsContext::strokeRect(const FloatRect& rect, float lineWidth)
1246 {
1247     if (paintingDisabled())
1248         return;
1249
1250     if (isRecording()) {
1251         m_displayListRecorder->strokeRect(rect, lineWidth);
1252         return;
1253     }
1254
1255     CGContextRef context = platformContext();
1256
1257     if (m_state.strokeGradient) {
1258         if (hasShadow()) {
1259             const float doubleLineWidth = lineWidth * 2;
1260             float adjustedWidth = ceilf(rect.width() + doubleLineWidth);
1261             float adjustedHeight = ceilf(rect.height() + doubleLineWidth);
1262             FloatSize layerSize = getCTM().mapSize(FloatSize(adjustedWidth, adjustedHeight));
1263
1264             CGLayerRef layer = CGLayerCreateWithContext(context, layerSize, 0);
1265
1266             CGContextRef layerContext = CGLayerGetContext(layer);
1267             m_state.strokeThickness = lineWidth;
1268             CGContextSetLineWidth(layerContext, lineWidth);
1269
1270             // Compensate for the line width, otherwise the layer's top-left corner would be
1271             // aligned with the rect's top-left corner. This would result in leaving pixels out of
1272             // the layer on the left and top sides.
1273             const float translationX = lineWidth - rect.x();
1274             const float translationY = lineWidth - rect.y();
1275             CGContextScaleCTM(layerContext, layerSize.width() / adjustedWidth, layerSize.height() / adjustedHeight);
1276             CGContextTranslateCTM(layerContext, translationX, translationY);
1277
1278             CGContextAddRect(layerContext, rect);
1279             CGContextReplacePathWithStrokedPath(layerContext);
1280             CGContextClip(layerContext);
1281             CGContextConcatCTM(layerContext, m_state.strokeGradient->gradientSpaceTransform());
1282             m_state.strokeGradient->paint(layerContext);
1283
1284             const float destinationX = roundf(rect.x() - lineWidth);
1285             const float destinationY = roundf(rect.y() - lineWidth);
1286             CGContextDrawLayerInRect(context, CGRectMake(destinationX, destinationY, adjustedWidth, adjustedHeight), layer);
1287             CGLayerRelease(layer);
1288         } else {
1289             CGContextStateSaver stateSaver(context);
1290             setStrokeThickness(lineWidth);
1291             CGContextAddRect(context, rect);
1292             CGContextReplacePathWithStrokedPath(context);
1293             CGContextClip(context);
1294             CGContextConcatCTM(context, m_state.strokeGradient->gradientSpaceTransform());
1295             m_state.strokeGradient->paint(this);
1296         }
1297         return;
1298     }
1299
1300     if (m_state.strokePattern)
1301         applyStrokePattern();
1302
1303     // Using CGContextAddRect and CGContextStrokePath to stroke rect rather than
1304     // convenience functions (CGContextStrokeRect/CGContextStrokeRectWithWidth).
1305     // The convenience functions currently (in at least OSX 10.9.4) fail to
1306     // apply some attributes of the graphics state in certain cases
1307     // (as identified in https://bugs.webkit.org/show_bug.cgi?id=132948)
1308     CGContextStateSaver stateSaver(context);
1309     setStrokeThickness(lineWidth);
1310
1311     CGContextAddRect(context, rect);
1312     CGContextStrokePath(context);
1313 }
1314
1315 void GraphicsContext::setLineCap(LineCap cap)
1316 {
1317     if (paintingDisabled())
1318         return;
1319
1320     if (isRecording()) {
1321         m_displayListRecorder->setLineCap(cap);
1322         return;
1323     }
1324
1325     switch (cap) {
1326     case ButtCap:
1327         CGContextSetLineCap(platformContext(), kCGLineCapButt);
1328         break;
1329     case RoundCap:
1330         CGContextSetLineCap(platformContext(), kCGLineCapRound);
1331         break;
1332     case SquareCap:
1333         CGContextSetLineCap(platformContext(), kCGLineCapSquare);
1334         break;
1335     }
1336 }
1337
1338 void GraphicsContext::setLineDash(const DashArray& dashes, float dashOffset)
1339 {
1340     if (paintingDisabled())
1341         return;
1342
1343     if (isRecording()) {
1344         m_displayListRecorder->setLineDash(dashes, dashOffset);
1345         return;
1346     }
1347
1348     if (dashOffset < 0) {
1349         float length = 0;
1350         for (size_t i = 0; i < dashes.size(); ++i)
1351             length += static_cast<float>(dashes[i]);
1352         if (length)
1353             dashOffset = fmod(dashOffset, length) + length;
1354     }
1355     CGContextSetLineDash(platformContext(), dashOffset, dashes.data(), dashes.size());
1356 }
1357
1358 void GraphicsContext::setLineJoin(LineJoin join)
1359 {
1360     if (paintingDisabled())
1361         return;
1362
1363     if (isRecording()) {
1364         m_displayListRecorder->setLineJoin(join);
1365         return;
1366     }
1367
1368     switch (join) {
1369     case MiterJoin:
1370         CGContextSetLineJoin(platformContext(), kCGLineJoinMiter);
1371         break;
1372     case RoundJoin:
1373         CGContextSetLineJoin(platformContext(), kCGLineJoinRound);
1374         break;
1375     case BevelJoin:
1376         CGContextSetLineJoin(platformContext(), kCGLineJoinBevel);
1377         break;
1378     }
1379 }
1380
1381 void GraphicsContext::canvasClip(const Path& path, WindRule fillRule)
1382 {
1383     clipPath(path, fillRule);
1384 }
1385
1386 void GraphicsContext::scale(const FloatSize& size)
1387 {
1388     if (paintingDisabled())
1389         return;
1390
1391     if (isRecording()) {
1392         m_displayListRecorder->scale(size);
1393         return;
1394     }
1395
1396     CGContextScaleCTM(platformContext(), size.width(), size.height());
1397     m_data->scale(size);
1398     m_data->m_userToDeviceTransformKnownToBeIdentity = false;
1399 }
1400
1401 void GraphicsContext::rotate(float angle)
1402 {
1403     if (paintingDisabled())
1404         return;
1405
1406     if (isRecording()) {
1407         m_displayListRecorder->rotate(angle);
1408         return;
1409     }
1410
1411     CGContextRotateCTM(platformContext(), angle);
1412     m_data->rotate(angle);
1413     m_data->m_userToDeviceTransformKnownToBeIdentity = false;
1414 }
1415
1416 void GraphicsContext::translate(float x, float y)
1417 {
1418     if (paintingDisabled())
1419         return;
1420
1421     if (isRecording()) {
1422         m_displayListRecorder->translate(x, y);
1423         return;
1424     }
1425
1426     CGContextTranslateCTM(platformContext(), x, y);
1427     m_data->translate(x, y);
1428     m_data->m_userToDeviceTransformKnownToBeIdentity = false;
1429 }
1430
1431 void GraphicsContext::concatCTM(const AffineTransform& transform)
1432 {
1433     if (paintingDisabled())
1434         return;
1435
1436     if (isRecording()) {
1437         m_displayListRecorder->concatCTM(transform);
1438         return;
1439     }
1440
1441     CGContextConcatCTM(platformContext(), transform);
1442     m_data->concatCTM(transform);
1443     m_data->m_userToDeviceTransformKnownToBeIdentity = false;
1444 }
1445
1446 void GraphicsContext::setCTM(const AffineTransform& transform)
1447 {
1448     if (paintingDisabled())
1449         return;
1450
1451     if (isRecording()) {
1452         WTFLogAlways("GraphicsContext::setCTM() is not compatible with recording contexts.");
1453         return;
1454     }
1455
1456     CGContextSetCTM(platformContext(), transform);
1457     m_data->setCTM(transform);
1458     m_data->m_userToDeviceTransformKnownToBeIdentity = false;
1459 }
1460
1461 AffineTransform GraphicsContext::getCTM(IncludeDeviceScale includeScale) const
1462 {
1463     if (paintingDisabled())
1464         return AffineTransform();
1465
1466     if (isRecording()) {
1467         WTFLogAlways("GraphicsContext::getCTM() is not yet compatible with recording contexts.");
1468         return AffineTransform();
1469     }
1470
1471     // The CTM usually includes the deviceScaleFactor except in WebKit 1 when the
1472     // content is non-composited, since the scale factor is integrated at a lower
1473     // level. To guarantee the deviceScale is included, we can use this CG API.
1474     if (includeScale == DefinitelyIncludeDeviceScale)
1475         return CGContextGetUserSpaceToDeviceSpaceTransform(platformContext());
1476
1477     return CGContextGetCTM(platformContext());
1478 }
1479
1480 FloatRect GraphicsContext::roundToDevicePixels(const FloatRect& rect, RoundingMode roundingMode)
1481 {
1482     if (paintingDisabled())
1483         return rect;
1484
1485     if (!isRecording()) {
1486         WTFLogAlways("GraphicsContext::roundToDevicePixels() is not yet compatible with recording contexts.");
1487         return rect;
1488     }
1489
1490     // It is not enough just to round to pixels in device space. The rotation part of the
1491     // affine transform matrix to device space can mess with this conversion if we have a
1492     // rotating image like the hands of the world clock widget. We just need the scale, so
1493     // we get the affine transform matrix and extract the scale.
1494
1495     if (m_data->m_userToDeviceTransformKnownToBeIdentity)
1496         return roundedIntRect(rect);
1497
1498     CGAffineTransform deviceMatrix = CGContextGetUserSpaceToDeviceSpaceTransform(platformContext());
1499     if (CGAffineTransformIsIdentity(deviceMatrix)) {
1500         m_data->m_userToDeviceTransformKnownToBeIdentity = true;
1501         return roundedIntRect(rect);
1502     }
1503
1504     float deviceScaleX = sqrtf(deviceMatrix.a * deviceMatrix.a + deviceMatrix.b * deviceMatrix.b);
1505     float deviceScaleY = sqrtf(deviceMatrix.c * deviceMatrix.c + deviceMatrix.d * deviceMatrix.d);
1506
1507     CGPoint deviceOrigin = CGPointMake(rect.x() * deviceScaleX, rect.y() * deviceScaleY);
1508     CGPoint deviceLowerRight = CGPointMake((rect.x() + rect.width()) * deviceScaleX,
1509         (rect.y() + rect.height()) * deviceScaleY);
1510
1511     deviceOrigin.x = roundf(deviceOrigin.x);
1512     deviceOrigin.y = roundf(deviceOrigin.y);
1513     if (roundingMode == RoundAllSides) {
1514         deviceLowerRight.x = roundf(deviceLowerRight.x);
1515         deviceLowerRight.y = roundf(deviceLowerRight.y);
1516     } else {
1517         deviceLowerRight.x = deviceOrigin.x + roundf(rect.width() * deviceScaleX);
1518         deviceLowerRight.y = deviceOrigin.y + roundf(rect.height() * deviceScaleY);
1519     }
1520
1521     // Don't let the height or width round to 0 unless either was originally 0
1522     if (deviceOrigin.y == deviceLowerRight.y && rect.height())
1523         deviceLowerRight.y += 1;
1524     if (deviceOrigin.x == deviceLowerRight.x && rect.width())
1525         deviceLowerRight.x += 1;
1526
1527     FloatPoint roundedOrigin = FloatPoint(deviceOrigin.x / deviceScaleX, deviceOrigin.y / deviceScaleY);
1528     FloatPoint roundedLowerRight = FloatPoint(deviceLowerRight.x / deviceScaleX, deviceLowerRight.y / deviceScaleY);
1529     return FloatRect(roundedOrigin, roundedLowerRight - roundedOrigin);
1530 }
1531
1532 void GraphicsContext::drawLineForText(const FloatPoint& point, float width, bool printing, bool doubleLines)
1533 {
1534     DashArray widths;
1535     widths.append(width);
1536     widths.append(0);
1537     drawLinesForText(point, widths, printing, doubleLines);
1538 }
1539
1540 void GraphicsContext::drawLinesForText(const FloatPoint& point, const DashArray& widths, bool printing, bool doubleLines)
1541 {
1542     if (paintingDisabled())
1543         return;
1544
1545     if (!widths.size())
1546         return;
1547
1548     if (isRecording()) {
1549         m_displayListRecorder->drawLinesForText(point, widths, printing, doubleLines, strokeThickness());
1550         return;
1551     }
1552
1553     Color localStrokeColor(strokeColor());
1554
1555     FloatRect bounds = computeLineBoundsAndAntialiasingModeForText(point, widths.last(), printing, localStrokeColor);
1556     bool fillColorIsNotEqualToStrokeColor = fillColor() != localStrokeColor;
1557     
1558     Vector<CGRect, 4> dashBounds;
1559     ASSERT(!(widths.size() % 2));
1560     dashBounds.reserveInitialCapacity(dashBounds.size() / 2);
1561     for (size_t i = 0; i < widths.size(); i += 2)
1562         dashBounds.append(CGRectMake(bounds.x() + widths[i], bounds.y(), widths[i+1] - widths[i], bounds.height()));
1563
1564     if (doubleLines) {
1565         // The space between double underlines is equal to the height of the underline
1566         for (size_t i = 0; i < widths.size(); i += 2)
1567             dashBounds.append(CGRectMake(bounds.x() + widths[i], bounds.y() + 2 * bounds.height(), widths[i+1] - widths[i], bounds.height()));
1568     }
1569
1570     if (fillColorIsNotEqualToStrokeColor)
1571         setCGFillColor(platformContext(), localStrokeColor);
1572
1573     CGContextFillRects(platformContext(), dashBounds.data(), dashBounds.size());
1574
1575     if (fillColorIsNotEqualToStrokeColor)
1576         setCGFillColor(platformContext(), fillColor());
1577 }
1578
1579 void GraphicsContext::setURLForRect(const URL& link, const IntRect& destRect)
1580 {
1581 #if !PLATFORM(IOS)
1582     if (paintingDisabled())
1583         return;
1584
1585     if (isRecording()) {
1586         WTFLogAlways("GraphicsContext::setURLForRect() is not yet compatible with recording contexts.");
1587         return; // FIXME for display lists.
1588     }
1589
1590     RetainPtr<CFURLRef> urlRef = link.createCFURL();
1591     if (!urlRef)
1592         return;
1593
1594     CGContextRef context = platformContext();
1595
1596     // Get the bounding box to handle clipping.
1597     CGRect box = CGContextGetClipBoundingBox(context);
1598
1599     IntRect intBox((int)box.origin.x, (int)box.origin.y, (int)box.size.width, (int)box.size.height);
1600     IntRect rect = destRect;
1601     rect.intersect(intBox);
1602
1603     CGPDFContextSetURLForRect(context, urlRef.get(),
1604         CGRectApplyAffineTransform(rect, CGContextGetCTM(context)));
1605 #else
1606     UNUSED_PARAM(link);
1607     UNUSED_PARAM(destRect);
1608 #endif
1609 }
1610
1611 void GraphicsContext::setPlatformImageInterpolationQuality(InterpolationQuality mode)
1612 {
1613     ASSERT(!paintingDisabled());
1614
1615     CGInterpolationQuality quality = kCGInterpolationDefault;
1616     switch (mode) {
1617     case InterpolationDefault:
1618         quality = kCGInterpolationDefault;
1619         break;
1620     case InterpolationNone:
1621         quality = kCGInterpolationNone;
1622         break;
1623     case InterpolationLow:
1624         quality = kCGInterpolationLow;
1625         break;
1626     case InterpolationMedium:
1627         quality = kCGInterpolationMedium;
1628         break;
1629     case InterpolationHigh:
1630         quality = kCGInterpolationHigh;
1631         break;
1632     }
1633     CGContextSetInterpolationQuality(platformContext(), quality);
1634 }
1635
1636 void GraphicsContext::setIsCALayerContext(bool isLayerContext)
1637 {
1638     if (paintingDisabled())
1639         return;
1640
1641     // FIXME
1642     if (isRecording())
1643         return;
1644
1645     if (isLayerContext)
1646         m_data->m_contextFlags |= IsLayerCGContext;
1647     else
1648         m_data->m_contextFlags &= ~IsLayerCGContext;
1649 }
1650
1651 bool GraphicsContext::isCALayerContext() const
1652 {
1653     if (paintingDisabled())
1654         return false;
1655
1656     // FIXME
1657     if (isRecording())
1658         return false;
1659
1660     return m_data->m_contextFlags & IsLayerCGContext;
1661 }
1662
1663 void GraphicsContext::setIsAcceleratedContext(bool isAccelerated)
1664 {
1665     if (paintingDisabled())
1666         return;
1667
1668     // FIXME
1669     if (isRecording())
1670         return;
1671
1672     if (isAccelerated)
1673         m_data->m_contextFlags |= IsAcceleratedCGContext;
1674     else
1675         m_data->m_contextFlags &= ~IsAcceleratedCGContext;
1676 }
1677
1678 bool GraphicsContext::isAcceleratedContext() const
1679 {
1680     if (paintingDisabled())
1681         return false;
1682
1683     // FIXME
1684     if (isRecording())
1685         return false;
1686
1687     return m_data->m_contextFlags & IsAcceleratedCGContext;
1688 }
1689
1690 void GraphicsContext::setPlatformTextDrawingMode(TextDrawingModeFlags mode)
1691 {
1692     if (paintingDisabled())
1693         return;
1694
1695     ASSERT(!isRecording());
1696
1697     CGContextRef context = platformContext();
1698     switch (mode) {
1699     case TextModeFill:
1700         CGContextSetTextDrawingMode(context, kCGTextFill);
1701         break;
1702     case TextModeStroke:
1703         CGContextSetTextDrawingMode(context, kCGTextStroke);
1704         break;
1705     case TextModeFill | TextModeStroke:
1706         CGContextSetTextDrawingMode(context, kCGTextFillStroke);
1707         break;
1708     default:
1709         break;
1710     }
1711 }
1712
1713 void GraphicsContext::setPlatformStrokeColor(const Color& color)
1714 {
1715     if (paintingDisabled())
1716         return;
1717
1718     ASSERT(!isRecording());
1719
1720     setCGStrokeColor(platformContext(), color);
1721 }
1722
1723 void GraphicsContext::setPlatformStrokeThickness(float thickness)
1724 {
1725     if (paintingDisabled())
1726         return;
1727
1728     ASSERT(!isRecording());
1729
1730     CGContextSetLineWidth(platformContext(), std::max(thickness, 0.f));
1731 }
1732
1733 void GraphicsContext::setPlatformFillColor(const Color& color)
1734 {
1735     if (paintingDisabled())
1736         return;
1737
1738     ASSERT(!isRecording());
1739
1740     setCGFillColor(platformContext(), color);
1741 }
1742
1743 void GraphicsContext::setPlatformShouldAntialias(bool enable)
1744 {
1745     if (paintingDisabled())
1746         return;
1747
1748     ASSERT(!isRecording());
1749
1750     CGContextSetShouldAntialias(platformContext(), enable);
1751 }
1752
1753 void GraphicsContext::setPlatformShouldSmoothFonts(bool enable)
1754 {
1755     if (paintingDisabled())
1756         return;
1757
1758     ASSERT(!isRecording());
1759
1760     CGContextSetShouldSmoothFonts(platformContext(), enable);
1761 }
1762
1763 void GraphicsContext::setPlatformAlpha(float alpha)
1764 {
1765     if (paintingDisabled())
1766         return;
1767
1768     ASSERT(!isRecording());
1769
1770     CGContextSetAlpha(platformContext(), alpha);
1771 }
1772
1773 void GraphicsContext::setPlatformCompositeOperation(CompositeOperator mode, BlendMode blendMode)
1774 {
1775     if (paintingDisabled())
1776         return;
1777
1778     ASSERT(!isRecording());
1779
1780     CGBlendMode target = kCGBlendModeNormal;
1781     if (blendMode != BlendModeNormal) {
1782         switch (blendMode) {
1783         case BlendModeMultiply:
1784             target = kCGBlendModeMultiply;
1785             break;
1786         case BlendModeScreen:
1787             target = kCGBlendModeScreen;
1788             break;
1789         case BlendModeOverlay:
1790             target = kCGBlendModeOverlay;
1791             break;
1792         case BlendModeDarken:
1793             target = kCGBlendModeDarken;
1794             break;
1795         case BlendModeLighten:
1796             target = kCGBlendModeLighten;
1797             break;
1798         case BlendModeColorDodge:
1799             target = kCGBlendModeColorDodge;
1800             break;
1801         case BlendModeColorBurn:
1802             target = kCGBlendModeColorBurn;
1803             break;
1804         case BlendModeHardLight:
1805             target = kCGBlendModeHardLight;
1806             break;
1807         case BlendModeSoftLight:
1808             target = kCGBlendModeSoftLight;
1809             break;
1810         case BlendModeDifference:
1811             target = kCGBlendModeDifference;
1812             break;
1813         case BlendModeExclusion:
1814             target = kCGBlendModeExclusion;
1815             break;
1816         case BlendModeHue:
1817             target = kCGBlendModeHue;
1818             break;
1819         case BlendModeSaturation:
1820             target = kCGBlendModeSaturation;
1821             break;
1822         case BlendModeColor:
1823             target = kCGBlendModeColor;
1824             break;
1825         case BlendModeLuminosity:
1826             target = kCGBlendModeLuminosity;
1827             break;
1828         case BlendModePlusDarker:
1829             target = kCGBlendModePlusDarker;
1830             break;
1831         case BlendModePlusLighter:
1832             target = kCGBlendModePlusLighter;
1833             break;
1834         default:
1835             break;
1836         }
1837     } else {
1838         switch (mode) {
1839         case CompositeClear:
1840             target = kCGBlendModeClear;
1841             break;
1842         case CompositeCopy:
1843             target = kCGBlendModeCopy;
1844             break;
1845         case CompositeSourceOver:
1846             // kCGBlendModeNormal
1847             break;
1848         case CompositeSourceIn:
1849             target = kCGBlendModeSourceIn;
1850             break;
1851         case CompositeSourceOut:
1852             target = kCGBlendModeSourceOut;
1853             break;
1854         case CompositeSourceAtop:
1855             target = kCGBlendModeSourceAtop;
1856             break;
1857         case CompositeDestinationOver:
1858             target = kCGBlendModeDestinationOver;
1859             break;
1860         case CompositeDestinationIn:
1861             target = kCGBlendModeDestinationIn;
1862             break;
1863         case CompositeDestinationOut:
1864             target = kCGBlendModeDestinationOut;
1865             break;
1866         case CompositeDestinationAtop:
1867             target = kCGBlendModeDestinationAtop;
1868             break;
1869         case CompositeXOR:
1870             target = kCGBlendModeXOR;
1871             break;
1872         case CompositePlusDarker:
1873             target = kCGBlendModePlusDarker;
1874             break;
1875         case CompositePlusLighter:
1876             target = kCGBlendModePlusLighter;
1877             break;
1878         case CompositeDifference:
1879             target = kCGBlendModeDifference;
1880             break;
1881         }
1882     }
1883     CGContextSetBlendMode(platformContext(), target);
1884 }
1885
1886 void GraphicsContext::platformApplyDeviceScaleFactor(float deviceScaleFactor)
1887 {
1888     if (paintingDisabled())
1889         return;
1890
1891     ASSERT(!isRecording());
1892
1893     // CoreGraphics expects the base CTM of a HiDPI context to have the scale factor applied to it.
1894     // Failing to change the base level CTM will cause certain CG features, such as focus rings,
1895     // to draw with a scale factor of 1 rather than the actual scale factor.
1896     CGContextSetBaseCTM(platformContext(), CGAffineTransformScale(CGContextGetBaseCTM(platformContext()), deviceScaleFactor, deviceScaleFactor));
1897 }
1898
1899 void GraphicsContext::platformFillEllipse(const FloatRect& ellipse)
1900 {
1901     if (paintingDisabled())
1902         return;
1903
1904     ASSERT(!isRecording());
1905
1906     // CGContextFillEllipseInRect only supports solid colors.
1907     if (m_state.fillGradient || m_state.fillPattern) {
1908         fillEllipseAsPath(ellipse);
1909         return;
1910     }
1911
1912     CGContextRef context = platformContext();
1913     CGContextFillEllipseInRect(context, ellipse);
1914 }
1915
1916 void GraphicsContext::platformStrokeEllipse(const FloatRect& ellipse)
1917 {
1918     if (paintingDisabled())
1919         return;
1920
1921     ASSERT(!isRecording());
1922
1923     // CGContextStrokeEllipseInRect only supports solid colors.
1924     if (m_state.strokeGradient || m_state.strokePattern) {
1925         strokeEllipseAsPath(ellipse);
1926         return;
1927     }
1928
1929     CGContextRef context = platformContext();
1930     CGContextStrokeEllipseInRect(context, ellipse);
1931 }
1932
1933 }