e1ef9fa4a9508a653a4fdb9e4e016951a98b9444
[WebKit-https.git] / Source / WebCore / platform / graphics / skia / PlatformContextSkia.cpp
1 /*
2  * Copyright (c) 2008, Google Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions are
6  * met:
7  *
8  *     * Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  *     * Redistributions in binary form must reproduce the above
11  * copyright notice, this list of conditions and the following disclaimer
12  * in the documentation and/or other materials provided with the
13  * distribution.
14  *     * Neither the name of Google Inc. nor the names of its
15  * contributors may be used to endorse or promote products derived from
16  * this software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  */
30
31 #include "config.h"
32
33 #include "PlatformContextSkia.h"
34
35 #include "AffineTransform.h"
36 #include "DrawingBuffer.h"
37 #include "Extensions3D.h"
38 #include "GraphicsContext.h"
39 #include "GraphicsContext3D.h"
40 #include "ImageBuffer.h"
41 #include "NativeImageSkia.h"
42 #include "SkiaUtils.h"
43 #include "Texture.h"
44 #include "TilingData.h"
45
46 #include "skia/ext/image_operations.h"
47 #include "skia/ext/platform_canvas.h"
48
49 #include "SkBitmap.h"
50 #include "SkColorPriv.h"
51 #include "SkDashPathEffect.h"
52 #include "SkShader.h"
53
54 #if ENABLE(SKIA_GPU)
55 #include "GrContext.h"
56 #include "SkGpuDevice.h"
57 #include "SkGpuDeviceFactory.h"
58 #endif
59
60 #include <wtf/MathExtras.h>
61 #include <wtf/OwnArrayPtr.h>
62 #include <wtf/Vector.h>
63
64 #if ENABLE(ACCELERATED_2D_CANVAS)
65 #include "GLES2Canvas.h"
66 #include "SharedGraphicsContext3D.h"
67 #endif
68
69 namespace WebCore {
70
71 extern bool isPathSkiaSafe(const SkMatrix& transform, const SkPath& path);
72
73 // State -----------------------------------------------------------------------
74
75 // Encapsulates the additional painting state information we store for each
76 // pushed graphics state.
77 struct PlatformContextSkia::State {
78     State();
79     State(const State&);
80     ~State();
81
82     // Common shader state.
83     float m_alpha;
84     SkXfermode::Mode m_xferMode;
85     bool m_useAntialiasing;
86     SkDrawLooper* m_looper;
87
88     // Fill.
89     SkColor m_fillColor;
90     SkShader* m_fillShader;
91
92     // Stroke.
93     StrokeStyle m_strokeStyle;
94     SkColor m_strokeColor;
95     SkShader* m_strokeShader;
96     float m_strokeThickness;
97     int m_dashRatio;  // Ratio of the length of a dash to its width.
98     float m_miterLimit;
99     SkPaint::Cap m_lineCap;
100     SkPaint::Join m_lineJoin;
101     SkDashPathEffect* m_dash;
102
103     // Text. (See TextModeFill & friends in GraphicsContext.h.)
104     TextDrawingModeFlags m_textDrawingMode;
105
106     // Helper function for applying the state's alpha value to the given input
107     // color to produce a new output color.
108     SkColor applyAlpha(SkColor) const;
109
110     // If non-empty, the current State is clipped to this image.
111     SkBitmap m_imageBufferClip;
112     // If m_imageBufferClip is non-empty, this is the region the image is clipped to.
113     FloatRect m_clip;
114
115     // This is a list of clipping paths which are currently active, in the
116     // order in which they were pushed.
117     WTF::Vector<SkPath> m_antiAliasClipPaths;
118     InterpolationQuality m_interpolationQuality;
119
120     // If we currently have a canvas (non-antialiased path) clip applied.
121     bool m_canvasClipApplied;
122
123     PlatformContextSkia::State cloneInheritedProperties();
124 private:
125     // Not supported.
126     void operator=(const State&);
127 };
128
129 // Note: Keep theses default values in sync with GraphicsContextState.
130 PlatformContextSkia::State::State()
131     : m_alpha(1)
132     , m_xferMode(SkXfermode::kSrcOver_Mode)
133     , m_useAntialiasing(true)
134     , m_looper(0)
135     , m_fillColor(0xFF000000)
136     , m_fillShader(0)
137     , m_strokeStyle(SolidStroke)
138     , m_strokeColor(Color::black)
139     , m_strokeShader(0)
140     , m_strokeThickness(0)
141     , m_dashRatio(3)
142     , m_miterLimit(4)
143     , m_lineCap(SkPaint::kDefault_Cap)
144     , m_lineJoin(SkPaint::kDefault_Join)
145     , m_dash(0)
146     , m_textDrawingMode(TextModeFill)
147     , m_interpolationQuality(InterpolationHigh)
148     , m_canvasClipApplied(false)
149 {
150 }
151
152 PlatformContextSkia::State::State(const State& other)
153     : m_alpha(other.m_alpha)
154     , m_xferMode(other.m_xferMode)
155     , m_useAntialiasing(other.m_useAntialiasing)
156     , m_looper(other.m_looper)
157     , m_fillColor(other.m_fillColor)
158     , m_fillShader(other.m_fillShader)
159     , m_strokeStyle(other.m_strokeStyle)
160     , m_strokeColor(other.m_strokeColor)
161     , m_strokeShader(other.m_strokeShader)
162     , m_strokeThickness(other.m_strokeThickness)
163     , m_dashRatio(other.m_dashRatio)
164     , m_miterLimit(other.m_miterLimit)
165     , m_lineCap(other.m_lineCap)
166     , m_lineJoin(other.m_lineJoin)
167     , m_dash(other.m_dash)
168     , m_textDrawingMode(other.m_textDrawingMode)
169     , m_imageBufferClip(other.m_imageBufferClip)
170     , m_clip(other.m_clip)
171     , m_antiAliasClipPaths(other.m_antiAliasClipPaths)
172     , m_interpolationQuality(other.m_interpolationQuality)
173     , m_canvasClipApplied(other.m_canvasClipApplied)
174 {
175     // Up the ref count of these. SkSafeRef does nothing if its argument is 0.
176     SkSafeRef(m_looper);
177     SkSafeRef(m_dash);
178     SkSafeRef(m_fillShader);
179     SkSafeRef(m_strokeShader);
180 }
181
182 PlatformContextSkia::State::~State()
183 {
184     SkSafeUnref(m_looper);
185     SkSafeUnref(m_dash);
186     SkSafeUnref(m_fillShader);
187     SkSafeUnref(m_strokeShader);
188 }
189
190 // Returns a new State with all of this object's inherited properties copied.
191 PlatformContextSkia::State PlatformContextSkia::State::cloneInheritedProperties()
192 {
193     PlatformContextSkia::State state(*this);
194
195     // Everything is inherited except for the clip paths.
196     state.m_antiAliasClipPaths.clear();
197
198     return state;
199 }
200
201 SkColor PlatformContextSkia::State::applyAlpha(SkColor c) const
202 {
203     int s = roundf(m_alpha * 256);
204     if (s >= 256)
205         return c;
206     if (s < 0)
207         return 0;
208
209     int a = SkAlphaMul(SkColorGetA(c), s);
210     return (c & 0x00FFFFFF) | (a << 24);
211 }
212
213 // PlatformContextSkia ---------------------------------------------------------
214
215 // Danger: canvas can be NULL.
216 PlatformContextSkia::PlatformContextSkia(skia::PlatformCanvas* canvas)
217     : m_canvas(canvas)
218     , m_drawingToImageBuffer(false)
219     , m_useGPU(false)
220 #if ENABLE(ACCELERATED_2D_CANVAS)
221     , m_gpuCanvas(0)
222 #endif
223     , m_backingStoreState(None)
224 {
225     m_stateStack.append(State());
226     m_state = &m_stateStack.last();
227 }
228
229 PlatformContextSkia::~PlatformContextSkia()
230 {
231 #if ENABLE(ACCELERATED_2D_CANVAS)
232     if (m_gpuCanvas) {
233 #if ENABLE(SKIA_GPU)
234         // make sure everything related to this platform context has been flushed
235         if (!m_useGPU)
236             m_gpuCanvas->context()->grContext()->flush(0);
237 #endif
238         m_gpuCanvas->drawingBuffer()->setWillPublishCallback(0);
239     }
240 #endif
241 }
242
243 void PlatformContextSkia::setCanvas(skia::PlatformCanvas* canvas)
244 {
245     m_canvas = canvas;
246 }
247
248 void PlatformContextSkia::setDrawingToImageBuffer(bool value)
249 {
250     m_drawingToImageBuffer = value;
251 }
252
253 bool PlatformContextSkia::isDrawingToImageBuffer() const
254 {
255     return m_drawingToImageBuffer;
256 }
257
258 void PlatformContextSkia::save()
259 {
260     ASSERT(!hasImageResamplingHint());
261
262     m_stateStack.append(m_state->cloneInheritedProperties());
263     m_state = &m_stateStack.last();
264
265     // The clip image only needs to be applied once. Reset the image so that we
266     // don't attempt to clip multiple times.
267     m_state->m_imageBufferClip.reset();
268
269     // Save our native canvas.
270     canvas()->save();
271 }
272
273 void PlatformContextSkia::beginLayerClippedToImage(const FloatRect& rect,
274                                                    const ImageBuffer* imageBuffer)
275 {
276     // Skia doesn't support clipping to an image, so we create a layer. The next
277     // time restore is invoked the layer and |imageBuffer| are combined to
278     // create the resulting image.
279     m_state->m_clip = rect;
280     SkRect bounds = { SkFloatToScalar(rect.x()), SkFloatToScalar(rect.y()),
281                       SkFloatToScalar(rect.maxX()), SkFloatToScalar(rect.maxY()) };
282
283     canvas()->clipRect(bounds);
284     canvas()->saveLayerAlpha(&bounds, 255,
285                              static_cast<SkCanvas::SaveFlags>(SkCanvas::kHasAlphaLayer_SaveFlag | SkCanvas::kFullColorLayer_SaveFlag));
286     // Copy off the image as |imageBuffer| may be deleted before restore is invoked.
287     const SkBitmap* bitmap = imageBuffer->context()->platformContext()->bitmap();
288     if (!bitmap->pixelRef()) {
289         // The bitmap owns it's pixels. This happens when we've allocated the
290         // pixels in some way and assigned them directly to the bitmap (as
291         // happens when we allocate a DIB). In this case the assignment operator
292         // does not copy the pixels, rather the copied bitmap ends up
293         // referencing the same pixels. As the pixels may not live as long as we
294         // need it to, we copy the image.
295         bitmap->copyTo(&m_state->m_imageBufferClip, SkBitmap::kARGB_8888_Config);
296     } else {
297         // If there is a pixel ref, we can safely use the assignment operator.
298         m_state->m_imageBufferClip = *bitmap;
299     }
300 }
301
302 void PlatformContextSkia::clipPathAntiAliased(const SkPath& clipPath)
303 {
304     // If we are currently tracking any anti-alias clip paths, then we already
305     // have a layer in place and don't need to add another.
306     bool haveLayerOutstanding = m_state->m_antiAliasClipPaths.size();
307
308     // See comments in applyAntiAliasedClipPaths about how this works.
309     m_state->m_antiAliasClipPaths.append(clipPath);
310
311     if (!haveLayerOutstanding) {
312         SkRect bounds = clipPath.getBounds();
313         canvas()->saveLayerAlpha(&bounds, 255, static_cast<SkCanvas::SaveFlags>(SkCanvas::kHasAlphaLayer_SaveFlag | SkCanvas::kFullColorLayer_SaveFlag | SkCanvas::kClipToLayer_SaveFlag));
314         // Guards state modification during clipped operations.
315         // The state is popped in applyAntiAliasedClipPaths().
316         canvas()->save();
317     }
318 }
319
320 void PlatformContextSkia::restore()
321 {
322     if (!m_state->m_imageBufferClip.empty()) {
323         applyClipFromImage(m_state->m_clip, m_state->m_imageBufferClip);
324         canvas()->restore();
325     }
326
327     if (!m_state->m_antiAliasClipPaths.isEmpty())
328         applyAntiAliasedClipPaths(m_state->m_antiAliasClipPaths);
329
330     m_stateStack.removeLast();
331     m_state = &m_stateStack.last();
332
333     // Restore our native canvas.
334     canvas()->restore();
335 }
336
337 void PlatformContextSkia::drawRect(SkRect rect)
338 {
339     SkPaint paint;
340     int fillcolorNotTransparent = m_state->m_fillColor & 0xFF000000;
341     if (fillcolorNotTransparent) {
342         setupPaintForFilling(&paint);
343         canvas()->drawRect(rect, paint);
344     }
345
346     if (m_state->m_strokeStyle != NoStroke
347         && (m_state->m_strokeColor & 0xFF000000)) {
348         // We do a fill of four rects to simulate the stroke of a border.
349         SkColor oldFillColor = m_state->m_fillColor;
350
351         // setFillColor() will set the shader to NULL, so save a ref to it now.
352         SkShader* oldFillShader = m_state->m_fillShader;
353         SkSafeRef(oldFillShader);
354         setFillColor(m_state->m_strokeColor);
355         paint.reset();
356         setupPaintForFilling(&paint);
357         SkRect topBorder = { rect.fLeft, rect.fTop, rect.fRight, rect.fTop + 1 };
358         canvas()->drawRect(topBorder, paint);
359         SkRect bottomBorder = { rect.fLeft, rect.fBottom - 1, rect.fRight, rect.fBottom };
360         canvas()->drawRect(bottomBorder, paint);
361         SkRect leftBorder = { rect.fLeft, rect.fTop + 1, rect.fLeft + 1, rect.fBottom - 1 };
362         canvas()->drawRect(leftBorder, paint);
363         SkRect rightBorder = { rect.fRight - 1, rect.fTop + 1, rect.fRight, rect.fBottom - 1 };
364         canvas()->drawRect(rightBorder, paint);
365         setFillColor(oldFillColor);
366         setFillShader(oldFillShader);
367         SkSafeUnref(oldFillShader);
368     }
369 }
370
371 void PlatformContextSkia::setupPaintCommon(SkPaint* paint) const
372 {
373 #if defined(SK_DEBUG)
374     {
375         SkPaint defaultPaint;
376         SkASSERT(*paint == defaultPaint);
377     }
378 #endif
379
380     paint->setAntiAlias(m_state->m_useAntialiasing);
381     paint->setXfermodeMode(m_state->m_xferMode);
382     paint->setLooper(m_state->m_looper);
383 }
384
385 void PlatformContextSkia::setupPaintForFilling(SkPaint* paint) const
386 {
387     setupPaintCommon(paint);
388     paint->setColor(m_state->applyAlpha(m_state->m_fillColor));
389     paint->setShader(m_state->m_fillShader);
390 }
391
392 float PlatformContextSkia::setupPaintForStroking(SkPaint* paint, SkRect* rect, int length) const
393 {
394     setupPaintCommon(paint);
395     float width = m_state->m_strokeThickness;
396
397     paint->setColor(m_state->applyAlpha(m_state->m_strokeColor));
398     paint->setShader(m_state->m_strokeShader);
399     paint->setStyle(SkPaint::kStroke_Style);
400     paint->setStrokeWidth(SkFloatToScalar(width));
401     paint->setStrokeCap(m_state->m_lineCap);
402     paint->setStrokeJoin(m_state->m_lineJoin);
403     paint->setStrokeMiter(SkFloatToScalar(m_state->m_miterLimit));
404
405     if (m_state->m_dash)
406         paint->setPathEffect(m_state->m_dash);
407     else {
408         switch (m_state->m_strokeStyle) {
409         case NoStroke:
410         case SolidStroke:
411             break;
412         case DashedStroke:
413             width = m_state->m_dashRatio * width;
414             // Fall through.
415         case DottedStroke:
416             // Truncate the width, since we don't want fuzzy dots or dashes.
417             int dashLength = static_cast<int>(width);
418             // Subtract off the endcaps, since they're rendered separately.
419             int distance = length - 2 * static_cast<int>(m_state->m_strokeThickness);
420             int phase = 1;
421             if (dashLength > 1) {
422                 // Determine how many dashes or dots we should have.
423                 int numDashes = distance / dashLength;
424                 int remainder = distance % dashLength;
425                 // Adjust the phase to center the dashes within the line.
426                 if (numDashes % 2 == 0) {
427                     // Even:  shift right half a dash, minus half the remainder
428                     phase = (dashLength - remainder) / 2;
429                 } else {
430                     // Odd:  shift right a full dash, minus half the remainder
431                     phase = dashLength - remainder / 2;
432                 }
433             }
434             SkScalar dashLengthSk = SkIntToScalar(dashLength);
435             SkScalar intervals[2] = { dashLengthSk, dashLengthSk };
436             paint->setPathEffect(new SkDashPathEffect(intervals, 2, SkIntToScalar(phase)))->unref();
437         }
438     }
439
440     return width;
441 }
442
443 void PlatformContextSkia::setDrawLooper(SkDrawLooper* dl)
444 {
445     SkRefCnt_SafeAssign(m_state->m_looper, dl);
446 }
447
448 void PlatformContextSkia::setMiterLimit(float ml)
449 {
450     m_state->m_miterLimit = ml;
451 }
452
453 void PlatformContextSkia::setAlpha(float alpha)
454 {
455     m_state->m_alpha = alpha;
456 }
457
458 void PlatformContextSkia::setLineCap(SkPaint::Cap lc)
459 {
460     m_state->m_lineCap = lc;
461 }
462
463 void PlatformContextSkia::setLineJoin(SkPaint::Join lj)
464 {
465     m_state->m_lineJoin = lj;
466 }
467
468 void PlatformContextSkia::setXfermodeMode(SkXfermode::Mode pdm)
469 {
470     m_state->m_xferMode = pdm;
471 }
472
473 void PlatformContextSkia::setFillColor(SkColor color)
474 {
475     m_state->m_fillColor = color;
476     setFillShader(0);
477 }
478
479 SkDrawLooper* PlatformContextSkia::getDrawLooper() const
480 {
481     return m_state->m_looper;
482 }
483
484 StrokeStyle PlatformContextSkia::getStrokeStyle() const
485 {
486     return m_state->m_strokeStyle;
487 }
488
489 void PlatformContextSkia::setStrokeStyle(StrokeStyle strokeStyle)
490 {
491     m_state->m_strokeStyle = strokeStyle;
492 }
493
494 void PlatformContextSkia::setStrokeColor(SkColor strokeColor)
495 {
496     m_state->m_strokeColor = strokeColor;
497     setStrokeShader(0);
498 }
499
500 float PlatformContextSkia::getStrokeThickness() const
501 {
502     return m_state->m_strokeThickness;
503 }
504
505 void PlatformContextSkia::setStrokeThickness(float thickness)
506 {
507     m_state->m_strokeThickness = thickness;
508 }
509
510 void PlatformContextSkia::setStrokeShader(SkShader* strokeShader)
511 {
512     if (strokeShader)
513         m_state->m_strokeColor = Color::black;
514
515     if (strokeShader != m_state->m_strokeShader) {
516         SkSafeUnref(m_state->m_strokeShader);
517         m_state->m_strokeShader = strokeShader;
518         SkSafeRef(m_state->m_strokeShader);
519     }
520 }
521
522 TextDrawingModeFlags PlatformContextSkia::getTextDrawingMode() const
523 {
524     return m_state->m_textDrawingMode;
525 }
526
527 float PlatformContextSkia::getAlpha() const
528 {
529     return m_state->m_alpha;
530 }
531
532 int PlatformContextSkia::getNormalizedAlpha() const
533 {
534     int alpha = roundf(m_state->m_alpha * 256);
535     if (alpha > 255)
536         alpha = 255;
537     else if (alpha < 0)
538         alpha = 0;
539     return alpha;
540 }
541
542 void PlatformContextSkia::setTextDrawingMode(TextDrawingModeFlags mode)
543 {
544     // TextModeClip is never used, so we assert that it isn't set:
545     // https://bugs.webkit.org/show_bug.cgi?id=21898
546     ASSERT(!(mode & TextModeClip));
547     m_state->m_textDrawingMode = mode;
548 }
549
550 void PlatformContextSkia::setUseAntialiasing(bool enable)
551 {
552     m_state->m_useAntialiasing = enable;
553 }
554
555 SkColor PlatformContextSkia::effectiveFillColor() const
556 {
557     return m_state->applyAlpha(m_state->m_fillColor);
558 }
559
560 SkColor PlatformContextSkia::effectiveStrokeColor() const
561 {
562     return m_state->applyAlpha(m_state->m_strokeColor);
563 }
564
565 void PlatformContextSkia::canvasClipPath(const SkPath& path)
566 {
567     m_state->m_canvasClipApplied = true;
568     m_canvas->clipPath(path);
569 }
570
571 void PlatformContextSkia::setFillShader(SkShader* fillShader)
572 {
573     if (fillShader)
574         m_state->m_fillColor = Color::black;
575
576     if (fillShader != m_state->m_fillShader) {
577         SkSafeUnref(m_state->m_fillShader);
578         m_state->m_fillShader = fillShader;
579         SkSafeRef(m_state->m_fillShader);
580     }
581 }
582
583 InterpolationQuality PlatformContextSkia::interpolationQuality() const
584 {
585     return m_state->m_interpolationQuality;
586 }
587
588 void PlatformContextSkia::setInterpolationQuality(InterpolationQuality interpolationQuality)
589 {
590     m_state->m_interpolationQuality = interpolationQuality;
591 }
592
593 void PlatformContextSkia::setDashPathEffect(SkDashPathEffect* dash)
594 {
595     if (dash != m_state->m_dash) {
596         SkSafeUnref(m_state->m_dash);
597         m_state->m_dash = dash;
598     }
599 }
600
601 void PlatformContextSkia::paintSkPaint(const SkRect& rect,
602                                        const SkPaint& paint)
603 {
604     m_canvas->drawRect(rect, paint);
605 }
606
607 const SkBitmap* PlatformContextSkia::bitmap() const
608 {
609     return &m_canvas->getDevice()->accessBitmap(false);
610 }
611
612 bool PlatformContextSkia::isPrinting()
613 {
614 #if ENABLE(SKIA_GPU)
615     return true;
616 #else
617     return m_canvas->getTopPlatformDevice().IsVectorial();
618 #endif
619 }
620
621 bool PlatformContextSkia::isNativeFontRenderingAllowed()
622 {
623 #if ENABLE(SKIA_GPU)
624     return false;
625 #else
626     return m_canvas->getTopPlatformDevice().IsNativeFontRenderingAllowed();
627 #endif
628 }
629
630 void PlatformContextSkia::getImageResamplingHint(IntSize* srcSize, FloatSize* dstSize) const
631 {
632     *srcSize = m_imageResamplingHintSrcSize;
633     *dstSize = m_imageResamplingHintDstSize;
634 }
635
636 void PlatformContextSkia::setImageResamplingHint(const IntSize& srcSize, const FloatSize& dstSize)
637 {
638     m_imageResamplingHintSrcSize = srcSize;
639     m_imageResamplingHintDstSize = dstSize;
640 }
641
642 void PlatformContextSkia::clearImageResamplingHint()
643 {
644     m_imageResamplingHintSrcSize = IntSize();
645     m_imageResamplingHintDstSize = FloatSize();
646 }
647
648 bool PlatformContextSkia::hasImageResamplingHint() const
649 {
650     return !m_imageResamplingHintSrcSize.isEmpty() && !m_imageResamplingHintDstSize.isEmpty();
651 }
652
653 void PlatformContextSkia::applyClipFromImage(const FloatRect& rect, const SkBitmap& imageBuffer)
654 {
655     // NOTE: this assumes the image mask contains opaque black for the portions that are to be shown, as such we
656     // only look at the alpha when compositing. I'm not 100% sure this is what WebKit expects for image clipping.
657     SkPaint paint;
658     paint.setXfermodeMode(SkXfermode::kDstIn_Mode);
659     m_canvas->drawBitmap(imageBuffer, SkFloatToScalar(rect.x()), SkFloatToScalar(rect.y()), &paint);
660 }
661
662 void PlatformContextSkia::applyAntiAliasedClipPaths(WTF::Vector<SkPath>& paths)
663 {
664     // Anti-aliased clipping:
665     //
666     // Skia's clipping is 1-bit only. Consider what would happen if it were 8-bit:
667     // We have a square canvas, filled with white and we declare a circular
668     // clipping path. Then we fill twice with a black rectangle. The fractional
669     // pixels would first get the correct color (white * alpha + black * (1 -
670     // alpha)), but the second fill would apply the alpha to the already
671     // modified color and the result would be too dark.
672     //
673     // This, anti-aliased clipping needs to be performed after the drawing has
674     // been done. In order to do this, we create a new layer of the canvas in
675     // clipPathAntiAliased and store the clipping path. All drawing is done to
676     // the layer's bitmap while it's in effect. When WebKit calls restore() to
677     // undo the clipping, this function is called.
678     //
679     // Here, we walk the list of clipping paths backwards and, for each, we
680     // clear outside of the clipping path. We only need a single extra layer
681     // for any number of clipping paths.
682     //
683     // When we call restore on the SkCanvas, the layer's bitmap is composed
684     // into the layer below and we end up with correct, anti-aliased clipping.
685
686     m_canvas->restore();
687
688     SkPaint paint;
689     paint.setXfermodeMode(SkXfermode::kClear_Mode);
690     paint.setAntiAlias(true);
691     paint.setStyle(SkPaint::kFill_Style);
692
693     for (size_t i = paths.size() - 1; i < paths.size(); --i) {
694         paths[i].toggleInverseFillType();
695         m_canvas->drawPath(paths[i], paint);
696     }
697
698     m_canvas->restore();
699 }
700
701 bool PlatformContextSkia::canAccelerate() const
702 {
703     return !m_state->m_fillShader; // Can't accelerate with a fill gradient or pattern.
704 }
705
706 bool PlatformContextSkia::canvasClipApplied() const
707 {
708     return m_state->m_canvasClipApplied;
709 }
710
711 class WillPublishCallbackImpl : public DrawingBuffer::WillPublishCallback {
712 public:
713     static PassOwnPtr<WillPublishCallback> create(PlatformContextSkia* pcs)
714     {
715         return adoptPtr(new WillPublishCallbackImpl(pcs));
716     }
717
718     virtual void willPublish()
719     {
720         m_pcs->prepareForHardwareDraw();
721     }
722
723 private:
724     explicit WillPublishCallbackImpl(PlatformContextSkia* pcs)
725         : m_pcs(pcs)
726     {
727     }
728
729     PlatformContextSkia* m_pcs;
730 };
731
732 void PlatformContextSkia::setSharedGraphicsContext3D(SharedGraphicsContext3D* context, DrawingBuffer* drawingBuffer, const WebCore::IntSize& size)
733 {
734 #if ENABLE(ACCELERATED_2D_CANVAS)
735     if (context && drawingBuffer) {
736         m_useGPU = true;
737         m_gpuCanvas = new GLES2Canvas(context, drawingBuffer, size);
738         m_uploadTexture.clear();
739         drawingBuffer->setWillPublishCallback(WillPublishCallbackImpl::create(this));
740
741 #if ENABLE(SKIA_GPU)
742         m_useGPU = false;
743         context->makeContextCurrent();
744         m_gpuCanvas->bindFramebuffer();
745
746         GrContext* gr = context->grContext();
747         gr->resetContext();
748         drawingBuffer->setGrContext(gr);
749
750         SkDeviceFactory* factory = new SkGpuDeviceFactory(gr, SkGpuDevice::Current3DApiRenderTarget());
751         SkDevice* device = factory->newDevice(m_canvas, SkBitmap::kARGB_8888_Config, drawingBuffer->size().width(), drawingBuffer->size().height(), false, false);
752         m_canvas->setDevice(device)->unref();
753         m_canvas->setDeviceFactory(factory);
754 #endif
755     } else {
756         syncSoftwareCanvas();
757         m_uploadTexture.clear();
758         m_gpuCanvas.clear();
759         m_useGPU = false;
760     }
761 #endif
762 }
763
764 void PlatformContextSkia::prepareForSoftwareDraw() const
765 {
766     if (!m_useGPU) {
767 #if ENABLE(SKIA_GPU)
768         if (m_gpuCanvas)
769             m_gpuCanvas->context()->makeContextCurrent();
770 #endif
771         return;
772     }
773
774     if (m_backingStoreState == Hardware) {
775         // Depending on the blend mode we need to do one of a few things:
776
777         // * For associative blend modes, we can draw into an initially empty
778         // canvas and then composite the results on top of the hardware drawn
779         // results before the next hardware draw or swapBuffers().
780
781         // * For non-associative blend modes we have to do a readback and then
782         // software draw.  When we re-upload in this mode we have to blow
783         // away whatever is in the hardware backing store (do a copy instead
784         // of a compositing operation).
785
786         if (m_state->m_xferMode == SkXfermode::kSrcOver_Mode) {
787             // Note that we have rendering results in both the hardware and software backing stores.
788             m_backingStoreState = Mixed;
789         } else {
790             readbackHardwareToSoftware();
791             // When we switch back to hardware copy the results, don't composite.
792             m_backingStoreState = Software;
793         }
794     } else if (m_backingStoreState == Mixed) {
795         if (m_state->m_xferMode != SkXfermode::kSrcOver_Mode) {
796             // Have to composite our currently software drawn data...
797             uploadSoftwareToHardware(CompositeSourceOver);
798             // then do a readback so we can hardware draw stuff.
799             readbackHardwareToSoftware();
800             m_backingStoreState = Software;
801         }
802     } else if (m_backingStoreState == None) {
803         m_backingStoreState = Software;
804     }
805 }
806
807 void PlatformContextSkia::prepareForHardwareDraw() const
808 {
809     if (!m_useGPU)
810         return;
811
812     if (m_backingStoreState == Software) {
813         // Last drawn in software; upload everything we've drawn.
814         uploadSoftwareToHardware(CompositeCopy);
815     } else if (m_backingStoreState == Mixed) {
816         // Stuff in software/hardware, composite the software stuff on top of
817         // the hardware stuff.
818         uploadSoftwareToHardware(CompositeSourceOver);
819     }
820     m_backingStoreState = Hardware;
821 }
822
823 void PlatformContextSkia::syncSoftwareCanvas() const
824 {
825     if (!m_useGPU) {
826 #if ENABLE(SKIA_GPU)
827         if (m_gpuCanvas)
828             m_gpuCanvas->context()->makeContextCurrent();
829 #endif
830         return;
831     }
832
833     if (m_backingStoreState == Hardware)
834         readbackHardwareToSoftware();
835     else if (m_backingStoreState == Mixed) {
836         // Have to composite our currently software drawn data..
837         uploadSoftwareToHardware(CompositeSourceOver);
838         // then do a readback.
839         readbackHardwareToSoftware();
840         m_backingStoreState = Software;
841     }
842     m_backingStoreState = Software;
843 }
844
845 void PlatformContextSkia::markDirtyRect(const IntRect& rect)
846 {
847     if (!m_useGPU)
848         return;
849
850     switch (m_backingStoreState) {
851     case Software:
852     case Mixed:
853         m_softwareDirtyRect.unite(rect);
854         return;
855     case Hardware:
856         return;
857     default:
858         ASSERT_NOT_REACHED();
859     }
860 }
861
862 void PlatformContextSkia::uploadSoftwareToHardware(CompositeOperator op) const
863 {
864 #if ENABLE(ACCELERATED_2D_CANVAS)
865     const SkBitmap& bitmap = m_canvas->getDevice()->accessBitmap(false);
866     SkAutoLockPixels lock(bitmap);
867     SharedGraphicsContext3D* context = m_gpuCanvas->context();
868     if (!m_uploadTexture || m_uploadTexture->tiles().totalSizeX() < bitmap.width() || m_uploadTexture->tiles().totalSizeY() < bitmap.height())
869         m_uploadTexture = context->createTexture(Texture::BGRA8, bitmap.width(), bitmap.height());
870
871     m_uploadTexture->updateSubRect(bitmap.getPixels(), m_softwareDirtyRect);
872     AffineTransform identity;
873     gpuCanvas()->drawTexturedRect(m_uploadTexture.get(), m_softwareDirtyRect, m_softwareDirtyRect, identity, 1.0, ColorSpaceDeviceRGB, op, false);
874     // Clear out the region of the software canvas we just uploaded.
875     m_canvas->save();
876     m_canvas->resetMatrix();
877     SkRect bounds = m_softwareDirtyRect;
878     m_canvas->clipRect(bounds, SkRegion::kReplace_Op);
879     m_canvas->drawARGB(0, 0, 0, 0, SkXfermode::kClear_Mode);
880     m_canvas->restore();
881     m_softwareDirtyRect.setWidth(0); // Clear dirty rect.
882 #endif
883 }
884
885 void PlatformContextSkia::readbackHardwareToSoftware() const
886 {
887 #if ENABLE(ACCELERATED_2D_CANVAS)
888     const SkBitmap& bitmap = m_canvas->getDevice()->accessBitmap(true);
889     SkAutoLockPixels lock(bitmap);
890     int width = bitmap.width(), height = bitmap.height();
891     OwnArrayPtr<uint32_t> buf = adoptArrayPtr(new uint32_t[width]);
892     SharedGraphicsContext3D* context = m_gpuCanvas->context();
893     m_gpuCanvas->bindFramebuffer();
894     // Flips the image vertically.
895     for (int y = 0; y < height; ++y) {
896         uint32_t* pixels = bitmap.getAddr32(0, y);
897         if (context->supportsBGRA())
898             context->readPixels(0, height - 1 - y, width, 1, Extensions3D::BGRA_EXT, GraphicsContext3D::UNSIGNED_BYTE, pixels);
899         else {
900             context->readPixels(0, height - 1 - y, width, 1, GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, pixels);
901             for (int i = 0; i < width; ++i) {
902                 uint32_t pixel = pixels[i];
903                 // Swizzles from RGBA -> BGRA.
904                 pixels[i] = (pixel & 0xFF00FF00) | ((pixel & 0x00FF0000) >> 16) | ((pixel & 0x000000FF) << 16);
905             }
906         }
907     }
908     m_softwareDirtyRect.unite(IntRect(0, 0, width, height)); // Mark everything as dirty.
909 #endif
910 }
911
912 } // namespace WebCore