Add mixed samples support to XPs

include/gpu/GrXferProcessor.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrXferProcessor_DEFINED
 #define GrXferProcessor_DEFINED
 
@@ skipping 234 matching lines @@
     /**
      * Returns the offset in device coords to use when accessing the dst texture to get the dst
      * pixel color in the shader. This value is only valid if getDstTexture() != NULL.
      */
     const SkIPoint& dstTextureOffset() const {
         SkASSERT(this->getDstTexture());
         return fDstTextureOffset;
     }
 
     /**
+     * If we are performing a dst read, returns whether the base class will use mixed samples to
+     * antialias the shader's final output. If not doing a dst read, the subclass is responsible
+     * for antialiasing and this returns false.
+     */
+    bool dstReadUsesMixedSamples() const { return fDstReadUsesMixedSamples; }
+
+    /**
      * Returns whether or not the XP will look at coverage when doing its blending.
      */
     bool readsCoverage() const { return fReadsCoverage; }
 
     /**
      * Returns whether or not this xferProcossor will set a secondary output to be used with dual
      * source blending.
      */
     bool hasSecondaryOutput() const;
 
@@ skipping 13 matching lines @@
         }
         if (this->fReadsCoverage != that.fReadsCoverage) {
             return false;
         }
         if (this->fDstTexture.getTexture() != that.fDstTexture.getTexture()) {
             return false;
         }
         if (this->fDstTextureOffset != that.fDstTextureOffset) {
             return false;
         }
+        if (this->fDstReadUsesMixedSamples != that.fDstReadUsesMixedSamples) {
+            return false;
+        }
         return this->onIsEqual(that);
     }
    
 protected:
     GrXferProcessor();
-    GrXferProcessor(const DstTexture*, bool willReadDstColor);
+    GrXferProcessor(const DstTexture*, bool willReadDstColor, bool hasMixedSamples);
 
 private:
     virtual OptFlags onGetOptimizations(const GrProcOptInfo& colorPOI,
                                         const GrProcOptInfo& coveragePOI,
                                         bool doesStencilWrite,
                                         GrColor* overrideColor,
                                         const GrCaps& caps) = 0;
 
     /**
      * Sets a unique key on the GrProcessorKeyBuilder that is directly associated with this xfer
      * processor's GL backend implementation.
      */
     virtual void onGetGLProcessorKey(const GrGLSLCaps& caps,
                                      GrProcessorKeyBuilder* b) const = 0;
 
     /**
      * If not using a texture barrier, retrieves whether the subclass will require a different type
      * of barrier.
      */
     virtual bool onWillNeedXferBarrier(const GrRenderTarget*,
                                        const GrCaps&,
                                        GrXferBarrierType* outBarrierType SK_UNUSED) const {
         return false;
     }
 
     /**
      * If we are not performing a dst read, returns whether the subclass will set a secondary
-     * output. When using dst reads, the base class disables the secondary output and this method
+     * output. When using dst reads, the base class controls the secondary output and this method
      * will not be called.
      */
     virtual bool onHasSecondaryOutput() const { return false; }
 
     /**
      * If we are not performing a dst read, retrieves the fixed-function blend state required by the
-     * subclass. When using dst reads, the base class disables fixed-function blending and this
-     * method will not be called. The BlendInfo struct comes initialized to "no blending".
+     * subclass. When using dst reads, the base class controls the fixed-function blend state and
+     * this method will not be called. The BlendInfo struct comes initialized to "no blending".
      */
     virtual void onGetBlendInfo(BlendInfo*) const {}
 
     virtual bool onIsEqual(const GrXferProcessor&) const = 0;
 
     bool                    fWillReadDstColor;
