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