Re-land "Clean up Buffer11."

src/libANGLE/Error.h

@@ -53,7 +53,17 @@ class ErrorOrResult
 {
   public:
     ErrorOrResult(const gl::Error &error) : mError(error) {}
-    ErrorOrResult(T &&result) : mError(GL_NO_ERROR), mResult(std::move(result)) {}
+    ErrorOrResult(gl::Error &&error) : mError(std::move(error)) {}
+
+    ErrorOrResult(T &&result)
+        : mError(GL_NO_ERROR), mResult(std::forward<T>(result))
+    {
+    }
+
+    ErrorOrResult(const T &result)
+        : mError(GL_NO_ERROR), mResult(result)
+    {
+    }
 
     bool isError() const { return mError.isError(); }
     const gl::Error &getError() const { return mError; }

src/libANGLE/renderer/d3d/BufferD3D.h

@@ -37,7 +37,7 @@ class BufferD3D : public BufferImpl
 
     virtual size_t getSize() const = 0;
     virtual bool supportsDirectBinding() const = 0;
-    virtual void markTransformFeedbackUsage() = 0;
+    virtual gl::Error markTransformFeedbackUsage() = 0;
     virtual gl::Error getData(const uint8_t **outData) = 0;
 
     StaticVertexBufferInterface *getStaticVertexBuffer(const gl::VertexAttribute &attribute);

src/libANGLE/renderer/d3d/RendererD3D.cpp

@@ -272,7 +272,11 @@ gl::Error RendererD3D::genericDrawArrays(const gl::Data &data,
 
         if (data.state->isTransformFeedbackActiveUnpaused())
         {
-            markTransformFeedbackUsage(data);
+            error = markTransformFeedbackUsage(data);
+            if (error.isError())
+            {
+                return error;
+            }
         }
     }
 
@@ -509,7 +513,7 @@ bool RendererD3D::skipDraw(const gl::Data &data, GLenum drawMode)
     return false;
 }
 
-void RendererD3D::markTransformFeedbackUsage(const gl::Data &data)
+gl::Error RendererD3D::markTransformFeedbackUsage(const gl::Data &data)
 {
     const gl::TransformFeedback *transformFeedback = data.state->getCurrentTransformFeedback();
     for (size_t i = 0; i < transformFeedback->getIndexedBufferCount(); i++)
@@ -518,9 +522,15 @@ void RendererD3D::markTransformFeedbackUsage(const gl::Data &data)
         if (binding.get() != nullptr)
         {
             BufferD3D *bufferD3D = GetImplAs<BufferD3D>(binding.get());
-            bufferD3D->markTransformFeedbackUsage();
+            auto error = bufferD3D->markTransformFeedbackUsage();
+            if (error.isError())
+            {
+                return error;
+            }
         }
     }
+
+    return gl::Error(GL_NO_ERROR);
 }
 
 size_t RendererD3D::getBoundFramebufferTextures(const gl::Data &data, FramebufferTextureArray *outTextureArray)

src/libANGLE/renderer/d3d/RendererD3D.h

@@ -180,7 +180,7 @@ class RendererD3D : public Renderer, public BufferFactoryD3D
                                        GLenum mode,
                                        GLenum type,
                                        TranslatedIndexData *indexInfo) = 0;
-    virtual void applyTransformFeedbackBuffers(const gl::State& state) = 0;
+    virtual gl::Error applyTransformFeedbackBuffers(const gl::State &state) = 0;
 
     virtual unsigned int getReservedVertexUniformVectors() const = 0;
     virtual unsigned int getReservedFragmentUniformVectors() const = 0;
@@ -326,7 +326,7 @@ class RendererD3D : public Renderer, public BufferFactoryD3D
     gl::Error applyTextures(const gl::Data &data);
 
     bool skipDraw(const gl::Data &data, GLenum drawMode);
-    void markTransformFeedbackUsage(const gl::Data &data);
+    gl::Error markTransformFeedbackUsage(const gl::Data &data);
 
     size_t getBoundFramebufferTextures(const gl::Data &data, FramebufferTextureArray *outTextureArray);
     gl::Texture *getIncompleteTexture(GLenum type);

src/libANGLE/renderer/d3d/VertexBuffer.cpp

