Make BlobCache use independent from ANGLE_program_cache_control

src/libANGLE/BlobCache.cpp

@@ -64,11 +64,7 @@ void BlobCache::populate(const BlobCache::Key &key, angle::MemoryBuffer &&value,
     newEntry.second = source;
 
     // Cache it inside blob cache only if caching inside the application is not possible.
-    const CacheEntry *result = mBlobCache.put(key, std::move(newEntry), newEntry.first.size());
-    if (!result)
-    {
-        ERR() << "Failed to store binary blob in memory cache, blob is too large.";
-    }
+    mBlobCache.put(key, std::move(newEntry), newEntry.first.size());
 }
 
 bool BlobCache::get(angle::ScratchBuffer *scratchBuffer,
@@ -92,11 +88,12 @@ bool BlobCache::get(angle::ScratchBuffer *scratchBuffer,
             return false;
         }
 
+        EGLsizeiANDROID originalValueSize = valueSize;
         valueSize = mGetBlobFunc(key.data(), key.size(), scratchMemory->data(), valueSize);
 
         // Make sure the key/value pair still exists/is unchanged after the second call
         // (modifications to the application cache by another thread are a possibility)
-        if (static_cast<size_t>(valueSize) != scratchMemory->size())
+        if (valueSize != originalValueSize)
         {
             // This warning serves to find issues with the application cache, none of which are
             // currently known to be thread-safe.  If such a use ever arises, this WARN can be

src/libANGLE/BlobCache.h

@@ -137,6 +137,8 @@ class BlobCache final : angle::NonCopyable
 
     bool areBlobCacheFuncsSet() const;
 
+    bool isCachingEnabled() const { return areBlobCacheFuncsSet() || maxSize() > 0; }
+
   private:
     // This internal cache is used only if the application is not providing caching callbacks
     using CacheEntry = std::pair<angle::MemoryBuffer, CacheSource>;

src/libANGLE/Display.cpp

@@ -786,16 +786,20 @@ Error Display::createContext(const Config *configuration,
 
     gl::MemoryProgramCache *cachePointer = &mMemoryProgramCache;
 
-    // Check context creation attributes to see if we should enable the cache.
-    if (mAttributeMap.get(EGL_CONTEXT_PROGRAM_BINARY_CACHE_ENABLED_ANGLE, EGL_TRUE) == EGL_FALSE)
+    // Check context creation attributes to see if we are using EGL_ANGLE_program_cache_control.
+    // If not, keep caching enabled for EGL_ANDROID_blob_cache, which can have its callbacks set
+    // at any time.
+    bool usesProgramCacheControl =
+        mAttributeMap.contains(EGL_CONTEXT_PROGRAM_BINARY_CACHE_ENABLED_ANGLE);
+    if (usesProgramCacheControl)
     {
-        cachePointer = nullptr;
-    }
-
-    // A program cache size of zero indicates it should be disabled.
-    if (mMemoryProgramCache.maxSize() == 0)
-    {
-        cachePointer = nullptr;
+        bool programCacheControlEnabled =
+            mAttributeMap.get(EGL_CONTEXT_PROGRAM_BINARY_CACHE_ENABLED_ANGLE, GL_FALSE);
+        // A program cache size of zero indicates it should be disabled.
+        if (!programCacheControlEnabled || mMemoryProgramCache.maxSize() == 0)
+        {
+            cachePointer = nullptr;
+        }
     }
 
     gl::Context *context =

src/libANGLE/MemoryProgramCache.cpp

@@ -123,6 +123,12 @@ angle::Result MemoryProgramCache::getProgram(const Context *context,
                                              Program *program,
                                              egl::BlobCache::Key *hashOut)
 {
+    // If caching is effectively disabled, don't bother calculating the hash.
+    if (!mBlobCache.isCachingEnabled())
+    {
+        return angle::Result::Incomplete;
+    }
+
     ComputeHash(context, program, hashOut);
     egl::BlobCache::Value binaryProgram;
     if (get(context, *hashOut, &binaryProgram))
@@ -176,6 +182,12 @@ void MemoryProgramCache::putProgram(const egl::BlobCache::Key &programHash,
                                     const Context *context,
                                     const Program *program)
 {
+    // If caching is effectively disabled, don't bother serializing the program.
+    if (!mBlobCache.isCachingEnabled())
+    {
+        return;
+    }
+
     angle::MemoryBuffer serializedProgram;
     program->serialize(context, &serializedProgram);
 

src/tests/egl_tests/EGLBlobCacheTest.cpp

@@ -78,39 +78,24 @@ EGLsizeiANDROID GetBlob(const void *key,
 class EGLBlobCacheTest : public ANGLETest
 {
   protected:
-    EGLBlobCacheTest() : mHasProgramCache(false) { setDeferContextInit(true); }
+    EGLBlobCacheTest() : mHasBlobCache(false) {}
 
     void SetUp() override
     {
         ANGLETest::SetUp();
 
-        // Enable the program cache so that angle would do caching, which eventually lands in the
-        // BlobCache
         EGLDisplay display = getEGLWindow()->getDisplay();
-        if (eglDisplayExtensionEnabled(display, "EGL_ANGLE_program_cache_control"))
-        {
-            mHasProgramCache = true;
-            setContextProgramCacheEnabled(true);
-            eglProgramCacheResizeANGLE(display, 0x10000, EGL_PROGRAM_CACHE_RESIZE_ANGLE);
-        }
-
-        getEGLWindow()->initializeContext();
+        mHasBlobCache      = eglDisplayExtensionEnabled(display, kEGLExtName);
     }
 
     void TearDown() override { ANGLETest::TearDown(); }
 
-    bool extensionAvailable()
-    {
-        EGLDisplay display = getEGLWindow()->getDisplay();
-        return eglDisplayExtensionEnabled(display, kEGLExtName);
-    }
-
     bool programBinaryAvailable()
     {
         return (getClientMajorVersion() >= 3 || extensionEnabled("GL_OES_get_program_binary"));
     }
 
-    bool mHasProgramCache;
+    bool mHasBlobCache;
 };
 
 // Makes sure the extension exists and works
@@ -118,7 +103,7 @@ TEST_P(EGLBlobCacheTest, Functional)
 {
     EGLDisplay display = getEGLWindow()->getDisplay();
 
-    EXPECT_EQ(true, extensionAvailable());
+    EXPECT_EQ(true, mHasBlobCache);
     eglSetBlobCacheFuncsANDROID(display, SetBlob, GetBlob);
     ASSERT_EGL_SUCCESS();
 
@@ -157,7 +142,7 @@ void main()
 })";
 
     // Compile a shader so it puts something in the cache
-    if (mHasProgramCache && programBinaryAvailable())
+    if (programBinaryAvailable())
     {
         GLuint program = CompileProgram(kVertexShaderSrc, kFragmentShaderSrc);
         ASSERT_NE(0u, program);
@@ -187,7 +172,7 @@ void main()
 // Tests error conditions of the APIs.
 TEST_P(EGLBlobCacheTest, NegativeAPI)
 {
-    EXPECT_EQ(true, extensionAvailable());
+    EXPECT_EQ(true, mHasBlobCache);
 
     // Test bad display
     eglSetBlobCacheFuncsANDROID(EGL_NO_DISPLAY, nullptr, nullptr);