+    bool                    fDstReadUsesMixedSamples;
     bool                    fReadsCoverage;
     SkIPoint                fDstTextureOffset;
     GrTextureAccess         fDstTexture;
 
     typedef GrFragmentProcessor INHERITED;
 };
 
 GR_MAKE_BITFIELD_OPS(GrXferProcessor::OptFlags);
 
 ///////////////////////////////////////////////////////////////////////////////
 
 /**
  * We install a GrXPFactory (XPF) early on in the pipeline before all the final draw information is
  * known (e.g. whether there is fractional pixel coverage, will coverage be 1 or 4 channel, is the
  * draw opaque, etc.). Once the state of the draw is finalized, we use the XPF along with all the
  * draw information to create a GrXferProcessor (XP) which can implement the desired blending for
  * the draw.
  *
  * Before the XP is created, the XPF is able to answer queries about what functionality the XPs it
  * creates will have. For example, can it create an XP that supports RGB coverage or will the XP
  * blend with the destination color.
  */
 class GrXPFactory : public SkRefCnt {
 public:
     typedef GrXferProcessor::DstTexture DstTexture;
     GrXferProcessor* createXferProcessor(const GrProcOptInfo& colorPOI,
                                          const GrProcOptInfo& coveragePOI,
+                                         bool hasMixedSamples,
                                          const DstTexture*,
                                          const GrCaps& caps) const;
 
     /**
      * This function returns true if the GrXferProcessor generated from this factory will be able to
      * correctly blend when using RGB coverage. The knownColor and knownColorFlags represent the
      * final computed color from the color stages.
      */
     virtual bool supportsRGBCoverage(GrColor knownColor, uint32_t knownColorFlags) const = 0;
 
     /**
      * Known color information after blending, but before accounting for any coverage.
      */
     struct InvariantBlendedColor {
         bool                     fWillBlendWithDst;
         GrColor                  fKnownColor;
         GrColorComponentFlags    fKnownColorFlags;
     };
 
     /** 
      * Returns information about the output color, produced by XPs from this factory, that will be
      * known after blending. Note that we can conflate coverage and color, so the actual values
      * written to pixels with partial coverage may not always seem consistent with the invariant
      * information returned by this function.
      */
     virtual void getInvariantBlendedColor(const GrProcOptInfo& colorPOI,
                                           InvariantBlendedColor*) const = 0;
 
     bool willNeedDstTexture(const GrCaps& caps, const GrProcOptInfo& colorPOI,
-                            const GrProcOptInfo& coveragePOI) const;
+                            const GrProcOptInfo& coveragePOI, bool hasMixedSamples) const;
 
     bool isEqual(const GrXPFactory& that) const {
         if (this->classID() != that.classID()) {
             return false;
         }
         return this->onIsEqual(that);
     }
 
     /**
       * Helper for down-casting to a GrXPFactory subclass
       */
     template <typename T> const T& cast() const { return *static_cast<const T*>(this); }
 
     uint32_t classID() const { SkASSERT(kIllegalXPFClassID != fClassID); return fClassID; }
 
 protected:
     GrXPFactory() : fClassID(kIllegalXPFClassID) {}
 
     template <typename XPF_SUBCLASS> void initClassID() {
          static uint32_t kClassID = GenClassID();
          fClassID = kClassID;
     }
 
     uint32_t fClassID;
 
 private:
     virtual GrXferProcessor* onCreateXferProcessor(const GrCaps& caps,
                                                    const GrProcOptInfo& colorPOI,
                                                    const GrProcOptInfo& coveragePOI,
+                                                   bool hasMixedSamples,
                                                    const DstTexture*) const = 0;
     /**
      *  Returns true if the XP generated by this factory will explicitly read dst in the fragment
      *  shader.
      */
     virtual bool willReadDstColor(const GrCaps& caps,
                                   const GrProcOptInfo& colorPOI,
-                                  const GrProcOptInfo& coveragePOI) const = 0;
+                                  const GrProcOptInfo& coveragePOI,
+                                  bool hasMixedSamples) const = 0;
 
     virtual bool onIsEqual(const GrXPFactory&) const = 0;
 
     static uint32_t GenClassID() {
         // fCurrXPFactoryID has been initialized to kIllegalXPFactoryID. The
         // atomic inc returns the old value not the incremented value. So we add
         // 1 to the returned value.
         uint32_t id = static_cast<uint32_t>(sk_atomic_inc(&gCurrXPFClassID)) + 1;
         if (!id) {
             SkFAIL("This should never wrap as it should only be called once for each GrXPFactory "
                    "subclass.");
         }
         return id;
     }
 
     enum {
         kIllegalXPFClassID = 0,
     };
     static int32_t gCurrXPFClassID;
 
     typedef GrProgramElement INHERITED;
 };
 
 #endif