@@ -111,7 +111,7 @@ gl::ErrorOrResult<unsigned int> VertexBufferInterface::getSpaceRequired(
                          "Vertex buffer overflow in VertexBufferInterface::getSpaceRequired.");
     }
 
-    return std::move(alignedSpaceRequired);
+    return alignedSpaceRequired;
 }
 
 gl::Error VertexBufferInterface::discard()

src/libANGLE/renderer/d3d/d3d11/Buffer11.h

@@ -62,11 +62,13 @@ class Buffer11 : public BufferD3D
     Buffer11(Renderer11 *renderer);
     virtual ~Buffer11();
 
-    ID3D11Buffer *getBuffer(BufferUsage usage);
-    ID3D11Buffer *getEmulatedIndexedBuffer(SourceIndexData *indexInfo, const TranslatedAttribute *attribute);
-    ID3D11Buffer *getConstantBufferRange(GLintptr offset, GLsizeiptr size);
-    ID3D11ShaderResourceView *getSRV(DXGI_FORMAT srvFormat);
-    bool isMapped() const { return mMappedStorage != NULL; }
+    gl::ErrorOrResult<ID3D11Buffer *> getBuffer(BufferUsage usage);
+    gl::ErrorOrResult<ID3D11Buffer *> getEmulatedIndexedBuffer(
+        SourceIndexData *indexInfo,
+        const TranslatedAttribute &attribute);
+    gl::ErrorOrResult<ID3D11Buffer *> getConstantBufferRange(GLintptr offset, GLsizeiptr size);
+    gl::ErrorOrResult<ID3D11ShaderResourceView *> getSRV(DXGI_FORMAT srvFormat);
+    bool isMapped() const { return mMappedStorage != nullptr; }
     gl::Error packPixels(const gl::FramebufferAttachment &readAttachment,
                          const PackPixelsParams &params);
     size_t getTotalCPUBufferMemoryBytes() const;
@@ -83,7 +85,7 @@ class Buffer11 : public BufferD3D
     virtual gl::Error map(GLenum access, GLvoid **mapPtr);
     virtual gl::Error mapRange(size_t offset, size_t length, GLbitfield access, GLvoid **mapPtr);
     virtual gl::Error unmap(GLboolean *result);
-    virtual void markTransformFeedbackUsage();
+    virtual gl::Error markTransformFeedbackUsage();
 
   private:
     class BufferStorage;
@@ -120,20 +122,19 @@ class Buffer11 : public BufferD3D
 
     unsigned int mReadUsageCount;
 
-    void markBufferUsage();
-    NativeStorage *getStagingStorage();
-    PackStorage *getPackStorage();
-    gl::Error getSystemMemoryStorage(SystemMemoryStorage **storageOut);
+    gl::Error markBufferUsage();
+    gl::ErrorOrResult<NativeStorage *> getStagingStorage();
+    gl::ErrorOrResult<PackStorage *> getPackStorage();
+    gl::ErrorOrResult<SystemMemoryStorage *> getSystemMemoryStorage();
 
-    void updateBufferStorage(BufferStorage *storage, size_t sourceOffset, size_t storageSize);
-    BufferStorage *getBufferStorage(BufferUsage usage);
-    BufferStorage *getLatestBufferStorage() const;
+    gl::Error updateBufferStorage(BufferStorage *storage, size_t sourceOffset, size_t storageSize);
+    gl::ErrorOrResult<BufferStorage *> getBufferStorage(BufferUsage usage);
+    gl::ErrorOrResult<BufferStorage *> getLatestBufferStorage() const;
 
-    BufferStorage *getConstantBufferRangeStorage(GLintptr offset, GLsizeiptr size);
-
-    void invalidateEmulatedIndexedBuffer();
+    gl::ErrorOrResult<BufferStorage *> getConstantBufferRangeStorage(GLintptr offset,
+                                                                     GLsizeiptr size);
 };
 
-}
+}  // namespace rx
 
 #endif // LIBANGLE_RENDERER_D3D_D3D11_BUFFER11_H_

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

@@ -293,11 +293,23 @@ gl::Error InputLayoutCache::applyVertexBuffers(
                     indexInfo->srcIndexData.srcIndices = bufferData + offset;
                 }
 
