Store context options on caps.

include/gpu/GrContext.h

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrContext_DEFINED
 #define GrContext_DEFINED
 
 #include "GrClip.h"
 #include "GrColor.h"
 #include "GrPaint.h"
 #include "GrPathRendererChain.h"
 #include "GrRenderTarget.h"
 #include "GrTextureProvider.h"
 #include "SkMatrix.h"
 #include "SkPathEffect.h"
 #include "SkTypes.h"
 
 class GrAARectRenderer;
 class GrBatchFontCache;
+struct GrContextOptions;
 class GrDrawTarget;
 class GrFragmentProcessor;
 class GrGpu;
 class GrGpuTraceMarker;
 class GrIndexBuffer;
 class GrLayerCache;
 class GrOvalRenderer;
 class GrPath;
 class GrPathRenderer;
 class GrPipelineBuilder;
 class GrResourceEntry;
 class GrResourceCache;
 class GrResourceProvider;
 class GrTestTarget;
 class GrTextBlobCache;
 class GrTextContext;
 class GrTextureParams;
 class GrVertexBuffer;
 class GrStrokeInfo;
 class GrSoftwarePathRenderer;
 class SkGpuDevice;
 
 class SK_API GrContext : public SkRefCnt {
 public:
     SK_DECLARE_INST_COUNT(GrContext)
 
-    struct Options {
-        Options() : fDrawPathToCompressedTexture(false), fSuppressPrints(false) { }
-
-        // EXPERIMENTAL
-        // May be removed in the future, or may become standard depending
-        // on the outcomes of a variety of internal tests.
-        bool fDrawPathToCompressedTexture;
-        bool fSuppressPrints;
-    };
-
     /**
      * Creates a GrContext for a backend context.
      */
-    static GrContext* Create(GrBackend, GrBackendContext, const Options* opts = NULL);
+    static GrContext* Create(GrBackend, GrBackendContext, const GrContextOptions& options);
+    static GrContext* Create(GrBackend, GrBackendContext);
 
     /**
      * Only defined in test apps.
      */
     static GrContext* CreateMockContext();
 
     virtual ~GrContext();
 
     /**
      * The GrContext normally assumes that no outsider is setting state
@@ skipping 450 matching lines @@
     GrGpu* getGpu() { return fGpu; }
     const GrGpu* getGpu() const { return fGpu; }
     GrBatchFontCache* getBatchFontCache() { return fBatchFontCache; }
     GrLayerCache* getLayerCache() { return fLayerCache.get(); }
     GrTextBlobCache* getTextBlobCache() { return fTextBlobCache; }
     GrDrawTarget* getTextTarget();
     GrAARectRenderer* getAARectRenderer() { return fAARectRenderer; }
     GrResourceProvider* resourceProvider() { return fResourceProvider; }
     const GrResourceProvider* resourceProvider() const { return fResourceProvider; }
     GrResourceCache* getResourceCache() { return fResourceCache; }
-    bool suppressPrints() const { return fOptions.fSuppressPrints; }
 
     // Called by tests that draw directly to the context via GrDrawTarget
     void getTestTarget(GrTestTarget*);
 
     void addGpuTraceMarker(const GrGpuTraceMarker* marker);
     void removeGpuTraceMarker(const GrGpuTraceMarker* marker);
 
     GrPathRenderer* getPathRenderer(
                     const GrDrawTarget* target,
                     const GrPipelineBuilder*,
                     const SkMatrix& viewMatrix,
                     const SkPath& path,
                     const GrStrokeInfo& stroke,
                     bool allowSW,
                     GrPathRendererChain::DrawType drawType = GrPathRendererChain::kColor_DrawType,
                     GrPathRendererChain::StencilSupport* stencilSupport = NULL);
 
-    /**
-     *  This returns a copy of the the GrContext::Options that was passed to the
-     *  constructor of this class.
-     */
-    const Options& getOptions() const { return fOptions; }
-
     /** Prints cache stats to the string if GR_CACHE_STATS == 1. */
     void dumpCacheStats(SkString*) const;
     void printCacheStats() const;
 
     /** Prints GPU stats to the string if GR_GPU_STATS == 1. */
     void dumpGpuStats(SkString*) const;
     void printGpuStats() const;
 
 private:
     GrGpu*                          fGpu;
@@ skipping 25 matching lines @@
 
     struct CleanUpData {
         PFCleanUpFunc fFunc;
         void*         fInfo;
     };
 
     SkTDArray<CleanUpData>          fCleanUpData;
 
     int                             fMaxTextureSizeOverride;
 
-    const Options                   fOptions;
     const uint32_t                  fUniqueID;
 
-    GrContext(const Options&); // init must be called after the constructor.
-    bool init(GrBackend, GrBackendContext);
+    GrContext(); // init must be called after the constructor.
+    bool init(GrBackend, GrBackendContext, const GrContextOptions& options);
     void initMockContext();
     void initCommon();
 
     class AutoCheckFlush;
     // Sets the paint and returns the target to draw into.
     GrDrawTarget* prepareToDraw(GrPipelineBuilder*,
                                 GrRenderTarget* rt,
                                 const GrClip&,
                                 const GrPaint* paint,
                                 const AutoCheckFlush*);
@@ skipping 43 matching lines @@
      */
     static void TextBlobCacheOverBudgetCB(void* data);
 
     // TODO see note on createTextContext
     friend class SkGpuDevice;
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif