Revert of Restructure flushing relationship between GrContext, GrDrawingManager, and GrResourceCache

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
 
@@ skipping 196 matching lines @@
                                                  sk_sp<SkColorSpace> colorSpace,
                                                  int sampleCnt = 0,
                                                  GrSurfaceOrigin origin = kDefault_GrSurfaceOrigin,
                                                  const SkSurfaceProps* surfaceProps = nullptr,
                                                  SkBudgeted budgeted = SkBudgeted::kYes);
 
     ///////////////////////////////////////////////////////////////////////////
     // Misc.
 
     /**
+     * Flags that affect flush() behavior.
+     */
+    enum FlushBits {
+        /**
+         * A client may reach a point where it has partially rendered a frame
+         * through a GrContext that it knows the user will never see. This flag
+         * causes the flush to skip submission of deferred content to the 3D API
+         * during the flush.
+         */
+        kDiscard_FlushBit                    = 0x2,
+    };
+
+    /**
      * Call to ensure all drawing to the context has been issued to the
      * underlying 3D API.
+     * @param flagsBitfield     flags that control the flushing behavior. See
+     *                          FlushBits.
      */
-    void flush();
+    void flush(int flagsBitfield = 0);
+
+    void flushIfNecessary() {
+        if (fFlushToReduceCacheSize || this->caps()->immediateFlush()) {
+            this->flush();
+        }
+    }
 
    /**
     * These flags can be used with the read/write pixels functions below.
     */
     enum PixelOpsFlags {
         /** The GrContext will not be flushed before the surface read or write. This means that
             the read or write may occur before previous draws have executed. */
         kDontFlush_PixelOpsFlag = 0x1,
         /** Any surface writes should be flushed to the backend 3D API after the surface operation
             is complete */
@@ skipping 150 matching lines @@
     union {
         GrResourceProvider*                 fResourceProvider;
         GrTextureProvider*                  fTextureProvider;
     };
 
     SkAutoTUnref<GrContextThreadSafeProxy>  fThreadSafeProxy;
 
     GrBatchFontCache*                       fBatchFontCache;
     SkAutoTDelete<GrTextBlobCache>          fTextBlobCache;
 
+    // Set by OverbudgetCB() to request that GrContext flush before exiting a draw.
+    bool                                    fFlushToReduceCacheSize;
     bool                                    fDidTestPMConversions;
     int                                     fPMToUPMConversion;
     int                                     fUPMToPMConversion;
     // The sw backend may call GrContext::readSurfacePixels on multiple threads
     // We may transfer the responsibilty for using a mutex to the sw backend
     // when there are fewer code paths that lead to a readSurfacePixels call
     // from the sw backend. readSurfacePixels is reentrant in one case - when performing
     // the PM conversions test. To handle this we do the PM conversions test outside
     // of fReadPixelsMutex and use a separate mutex to guard it. When it re-enters
     // readSurfacePixels it will grab fReadPixelsMutex and release it before the outer
@@ skipping 41 matching lines @@
                                                    const SkMatrix&) const;
     /** Called before either of the above two functions to determine the appropriate fragment
         processors for conversions. This must be called by readSurfacePixels before a mutex is
         taken, since testingvPM conversions itself will call readSurfacePixels */
     void testPMConversionsIfNecessary(uint32_t flags);
     /** Returns true if we've already determined that createPMtoUPMEffect and createUPMToPMEffect
         will fail. In such cases fall back to SW conversion. */
     bool didFailPMUPMConversionTest() const;
 
     /**
+     *  This callback allows the resource cache to callback into the GrContext
+     *  when the cache is still over budget after a purge.
+     */
+    static void OverBudgetCB(void* data);
+
+    /**
      * A callback similar to the above for use by the TextBlobCache
      * TODO move textblob draw calls below context so we can use the call above.
      */
     static void TextBlobCacheOverBudgetCB(void* data);
 
     typedef SkRefCnt INHERITED;
 };
 
 /**
  * Can be used to perform actions related to the generating GrContext in a thread safe manner. The
  * proxy does not access the 3D API (e.g. OpenGL) that backs the generating GrContext.
  */
 class GrContextThreadSafeProxy : public SkRefCnt {
 private:
     GrContextThreadSafeProxy(const GrCaps* caps, uint32_t uniqueID)
         : fCaps(SkRef(caps))
         , fContextUniqueID(uniqueID) {}
 
     SkAutoTUnref<const GrCaps>  fCaps;
     uint32_t                    fContextUniqueID;
 
     friend class GrContext;
     friend class SkImage;
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif