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