Remove dashing from gpu veto

src/core/SkPicturePlayback.h

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkPicturePlayback_DEFINED
 #define SkPicturePlayback_DEFINED
@@ skipping 52 matching lines @@
 // SkPictureContentInfo is not serialized! It is intended solely for use
 // with suitableForGpuRasterization.
 class SkPictureContentInfo {
 public:
     SkPictureContentInfo() { this->reset(); }
 
     SkPictureContentInfo(const SkPictureContentInfo& src) { this->set(src); }
 
     void set(const SkPictureContentInfo& src) {
         fNumPaintWithPathEffectUses = src.fNumPaintWithPathEffectUses;
+        fNumFastPathDashEffects = src.fNumFastPathDashEffects;
         fNumAAConcavePaths = src.fNumAAConcavePaths;
         fNumAAHairlineConcavePaths = src.fNumAAHairlineConcavePaths;
     }
 
     void reset() {
         fNumPaintWithPathEffectUses = 0;
+        fNumFastPathDashEffects = 0;
         fNumAAConcavePaths = 0;
         fNumAAHairlineConcavePaths = 0;
     }
 
     void swap(SkPictureContentInfo* other) {
         SkTSwap(fNumPaintWithPathEffectUses, other->fNumPaintWithPathEffectUses);
+        SkTSwap(fNumFastPathDashEffects, other->fNumFastPathDashEffects);
         SkTSwap(fNumAAConcavePaths, other->fNumAAConcavePaths);
         SkTSwap(fNumAAHairlineConcavePaths, other->fNumAAHairlineConcavePaths);
     }
 
     void incPaintWithPathEffectUses() { ++fNumPaintWithPathEffectUses; }
     int numPaintWithPathEffectUses() const { return fNumPaintWithPathEffectUses; }
 
+    void incFastPathDashEffects() { ++fNumFastPathDashEffects; }
+    int numFastPathDashEffects() const { return fNumFastPathDashEffects; }
+
     void incAAConcavePaths() { ++fNumAAConcavePaths; }
     int numAAConcavePaths() const { return fNumAAConcavePaths; }
 
     void incAAHairlineConcavePaths() {
         ++fNumAAHairlineConcavePaths;
         SkASSERT(fNumAAHairlineConcavePaths <= fNumAAConcavePaths);
     }
     int numAAHairlineConcavePaths() const { return fNumAAHairlineConcavePaths; }
 
 private:
     // This field is incremented every time a paint with a path effect is
     // used (i.e., it is not a de-duplicated count)
     int fNumPaintWithPathEffectUses;
+    // This field is incremented every time a paint with a path effect that is
+    // dashed, we are drawing a line, and we can use the gpu fast path
+    int fNumFastPathDashEffects;
     // This field is incremented every time an anti-aliased drawPath call is
     // issued with a concave path
     int fNumAAConcavePaths;
     // This field is incremented every time a drawPath call is
     // issued for a hairline stroked concave path.
     int fNumAAHairlineConcavePaths;
 };
 
 /**
  * Container for data that is needed to deep copy a SkPicture. The container
@@ skipping 147 matching lines @@
     int dumpRectPtr(char* bufferPtr, char* buffer, char* name);
     int dumpScalar(char* bufferPtr, char* buffer, char* name);
     void dumpText(char** bufferPtrPtr, char* buffer);
     void dumpStream();
 
 public:
     void dump() const;
 #endif
 
 #if SK_SUPPORT_GPU
-    bool suitableForGpuRasterization(GrContext* context, const char **reason) const;
+    /**
+     * sampleCount is the number of samples-per-pixel or zero if non-MSAA.
+     * It is defaulted to be zero.
+     */
+    bool suitableForGpuRasterization(GrContext* context, const char **reason,
+                                     int sampleCount = 0) const;
+
+    /**
+     * Calls getRecommendedSampleCount with GrPixelConfig and dpi to calculate sampleCount
+     * and then calls the above version of suitableForGpuRasterization
+     */
+    bool suitableForGpuRasterization(GrContext* context, const char **reason,
+                                     GrPixelConfig config, SkScalar dpi) const;
 #endif
 
 private:    // these help us with reading/writing
     bool parseStreamTag(SkStream*, uint32_t tag, uint32_t size, SkPicture::InstallPixelRefProc);
     bool parseBufferTag(SkReadBuffer&, uint32_t tag, uint32_t size);
     void flattenToBuffer(SkWriteBuffer&) const;
 
 private:
     friend class SkPicture;
     friend class SkGpuDevice;   // for access to setDrawLimits & setReplacements
@@ skipping 116 matching lines @@
 
     void initForPlayback() const;
 
 #ifdef SK_BUILD_FOR_ANDROID
     SkMutex fDrawMutex;
     bool fAbortCurrentPlayback;
 #endif
 };
 
 #endif