src/third_party/WebKit/Source/platform/graphics/GraphicsContext.cpp

   1 /*
   2  * Copyright (C) 2003, 2004, 2005, 2006, 2009 Apple Inc. All rights reserved.
   3  * Copyright (C) 2013 Google Inc. All rights reserved.
   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. AND ITS CONTRIBUTORS ``AS IS''
  15  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  16  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
  18  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  19  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  20  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  21  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  22  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  23  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  24  * THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 #include "config.h"
  28 #include "platform/graphics/GraphicsContext.h"
  29
  30 #include "platform/TraceEvent.h"
  31 #include "platform/geometry/IntRect.h"
  32 #include "platform/geometry/RoundedRect.h"
  33 #include "platform/graphics/BitmapImage.h"
  34 #include "platform/graphics/DisplayList.h"
  35 #include "platform/graphics/Gradient.h"
  36 #include "platform/graphics/ImageBuffer.h"
  37 #include "platform/text/BidiResolver.h"
  38 #include "platform/text/TextRunIterator.h"
  39 #include "platform/weborigin/KURL.h"
  40 #include "third_party/skia/include/core/SkAnnotation.h"
  41 #include "third_party/skia/include/core/SkColorFilter.h"
  42 #include "third_party/skia/include/core/SkData.h"
  43 #include "third_party/skia/include/core/SkDevice.h"
  44 #include "third_party/skia/include/core/SkPicture.h"
  45 #include "third_party/skia/include/core/SkRRect.h"
  46 #include "third_party/skia/include/core/SkRefCnt.h"
  47 #include "third_party/skia/include/core/SkSurface.h"
  48 #include "third_party/skia/include/effects/SkBlurMaskFilter.h"
  49 #include "third_party/skia/include/effects/SkCornerPathEffect.h"
  50 #include "third_party/skia/include/effects/SkLumaColorFilter.h"
  51 #include "third_party/skia/include/gpu/GrRenderTarget.h"
  52 #include "third_party/skia/include/gpu/GrTexture.h"
  53 #include "wtf/Assertions.h"
  54 #include "wtf/MathExtras.h"
  55
  56 using namespace std;
  57 using blink::WebBlendMode;
  58
  59 namespace WebCore {
  60
  61 namespace {
  62
  63 class CompatibleImageBufferSurface : public ImageBufferSurface {
  64     WTF_MAKE_NONCOPYABLE(CompatibleImageBufferSurface); WTF_MAKE_FAST_ALLOCATED;
  65 public:
  66     CompatibleImageBufferSurface(PassRefPtr<SkSurface> surface, const IntSize& size, OpacityMode opacityMode)
  67         : ImageBufferSurface(size, opacityMode)
  68         , m_surface(surface)
  69     {
  70     }
  71     virtual ~CompatibleImageBufferSurface() { }
  72
  73     virtual SkCanvas* canvas() const OVERRIDE { return m_surface ? m_surface->getCanvas() : 0; }
  74     virtual bool isValid() const OVERRIDE { return m_surface; }
  75     virtual bool isAccelerated() const OVERRIDE { return isValid() && m_surface->getCanvas()->getTopDevice()->accessRenderTarget(); }
  76     virtual Platform3DObject getBackingTexture() const OVERRIDE
  77     {
  78         ASSERT(isAccelerated());
  79         GrRenderTarget* renderTarget = m_surface->getCanvas()->getTopDevice()->accessRenderTarget();
  80         if (renderTarget) {
  81             return renderTarget->asTexture()->getTextureHandle();
  82         }
  83         return 0;
  84     };
  85
  86 private:
  87     RefPtr<SkSurface> m_surface;
  88 };
  89
  90 } // unnamed namespace
  91
  92 struct GraphicsContext::CanvasSaveState {
  93     CanvasSaveState(bool pendingSave, int count)
  94         : m_pendingSave(pendingSave), m_restoreCount(count) { }
  95
  96     bool m_pendingSave;
  97     int m_restoreCount;
  98 };
  99
 100 struct GraphicsContext::RecordingState {
 101     RecordingState(SkCanvas* currentCanvas, const SkMatrix& currentMatrix, PassRefPtr<DisplayList> displayList)
 102         : m_savedCanvas(currentCanvas)
 103         , m_displayList(displayList)
 104         , m_savedMatrix(currentMatrix)
 105     {
 106     }
 107
 108     SkCanvas* m_savedCanvas;
 109     RefPtr<DisplayList> m_displayList;
 110     const SkMatrix m_savedMatrix;
 111 };
 112
 113 GraphicsContext::GraphicsContext(SkCanvas* canvas, DisabledMode disableContextOrPainting)
 114     : m_canvas(canvas)
 115     , m_paintStateStack()
 116     , m_paintStateIndex(0)
 117     , m_pendingCanvasSave(false)
 118     , m_annotationMode(0)
 119 #if ASSERT_ENABLED
 120     , m_annotationCount(0)
 121     , m_layerCount(0)
 122     , m_disableDestructionChecks(false)
 123 #endif
 124     , m_disabledState(disableContextOrPainting)
 125     , m_trackOpaqueRegion(false)
 126     , m_trackTextRegion(false)
 127     , m_useHighResMarker(false)
 128     , m_updatingControlTints(false)
 129     , m_accelerated(false)
 130     , m_isCertainlyOpaque(true)
 131     , m_printing(false)
 132     , m_antialiasHairlineImages(false)
 133 {
 134     if (!canvas)
 135         m_disabledState |= PaintingDisabled;
 136
 137     // FIXME: Do some tests to determine how many states are typically used, and allocate
 138     // several here.
 139     m_paintStateStack.append(GraphicsContextState::create());
 140     m_paintState = m_paintStateStack.last().get();
 141 }
 142
 143 GraphicsContext::~GraphicsContext()
 144 {
 145 #if ASSERT_ENABLED
 146     if (!m_disableDestructionChecks) {
 147         ASSERT(!m_paintStateIndex);
 148         ASSERT(!m_paintState->saveCount());
 149         ASSERT(!m_annotationCount);
 150         ASSERT(!m_layerCount);
 151         ASSERT(m_recordingStateStack.isEmpty());
 152         ASSERT(m_canvasStateStack.isEmpty());
 153     }
 154 #endif
 155 }
 156
 157 void GraphicsContext::save()
 158 {
 159     if (contextDisabled())
 160         return;
 161
 162     m_paintState->incrementSaveCount();
 163
 164     m_canvasStateStack.append(CanvasSaveState(m_pendingCanvasSave, m_canvas->getSaveCount()));
 165     m_pendingCanvasSave = true;
 166 }
 167
 168 void GraphicsContext::restore()
 169 {
 170     if (contextDisabled())
 171         return;
 172
 173     if (!m_paintStateIndex && !m_paintState->saveCount()) {
 174         WTF_LOG_ERROR("ERROR void GraphicsContext::restore() stack is empty");
 175         return;
 176     }
 177
 178     if (m_paintState->saveCount()) {
 179         m_paintState->decrementSaveCount();
 180     } else {
 181         m_paintStateIndex--;
 182         m_paintState = m_paintStateStack[m_paintStateIndex].get();
 183     }
 184
 185     CanvasSaveState savedState = m_canvasStateStack.last();
 186     m_canvasStateStack.removeLast();
 187     m_pendingCanvasSave = savedState.m_pendingSave;
 188     m_canvas->restoreToCount(savedState.m_restoreCount);
 189 }
 190
 191 void GraphicsContext::saveLayer(const SkRect* bounds, const SkPaint* paint)
 192 {
 193     if (contextDisabled())
 194         return;
 195
 196     realizeCanvasSave();
 197
 198     m_canvas->saveLayer(bounds, paint);
 199     if (m_trackOpaqueRegion)
 200         m_opaqueRegion.pushCanvasLayer(paint);
 201 }
 202
 203 void GraphicsContext::restoreLayer()
 204 {
 205     if (contextDisabled())
 206         return;
 207
 208     m_canvas->restore();
 209     if (m_trackOpaqueRegion)
 210         m_opaqueRegion.popCanvasLayer(this);
 211 }
 212
 213 void GraphicsContext::beginAnnotation(const char* rendererName, const char* paintPhase,
 214     const String& elementId, const String& elementClass, const String& elementTag)
 215 {
 216     if (contextDisabled())
 217         return;
 218
 219     canvas()->beginCommentGroup("GraphicsContextAnnotation");
 220
 221     GraphicsContextAnnotation annotation(rendererName, paintPhase, elementId, elementClass, elementTag);
 222     AnnotationList annotations;
 223     annotation.asAnnotationList(annotations);
 224
 225     AnnotationList::const_iterator end = annotations.end();
 226     for (AnnotationList::const_iterator it = annotations.begin(); it != end; ++it)
 227         canvas()->addComment(it->first, it->second.ascii().data());
 228
 229 #if ASSERT_ENABLED
 230     ++m_annotationCount;
 231 #endif
 232 }
 233
 234 void GraphicsContext::endAnnotation()
 235 {
 236     if (contextDisabled())
 237         return;
 238
 239     canvas()->endCommentGroup();
 240
 241     ASSERT(m_annotationCount > 0);
 242 #if ASSERT_ENABLED
 243     --m_annotationCount;
 244 #endif
 245 }
 246
 247 void GraphicsContext::setStrokePattern(PassRefPtr<Pattern> pattern)
 248 {
 249     if (contextDisabled())
 250         return;
 251
 252     ASSERT(pattern);
 253     if (!pattern) {
 254         setStrokeColor(Color::black);
 255         return;
 256     }
 257     mutableState()->setStrokePattern(pattern);
 258 }
 259
 260 void GraphicsContext::setStrokeGradient(PassRefPtr<Gradient> gradient)
 261 {
 262     if (contextDisabled())
 263         return;
 264
 265     ASSERT(gradient);
 266     if (!gradient) {
 267         setStrokeColor(Color::black);
 268         return;
 269     }
 270     mutableState()->setStrokeGradient(gradient);
 271 }
 272
 273 void GraphicsContext::setFillPattern(PassRefPtr<Pattern> pattern)
 274 {
 275     if (contextDisabled())
 276         return;
 277
 278     ASSERT(pattern);
 279     if (!pattern) {
 280         setFillColor(Color::black);
 281         return;
 282     }
 283
 284     mutableState()->setFillPattern(pattern);
 285 }
 286
 287 void GraphicsContext::setFillGradient(PassRefPtr<Gradient> gradient)
 288 {
 289     if (contextDisabled())
 290         return;
 291
 292     ASSERT(gradient);
 293     if (!gradient) {
 294         setFillColor(Color::black);
 295         return;
 296     }
 297
 298     mutableState()->setFillGradient(gradient);
 299 }
 300
 301 void GraphicsContext::setShadow(const FloatSize& offset, float blur, const Color& color,
 302     DrawLooperBuilder::ShadowTransformMode shadowTransformMode,
 303     DrawLooperBuilder::ShadowAlphaMode shadowAlphaMode)
 304 {
 305     if (contextDisabled())
 306         return;
 307
 308     if (!color.alpha() || (!offset.width() && !offset.height() && !blur)) {
 309         clearShadow();
 310         return;
 311     }
 312
 313     OwnPtr<DrawLooperBuilder> drawLooperBuilder = DrawLooperBuilder::create();
 314     drawLooperBuilder->addShadow(offset, blur, color, shadowTransformMode, shadowAlphaMode);
 315     drawLooperBuilder->addUnmodifiedContent();
 316     setDrawLooper(drawLooperBuilder.release());
 317 }
 318
 319 void GraphicsContext::setDrawLooper(PassOwnPtr<DrawLooperBuilder> drawLooperBuilder)
 320 {
 321     if (contextDisabled())
 322         return;
 323
 324     mutableState()->setDrawLooper(drawLooperBuilder->detachDrawLooper());
 325 }
 326
 327 void GraphicsContext::clearDrawLooper()
 328 {
 329     if (contextDisabled())
 330         return;
 331
 332     mutableState()->clearDrawLooper();
 333 }
 334
 335 bool GraphicsContext::hasShadow() const
 336 {
 337     return !!immutableState()->drawLooper();
 338 }
 339
 340 bool GraphicsContext::getTransformedClipBounds(FloatRect* bounds) const
 341 {
 342     if (contextDisabled())
 343         return false;
 344     SkIRect skIBounds;
 345     if (!m_canvas->getClipDeviceBounds(&skIBounds))
 346         return false;
 347     SkRect skBounds = SkRect::Make(skIBounds);
 348     *bounds = FloatRect(skBounds);
 349     return true;
 350 }
 351
 352 SkMatrix GraphicsContext::getTotalMatrix() const
 353 {
 354     if (contextDisabled())
 355         return SkMatrix::I();
 356
 357     if (!isRecording())
 358         return m_canvas->getTotalMatrix();
 359
 360     const RecordingState& recordingState = m_recordingStateStack.last();
 361     SkMatrix totalMatrix = recordingState.m_savedMatrix;
 362     totalMatrix.preConcat(m_canvas->getTotalMatrix());
 363
 364     return totalMatrix;
 365 }
 366
 367 void GraphicsContext::adjustTextRenderMode(SkPaint* paint)
 368 {
 369     if (contextDisabled())
 370         return;
 371
 372     if (!paint->isLCDRenderText())
 373         return;
 374
 375     paint->setLCDRenderText(couldUseLCDRenderedText());
 376 }
 377
 378 bool GraphicsContext::couldUseLCDRenderedText()
 379 {
 380     // Our layers only have a single alpha channel. This means that subpixel
 381     // rendered text cannot be composited correctly when the layer is
 382     // collapsed. Therefore, subpixel text is contextDisabled when we are drawing
 383     // onto a layer.
 384     if (contextDisabled() || m_canvas->isDrawingToLayer() || !isCertainlyOpaque())
 385         return false;
 386
 387     return shouldSmoothFonts();
 388 }
 389
 390 void GraphicsContext::setCompositeOperation(CompositeOperator compositeOperation, WebBlendMode blendMode)
 391 {
 392     if (contextDisabled())
 393         return;
 394     mutableState()->setCompositeOperation(compositeOperation, blendMode);
 395 }
 396
 397 SkColorFilter* GraphicsContext::colorFilter()
 398 {
 399     return immutableState()->colorFilter();
 400 }
 401
 402 void GraphicsContext::setColorFilter(ColorFilter colorFilter)
 403 {
 404     GraphicsContextState* stateToSet = mutableState();
 405
 406     // We only support one active color filter at the moment. If (when) this becomes a problem,
 407     // we should switch to using color filter chains (Skia work in progress).
 408     ASSERT(!stateToSet->colorFilter());
 409     stateToSet->setColorFilter(WebCoreColorFilterToSkiaColorFilter(colorFilter));
 410 }
 411
 412 bool GraphicsContext::readPixels(const SkImageInfo& info, void* pixels, size_t rowBytes, int x, int y)
 413 {
 414     if (contextDisabled())
 415         return false;
 416
 417     return m_canvas->readPixels(info, pixels, rowBytes, x, y);
 418 }
 419
 420 void GraphicsContext::setMatrix(const SkMatrix& matrix)
 421 {
 422     if (contextDisabled())
 423         return;
 424
 425     realizeCanvasSave();
 426
 427     m_canvas->setMatrix(matrix);
 428 }
 429
 430 void GraphicsContext::concat(const SkMatrix& matrix)
 431 {
 432     if (contextDisabled())
 433         return;
 434
 435     if (matrix.isIdentity())
 436         return;
 437
 438     realizeCanvasSave();
 439
 440     m_canvas->concat(matrix);
 441 }
 442
 443 void GraphicsContext::beginTransparencyLayer(float opacity, const FloatRect* bounds)
 444 {
 445     beginLayer(opacity, immutableState()->compositeOperator(), bounds);
 446 }
 447
 448 void GraphicsContext::beginLayer(float opacity, CompositeOperator op, const FloatRect* bounds, ColorFilter colorFilter, ImageFilter* imageFilter)
 449 {
 450     if (contextDisabled())
 451         return;
 452
 453     SkPaint layerPaint;
 454     layerPaint.setAlpha(static_cast<unsigned char>(opacity * 255));
 455     layerPaint.setXfermode(WebCoreCompositeToSkiaComposite(op, m_paintState->blendMode()).get());
 456     layerPaint.setColorFilter(WebCoreColorFilterToSkiaColorFilter(colorFilter).get());
 457     layerPaint.setImageFilter(imageFilter);
 458
 459     if (bounds) {
 460         SkRect skBounds = WebCoreFloatRectToSKRect(*bounds);
 461         saveLayer(&skBounds, &layerPaint);
 462     } else {
 463         saveLayer(0, &layerPaint);
 464     }
 465
 466 #if ASSERT_ENABLED
 467     ++m_layerCount;
 468 #endif
 469 }
 470
 471 void GraphicsContext::endLayer()
 472 {
 473     if (contextDisabled())
 474         return;
 475
 476     restoreLayer();
 477
 478     ASSERT(m_layerCount > 0);
 479 #if ASSERT_ENABLED
 480     --m_layerCount;
 481 #endif
 482 }
 483
 484 void GraphicsContext::beginRecording(const FloatRect& bounds)
 485 {
 486     RefPtr<DisplayList> displayList = adoptRef(new DisplayList(bounds));
 487
 488     SkCanvas* savedCanvas = m_canvas;
 489     SkMatrix savedMatrix = getTotalMatrix();
 490
 491     if (!contextDisabled()) {
 492         IntRect recordingRect = enclosingIntRect(bounds);
 493         m_canvas = displayList->beginRecording(recordingRect.size());
 494
 495         // We want the bounds offset mapped to (0, 0), such that the display list content
 496         // is fully contained within the SkPictureRecord's bounds.
 497         if (!toFloatSize(bounds.location()).isZero()) {
 498             m_canvas->translate(-bounds.x(), -bounds.y());
 499             // To avoid applying the offset repeatedly in getTotalMatrix(), we pre-apply it here.
 500             savedMatrix.preTranslate(bounds.x(), bounds.y());
 501         }
 502     }
 503
 504     m_recordingStateStack.append(RecordingState(savedCanvas, savedMatrix, displayList));
 505 }
 506
 507 PassRefPtr<DisplayList> GraphicsContext::endRecording()
 508 {
 509     ASSERT(!m_recordingStateStack.isEmpty());
 510
 511     RecordingState recording = m_recordingStateStack.last();
 512     if (!contextDisabled()) {
 513         ASSERT(recording.m_displayList->isRecording());
 514         recording.m_displayList->endRecording();
 515     }
 516
 517     m_recordingStateStack.removeLast();
 518     m_canvas = recording.m_savedCanvas;
 519
 520     return recording.m_displayList.release();
 521 }
 522
 523 bool GraphicsContext::isRecording() const
 524 {
 525     return !m_recordingStateStack.isEmpty();
 526 }
 527
 528 void GraphicsContext::drawDisplayList(DisplayList* displayList)
 529 {
 530     ASSERT(displayList);
 531     ASSERT(!displayList->isRecording());
 532
 533     if (contextDisabled() || displayList->bounds().isEmpty())
 534         return;
 535
 536     realizeCanvasSave();
 537
 538     const FloatRect& bounds = displayList->bounds();
 539     if (bounds.x() || bounds.y())
 540         m_canvas->translate(bounds.x(), bounds.y());
 541
 542     m_canvas->drawPicture(displayList->picture());
 543
 544     if (bounds.x() || bounds.y())
 545         m_canvas->translate(-bounds.x(), -bounds.y());
 546 }
 547
 548 void GraphicsContext::drawConvexPolygon(size_t numPoints, const FloatPoint* points, bool shouldAntialias)
 549 {
 550     if (contextDisabled())
 551         return;
 552
 553     if (numPoints <= 1)
 554         return;
 555
 556     SkPath path;
 557     setPathFromConvexPoints(&path, numPoints, points);
 558
 559     SkPaint paint(immutableState()->fillPaint());
 560     paint.setAntiAlias(shouldAntialias);
 561     drawPath(path, paint);
 562
 563     if (strokeStyle() != NoStroke)
 564         drawPath(path, immutableState()->strokePaint());
 565 }
 566
 567 void GraphicsContext::drawFocusRing(const Path& focusRingPath, int width, int offset, const Color& color)
 568 {
 569     // FIXME: Implement support for offset.
 570     if (contextDisabled())
 571         return;
 572
 573     SkPaint paint;
 574     paint.setAntiAlias(true);
 575     paint.setStyle(SkPaint::kStroke_Style);
 576     paint.setColor(color.rgb());
 577
 578     drawOuterPath(focusRingPath.skPath(), paint, width);
 579     drawInnerPath(focusRingPath.skPath(), paint, width);
 580 }
 581
 582 void GraphicsContext::drawFocusRing(const Vector<IntRect>& rects, int width, int offset, const Color& color)
 583 {
 584     if (contextDisabled())
 585         return;
 586
 587     unsigned rectCount = rects.size();
 588     if (!rectCount)
 589         return;
 590
 591     SkRegion focusRingRegion;
 592     const int focusRingOutset = getFocusRingOutset(offset);
 593     for (unsigned i = 0; i < rectCount; i++) {
 594         SkIRect r = rects[i];
 595         r.inset(-focusRingOutset, -focusRingOutset);
 596         focusRingRegion.op(r, SkRegion::kUnion_Op);
 597     }
 598
 599     SkPath path;
 600     SkPaint paint;
 601     paint.setAntiAlias(true);
 602     paint.setStyle(SkPaint::kStroke_Style);
 603
 604     paint.setColor(color.rgb());
 605     focusRingRegion.getBoundaryPath(&path);
 606     drawOuterPath(path, paint, width);
 607     drawInnerPath(path, paint, width);
 608 }
 609
 610 static inline IntRect areaCastingShadowInHole(const IntRect& holeRect, int shadowBlur, int shadowSpread, const IntSize& shadowOffset)
 611 {
 612     IntRect bounds(holeRect);
 613
 614     bounds.inflate(shadowBlur);
 615
 616     if (shadowSpread < 0)
 617         bounds.inflate(-shadowSpread);
 618
 619     IntRect offsetBounds = bounds;
 620     offsetBounds.move(-shadowOffset);
 621     return unionRect(bounds, offsetBounds);
 622 }
 623
 624 void GraphicsContext::drawInnerShadow(const RoundedRect& rect, const Color& shadowColor, const IntSize shadowOffset, int shadowBlur, int shadowSpread, Edges clippedEdges)
 625 {
 626     if (contextDisabled())
 627         return;
 628
 629     IntRect holeRect(rect.rect());
 630     holeRect.inflate(-shadowSpread);
 631
 632     if (holeRect.isEmpty()) {
 633         if (rect.isRounded())
 634             fillRoundedRect(rect, shadowColor);
 635         else
 636             fillRect(rect.rect(), shadowColor);
 637         return;
 638     }
 639
 640     if (clippedEdges & LeftEdge) {
 641         holeRect.move(-max(shadowOffset.width(), 0) - shadowBlur, 0);
 642         holeRect.setWidth(holeRect.width() + max(shadowOffset.width(), 0) + shadowBlur);
 643     }
 644     if (clippedEdges & TopEdge) {
 645         holeRect.move(0, -max(shadowOffset.height(), 0) - shadowBlur);
 646         holeRect.setHeight(holeRect.height() + max(shadowOffset.height(), 0) + shadowBlur);
 647     }
 648     if (clippedEdges & RightEdge)
 649         holeRect.setWidth(holeRect.width() - min(shadowOffset.width(), 0) + shadowBlur);
 650     if (clippedEdges & BottomEdge)
 651         holeRect.setHeight(holeRect.height() - min(shadowOffset.height(), 0) + shadowBlur);
 652
 653     Color fillColor(shadowColor.red(), shadowColor.green(), shadowColor.blue(), 255);
 654
 655     IntRect outerRect = areaCastingShadowInHole(rect.rect(), shadowBlur, shadowSpread, shadowOffset);
 656     RoundedRect roundedHole(holeRect, rect.radii());
 657
 658     save();
 659     if (rect.isRounded()) {
 660         Path path;
 661         path.addRoundedRect(rect);
 662         clipPath(path);
 663         roundedHole.shrinkRadii(shadowSpread);
 664     } else {
 665         clip(rect.rect());
 666     }
 667
 668     OwnPtr<DrawLooperBuilder> drawLooperBuilder = DrawLooperBuilder::create();
 669     drawLooperBuilder->addShadow(shadowOffset, shadowBlur, shadowColor,
 670         DrawLooperBuilder::ShadowRespectsTransforms, DrawLooperBuilder::ShadowIgnoresAlpha);
 671     setDrawLooper(drawLooperBuilder.release());
 672     fillRectWithRoundedHole(outerRect, roundedHole, fillColor);
 673     restore();
 674     clearDrawLooper();
 675 }
 676
 677 void GraphicsContext::drawLine(const IntPoint& point1, const IntPoint& point2)
 678 {
 679     if (contextDisabled())
 680         return;
 681
 682     StrokeStyle penStyle = strokeStyle();
 683     if (penStyle == NoStroke)
 684         return;
 685
 686     FloatPoint p1 = point1;
 687     FloatPoint p2 = point2;
 688     bool isVerticalLine = (p1.x() == p2.x());
 689     int width = roundf(strokeThickness());
 690
 691     // We know these are vertical or horizontal lines, so the length will just
 692     // be the sum of the displacement component vectors give or take 1 -
 693     // probably worth the speed up of no square root, which also won't be exact.
 694     FloatSize disp = p2 - p1;
 695     int length = SkScalarRoundToInt(disp.width() + disp.height());
 696     SkPaint paint(immutableState()->strokePaint(length));
 697
 698     if (strokeStyle() == DottedStroke || strokeStyle() == DashedStroke) {
 699         // Do a rect fill of our endpoints.  This ensures we always have the
 700         // appearance of being a border.  We then draw the actual dotted/dashed line.
 701         SkRect r1, r2;
 702         r1.set(p1.x(), p1.y(), p1.x() + width, p1.y() + width);
 703         r2.set(p2.x(), p2.y(), p2.x() + width, p2.y() + width);
 704
 705         if (isVerticalLine) {
 706             r1.offset(-width / 2, 0);
 707             r2.offset(-width / 2, -width);
 708         } else {
 709             r1.offset(0, -width / 2);
 710             r2.offset(-width, -width / 2);
 711         }
 712         SkPaint fillPaint;
 713         fillPaint.setColor(paint.getColor());
 714         drawRect(r1, fillPaint);
 715         drawRect(r2, fillPaint);
 716     }
 717
 718     adjustLineToPixelBoundaries(p1, p2, width, penStyle);
 719     SkPoint pts[2] = { p1.data(), p2.data() };
 720
 721     m_canvas->drawPoints(SkCanvas::kLines_PointMode, 2, pts, paint);
 722
 723     if (m_trackOpaqueRegion)
 724         m_opaqueRegion.didDrawPoints(this, SkCanvas::kLines_PointMode, 2, pts, paint);
 725 }
 726
 727 void GraphicsContext::drawLineForDocumentMarker(const FloatPoint& pt, float width, DocumentMarkerLineStyle style)
 728 {
 729     if (contextDisabled())
 730         return;
 731
 732     int deviceScaleFactor = m_useHighResMarker ? 2 : 1;
 733
 734     // Create the pattern we'll use to draw the underline.
 735     int index = style == DocumentMarkerGrammarLineStyle ? 1 : 0;
 736     static SkBitmap* misspellBitmap1x[2] = { 0, 0 };
 737     static SkBitmap* misspellBitmap2x[2] = { 0, 0 };
 738     SkBitmap** misspellBitmap = deviceScaleFactor == 2 ? misspellBitmap2x : misspellBitmap1x;
 739     if (!misspellBitmap[index]) {
 740 #if OS(MACOSX)
 741         // Match the artwork used by the Mac.
 742         const int rowPixels = 4 * deviceScaleFactor;
 743         const int colPixels = 3 * deviceScaleFactor;
 744         SkBitmap bitmap;
 745         if (!bitmap.allocN32Pixels(rowPixels, colPixels))
 746             return;
 747
 748         bitmap.eraseARGB(0, 0, 0, 0);
 749         const uint32_t transparentColor = 0x00000000;
 750
 751         if (deviceScaleFactor == 1) {
 752             const uint32_t colors[2][6] = {
 753                 { 0x2a2a0600, 0x57571000,  0xa8a81b00, 0xbfbf1f00,  0x70701200, 0xe0e02400 },
 754                 { 0x2a0f0f0f, 0x571e1e1e,  0xa83d3d3d, 0xbf454545,  0x70282828, 0xe0515151 }
 755             };
 756
 757             // Pattern: a b a   a b a
 758             //          c d c   c d c
 759             //          e f e   e f e
 760             for (int x = 0; x < colPixels; ++x) {
 761                 uint32_t* row = bitmap.getAddr32(0, x);
 762                 row[0] = colors[index][x * 2];
 763                 row[1] = colors[index][x * 2 + 1];
 764                 row[2] = colors[index][x * 2];
 765                 row[3] = transparentColor;
 766             }
 767         } else if (deviceScaleFactor == 2) {
 768             const uint32_t colors[2][18] = {
 769                 { 0x0a090101, 0x33320806, 0x55540f0a,  0x37360906, 0x6e6c120c, 0x6e6c120c,  0x7674140d, 0x8d8b1810, 0x8d8b1810,
 770                   0x96941a11, 0xb3b01f15, 0xb3b01f15,  0x6d6b130c, 0xd9d62619, 0xd9d62619,  0x19180402, 0x7c7a150e, 0xcecb2418 },
 771                 { 0x0a020202, 0x33141414, 0x55232323,  0x37161616, 0x6e2e2e2e, 0x6e2e2e2e,  0x76313131, 0x8d3a3a3a, 0x8d3a3a3a,
 772                   0x963e3e3e, 0xb34b4b4b, 0xb34b4b4b,  0x6d2d2d2d, 0xd95b5b5b, 0xd95b5b5b,  0x19090909, 0x7c343434, 0xce575757 }
 773             };
 774
 775             // Pattern: a b c c b a
 776             //          d e f f e d
 777             //          g h j j h g
 778             //          k l m m l k
 779             //          n o p p o n
 780             //          q r s s r q
 781             for (int x = 0; x < colPixels; ++x) {
 782                 uint32_t* row = bitmap.getAddr32(0, x);
 783                 row[0] = colors[index][x * 3];
 784                 row[1] = colors[index][x * 3 + 1];
 785                 row[2] = colors[index][x * 3 + 2];
 786                 row[3] = colors[index][x * 3 + 2];
 787                 row[4] = colors[index][x * 3 + 1];
 788                 row[5] = colors[index][x * 3];
 789                 row[6] = transparentColor;
 790                 row[7] = transparentColor;
 791             }
 792         } else
 793             ASSERT_NOT_REACHED();
 794
 795         misspellBitmap[index] = new SkBitmap(bitmap);
 796 #else
 797         // We use a 2-pixel-high misspelling indicator because that seems to be
 798         // what WebKit is designed for, and how much room there is in a typical
 799         // page for it.
 800         const int rowPixels = 32 * deviceScaleFactor; // Must be multiple of 4 for pattern below.
 801         const int colPixels = 2 * deviceScaleFactor;
 802         SkBitmap bitmap;
 803         if (!bitmap.allocN32Pixels(rowPixels, colPixels))
 804             return;
 805
 806         bitmap.eraseARGB(0, 0, 0, 0);
 807         if (deviceScaleFactor == 1)
 808             draw1xMarker(&bitmap, index);
 809         else if (deviceScaleFactor == 2)
 810             draw2xMarker(&bitmap, index);
 811         else
 812             ASSERT_NOT_REACHED();
 813
 814         misspellBitmap[index] = new SkBitmap(bitmap);
 815 #endif
 816     }
 817
 818 #if OS(MACOSX)
 819     SkScalar originX = WebCoreFloatToSkScalar(pt.x()) * deviceScaleFactor;
 820     SkScalar originY = WebCoreFloatToSkScalar(pt.y()) * deviceScaleFactor;
 821
 822     // Make sure to draw only complete dots.
 823     int rowPixels = misspellBitmap[index]->width();
 824     float widthMod = fmodf(width * deviceScaleFactor, rowPixels);
 825     if (rowPixels - widthMod > deviceScaleFactor)
 826         width -= widthMod / deviceScaleFactor;
 827 #else
 828     SkScalar originX = WebCoreFloatToSkScalar(pt.x());
 829
 830     // Offset it vertically by 1 so that there's some space under the text.
 831     SkScalar originY = WebCoreFloatToSkScalar(pt.y()) + 1;
 832     originX *= deviceScaleFactor;
 833     originY *= deviceScaleFactor;
 834 #endif
 835
 836     SkMatrix localMatrix;
 837     localMatrix.setTranslate(originX, originY);
 838     RefPtr<SkShader> shader = adoptRef(SkShader::CreateBitmapShader(
 839         *misspellBitmap[index], SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode, &localMatrix));
 840
 841     SkPaint paint;
 842     paint.setShader(shader.get());
 843
 844     SkRect rect;
 845     rect.set(originX, originY, originX + WebCoreFloatToSkScalar(width) * deviceScaleFactor, originY + SkIntToScalar(misspellBitmap[index]->height()));
 846
 847     if (deviceScaleFactor == 2) {
 848         save();
 849         scale(0.5, 0.5);
 850     }
 851     drawRect(rect, paint);
 852     if (deviceScaleFactor == 2)
 853         restore();
 854 }
 855
 856 void GraphicsContext::drawLineForText(const FloatPoint& pt, float width, bool printing)
 857 {
 858     if (contextDisabled())
 859         return;
 860
 861     if (width <= 0)
 862         return;
 863
 864     SkPaint paint;
 865     switch (strokeStyle()) {
 866     case NoStroke:
 867     case SolidStroke:
 868     case DoubleStroke:
 869     case WavyStroke: {
 870         int thickness = SkMax32(static_cast<int>(strokeThickness()), 1);
 871         SkRect r;
 872         r.fLeft = WebCoreFloatToSkScalar(pt.x());
 873         // Avoid anti-aliasing lines. Currently, these are always horizontal.
 874         // Round to nearest pixel to match text and other content.
 875         r.fTop = WebCoreFloatToSkScalar(floorf(pt.y() + 0.5f));
 876         r.fRight = r.fLeft + WebCoreFloatToSkScalar(width);
 877         r.fBottom = r.fTop + SkIntToScalar(thickness);
 878         paint = immutableState()->fillPaint();
 879         // Text lines are drawn using the stroke color.
 880         paint.setColor(effectiveStrokeColor());
 881         drawRect(r, paint);
 882         return;
 883     }
 884     case DottedStroke:
 885     case DashedStroke: {
 886         int y = floorf(pt.y() + std::max<float>(strokeThickness() / 2.0f, 0.5f));
 887         drawLine(IntPoint(pt.x(), y), IntPoint(pt.x() + width, y));
 888         return;
 889     }
 890     }
 891
 892     ASSERT_NOT_REACHED();
 893 }
 894
 895 // Draws a filled rectangle with a stroked border.
 896 void GraphicsContext::drawRect(const IntRect& rect)
 897 {
 898     if (contextDisabled())
 899         return;
 900
 901     ASSERT(!rect.isEmpty());
 902     if (rect.isEmpty())
 903         return;
 904
 905     SkRect skRect = rect;
 906     int fillcolorNotTransparent = immutableState()->fillColor().rgb() & 0xFF000000;
 907     if (fillcolorNotTransparent)
 908         drawRect(skRect, immutableState()->fillPaint());
 909
 910     if (immutableState()->strokeData().style() != NoStroke
 911         && immutableState()->strokeData().color().alpha()) {
 912         // Stroke a width: 1 inset border
 913         SkPaint paint(immutableState()->fillPaint());
 914         paint.setColor(effectiveStrokeColor());
 915         paint.setStyle(SkPaint::kStroke_Style);
 916         paint.setStrokeWidth(1);
 917
 918         skRect.inset(0.5f, 0.5f);
 919         drawRect(skRect, paint);
 920     }
 921 }
 922
 923 void GraphicsContext::drawText(const Font& font, const TextRunPaintInfo& runInfo, const FloatPoint& point)
 924 {
 925     if (contextDisabled())
 926         return;
 927
 928     font.drawText(this, runInfo, point);
 929 }
 930
 931 void GraphicsContext::drawEmphasisMarks(const Font& font, const TextRunPaintInfo& runInfo, const AtomicString& mark, const FloatPoint& point)
 932 {
 933     if (contextDisabled())
 934         return;
 935
 936     font.drawEmphasisMarks(this, runInfo, mark, point);
 937 }
 938
 939 void GraphicsContext::drawBidiText(const Font& font, const TextRunPaintInfo& runInfo, const FloatPoint& point, Font::CustomFontNotReadyAction customFontNotReadyAction)
 940 {
 941     if (contextDisabled())
 942         return;
 943
 944     // sub-run painting is not supported for Bidi text.
 945     const TextRun& run = runInfo.run;
 946     ASSERT((runInfo.from == 0) && (runInfo.to == run.length()));
 947     BidiResolver<TextRunIterator, BidiCharacterRun> bidiResolver;
 948     bidiResolver.setStatus(BidiStatus(run.direction(), run.directionalOverride()));
 949     bidiResolver.setPositionIgnoringNestedIsolates(TextRunIterator(&run, 0));
 950
 951     // FIXME: This ownership should be reversed. We should pass BidiRunList
 952     // to BidiResolver in createBidiRunsForLine.
 953     BidiRunList<BidiCharacterRun>& bidiRuns = bidiResolver.runs();
 954     bidiResolver.createBidiRunsForLine(TextRunIterator(&run, run.length()));
 955     if (!bidiRuns.runCount())
 956         return;
 957
 958     FloatPoint currPoint = point;
 959     BidiCharacterRun* bidiRun = bidiRuns.firstRun();
 960     while (bidiRun) {
 961         TextRun subrun = run.subRun(bidiRun->start(), bidiRun->stop() - bidiRun->start());
 962         bool isRTL = bidiRun->level() % 2;
 963         subrun.setDirection(isRTL ? RTL : LTR);
 964         subrun.setDirectionalOverride(bidiRun->dirOverride(false));
 965
 966         TextRunPaintInfo subrunInfo(subrun);
 967         subrunInfo.bounds = runInfo.bounds;
 968         font.drawText(this, subrunInfo, currPoint, customFontNotReadyAction);
 969
 970         bidiRun = bidiRun->next();
 971         // FIXME: Have Font::drawText return the width of what it drew so that we don't have to re-measure here.
 972         if (bidiRun)
 973             currPoint.move(font.width(subrun), 0);
 974     }
 975
 976     bidiRuns.deleteRuns();
 977 }
 978
 979 void GraphicsContext::drawHighlightForText(const Font& font, const TextRun& run, const FloatPoint& point, int h, const Color& backgroundColor, int from, int to)
 980 {
 981     if (contextDisabled())
 982         return;
 983
 984     fillRect(font.selectionRectForText(run, point, h, from, to), backgroundColor);
 985 }
 986
 987 void GraphicsContext::drawImage(Image* image, const IntPoint& p, CompositeOperator op, RespectImageOrientationEnum shouldRespectImageOrientation)
 988 {
 989     if (!image)
 990         return;
 991     drawImage(image, FloatRect(IntRect(p, image->size())), FloatRect(FloatPoint(), FloatSize(image->size())), op, shouldRespectImageOrientation);
 992 }
 993
 994 void GraphicsContext::drawImage(Image* image, const IntRect& r, CompositeOperator op, RespectImageOrientationEnum shouldRespectImageOrientation)
 995 {
 996     if (!image)
 997         return;
 998     drawImage(image, FloatRect(r), FloatRect(FloatPoint(), FloatSize(image->size())), op, shouldRespectImageOrientation);
 999 }
1000
1001 void GraphicsContext::drawImage(Image* image, const FloatRect& dest, const FloatRect& src, CompositeOperator op, RespectImageOrientationEnum shouldRespectImageOrientation)
1002 {
1003     drawImage(image, dest, src, op, blink::WebBlendModeNormal, shouldRespectImageOrientation);
1004 }
1005
1006 void GraphicsContext::drawImage(Image* image, const FloatRect& dest)
1007 {
1008     if (!image)
1009         return;
1010     drawImage(image, dest, FloatRect(IntRect(IntPoint(), image->size())));
1011 }
1012
1013 void GraphicsContext::drawImage(Image* image, const FloatRect& dest, const FloatRect& src, CompositeOperator op, WebBlendMode blendMode, RespectImageOrientationEnum shouldRespectImageOrientation)
1014 {
1015     if (contextDisabled() || !image)
1016         return;
1017     image->draw(this, dest, src, op, blendMode, shouldRespectImageOrientation);
1018 }
1019
1020 void GraphicsContext::drawTiledImage(Image* image, const IntRect& destRect, const IntPoint& srcPoint, const IntSize& tileSize, CompositeOperator op, WebBlendMode blendMode, const IntSize& repeatSpacing)
1021 {
1022     if (contextDisabled() || !image)
1023         return;
1024     image->drawTiled(this, destRect, srcPoint, tileSize, op, blendMode, repeatSpacing);
1025 }
1026
1027 void GraphicsContext::drawTiledImage(Image* image, const IntRect& dest, const IntRect& srcRect,
1028     const FloatSize& tileScaleFactor, Image::TileRule hRule, Image::TileRule vRule, CompositeOperator op)
1029 {
1030     if (contextDisabled() || !image)
1031         return;
1032
1033     if (hRule == Image::StretchTile && vRule == Image::StretchTile) {
1034         // Just do a scale.
1035         drawImage(image, dest, srcRect, op);
1036         return;
1037     }
1038
1039     image->drawTiled(this, dest, srcRect, tileScaleFactor, hRule, vRule, op);
1040 }
1041
1042 void GraphicsContext::drawImageBuffer(ImageBuffer* image, const FloatRect& dest,
1043     const FloatRect* src, CompositeOperator op)
1044 {
1045     if (contextDisabled() || !image)
1046         return;
1047
1048     image->draw(this, dest, src, op);
1049 }
1050
1051 void GraphicsContext::writePixels(const SkImageInfo& info, const void* pixels, size_t rowBytes, int x, int y)
1052 {
1053     if (contextDisabled())
1054         return;
1055
1056     m_canvas->writePixels(info, pixels, rowBytes, x, y);
1057
1058     if (m_trackOpaqueRegion) {
1059         SkRect rect = SkRect::MakeXYWH(x, y, info.width(), info.height());
1060         SkPaint paint;
1061
1062         paint.setXfermodeMode(SkXfermode::kSrc_Mode);
1063         if (kOpaque_SkAlphaType != info.alphaType())
1064             paint.setAlpha(0x80); // signal to m_opaqueRegion that we are not fully opaque
1065
1066         m_opaqueRegion.didDrawRect(this, rect, paint, 0);
1067         // more efficient would be to call markRectAsOpaque or MarkRectAsNonOpaque directly,
1068         // rather than cons-ing up a paint with an xfermode and alpha
1069     }
1070 }
1071
1072 void GraphicsContext::writePixels(const SkBitmap& bitmap, int x, int y)
1073 {
1074     if (contextDisabled())
1075         return;
1076
1077     if (!bitmap.getTexture()) {
1078         SkAutoLockPixels alp(bitmap);
1079         if (bitmap.getPixels())
1080             writePixels(bitmap.info(), bitmap.getPixels(), bitmap.rowBytes(), x, y);
1081     }
1082 }
1083
1084 void GraphicsContext::drawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar top, const SkPaint* paint)
1085 {
1086     if (contextDisabled())
1087         return;
1088
1089     m_canvas->drawBitmap(bitmap, left, top, paint);
1090
1091     if (m_trackOpaqueRegion) {
1092         SkRect rect = SkRect::MakeXYWH(left, top, bitmap.width(), bitmap.height());
1093         m_opaqueRegion.didDrawRect(this, rect, *paint, &bitmap);
1094     }
1095 }
1096
1097 void GraphicsContext::drawBitmapRect(const SkBitmap& bitmap, const SkRect* src,
1098     const SkRect& dst, const SkPaint* paint)
1099 {
1100     if (contextDisabled())
1101         return;
1102
1103     SkCanvas::DrawBitmapRectFlags flags =
1104         immutableState()->shouldClampToSourceRect() ? SkCanvas::kNone_DrawBitmapRectFlag : SkCanvas::kBleed_DrawBitmapRectFlag;
1105
1106     m_canvas->drawBitmapRectToRect(bitmap, src, dst, paint, flags);
1107
1108     if (m_trackOpaqueRegion)
1109         m_opaqueRegion.didDrawRect(this, dst, *paint, &bitmap);
1110 }
1111
1112 void GraphicsContext::drawOval(const SkRect& oval, const SkPaint& paint)
1113 {
1114     if (contextDisabled())
1115         return;
1116
1117     m_canvas->drawOval(oval, paint);
1118
1119     if (m_trackOpaqueRegion)
1120         m_opaqueRegion.didDrawBounded(this, oval, paint);
1121 }
1122
1123 void GraphicsContext::drawPath(const SkPath& path, const SkPaint& paint)
1124 {
1125     if (contextDisabled())
1126         return;
1127
1128     m_canvas->drawPath(path, paint);
1129
1130     if (m_trackOpaqueRegion)
1131         m_opaqueRegion.didDrawPath(this, path, paint);
1132 }
1133
1134 void GraphicsContext::drawRect(const SkRect& rect, const SkPaint& paint)
1135 {
1136     if (contextDisabled())
1137         return;
1138
1139     m_canvas->drawRect(rect, paint);
1140
1141     if (m_trackOpaqueRegion)
1142         m_opaqueRegion.didDrawRect(this, rect, paint, 0);
1143 }
1144
1145 void GraphicsContext::didDrawRect(const SkRect& rect, const SkPaint& paint, const SkBitmap* bitmap)
1146 {
1147     if (contextDisabled())
1148         return;
1149
1150     if (m_trackOpaqueRegion)
1151         m_opaqueRegion.didDrawRect(this, rect, paint, bitmap);
1152 }
1153
1154 void GraphicsContext::drawPosText(const void* text, size_t byteLength,
1155     const SkPoint pos[],  const SkRect& textRect, const SkPaint& paint)
1156 {
1157     if (contextDisabled())
1158         return;
1159
1160     m_canvas->drawPosText(text, byteLength, pos, paint);
1161     didDrawTextInRect(textRect);
1162
1163     // FIXME: compute bounds for positioned text.
1164     if (m_trackOpaqueRegion)
1165         m_opaqueRegion.didDrawUnbounded(this, paint, OpaqueRegionSkia::FillOrStroke);
1166 }
1167
1168 void GraphicsContext::fillPath(const Path& pathToFill)
1169 {
1170     if (contextDisabled() || pathToFill.isEmpty())
1171         return;
1172
1173     // Use const_cast and temporarily modify the fill type instead of copying the path.
1174     SkPath& path = const_cast<SkPath&>(pathToFill.skPath());
1175     SkPath::FillType previousFillType = path.getFillType();
1176
1177     SkPath::FillType temporaryFillType =
1178         immutableState()->fillRule() == RULE_EVENODD ? SkPath::kEvenOdd_FillType : SkPath::kWinding_FillType;
1179     path.setFillType(temporaryFillType);
1180
1181     drawPath(path, immutableState()->fillPaint());
1182
1183     path.setFillType(previousFillType);
1184 }
1185
1186 void GraphicsContext::fillRect(const FloatRect& rect)
1187 {
1188     if (contextDisabled())
1189         return;
1190
1191     SkRect r = rect;
1192
1193     drawRect(r, immutableState()->fillPaint());
1194 }
1195
1196 void GraphicsContext::fillRect(const FloatRect& rect, const Color& color)
1197 {
1198     if (contextDisabled())
1199         return;
1200
1201     SkRect r = rect;
1202     SkPaint paint = immutableState()->fillPaint();
1203     paint.setColor(color.rgb());
1204     drawRect(r, paint);
1205 }
1206
1207 void GraphicsContext::fillBetweenRoundedRects(const IntRect& outer, const IntSize& outerTopLeft, const IntSize& outerTopRight, const IntSize& outerBottomLeft, const IntSize& outerBottomRight,
1208     const IntRect& inner, const IntSize& innerTopLeft, const IntSize& innerTopRight, const IntSize& innerBottomLeft, const IntSize& innerBottomRight, const Color& color) {
1209     if (contextDisabled())
1210         return;
1211
1212     SkVector outerRadii[4];
1213     SkVector innerRadii[4];
1214     setRadii(outerRadii, outerTopLeft, outerTopRight, outerBottomRight, outerBottomLeft);
1215     setRadii(innerRadii, innerTopLeft, innerTopRight, innerBottomRight, innerBottomLeft);
1216
1217     SkRRect rrOuter;
1218     SkRRect rrInner;
1219     rrOuter.setRectRadii(outer, outerRadii);
1220     rrInner.setRectRadii(inner, innerRadii);
1221
1222     SkPaint paint(immutableState()->fillPaint());
1223     paint.setColor(color.rgb());
1224
1225     m_canvas->drawDRRect(rrOuter, rrInner, paint);
1226
1227     if (m_trackOpaqueRegion)
1228         m_opaqueRegion.didDrawBounded(this, rrOuter.getBounds(), paint);
1229 }
1230
1231 void GraphicsContext::fillBetweenRoundedRects(const RoundedRect& outer, const RoundedRect& inner, const Color& color)
1232 {
1233     fillBetweenRoundedRects(outer.rect(), outer.radii().topLeft(), outer.radii().topRight(), outer.radii().bottomLeft(), outer.radii().bottomRight(),
1234         inner.rect(), inner.radii().topLeft(), inner.radii().topRight(), inner.radii().bottomLeft(), inner.radii().bottomRight(), color);
1235 }
1236
1237 void GraphicsContext::fillRoundedRect(const IntRect& rect, const IntSize& topLeft, const IntSize& topRight,
1238     const IntSize& bottomLeft, const IntSize& bottomRight, const Color& color)
1239 {
1240     if (contextDisabled())
1241         return;
1242
1243     if (topLeft.width() + topRight.width() > rect.width()
1244             || bottomLeft.width() + bottomRight.width() > rect.width()
1245             || topLeft.height() + bottomLeft.height() > rect.height()
1246             || topRight.height() + bottomRight.height() > rect.height()) {
1247         // Not all the radii fit, return a rect. This matches the behavior of
1248         // Path::createRoundedRectangle. Without this we attempt to draw a round
1249         // shadow for a square box.
1250         fillRect(rect, color);
1251         return;
1252     }
1253
1254     SkVector radii[4];
1255     setRadii(radii, topLeft, topRight, bottomRight, bottomLeft);
1256
1257     SkRRect rr;
1258     rr.setRectRadii(rect, radii);
1259
1260     SkPaint paint(immutableState()->fillPaint());
1261     paint.setColor(color.rgb());
1262
1263     m_canvas->drawRRect(rr, paint);
1264
1265     if (m_trackOpaqueRegion)
1266         m_opaqueRegion.didDrawBounded(this, rr.getBounds(), paint);
1267 }
1268
1269 void GraphicsContext::fillEllipse(const FloatRect& ellipse)
1270 {
1271     if (contextDisabled())
1272         return;
1273
1274     SkRect rect = ellipse;
1275     drawOval(rect, immutableState()->fillPaint());
1276 }
1277
1278 void GraphicsContext::strokePath(const Path& pathToStroke)
1279 {
1280     if (contextDisabled() || pathToStroke.isEmpty())
1281         return;
1282
1283     const SkPath& path = pathToStroke.skPath();
1284     drawPath(path, immutableState()->strokePaint());
1285 }
1286
1287 void GraphicsContext::strokeRect(const FloatRect& rect)
1288 {
1289     strokeRect(rect, strokeThickness());
1290 }
1291
1292 void GraphicsContext::strokeRect(const FloatRect& rect, float lineWidth)
1293 {
1294     if (contextDisabled())
1295         return;
1296
1297     SkPaint paint(immutableState()->strokePaint());
1298     paint.setStrokeWidth(WebCoreFloatToSkScalar(lineWidth));
1299     // Reset the dash effect to account for the width
1300     immutableState()->strokeData().setupPaintDashPathEffect(&paint, 0);
1301     // strokerect has special rules for CSS when the rect is degenerate:
1302     // if width==0 && height==0, do nothing
1303     // if width==0 || height==0, then just draw line for the other dimension
1304     SkRect r(rect);
1305     bool validW = r.width() > 0;
1306     bool validH = r.height() > 0;
1307     if (validW && validH) {
1308         drawRect(r, paint);
1309     } else if (validW || validH) {
1310         // we are expected to respect the lineJoin, so we can't just call
1311         // drawLine -- we have to create a path that doubles back on itself.
1312         SkPath path;
1313         path.moveTo(r.fLeft, r.fTop);
1314         path.lineTo(r.fRight, r.fBottom);
1315         path.close();
1316         drawPath(path, paint);
1317     }
1318 }
1319
1320 void GraphicsContext::strokeEllipse(const FloatRect& ellipse)
1321 {
1322     if (contextDisabled())
1323         return;
1324
1325     drawOval(ellipse, immutableState()->strokePaint());
1326 }
1327
1328 void GraphicsContext::clipRoundedRect(const RoundedRect& rect, SkRegion::Op regionOp)
1329 {
1330     if (contextDisabled())
1331         return;
1332
1333     if (!rect.isRounded()) {
1334         clipRect(rect.rect(), NotAntiAliased, regionOp);
1335         return;
1336     }
1337
1338     SkVector radii[4];
1339     RoundedRect::Radii wkRadii = rect.radii();
1340     setRadii(radii, wkRadii.topLeft(), wkRadii.topRight(), wkRadii.bottomRight(), wkRadii.bottomLeft());
1341
1342     SkRRect r;
1343     r.setRectRadii(rect.rect(), radii);
1344
1345     clipRRect(r, AntiAliased, regionOp);
1346 }
1347
1348 void GraphicsContext::clipOut(const Path& pathToClip)
1349 {
1350     if (contextDisabled())
1351         return;
1352
1353     // Use const_cast and temporarily toggle the inverse fill type instead of copying the path.
1354     SkPath& path = const_cast<SkPath&>(pathToClip.skPath());
1355     path.toggleInverseFillType();
1356     clipPath(path, AntiAliased);
1357     path.toggleInverseFillType();
1358 }
1359
1360 void GraphicsContext::clipPath(const Path& pathToClip, WindRule clipRule)
1361 {
1362     if (contextDisabled() || pathToClip.isEmpty())
1363         return;
1364
1365     // Use const_cast and temporarily modify the fill type instead of copying the path.
1366     SkPath& path = const_cast<SkPath&>(pathToClip.skPath());
1367     SkPath::FillType previousFillType = path.getFillType();
1368
1369     SkPath::FillType temporaryFillType = clipRule == RULE_EVENODD ? SkPath::kEvenOdd_FillType : SkPath::kWinding_FillType;
1370     path.setFillType(temporaryFillType);
1371     clipPath(path, AntiAliased);
1372
1373     path.setFillType(previousFillType);
1374 }
1375
1376 void GraphicsContext::clipConvexPolygon(size_t numPoints, const FloatPoint* points, bool antialiased)
1377 {
1378     if (contextDisabled())
1379         return;
1380
1381     if (numPoints <= 1)
1382         return;
1383
1384     SkPath path;
1385     setPathFromConvexPoints(&path, numPoints, points);
1386     clipPath(path, antialiased ? AntiAliased : NotAntiAliased);
1387 }
1388
1389 void GraphicsContext::clipOutRoundedRect(const RoundedRect& rect)
1390 {
1391     if (contextDisabled())
1392         return;
1393
1394     clipRoundedRect(rect, SkRegion::kDifference_Op);
1395 }
1396
1397 void GraphicsContext::canvasClip(const Path& pathToClip, WindRule clipRule)
1398 {
1399     if (contextDisabled())
1400         return;
1401
1402     // Use const_cast and temporarily modify the fill type instead of copying the path.
1403     SkPath& path = const_cast<SkPath&>(pathToClip.skPath());
1404     SkPath::FillType previousFillType = path.getFillType();
1405
1406     SkPath::FillType temporaryFillType = clipRule == RULE_EVENODD ? SkPath::kEvenOdd_FillType : SkPath::kWinding_FillType;
1407     path.setFillType(temporaryFillType);
1408     clipPath(path);
1409
1410     path.setFillType(previousFillType);
1411 }
1412
1413 void GraphicsContext::clipRect(const SkRect& rect, AntiAliasingMode aa, SkRegion::Op op)
1414 {
1415     if (contextDisabled())
1416         return;
1417
1418     realizeCanvasSave();
1419
1420     m_canvas->clipRect(rect, op, aa == AntiAliased);
1421 }
1422
1423 void GraphicsContext::clipPath(const SkPath& path, AntiAliasingMode aa, SkRegion::Op op)
1424 {
1425     if (contextDisabled())
1426         return;
1427
1428     realizeCanvasSave();
1429
1430     m_canvas->clipPath(path, op, aa == AntiAliased);
1431 }
1432
1433 void GraphicsContext::clipRRect(const SkRRect& rect, AntiAliasingMode aa, SkRegion::Op op)
1434 {
1435     if (contextDisabled())
1436         return;
1437
1438     realizeCanvasSave();
1439
1440     m_canvas->clipRRect(rect, op, aa == AntiAliased);
1441 }
1442
1443 void GraphicsContext::beginCull(const FloatRect& rect)
1444 {
1445     if (contextDisabled())
1446         return;
1447
1448     realizeCanvasSave();
1449     m_canvas->pushCull(rect);
1450 }
1451
1452 void GraphicsContext::endCull()
1453 {
1454     if (contextDisabled())
1455         return;
1456
1457     realizeCanvasSave();
1458
1459     m_canvas->popCull();
1460 }
1461
1462 void GraphicsContext::rotate(float angleInRadians)
1463 {
1464     if (contextDisabled())
1465         return;
1466
1467     realizeCanvasSave();
1468
1469     m_canvas->rotate(WebCoreFloatToSkScalar(angleInRadians * (180.0f / 3.14159265f)));
1470 }
1471
1472 void GraphicsContext::translate(float x, float y)
1473 {
1474     if (contextDisabled())
1475         return;
1476
1477     if (!x && !y)
1478         return;
1479
1480     realizeCanvasSave();
1481
1482     m_canvas->translate(WebCoreFloatToSkScalar(x), WebCoreFloatToSkScalar(y));
1483 }
1484
1485 void GraphicsContext::scale(float x, float y)
1486 {
1487     if (contextDisabled())
1488         return;
1489
1490     if (x == 1.0f && y == 1.0f)
1491         return;
1492
1493     realizeCanvasSave();
1494
1495     m_canvas->scale(WebCoreFloatToSkScalar(x), WebCoreFloatToSkScalar(y));
1496 }
1497
1498 void GraphicsContext::setURLForRect(const KURL& link, const IntRect& destRect)
1499 {
1500     if (contextDisabled())
1501         return;
1502
1503     SkAutoDataUnref url(SkData::NewWithCString(link.string().utf8().data()));
1504     SkAnnotateRectWithURL(m_canvas, destRect, url.get());
1505 }
1506
1507 void GraphicsContext::setURLFragmentForRect(const String& destName, const IntRect& rect)
1508 {
1509     if (contextDisabled())
1510         return;
1511
1512     SkAutoDataUnref skDestName(SkData::NewWithCString(destName.utf8().data()));
1513     SkAnnotateLinkToDestination(m_canvas, rect, skDestName.get());
1514 }
1515
1516 void GraphicsContext::addURLTargetAtPoint(const String& name, const IntPoint& pos)
1517 {
1518     if (contextDisabled())
1519         return;
1520
1521     SkAutoDataUnref nameData(SkData::NewWithCString(name.utf8().data()));
1522     SkAnnotateNamedDestination(m_canvas, SkPoint::Make(pos.x(), pos.y()), nameData);
1523 }
1524
1525 AffineTransform GraphicsContext::getCTM() const
1526 {
1527     if (contextDisabled())
1528         return AffineTransform();
1529
1530     SkMatrix m = getTotalMatrix();
1531     return AffineTransform(SkScalarToDouble(m.getScaleX()),
1532                            SkScalarToDouble(m.getSkewY()),
1533                            SkScalarToDouble(m.getSkewX()),
1534                            SkScalarToDouble(m.getScaleY()),
1535                            SkScalarToDouble(m.getTranslateX()),
1536                            SkScalarToDouble(m.getTranslateY()));
1537 }
1538
1539 void GraphicsContext::fillRect(const FloatRect& rect, const Color& color, CompositeOperator op)
1540 {
1541     if (contextDisabled())
1542         return;
1543
1544     CompositeOperator previousOperator = compositeOperation();
1545     setCompositeOperation(op);
1546     fillRect(rect, color);
1547     setCompositeOperation(previousOperator);
1548 }
1549
1550 void GraphicsContext::fillRoundedRect(const RoundedRect& rect, const Color& color)
1551 {
1552     if (contextDisabled())
1553         return;
1554
1555     if (rect.isRounded())
1556         fillRoundedRect(rect.rect(), rect.radii().topLeft(), rect.radii().topRight(), rect.radii().bottomLeft(), rect.radii().bottomRight(), color);
1557     else
1558         fillRect(rect.rect(), color);
1559 }
1560
1561 void GraphicsContext::fillRectWithRoundedHole(const IntRect& rect, const RoundedRect& roundedHoleRect, const Color& color)
1562 {
1563     if (contextDisabled())
1564         return;
1565
1566     Path path;
1567     path.addRect(rect);
1568
1569     if (!roundedHoleRect.radii().isZero())
1570         path.addRoundedRect(roundedHoleRect);
1571     else
1572         path.addRect(roundedHoleRect.rect());
1573
1574     WindRule oldFillRule = fillRule();
1575     Color oldFillColor = fillColor();
1576
1577     setFillRule(RULE_EVENODD);
1578     setFillColor(color);
1579
1580     fillPath(path);
1581
1582     setFillRule(oldFillRule);
1583     setFillColor(oldFillColor);
1584 }
1585
1586 void GraphicsContext::clearRect(const FloatRect& rect)
1587 {
1588     if (contextDisabled())
1589         return;
1590
1591     SkRect r = rect;
1592     SkPaint paint(immutableState()->fillPaint());
1593     paint.setXfermodeMode(SkXfermode::kClear_Mode);
1594     drawRect(r, paint);
1595 }
1596
1597 void GraphicsContext::adjustLineToPixelBoundaries(FloatPoint& p1, FloatPoint& p2, float strokeWidth, StrokeStyle penStyle)
1598 {
1599     // For odd widths, we add in 0.5 to the appropriate x/y so that the float arithmetic
1600     // works out.  For example, with a border width of 3, WebKit will pass us (y1+y2)/2, e.g.,
1601     // (50+53)/2 = 103/2 = 51 when we want 51.5.  It is always true that an even width gave
1602     // us a perfect position, but an odd width gave us a position that is off by exactly 0.5.
1603     if (penStyle == DottedStroke || penStyle == DashedStroke) {
1604         if (p1.x() == p2.x()) {
1605             p1.setY(p1.y() + strokeWidth);
1606             p2.setY(p2.y() - strokeWidth);
1607         } else {
1608             p1.setX(p1.x() + strokeWidth);
1609             p2.setX(p2.x() - strokeWidth);
1610         }
1611     }
1612
1613     if (static_cast<int>(strokeWidth) % 2) { //odd
1614         if (p1.x() == p2.x()) {
1615             // We're a vertical line.  Adjust our x.
1616             p1.setX(p1.x() + 0.5f);
1617             p2.setX(p2.x() + 0.5f);
1618         } else {
1619             // We're a horizontal line. Adjust our y.
1620             p1.setY(p1.y() + 0.5f);
1621             p2.setY(p2.y() + 0.5f);
1622         }
1623     }
1624 }
1625
1626 PassOwnPtr<ImageBuffer> GraphicsContext::createCompatibleBuffer(const IntSize& size, OpacityMode opacityMode) const
1627 {
1628     // Make the buffer larger if the context's transform is scaling it so we need a higher
1629     // resolution than one pixel per unit. Also set up a corresponding scale factor on the
1630     // graphics context.
1631
1632     AffineTransform transform = getCTM();
1633     IntSize scaledSize(static_cast<int>(ceil(size.width() * transform.xScale())), static_cast<int>(ceil(size.height() * transform.yScale())));
1634
1635     SkAlphaType alphaType = (opacityMode == Opaque) ? kOpaque_SkAlphaType : kPremul_SkAlphaType;
1636     SkImageInfo info = SkImageInfo::MakeN32(size.width(), size.height(), alphaType);
1637     RefPtr<SkSurface> skSurface = adoptRef(m_canvas->newSurface(info));
1638     if (!skSurface)
1639         return nullptr;
1640     OwnPtr<ImageBufferSurface> surface = adoptPtr(new CompatibleImageBufferSurface(skSurface.release(), scaledSize, opacityMode));
1641     ASSERT(surface->isValid());
1642     OwnPtr<ImageBuffer> buffer = adoptPtr(new ImageBuffer(surface.release()));
1643
1644     buffer->context()->scale(static_cast<float>(scaledSize.width()) / size.width(),
1645         static_cast<float>(scaledSize.height()) / size.height());
1646
1647     return buffer.release();
1648 }
1649
1650 void GraphicsContext::setPathFromConvexPoints(SkPath* path, size_t numPoints, const FloatPoint* points)
1651 {
1652     path->incReserve(numPoints);
1653     path->moveTo(WebCoreFloatToSkScalar(points[0].x()),
1654                  WebCoreFloatToSkScalar(points[0].y()));
1655     for (size_t i = 1; i < numPoints; ++i) {
1656         path->lineTo(WebCoreFloatToSkScalar(points[i].x()),
1657                      WebCoreFloatToSkScalar(points[i].y()));
1658     }
1659
1660     /*  The code used to just blindly call this
1661             path->setIsConvex(true);
1662         But webkit can sometimes send us non-convex 4-point values, so we mark the path's
1663         convexity as unknown, so it will get computed by skia at draw time.
1664         See crbug.com 108605
1665     */
1666     SkPath::Convexity convexity = SkPath::kConvex_Convexity;
1667     if (numPoints == 4)
1668         convexity = SkPath::kUnknown_Convexity;
1669     path->setConvexity(convexity);
1670 }
1671
1672 void GraphicsContext::drawOuterPath(const SkPath& path, SkPaint& paint, int width)
1673 {
1674 #if OS(MACOSX)
1675     paint.setAlpha(64);
1676     paint.setStrokeWidth(width);
1677     paint.setPathEffect(SkCornerPathEffect::Create((width - 1) * 0.5f))->unref();
1678 #else
1679     paint.setStrokeWidth(1);
1680     paint.setPathEffect(SkCornerPathEffect::Create(1))->unref();
1681 #endif
1682     drawPath(path, paint);
1683 }
1684
1685 void GraphicsContext::drawInnerPath(const SkPath& path, SkPaint& paint, int width)
1686 {
1687 #if OS(MACOSX)
1688     paint.setAlpha(128);
1689     paint.setStrokeWidth(width * 0.5f);
1690     drawPath(path, paint);
1691 #endif
1692 }
1693
1694 void GraphicsContext::setRadii(SkVector* radii, IntSize topLeft, IntSize topRight, IntSize bottomRight, IntSize bottomLeft)
1695 {
1696     radii[SkRRect::kUpperLeft_Corner].set(SkIntToScalar(topLeft.width()),
1697         SkIntToScalar(topLeft.height()));
1698     radii[SkRRect::kUpperRight_Corner].set(SkIntToScalar(topRight.width()),
1699         SkIntToScalar(topRight.height()));
1700     radii[SkRRect::kLowerRight_Corner].set(SkIntToScalar(bottomRight.width()),
1701         SkIntToScalar(bottomRight.height()));
1702     radii[SkRRect::kLowerLeft_Corner].set(SkIntToScalar(bottomLeft.width()),
1703         SkIntToScalar(bottomLeft.height()));
1704 }
1705
1706 PassRefPtr<SkColorFilter> GraphicsContext::WebCoreColorFilterToSkiaColorFilter(ColorFilter colorFilter)
1707 {
1708     switch (colorFilter) {
1709     case ColorFilterLuminanceToAlpha:
1710         return adoptRef(SkLumaColorFilter::Create());
1711     case ColorFilterLinearRGBToSRGB:
1712         return ImageBuffer::createColorSpaceFilter(ColorSpaceLinearRGB, ColorSpaceDeviceRGB);
1713     case ColorFilterSRGBToLinearRGB:
1714         return ImageBuffer::createColorSpaceFilter(ColorSpaceDeviceRGB, ColorSpaceLinearRGB);
1715     case ColorFilterNone:
1716         break;
1717     default:
1718         ASSERT_NOT_REACHED();
1719         break;
1720     }
1721
1722     return nullptr;
1723 }
1724
1725 #if !OS(MACOSX)
1726 void GraphicsContext::draw2xMarker(SkBitmap* bitmap, int index)
1727 {
1728     const SkPMColor lineColor = lineColors(index);
1729     const SkPMColor antiColor1 = antiColors1(index);
1730     const SkPMColor antiColor2 = antiColors2(index);
1731
1732     uint32_t* row1 = bitmap->getAddr32(0, 0);
1733     uint32_t* row2 = bitmap->getAddr32(0, 1);
1734     uint32_t* row3 = bitmap->getAddr32(0, 2);
1735     uint32_t* row4 = bitmap->getAddr32(0, 3);
1736
1737     // Pattern: X0o   o0X0o   o0
1738     //          XX0o o0XXX0o o0X
1739     //           o0XXX0o o0XXX0o
1740     //            o0X0o   o0X0o
1741     const SkPMColor row1Color[] = { lineColor, antiColor1, antiColor2, 0,          0,         0,          antiColor2, antiColor1 };
1742     const SkPMColor row2Color[] = { lineColor, lineColor,  antiColor1, antiColor2, 0,         antiColor2, antiColor1, lineColor };
1743     const SkPMColor row3Color[] = { 0,         antiColor2, antiColor1, lineColor,  lineColor, lineColor,  antiColor1, antiColor2 };
1744     const SkPMColor row4Color[] = { 0,         0,          antiColor2, antiColor1, lineColor, antiColor1, antiColor2, 0 };
1745
1746     for (int x = 0; x < bitmap->width() + 8; x += 8) {
1747         int count = std::min(bitmap->width() - x, 8);
1748         if (count > 0) {
1749             memcpy(row1 + x, row1Color, count * sizeof(SkPMColor));
1750             memcpy(row2 + x, row2Color, count * sizeof(SkPMColor));
1751             memcpy(row3 + x, row3Color, count * sizeof(SkPMColor));
1752             memcpy(row4 + x, row4Color, count * sizeof(SkPMColor));
1753         }
1754     }
1755 }
1756
1757 void GraphicsContext::draw1xMarker(SkBitmap* bitmap, int index)
1758 {
1759     const uint32_t lineColor = lineColors(index);
1760     const uint32_t antiColor = antiColors2(index);
1761
1762     // Pattern: X o   o X o   o X
1763     //            o X o   o X o
1764     uint32_t* row1 = bitmap->getAddr32(0, 0);
1765     uint32_t* row2 = bitmap->getAddr32(0, 1);
1766     for (int x = 0; x < bitmap->width(); x++) {
1767         switch (x % 4) {
1768         case 0:
1769             row1[x] = lineColor;
1770             break;
1771         case 1:
1772             row1[x] = antiColor;
1773             row2[x] = antiColor;
1774             break;
1775         case 2:
1776             row2[x] = lineColor;
1777             break;
1778         case 3:
1779             row1[x] = antiColor;
1780             row2[x] = antiColor;
1781             break;
1782         }
1783     }
1784 }
1785
1786 const SkPMColor GraphicsContext::lineColors(int index)
1787 {
1788     static const SkPMColor colors[] = {
1789         SkPreMultiplyARGB(0xFF, 0xFF, 0x00, 0x00), // Opaque red.
1790         SkPreMultiplyARGB(0xFF, 0xC0, 0xC0, 0xC0) // Opaque gray.
1791     };
1792
1793     return colors[index];
1794 }
1795
1796 const SkPMColor GraphicsContext::antiColors1(int index)
1797 {
1798     static const SkPMColor colors[] = {
1799         SkPreMultiplyARGB(0xB0, 0xFF, 0x00, 0x00), // Semitransparent red.
1800         SkPreMultiplyARGB(0xB0, 0xC0, 0xC0, 0xC0)  // Semitransparent gray.
1801     };
1802
1803     return colors[index];
1804 }
1805
1806 const SkPMColor GraphicsContext::antiColors2(int index)
1807 {
1808     static const SkPMColor colors[] = {
1809         SkPreMultiplyARGB(0x60, 0xFF, 0x00, 0x00), // More transparent red
1810         SkPreMultiplyARGB(0x60, 0xC0, 0xC0, 0xC0)  // More transparent gray
1811     };
1812
1813     return colors[index];
1814 }
1815 #endif
1816
1817 void GraphicsContext::didDrawTextInRect(const SkRect& textRect)
1818 {
1819     if (m_trackTextRegion) {
1820         TRACE_EVENT0("skia", "GraphicsContext::didDrawTextInRect");
1821         m_textRegion.join(textRect);
1822     }
1823 }
1824
1825 }