Mark MemoryBuffer allocation functions as NO_DISCARD

src/common/MemoryBuffer.cpp

@@ -112,7 +112,7 @@ bool ScratchBuffer::getImpl(size_t requestedSize,
 
     if (mResetCounter == 0 || mScratchMemory.size() < requestedSize)
     {
-        mScratchMemory.resize(0);
+        clear();
         if (!mScratchMemory.resize(requestedSize))
         {
             return false;
@@ -141,7 +141,7 @@ void ScratchBuffer::tick()
 void ScratchBuffer::clear()
 {
     mResetCounter = mLifetime;
-    mScratchMemory.resize(0);
+    mScratchMemory.clear();
 }
 
 }  // namespace angle

src/common/MemoryBuffer.h

@@ -21,13 +21,13 @@ class MemoryBuffer final : NonCopyable
 {
   public:
     MemoryBuffer() = default;
-    MemoryBuffer(size_t size) { resize(size); }
     ~MemoryBuffer();
 
     MemoryBuffer(MemoryBuffer &&other);
     MemoryBuffer &operator=(MemoryBuffer &&other);
 
-    bool resize(size_t size);
+    ANGLE_NO_DISCARD bool resize(size_t size);
+    void clear() { (void)resize(0); }
     size_t size() const { return mSize; }
     bool empty() const { return mSize == 0; }
 

src/libANGLE/BlobCache_unittest.cpp

@@ -31,7 +31,7 @@ void MakeSequence(T &seq, uint8_t start)
 BlobPut MakeBlob(size_t size, uint8_t start = 0)
 {
     BlobPut blob;
-    blob.resize(size);
+    EXPECT_TRUE(blob.resize(size));
     MakeSequence(blob, start);
     return blob;
 }

src/libANGLE/Display.cpp

@@ -1586,8 +1586,12 @@ Error Display::programCachePopulate(const void *key,
     BlobCache::Key programHash;
     memcpy(programHash.data(), key, BlobCache::kKeyLength);
 
-    mMemoryProgramCache.putBinary(programHash, reinterpret_cast<const uint8_t *>(binary),
-                                  static_cast<size_t>(binarysize));
+    if (!mMemoryProgramCache.putBinary(programHash, reinterpret_cast<const uint8_t *>(binary),
+                                       static_cast<size_t>(binarysize)))
+    {
+        return EglBadAccess() << "Failed to copy program binary into the cache.";
+    }
+
     return NoError();
 }
 

src/libANGLE/MemoryProgramCache.cpp

@@ -187,18 +187,18 @@ void MemoryProgramCache::remove(const egl::BlobCache::Key &programHash)
     mBlobCache.remove(programHash);
 }
 
-void MemoryProgramCache::putProgram(const egl::BlobCache::Key &programHash,
-                                    const Context *context,
-                                    const Program *program)
+angle::Result 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;
+        return angle::Result::Incomplete;
     }
 
     angle::MemoryBuffer serializedProgram;
-    program->serialize(context, &serializedProgram);
+    ANGLE_TRY(program->serialize(context, &serializedProgram));
 
     ANGLE_HISTOGRAM_COUNTS("GPU.ANGLE.ProgramCache.ProgramBinarySizeBytes",
                            static_cast<int>(serializedProgram.size()));
@@ -210,26 +210,32 @@ void MemoryProgramCache::putProgram(const egl::BlobCache::Key &programHash,
                            serializedProgram.data());
 
     mBlobCache.put(programHash, std::move(serializedProgram));
+    return angle::Result::Continue;
 }
 
-void MemoryProgramCache::updateProgram(const Context *context, const Program *program)
+angle::Result MemoryProgramCache::updateProgram(const Context *context, const Program *program)
 {
     egl::BlobCache::Key programHash;
     ComputeHash(context, program, &programHash);
-    putProgram(programHash, context, program);
+    return putProgram(programHash, context, program);
 }
 
-void MemoryProgramCache::putBinary(const egl::BlobCache::Key &programHash,
+bool MemoryProgramCache::putBinary(const egl::BlobCache::Key &programHash,
                                    const uint8_t *binary,
                                    size_t length)
 {
     // Copy the binary.
     angle::MemoryBuffer newEntry;
-    newEntry.resize(length);
+    if (!newEntry.resize(length))
+    {
+        return false;
+    }
     memcpy(newEntry.data(), binary, length);
 
     // Store the binary.
     mBlobCache.populate(programHash, std::move(newEntry));
+
+    return true;
 }
 
 void MemoryProgramCache::clear()

src/libANGLE/MemoryProgramCache.h

@@ -46,16 +46,18 @@ class MemoryProgramCache final : angle::NonCopyable
     void remove(const egl::BlobCache::Key &programHash);
 
     // Helper method that serializes a program.
-    void putProgram(const egl::BlobCache::Key &programHash,
-                    const Context *context,
-                    const Program *program);
+    angle::Result putProgram(const egl::BlobCache::Key &programHash,
+                             const Context *context,
+                             const Program *program);
 
     // Same as putProgram but computes the hash.
-    void updateProgram(const Context *context, const Program *program);
+    angle::Result updateProgram(const Context *context, const Program *program);
 
     // Store a binary directly.  TODO(syoussefi): deprecated.  Will be removed once Chrome supports
     // EGL_ANDROID_blob_cache. http://anglebug.com/2516
-    void putBinary(const egl::BlobCache::Key &programHash, const uint8_t *binary, size_t length);
+    ANGLE_NO_DISCARD bool putBinary(const egl::BlobCache::Key &programHash,
+                                    const uint8_t *binary,
+                                    size_t length);
 
     // Check the cache, and deserialize and load the program if found. Evict existing hash if load
     // fails.

src/libANGLE/Program.cpp

@@ -1674,7 +1674,12 @@ void Program::resolveLinkImpl(const Context *context)
         (mState.mLinkedTransformFeedbackVaryings.empty() ||
          !context->getFrontendFeatures().disableProgramCachingForTransformFeedback.enabled))
     {
-        cache->putProgram(linkingState->programHash, context, this);
+        if (cache->putProgram(linkingState->programHash, context, this) == angle::Result::Stop)
+        {
+            // Don't fail linking if putting the program binary into the cache fails, the program is
+            // still usable.
+            WARN() << "Failed to save linked program to memory program cache.";
+        }
     }
 }
 
