Implement support for mixed sampled render targets

src/gpu/GrStencilAndCoverTextContext.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrStencilAndCoverTextContext.h"
 #include "GrBitmapTextContext.h"
 #include "GrDrawTarget.h"
@@ skipping 43 matching lines @@
     // No hairlines unless we can map the 1 px width to the object space.
     if (paint.getStyle() == SkPaint::kStroke_Style
         && paint.getStrokeWidth() == 0
         && viewMatrix.hasPerspective()) {
         return false;
     }
 
     // No color bitmap fonts.
     SkScalerContext::Rec    rec;
     SkScalerContext::MakeRec(paint, &fDeviceProperties, NULL, &rec);
     return rec.getFormat() != SkMask::kARGB32_Format;

[Chris Dalton, 2015/03/17 00:39:35]

Add some sort of check about:

 if (paint.isAntiAlias() && kStencil_GrSampleConfig == rt->sampleConfig()) {
     // Somehow call through to can_tweak_alpha_for_coverage in
GrPorterDuffXferProcessor.cpp
 }

I added https://codereview.chromium.org/1010113004/ , which should gives an an
rt variable in this funciton.

 }
 
 void GrStencilAndCoverTextContext::onDrawText(GrRenderTarget* rt,
                                               const GrClip& clip,
                                               const GrPaint& paint,
                                               const SkPaint& skPaint,
                                               const SkMatrix& viewMatrix,
                                               const char text[],
                                               size_t byteLength,
                                               SkScalar x, SkScalar y) {
@@ skipping 276 matching lines @@
         fGlyphCache = fSkPaint.detachCache(&fDeviceProperties, NULL, true /*ignoreGamma*/);
         fGlyphs = canUseRawPaths ?
                       get_gr_glyphs(fContext, fSkPaint.getTypeface(), NULL, fStroke) :
                       get_gr_glyphs(fContext, fGlyphCache->getScalerContext()->getTypeface(),
                                     &fGlyphCache->getDescriptor(), fStroke);
     }
 
     fStateRestore.set(&fPipelineBuilder);
 
     fPipelineBuilder.setFromPaint(fPaint, fRenderTarget, fClip);
+    fPipelineBuilder.enableState(GrPipelineBuilder::kHWAntialias_StateBit);

[Chris Dalton, 2015/03/16 19:31:24]

I forgot before that we technically should only enable MSAA if the paint wants
it.

  fPaint.setState(GrPipelineBuilder::kHWAntialias_StateBit,
fPaint.isAntiAlias());

But on second thought, maybe we should modify GrPipelineBuilder::setFromPaint
instead? That way we wouldn't have to turn around and enable kHWAntialias right
after setFromPaint disables it.

  setFromPaint(const GrPaint&, bool rtIsMultisampled, const GrClip&)
  setFromPaint(const GrPaint&, GrRenderTarget* rt, const GrClip&, GrSampleConfig
= kUnified)

I'm not convinced whether it would be better or worse to modify setFromPaint
something like the above. What do you think?

 
     GR_STATIC_CONST_SAME_STENCIL(kStencilPass,
                                  kZero_StencilOp,
                                  kZero_StencilOp,
                                  kNotEqual_StencilFunc,
                                  0xffff,
                                  0x0000,
                                  0xffff);
 
     *fPipelineBuilder.stencil() = kStencilPass;
@@ skipping 92 matching lines @@
 
     SkGlyphCache::AttachCache(fGlyphCache);
     fGlyphCache = NULL;
 
     fPipelineBuilder.stencil()->setDisabled();
     fStateRestore.set(NULL);
     fViewMatrix = fContextInitialMatrix;
     GrTextContext::finish();
 }