-                buffer = bufferStorage->getEmulatedIndexedBuffer(&indexInfo->srcIndexData, &attrib);
+                auto bufferOrError =
+                    bufferStorage->getEmulatedIndexedBuffer(&indexInfo->srcIndexData, attrib);
+                if (bufferOrError.isError())
+                {
+                    return bufferOrError.getError();
+                }
+                buffer = bufferOrError.getResult();
             }
             else
             {
-                buffer = bufferStorage->getBuffer(BUFFER_USAGE_VERTEX_OR_TRANSFORM_FEEDBACK);
+                auto bufferOrError =
+                    bufferStorage->getBuffer(BUFFER_USAGE_VERTEX_OR_TRANSFORM_FEEDBACK);
+                if (bufferOrError.isError())
+                {
+                    return bufferOrError.getError();
+                }
+                buffer = bufferOrError.getResult();
             }
 
             vertexStride = attrib.stride;

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

@@ -208,18 +208,23 @@ gl::Error PixelTransfer11::copyBufferToTexture(const gl::PixelUnpackState &unpac
     DXGI_FORMAT srvFormat = sourceFormatInfo.formatSet->srvFormat;
     ASSERT(srvFormat != DXGI_FORMAT_UNKNOWN);
     Buffer11 *bufferStorage11 = GetAs<Buffer11>(sourceBuffer.getImplementation());
-    ID3D11ShaderResourceView *bufferSRV = bufferStorage11->getSRV(srvFormat);
-    ASSERT(bufferSRV != NULL);
+    auto srvOrError = bufferStorage11->getSRV(srvFormat);
+    if (srvOrError.isError())
+    {
+        return srvOrError.getError();
+    }
+    ID3D11ShaderResourceView *bufferSRV = srvOrError.getResult();
+    ASSERT(bufferSRV != nullptr);
 
     ID3D11RenderTargetView *textureRTV = GetAs<RenderTarget11>(destRenderTarget)->getRenderTargetView();
-    ASSERT(textureRTV != NULL);
+    ASSERT(textureRTV != nullptr);
 
     CopyShaderParams shaderParams;
     setBufferToTextureCopyParams(destArea, destSize, sourceFormat, unpack, offset, &shaderParams);
 
     ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext();
 
-    ID3D11Buffer *nullBuffer = NULL;
+    ID3D11Buffer *nullBuffer = nullptr;
     UINT zero = 0;
 
     // Are we doing a 2D or 3D copy?

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

@@ -1288,11 +1288,22 @@ gl::Error Renderer11::setUniformBuffers(const gl::Data &data,
 
             if (mRenderer11DeviceCaps.supportsConstantBufferOffsets)
             {
-                constantBuffer = bufferStorage->getBuffer(BUFFER_USAGE_UNIFORM);
+                auto bufferOrError = bufferStorage->getBuffer(BUFFER_USAGE_UNIFORM);
+                if (bufferOrError.isError())
+                {
+                    return bufferOrError.getError();
+                }
+                constantBuffer = bufferOrError.getResult();
             }
             else
             {
-                constantBuffer = bufferStorage->getConstantBufferRange(uniformBufferOffset, uniformBufferSize);
+                auto bufferOrError =
+                    bufferStorage->getConstantBufferRange(uniformBufferOffset, uniformBufferSize);
+                if (bufferOrError.isError())
+                {
+                    return bufferOrError.getError();
+                }
+                constantBuffer = bufferOrError.getResult();
             }
 
             if (!constantBuffer)
@@ -1349,11 +1360,22 @@ gl::Error Renderer11::setUniformBuffers(const gl::Data &data,
 
             if (mRenderer11DeviceCaps.supportsConstantBufferOffsets)
             {
-                constantBuffer = bufferStorage->getBuffer(BUFFER_USAGE_UNIFORM);
+                auto bufferOrError = bufferStorage->getBuffer(BUFFER_USAGE_UNIFORM);
+                if (bufferOrError.isError())
+                {
+                    return bufferOrError.getError();
+                }
+                constantBuffer = bufferOrError.getResult();
             }
             else
             {
-                constantBuffer = bufferStorage->getConstantBufferRange(uniformBufferOffset, uniformBufferSize);
+                auto bufferOrError =
+                    bufferStorage->getConstantBufferRange(uniformBufferOffset, uniformBufferSize);
+                if (bufferOrError.isError())
+                {
+                    return bufferOrError.getError();
+                }
+                constantBuffer = bufferOrError.getResult();
             }
 
             if (!constantBuffer)
@@ -1542,7 +1564,12 @@ gl::Error Renderer11::applyIndexBuffer(const gl::Data &data,
     if (indexInfo->storage)
     {
         Buffer11 *storage = GetAs<Buffer11>(indexInfo->storage);
-        buffer = storage->getBuffer(BUFFER_USAGE_INDEX);
+        auto indexOrError = storage->getBuffer(BUFFER_USAGE_INDEX);
+        if (indexOrError.isError())
+        {
+            return indexOrError.getError();
+        }
+        buffer = indexOrError.getResult();
     }
     else
     {
@@ -1564,7 +1591,7 @@ gl::Error Renderer11::applyIndexBuffer(const gl::Data &data,
     return gl::Error(GL_NO_ERROR);
 }
 
-void Renderer11::applyTransformFeedbackBuffers(const gl::State &state)
+gl::Error Renderer11::applyTransformFeedbackBuffers(const gl::State &state)
 {
     size_t numXFBBindings = 0;
     bool requiresUpdate = false;
@@ -1579,11 +1606,16 @@ void Renderer11::applyTransformFeedbackBuffers(const gl::State &state)
         {
             const OffsetBindingPointer<gl::Buffer> &binding = transformFeedback->getIndexedBuffer(i);
 
-            ID3D11Buffer *d3dBuffer = NULL;
+            ID3D11Buffer *d3dBuffer = nullptr;
             if (binding.get() != nullptr)
             {
                 Buffer11 *storage = GetImplAs<Buffer11>(binding.get());
-                d3dBuffer = storage->getBuffer(BUFFER_USAGE_VERTEX_OR_TRANSFORM_FEEDBACK);
+                auto bufferOrError = storage->getBuffer(BUFFER_USAGE_VERTEX_OR_TRANSFORM_FEEDBACK);
+                if (bufferOrError.isError())
+                {
+                    return bufferOrError.getError();
+                }
+                d3dBuffer = bufferOrError.getResult();
             }
 
             // TODO: mAppliedTFBuffers and friends should also be kept in a vector.
@@ -1603,7 +1635,12 @@ void Renderer11::applyTransformFeedbackBuffers(const gl::State &state)
             if (binding.get() != nullptr)
             {
                 Buffer11 *storage = GetImplAs<Buffer11>(binding.get());
-                ID3D11Buffer *d3dBuffer = storage->getBuffer(BUFFER_USAGE_VERTEX_OR_TRANSFORM_FEEDBACK);
+                auto bufferOrError = storage->getBuffer(BUFFER_USAGE_VERTEX_OR_TRANSFORM_FEEDBACK);
+                if (bufferOrError.isError())
+                {
+                    return bufferOrError.getError();
+                }
+                ID3D11Buffer *d3dBuffer = bufferOrError.getResult();
 
                 mCurrentD3DOffsets[i] = (mAppliedTFBuffers[i] != d3dBuffer || mAppliedTFOffsets[i] != binding.getOffset()) ?
                                         static_cast<UINT>(binding.getOffset()) : -1;
@@ -1611,7 +1648,7 @@ void Renderer11::applyTransformFeedbackBuffers(const gl::State &state)
             }
             else
             {
-                mAppliedTFBuffers[i] = NULL;
+                mAppliedTFBuffers[i]  = nullptr;
                 mCurrentD3DOffsets[i] = 0;
             }
             mAppliedTFOffsets[i] = binding.getOffset();
@@ -1622,6 +1659,8 @@ void Renderer11::applyTransformFeedbackBuffers(const gl::State &state)
         mDeviceContext->SOSetTargets(static_cast<unsigned int>(numXFBBindings), mAppliedTFBuffers,
                                      mCurrentD3DOffsets);
     }
+
+    return gl::Error(GL_NO_ERROR);
 }
 
 gl::Error Renderer11::drawArraysImpl(const gl::Data &data,

src/libANGLE/renderer/d3d/d3d11/Renderer11.h

@@ -148,7 +148,7 @@ class Renderer11 : public RendererD3D
                                GLenum mode,
                                GLenum type,
                                TranslatedIndexData *indexInfo) override;
-    void applyTransformFeedbackBuffers(const gl::State &state) override;
+    gl::Error applyTransformFeedbackBuffers(const gl::State &state) override;
 
     // lost device
     bool testDeviceLost() override;

src/libANGLE/renderer/d3d/d3d9/Buffer9.cpp

@@ -104,9 +104,10 @@ gl::Error Buffer9::unmap(GLboolean *result)
     return gl::Error(GL_INVALID_OPERATION);
 }
 
-void Buffer9::markTransformFeedbackUsage()
+gl::Error Buffer9::markTransformFeedbackUsage()
 {
     UNREACHABLE();
+    return gl::Error(GL_INVALID_OPERATION);
 }
 
-}
+}  // namespace rx

src/libANGLE/renderer/d3d/d3d9/Buffer9.h

@@ -35,13 +35,13 @@ class Buffer9 : public BufferD3D
     virtual gl::Error map(GLenum access, GLvoid **mapPtr);
     virtual gl::Error mapRange(size_t offset, size_t length, GLbitfield access, GLvoid **mapPtr);
     virtual gl::Error unmap(GLboolean *result);
-    virtual void markTransformFeedbackUsage();
+    virtual gl::Error markTransformFeedbackUsage();
 
   private:
     MemoryBuffer mMemory;
     size_t mSize;
 };
 
-}
+}  // namespace rx
 
 #endif // LIBANGLE_RENDERER_D3D_D3D9_BUFFER9_H_

