Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(588)

Side by Side Diff: src/gpu/SkGpuDevice.cpp

Issue 311183002: Push dash checks into GrContext. (Closed) Base URL: https://skia.googlesource.com/skia.git@master
Patch Set: Move intervals into GrStrokeInfo and NITS Created 6 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« src/gpu/GrStrokeInfo.h ('K') | « src/gpu/GrStrokeInfo.h ('k') | no next file » | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 /* 1 /*
2 * Copyright 2011 Google Inc. 2 * Copyright 2011 Google Inc.
3 * 3 *
4 * Use of this source code is governed by a BSD-style license that can be 4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file. 5 * found in the LICENSE file.
6 */ 6 */
7 7
8 #include "SkGpuDevice.h" 8 #include "SkGpuDevice.h"
9 9
10 #include "effects/GrBicubicEffect.h" 10 #include "effects/GrBicubicEffect.h"
11 #include "effects/GrDashingEffect.h" 11 #include "effects/GrDashingEffect.h"
12 #include "effects/GrTextureDomain.h" 12 #include "effects/GrTextureDomain.h"
13 #include "effects/GrSimpleTextureEffect.h" 13 #include "effects/GrSimpleTextureEffect.h"
14 14
15 #include "GrContext.h" 15 #include "GrContext.h"
16 #include "GrBitmapTextContext.h" 16 #include "GrBitmapTextContext.h"
17 #include "GrDistanceFieldTextContext.h" 17 #include "GrDistanceFieldTextContext.h"
18 #include "GrLayerCache.h" 18 #include "GrLayerCache.h"
19 #include "GrPictureUtils.h" 19 #include "GrPictureUtils.h"
20 #include "GrStrokeInfo.h"
20 21
21 #include "SkGrTexturePixelRef.h" 22 #include "SkGrTexturePixelRef.h"
22 23
23 #include "SkDeviceImageFilterProxy.h" 24 #include "SkDeviceImageFilterProxy.h"
24 #include "SkDrawProcs.h" 25 #include "SkDrawProcs.h"
25 #include "SkGlyphCache.h" 26 #include "SkGlyphCache.h"
26 #include "SkImageFilter.h" 27 #include "SkImageFilter.h"
27 #include "SkMaskFilter.h" 28 #include "SkMaskFilter.h"
28 #include "SkPathEffect.h" 29 #include "SkPathEffect.h"
29 #include "SkPicture.h" 30 #include "SkPicture.h"
(...skipping 429 matching lines...) Expand 10 before | Expand all | Expand 10 after
459 SkScalar width = paint.getStrokeWidth(); 460 SkScalar width = paint.getStrokeWidth();
460 461
461 /* 462 /*
462 We have special code for hairline strokes, miter-strokes, bevel-stroke 463 We have special code for hairline strokes, miter-strokes, bevel-stroke
463 and fills. Anything else we just call our path code. 464 and fills. Anything else we just call our path code.
464 */ 465 */
465 bool usePath = doStroke && width > 0 && 466 bool usePath = doStroke && width > 0 &&
466 (paint.getStrokeJoin() == SkPaint::kRound_Join || 467 (paint.getStrokeJoin() == SkPaint::kRound_Join ||
467 (paint.getStrokeJoin() == SkPaint::kBevel_Join && rect.isEmp ty())); 468 (paint.getStrokeJoin() == SkPaint::kBevel_Join && rect.isEmp ty()));
468 // another two reasons we might need to call drawPath... 469 // another two reasons we might need to call drawPath...
469 if (paint.getMaskFilter() || paint.getPathEffect()) { 470
471 if (paint.getMaskFilter()) {
470 usePath = true; 472 usePath = true;
471 } 473 }
474
472 if (!usePath && paint.isAntiAlias() && !fContext->getMatrix().rectStaysRect( )) { 475 if (!usePath && paint.isAntiAlias() && !fContext->getMatrix().rectStaysRect( )) {
473 #if defined(SHADER_AA_FILL_RECT) || !defined(IGNORE_ROT_AA_RECT_OPT) 476 #if defined(SHADER_AA_FILL_RECT) || !defined(IGNORE_ROT_AA_RECT_OPT)
474 if (doStroke) { 477 if (doStroke) {
475 #endif 478 #endif
476 usePath = true; 479 usePath = true;
477 #if defined(SHADER_AA_FILL_RECT) || !defined(IGNORE_ROT_AA_RECT_OPT) 480 #if defined(SHADER_AA_FILL_RECT) || !defined(IGNORE_ROT_AA_RECT_OPT)
478 } else { 481 } else {
479 usePath = !fContext->getMatrix().preservesRightAngles(); 482 usePath = !fContext->getMatrix().preservesRightAngles();
480 } 483 }
481 #endif 484 #endif
482 } 485 }
483 // until we can both stroke and fill rectangles 486 // until we can both stroke and fill rectangles
484 if (paint.getStyle() == SkPaint::kStrokeAndFill_Style) { 487 if (paint.getStyle() == SkPaint::kStrokeAndFill_Style) {
485 usePath = true; 488 usePath = true;
486 } 489 }
487 490
491 GrStrokeInfo strokeInfo(paint);
492
493 SkPathEffect* pe = paint.getPathEffect();
494 if (!usePath && NULL != pe && !strokeInfo.setDashInfo(pe)) {
495 usePath = true;
496 }
497
488 if (usePath) { 498 if (usePath) {
489 SkPath path; 499 SkPath path;
490 path.addRect(rect); 500 path.addRect(rect);
491 this->drawPath(draw, path, paint, NULL, true); 501 this->drawPath(draw, path, paint, NULL, true);
492 return; 502 return;
493 } 503 }
494 504
495 GrPaint grPaint; 505 GrPaint grPaint;
496 SkPaint2GrPaintShader(this->context(), paint, true, &grPaint); 506 SkPaint2GrPaintShader(this->context(), paint, true, &grPaint);
497 507
498 if (!doStroke) { 508 fContext->drawRect(grPaint, rect, &strokeInfo);
499 fContext->drawRect(grPaint, rect);
500 } else {
501 SkStrokeRec stroke(paint);
502 fContext->drawRect(grPaint, rect, &stroke);
503 }
504 } 509 }
505 510
506 /////////////////////////////////////////////////////////////////////////////// 511 ///////////////////////////////////////////////////////////////////////////////
507 512
508 void SkGpuDevice::drawRRect(const SkDraw& draw, const SkRRect& rect, 513 void SkGpuDevice::drawRRect(const SkDraw& draw, const SkRRect& rect,
509 const SkPaint& paint) { 514 const SkPaint& paint) {
510 CHECK_FOR_ANNOTATION(paint); 515 CHECK_FOR_ANNOTATION(paint);
511 CHECK_SHOULD_DRAW(draw, false); 516 CHECK_SHOULD_DRAW(draw, false);
512 517
513 GrPaint grPaint; 518 GrPaint grPaint;
514 SkPaint2GrPaintShader(this->context(), paint, true, &grPaint); 519 SkPaint2GrPaintShader(this->context(), paint, true, &grPaint);
515 520
516 SkStrokeRec stroke(paint); 521 GrStrokeInfo strokeInfo(paint);
517 if (paint.getMaskFilter()) { 522 if (paint.getMaskFilter()) {
518 // try to hit the fast path for drawing filtered round rects 523 // try to hit the fast path for drawing filtered round rects
519 524
520 SkRRect devRRect; 525 SkRRect devRRect;
521 if (rect.transform(fContext->getMatrix(), &devRRect)) { 526 if (rect.transform(fContext->getMatrix(), &devRRect)) {
522 if (devRRect.allCornersCircular()) { 527 if (devRRect.allCornersCircular()) {
523 SkRect maskRect; 528 SkRect maskRect;
524 if (paint.getMaskFilter()->canFilterMaskGPU(devRRect.rect(), 529 if (paint.getMaskFilter()->canFilterMaskGPU(devRRect.rect(),
525 draw.fClip->getBounds(), 530 draw.fClip->getBounds(),
526 fContext->getMatrix(), 531 fContext->getMatrix(),
527 &maskRect)) { 532 &maskRect)) {
528 SkIRect finalIRect; 533 SkIRect finalIRect;
529 maskRect.roundOut(&finalIRect); 534 maskRect.roundOut(&finalIRect);
530 if (draw.fClip->quickReject(finalIRect)) { 535 if (draw.fClip->quickReject(finalIRect)) {
531 // clipped out 536 // clipped out
532 return; 537 return;
533 } 538 }
534 if (paint.getMaskFilter()->directFilterRRectMaskGPU(fContext , &grPaint, 539 if (paint.getMaskFilter()->directFilterRRectMaskGPU(fContext , &grPaint,
535 stroke, devRRect)) { 540 strokeIn fo.getStrokeRec(),
541 devRRect )) {
536 return; 542 return;
537 } 543 }
538 } 544 }
539 545
540 } 546 }
541 } 547 }
542 548
543 } 549 }
544 550
545 if (paint.getMaskFilter() || paint.getPathEffect()) { 551 bool usePath = false;
552
553 if (paint.getMaskFilter()) {
554 usePath = true;
555 } else {
556 SkPathEffect* pe = paint.getPathEffect();
557 if (NULL != pe && !strokeInfo.setDashInfo(pe)) {
558 usePath = true;
559 }
560 }
561
562
563 if (usePath) {
546 SkPath path; 564 SkPath path;
547 path.addRRect(rect); 565 path.addRRect(rect);
548 this->drawPath(draw, path, paint, NULL, true); 566 this->drawPath(draw, path, paint, NULL, true);
549 return; 567 return;
550 } 568 }
551 569
552 fContext->drawRRect(grPaint, rect, stroke); 570 fContext->drawRRect(grPaint, rect, strokeInfo);
553 } 571 }
554 572
555 void SkGpuDevice::drawDRRect(const SkDraw& draw, const SkRRect& outer, 573 void SkGpuDevice::drawDRRect(const SkDraw& draw, const SkRRect& outer,
556 const SkRRect& inner, const SkPaint& paint) { 574 const SkRRect& inner, const SkPaint& paint) {
557 SkStrokeRec stroke(paint); 575 SkStrokeRec stroke(paint);
558 if (stroke.isFillStyle()) { 576 if (stroke.isFillStyle()) {
559 577
560 CHECK_FOR_ANNOTATION(paint); 578 CHECK_FOR_ANNOTATION(paint);
561 CHECK_SHOULD_DRAW(draw, false); 579 CHECK_SHOULD_DRAW(draw, false);
562 580
(...skipping 15 matching lines...) Expand all
578 } 596 }
579 597
580 598
581 ///////////////////////////////////////////////////////////////////////////// 599 /////////////////////////////////////////////////////////////////////////////
582 600
583 void SkGpuDevice::drawOval(const SkDraw& draw, const SkRect& oval, 601 void SkGpuDevice::drawOval(const SkDraw& draw, const SkRect& oval,
584 const SkPaint& paint) { 602 const SkPaint& paint) {
585 CHECK_FOR_ANNOTATION(paint); 603 CHECK_FOR_ANNOTATION(paint);
586 CHECK_SHOULD_DRAW(draw, false); 604 CHECK_SHOULD_DRAW(draw, false);
587 605
606 GrStrokeInfo strokeInfo(paint);
607
588 bool usePath = false; 608 bool usePath = false;
589 // some basic reasons we might need to call drawPath... 609 // some basic reasons we might need to call drawPath...
590 if (paint.getMaskFilter() || paint.getPathEffect()) { 610 if (paint.getMaskFilter()) {
591 usePath = true; 611 usePath = true;
612 } else {
613 SkPathEffect* pe = paint.getPathEffect();
614 if (NULL != pe && !strokeInfo.setDashInfo(pe)) {
615 usePath = true;
616 }
592 } 617 }
593 618
594 if (usePath) { 619 if (usePath) {
595 SkPath path; 620 SkPath path;
596 path.addOval(oval); 621 path.addOval(oval);
597 this->drawPath(draw, path, paint, NULL, true); 622 this->drawPath(draw, path, paint, NULL, true);
598 return; 623 return;
599 } 624 }
600 625
601 GrPaint grPaint; 626 GrPaint grPaint;
602 SkPaint2GrPaintShader(this->context(), paint, true, &grPaint); 627 SkPaint2GrPaintShader(this->context(), paint, true, &grPaint);
603 SkStrokeRec stroke(paint);
604 628
605 fContext->drawOval(grPaint, oval, stroke); 629 fContext->drawOval(grPaint, oval, strokeInfo);
606 } 630 }
607 631
608 #include "SkMaskFilter.h" 632 #include "SkMaskFilter.h"
609 633
610 /////////////////////////////////////////////////////////////////////////////// 634 ///////////////////////////////////////////////////////////////////////////////
611 635
612 // helpers for applying mask filters 636 // helpers for applying mask filters
613 namespace { 637 namespace {
614 638
615 // Draw a mask using the supplied paint. Since the coverage/geometry 639 // Draw a mask using the supplied paint. Since the coverage/geometry
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after
671 SkRect maskRect = SkRect::Make(dstM.fBounds); 695 SkRect maskRect = SkRect::Make(dstM.fBounds);
672 696
673 return draw_mask(context, maskRect, grp, texture); 697 return draw_mask(context, maskRect, grp, texture);
674 } 698 }
675 699
676 // Create a mask of 'devPath' and place the result in 'mask'. Return true on 700 // Create a mask of 'devPath' and place the result in 'mask'. Return true on
677 // success; false otherwise. 701 // success; false otherwise.
678 bool create_mask_GPU(GrContext* context, 702 bool create_mask_GPU(GrContext* context,
679 const SkRect& maskRect, 703 const SkRect& maskRect,
680 const SkPath& devPath, 704 const SkPath& devPath,
681 const SkStrokeRec& stroke, 705 const GrStrokeInfo& strokeInfo,
682 bool doAA, 706 bool doAA,
683 GrAutoScratchTexture* mask) { 707 GrAutoScratchTexture* mask) {
684 GrTextureDesc desc; 708 GrTextureDesc desc;
685 desc.fFlags = kRenderTarget_GrTextureFlagBit; 709 desc.fFlags = kRenderTarget_GrTextureFlagBit;
686 desc.fWidth = SkScalarCeilToInt(maskRect.width()); 710 desc.fWidth = SkScalarCeilToInt(maskRect.width());
687 desc.fHeight = SkScalarCeilToInt(maskRect.height()); 711 desc.fHeight = SkScalarCeilToInt(maskRect.height());
688 // We actually only need A8, but it often isn't supported as a 712 // We actually only need A8, but it often isn't supported as a
689 // render target so default to RGBA_8888 713 // render target so default to RGBA_8888
690 desc.fConfig = kRGBA_8888_GrPixelConfig; 714 desc.fConfig = kRGBA_8888_GrPixelConfig;
691 if (context->isConfigRenderable(kAlpha_8_GrPixelConfig, false)) { 715 if (context->isConfigRenderable(kAlpha_8_GrPixelConfig, false)) {
(...skipping 24 matching lines...) Expand all
716 // use a zero dst coeff when dual source blending isn't available. 740 // use a zero dst coeff when dual source blending isn't available.
717 tempPaint.setBlendFunc(kOne_GrBlendCoeff, kISC_GrBlendCoeff); 741 tempPaint.setBlendFunc(kOne_GrBlendCoeff, kISC_GrBlendCoeff);
718 } 742 }
719 743
720 GrContext::AutoMatrix am; 744 GrContext::AutoMatrix am;
721 745
722 // Draw the mask into maskTexture with the path's top-left at the origin usi ng tempPaint. 746 // Draw the mask into maskTexture with the path's top-left at the origin usi ng tempPaint.
723 SkMatrix translate; 747 SkMatrix translate;
724 translate.setTranslate(-maskRect.fLeft, -maskRect.fTop); 748 translate.setTranslate(-maskRect.fLeft, -maskRect.fTop);
725 am.set(context, translate); 749 am.set(context, translate);
726 context->drawPath(tempPaint, devPath, stroke); 750 context->drawPath(tempPaint, devPath, strokeInfo);
727 return true; 751 return true;
728 } 752 }
729 753
730 SkBitmap wrap_texture(GrTexture* texture) { 754 SkBitmap wrap_texture(GrTexture* texture) {
731 SkImageInfo info; 755 SkImageInfo info;
732 texture->asImageInfo(&info); 756 texture->asImageInfo(&info);
733 757
734 SkBitmap result; 758 SkBitmap result;
735 result.setInfo(info); 759 result.setInfo(info);
736 result.setPixelRef(SkNEW_ARGS(SkGrPixelRef, (info, texture)))->unref(); 760 result.setPixelRef(SkNEW_ARGS(SkGrPixelRef, (info, texture)))->unref();
(...skipping 26 matching lines...) Expand all
763 pathIsMutable = true; 787 pathIsMutable = true;
764 } 788 }
765 // should I push prePathMatrix on our MV stack temporarily, instead 789 // should I push prePathMatrix on our MV stack temporarily, instead
766 // of applying it here? See SkDraw.cpp 790 // of applying it here? See SkDraw.cpp
767 pathPtr->transform(*prePathMatrix, result); 791 pathPtr->transform(*prePathMatrix, result);
768 pathPtr = result; 792 pathPtr = result;
769 } 793 }
770 // at this point we're done with prePathMatrix 794 // at this point we're done with prePathMatrix
771 SkDEBUGCODE(prePathMatrix = (const SkMatrix*)0x50FF8001;) 795 SkDEBUGCODE(prePathMatrix = (const SkMatrix*)0x50FF8001;)
772 796
773 SkStrokeRec stroke(paint); 797 GrStrokeInfo strokeInfo(paint);
774 SkPathEffect* pathEffect = paint.getPathEffect(); 798 SkPathEffect* pathEffect = paint.getPathEffect();
775 const SkRect* cullRect = NULL; // TODO: what is our bounds? 799 const SkRect* cullRect = NULL; // TODO: what is our bounds?
776 if (pathEffect && pathEffect->filterPath(effectPath.init(), *pathPtr, &strok e, 800 SkStrokeRec* strokePtr = strokeInfo.getStrokeRecPtr();
801 if (pathEffect && pathEffect->filterPath(effectPath.init(), *pathPtr, stroke Ptr,
777 cullRect)) { 802 cullRect)) {
778 pathPtr = effectPath.get(); 803 pathPtr = effectPath.get();
779 pathIsMutable = true; 804 pathIsMutable = true;
780 } 805 }
781 806
807 const SkStrokeRec& stroke = strokeInfo.getStrokeRec();
782 if (paint.getMaskFilter()) { 808 if (paint.getMaskFilter()) {
783 if (!stroke.isHairlineStyle()) { 809 if (!stroke.isHairlineStyle()) {
784 SkPath* strokedPath = pathIsMutable ? pathPtr : tmpPath.init(); 810 SkPath* strokedPath = pathIsMutable ? pathPtr : tmpPath.init();
785 if (stroke.applyToPath(strokedPath, *pathPtr)) { 811 if (stroke.applyToPath(strokedPath, *pathPtr)) {
786 pathPtr = strokedPath; 812 pathPtr = strokedPath;
787 pathIsMutable = true; 813 pathIsMutable = true;
788 stroke.setFillStyle(); 814 strokeInfo.setFillStyle();
789 } 815 }
790 } 816 }
791 817
792 // avoid possibly allocating a new path in transform if we can 818 // avoid possibly allocating a new path in transform if we can
793 SkPath* devPathPtr = pathIsMutable ? pathPtr : tmpPath.init(); 819 SkPath* devPathPtr = pathIsMutable ? pathPtr : tmpPath.init();
794 820
795 // transform the path into device space 821 // transform the path into device space
796 pathPtr->transform(fContext->getMatrix(), devPathPtr); 822 pathPtr->transform(fContext->getMatrix(), devPathPtr);
797 823
798 SkRect maskRect; 824 SkRect maskRect;
(...skipping 14 matching lines...) Expand all
813 839
814 if (paint.getMaskFilter()->directFilterMaskGPU(fContext, &grPaint, 840 if (paint.getMaskFilter()->directFilterMaskGPU(fContext, &grPaint,
815 stroke, *devPathPtr)) { 841 stroke, *devPathPtr)) {
816 // the mask filter was able to draw itself directly, so there's nothing 842 // the mask filter was able to draw itself directly, so there's nothing
817 // left to do. 843 // left to do.
818 return; 844 return;
819 } 845 }
820 846
821 GrAutoScratchTexture mask; 847 GrAutoScratchTexture mask;
822 848
823 if (create_mask_GPU(fContext, maskRect, *devPathPtr, stroke, 849 if (create_mask_GPU(fContext, maskRect, *devPathPtr, strokeInfo,
824 grPaint.isAntiAlias(), &mask)) { 850 grPaint.isAntiAlias(), &mask)) {
825 GrTexture* filtered; 851 GrTexture* filtered;
826 852
827 if (paint.getMaskFilter()->filterMaskGPU(mask.texture(), 853 if (paint.getMaskFilter()->filterMaskGPU(mask.texture(),
828 ctm, maskRect, &filtere d, true)) { 854 ctm, maskRect, &filtere d, true)) {
829 // filterMaskGPU gives us ownership of a ref to the result 855 // filterMaskGPU gives us ownership of a ref to the result
830 SkAutoTUnref<GrTexture> atu(filtered); 856 SkAutoTUnref<GrTexture> atu(filtered);
831 857
832 // If the scratch texture that we used as the filter src als o holds the filter 858 // If the scratch texture that we used as the filter src als o holds the filter
833 // result then we must detach so that this texture isn't rec ycled for a later 859 // result then we must detach so that this texture isn't rec ycled for a later
834 // draw. 860 // draw.
835 if (filtered == mask.texture()) { 861 if (filtered == mask.texture()) {
836 mask.detach(); 862 mask.detach();
837 filtered->unref(); // detach transfers GrAutoScratchText ure's ref to us. 863 filtered->unref(); // detach transfers GrAutoScratchText ure's ref to us.
838 } 864 }
839 865
840 if (draw_mask(fContext, maskRect, &grPaint, filtered)) { 866 if (draw_mask(fContext, maskRect, &grPaint, filtered)) {
841 // This path is completely drawn 867 // This path is completely drawn
842 return; 868 return;
843 } 869 }
844 } 870 }
845 } 871 }
846 } 872 }
847 873
848 // draw the mask on the CPU - this is a fallthrough path in case the 874 // draw the mask on the CPU - this is a fallthrough path in case the
849 // GPU path fails 875 // GPU path fails
850 SkPaint::Style style = stroke.isHairlineStyle() ? SkPaint::kStroke_Style : 876 SkPaint::Style style = stroke.isHairlineStyle() ? SkPaint::kStroke_Style :
851 SkPaint::kFill_Style; 877 SkPaint::kFill_Style;
852 draw_with_mask_filter(fContext, *devPathPtr, paint.getMaskFilter(), *dra w.fClip, &grPaint, 878 draw_with_mask_filter(fContext, *devPathPtr, paint.getMaskFilter(),
853 style); 879 *draw.fClip, &grPaint, style);
854 return; 880 return;
855 } 881 }
856 882
857 fContext->drawPath(grPaint, *pathPtr, stroke); 883 fContext->drawPath(grPaint, *pathPtr, strokeInfo);
858 } 884 }
859 885
860 static const int kBmpSmallTileSize = 1 << 10; 886 static const int kBmpSmallTileSize = 1 << 10;
861 887
862 static inline int get_tile_count(const SkIRect& srcRect, int tileSize) { 888 static inline int get_tile_count(const SkIRect& srcRect, int tileSize) {
863 int tilesX = (srcRect.fRight / tileSize) - (srcRect.fLeft / tileSize) + 1; 889 int tilesX = (srcRect.fRight / tileSize) - (srcRect.fLeft / tileSize) + 1;
864 int tilesY = (srcRect.fBottom / tileSize) - (srcRect.fTop / tileSize) + 1; 890 int tilesY = (srcRect.fBottom / tileSize) - (srcRect.fTop / tileSize) + 1;
865 return tilesX * tilesY; 891 return tilesX * tilesY;
866 } 892 }
867 893
(...skipping 1138 matching lines...) Expand 10 before | Expand all | Expand 10 after
2006 GrCachedLayer* layer = fContext->getLayerCache()->findLayerOrCreate(pict ure, i); 2032 GrCachedLayer* layer = fContext->getLayerCache()->findLayerOrCreate(pict ure, i);
2007 2033
2008 if (NULL != layer->getTexture()) { 2034 if (NULL != layer->getTexture()) {
2009 fContext->unlockScratchTexture(layer->getTexture()); 2035 fContext->unlockScratchTexture(layer->getTexture());
2010 layer->setTexture(NULL); 2036 layer->setTexture(NULL);
2011 } 2037 }
2012 } 2038 }
2013 2039
2014 return true; 2040 return true;
2015 } 2041 }
OLDNEW
« src/gpu/GrStrokeInfo.h ('K') | « src/gpu/GrStrokeInfo.h ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698