@@ -1944,7 +1949,7 @@ angle::Result Program::saveBinary(Context *context,
     }
 
     angle::MemoryBuffer memoryBuf;
-    serialize(context, &memoryBuf);
+    ANGLE_TRY(serialize(context, &memoryBuf));
 
     GLsizei streamLength       = static_cast<GLsizei>(memoryBuf.size());
     const uint8_t *streamState = memoryBuf.data();
@@ -5006,7 +5011,7 @@ angle::Result Program::syncState(const Context *context)
     return angle::Result::Continue;
 }
 
-void Program::serialize(const Context *context, angle::MemoryBuffer *binaryOut) const
+angle::Result Program::serialize(const Context *context, angle::MemoryBuffer *binaryOut) const
 {
     BinaryOutputStream stream;
 
@@ -5196,8 +5201,14 @@ void Program::serialize(const Context *context, angle::MemoryBuffer *binaryOut)
     mProgram->save(context, &stream);
 
     ASSERT(binaryOut);
-    binaryOut->resize(stream.length());
+    if (!binaryOut->resize(stream.length()))
+    {
+        WARN() << "Failed to allocate enough memory to serialize a program. (" << stream.length()
+               << " bytes )";
+        return angle::Result::Incomplete;
+    }
     memcpy(binaryOut->data(), stream.data(), stream.length());
+    return angle::Result::Continue;
 }
 
 angle::Result Program::deserialize(const Context *context,

src/libANGLE/Program.h

@@ -972,7 +972,7 @@ class Program final : angle::NonCopyable, public LabeledObject
     ANGLE_INLINE bool hasAnyDirtyBit() const { return mDirtyBits.any(); }
 
     // Writes a program's binary to the output memory buffer.
-    void serialize(const Context *context, angle::MemoryBuffer *binaryOut) const;
+    angle::Result serialize(const Context *context, angle::MemoryBuffer *binaryOut) const;
 
     rx::Serial serial() const { return mSerial; }
 

src/libANGLE/renderer/d3d/d3d11/Context11.cpp

@@ -667,7 +667,7 @@ angle::Result Context11::triggerDrawCallProgramRecompilation(const gl::Context *
     // Refresh the program cache entry.
     if (mMemoryProgramCache)
     {
-        mMemoryProgramCache->updateProgram(context, program);
+        ANGLE_TRY(mMemoryProgramCache->updateProgram(context, program));
     }
 
     return angle::Result::Continue;
@@ -705,7 +705,7 @@ angle::Result Context11::triggerDispatchCallProgramRecompilation(const gl::Conte
     // Refresh the program cache entry.
     if (mMemoryProgramCache)
     {
-        mMemoryProgramCache->updateProgram(context, program);
+        ANGLE_TRY(mMemoryProgramCache->updateProgram(context, program));
     }
 
     return angle::Result::Continue;

src/libANGLE/renderer/d3d/d3d11/ResourceManager11.cpp

@@ -457,7 +457,11 @@ const D3D11_SUBRESOURCE_DATA *ResourceManager11::createInitDataIfNeeded<ID3D11Te
     size_t requiredSize = static_cast<size_t>(ComputeMemoryUsage(desc));
     if (mZeroMemory.size() < requiredSize)
     {
-        mZeroMemory.resize(requiredSize);
+        if (!mZeroMemory.resize(requiredSize))
+        {
+            ERR() << "Failed to allocate D3D texture initialization data.";
+            return nullptr;
+        }
         mZeroMemory.fill(kDebugInitTextureDataValue);
     }
 
@@ -503,7 +507,11 @@ const D3D11_SUBRESOURCE_DATA *ResourceManager11::createInitDataIfNeeded<ID3D11Te
     size_t requiredSize = static_cast<size_t>(ComputeMemoryUsage(desc));
     if (mZeroMemory.size() < requiredSize)
     {
-        mZeroMemory.resize(requiredSize);
+        if (!mZeroMemory.resize(requiredSize))
+        {
+            ERR() << "Failed to allocate D3D texture initialization data.";
+            return nullptr;
+        }
         mZeroMemory.fill(kDebugInitTextureDataValue);
     }
 

src/libANGLE/renderer/metal/BufferMtl.mm

@@ -88,7 +88,7 @@ BufferMtl::~BufferMtl() {}
 void BufferMtl::destroy(const gl::Context *context)
 {
     ContextMtl *contextMtl = mtl::GetImpl(context);
-    mShadowCopy.resize(0);
+    mShadowCopy.clear();
     mBufferPool.destroy(contextMtl);
     mBuffer = nullptr;