src/libANGLE/renderer/d3d/d3d9/Renderer9.cpp

@@ -1218,9 +1218,10 @@ gl::Error Renderer9::applyIndexBuffer(const gl::Data &data,
     return gl::Error(GL_NO_ERROR);
 }
 
-void Renderer9::applyTransformFeedbackBuffers(const gl::State& state)
+gl::Error Renderer9::applyTransformFeedbackBuffers(const gl::State &state)
 {
     ASSERT(!state.isTransformFeedbackActiveUnpaused());
+    return gl::Error(GL_NO_ERROR);
 }
 
 gl::Error Renderer9::drawArraysImpl(const gl::Data &data,

src/libANGLE/renderer/d3d/d3d9/Renderer9.h

@@ -134,7 +134,7 @@ class Renderer9 : public RendererD3D
                                GLenum type,
                                TranslatedIndexData *indexInfo) override;
 
-    void applyTransformFeedbackBuffers(const gl::State &state) override;
+    gl::Error applyTransformFeedbackBuffers(const gl::State &state) override;
 
     gl::Error clear(const ClearParameters &clearParams,
                     const gl::FramebufferAttachment *colorBuffer,

src/tests/gl_tests/D3D11EmulatedIndexedBufferTest.cpp

@@ -107,9 +107,10 @@ class D3D11EmulatedIndexedBufferTest : public ANGLETest
 
     void emulateAndCompare(rx::SourceIndexData *srcData)
     {
-        ID3D11Buffer* emulatedBuffer = mSourceBuffer->getEmulatedIndexedBuffer(srcData, &mTranslatedAttribute);
+        auto bufferOrError = mSourceBuffer->getEmulatedIndexedBuffer(srcData, mTranslatedAttribute);
+        ASSERT_FALSE(bufferOrError.isError());
+        ID3D11Buffer *emulatedBuffer = bufferOrError.getResult();
         ASSERT_TRUE(emulatedBuffer != nullptr);
-
         compareContents(emulatedBuffer);
     }
 

src/tests/perf_tests/IndexDataManagerTest.cpp

@@ -99,7 +99,7 @@ class MockBufferD3D : public rx::BufferD3D
     MOCK_METHOD1(unmap, gl::Error(GLboolean *));
 
     // BufferD3D
-    MOCK_METHOD0(markTransformFeedbackUsage, void());
+    MOCK_METHOD0(markTransformFeedbackUsage, gl::Error());
 
     // inlined for speed
     bool supportsDirectBinding() const override { return false; }