Revert "Clean up Buffer11."

src/libANGLE/Error.h

@@ -53,13 +53,7 @@ class ErrorOrResult
 {
   public:
     ErrorOrResult(const gl::Error &error) : mError(error) {}
-    ErrorOrResult(gl::Error &&error) : mError(std::move(error)) {}
-
-    template <typename ArgT>
-    ErrorOrResult(ArgT &&result)
-        : mError(GL_NO_ERROR), mResult(std::forward<T>(result))
-    {
-    }
+    ErrorOrResult(T &&result) : mError(GL_NO_ERROR), mResult(std::move(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 gl::Error markTransformFeedbackUsage() = 0;
+    virtual void markTransformFeedbackUsage() = 0;
     virtual gl::Error getData(const uint8_t **outData) = 0;
 
     StaticVertexBufferInterface *getStaticVertexBuffer(const gl::VertexAttribute &attribute);

src/libANGLE/renderer/d3d/RendererD3D.cpp

@@ -272,11 +272,7 @@ gl::Error RendererD3D::genericDrawArrays(const gl::Data &data,
 
         if (data.state->isTransformFeedbackActiveUnpaused())
         {
-            error = markTransformFeedbackUsage(data);
-            if (error.isError())
-            {
-                return error;
-            }
+            markTransformFeedbackUsage(data);
         }
     }
 
@@ -513,7 +509,7 @@ bool RendererD3D::skipDraw(const gl::Data &data, GLenum drawMode)
     return false;
 }
 
-gl::Error RendererD3D::markTransformFeedbackUsage(const gl::Data &data)
+void RendererD3D::markTransformFeedbackUsage(const gl::Data &data)
 {
     const gl::TransformFeedback *transformFeedback = data.state->getCurrentTransformFeedback();
     for (size_t i = 0; i < transformFeedback->getIndexedBufferCount(); i++)
@@ -522,15 +518,9 @@ gl::Error RendererD3D::markTransformFeedbackUsage(const gl::Data &data)
         if (binding.get() != nullptr)
         {
             BufferD3D *bufferD3D = GetImplAs<BufferD3D>(binding.get());
-            auto error = bufferD3D->markTransformFeedbackUsage();
-            if (error.isError())
-            {
-                return error;
-            }
+            bufferD3D->markTransformFeedbackUsage();
         }
     }
-
-    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 gl::Error applyTransformFeedbackBuffers(const gl::State &state) = 0;
+    virtual void 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);
-    gl::Error markTransformFeedbackUsage(const gl::Data &data);
+    void 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 alignedSpaceRequired;
+    return std::move(alignedSpaceRequired);
 }
 
 gl::Error VertexBufferInterface::discard()

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

@@ -62,13 +62,11 @@ class Buffer11 : public BufferD3D
     Buffer11(Renderer11 *renderer);
     virtual ~Buffer11();
 
-    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; }
+    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::Error packPixels(const gl::FramebufferAttachment &readAttachment,
                          const PackPixelsParams &params);
     size_t getTotalCPUBufferMemoryBytes() const;
@@ -85,7 +83,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 gl::Error markTransformFeedbackUsage();
+    virtual void markTransformFeedbackUsage();
 
   private:
     class BufferStorage;
@@ -122,19 +120,20 @@ class Buffer11 : public BufferD3D
 
     unsigned int mReadUsageCount;
 
-    gl::Error markBufferUsage();
-    gl::ErrorOrResult<NativeStorage *> getStagingStorage();
-    gl::ErrorOrResult<PackStorage *> getPackStorage();
-    gl::ErrorOrResult<SystemMemoryStorage *> getSystemMemoryStorage();
+    void markBufferUsage();
+    NativeStorage *getStagingStorage();
+    PackStorage *getPackStorage();
+    gl::Error getSystemMemoryStorage(SystemMemoryStorage **storageOut);
 
-    gl::Error updateBufferStorage(BufferStorage *storage, size_t sourceOffset, size_t storageSize);
-    gl::ErrorOrResult<BufferStorage *> getBufferStorage(BufferUsage usage);
-    gl::ErrorOrResult<BufferStorage *> getLatestBufferStorage() const;
+    void updateBufferStorage(BufferStorage *storage, size_t sourceOffset, size_t storageSize);
+    BufferStorage *getBufferStorage(BufferUsage usage);
+    BufferStorage *getLatestBufferStorage() const;
 
-    gl::ErrorOrResult<BufferStorage *> getConstantBufferRangeStorage(GLintptr offset,
-                                                                     GLsizeiptr size);
+    BufferStorage *getConstantBufferRangeStorage(GLintptr offset, GLsizeiptr size);
+
+    void invalidateEmulatedIndexedBuffer();
 };
 
-}  // namespace rx
+}
 
 #endif // LIBANGLE_RENDERER_D3D_D3D11_BUFFER11_H_

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

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

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

@@ -208,23 +208,18 @@ 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());
-    auto srvOrError = bufferStorage11->getSRV(srvFormat);
-    if (srvOrError.isError())
-    {
-        return srvOrError.getError();
-    }
-    ID3D11ShaderResourceView *bufferSRV = srvOrError.getResult();
-    ASSERT(bufferSRV != nullptr);
+    ID3D11ShaderResourceView *bufferSRV = bufferStorage11->getSRV(srvFormat);
+    ASSERT(bufferSRV != NULL);
 
     ID3D11RenderTargetView *textureRTV = GetAs<RenderTarget11>(destRenderTarget)->getRenderTargetView();
-    ASSERT(textureRTV != nullptr);
+    ASSERT(textureRTV != NULL);
 
     CopyShaderParams shaderParams;
     setBufferToTextureCopyParams(destArea, destSize, sourceFormat, unpack, offset, &shaderParams);
 
     ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext();
 
-    ID3D11Buffer *nullBuffer = nullptr;
+    ID3D11Buffer *nullBuffer = NULL;
     UINT zero = 0;
 
     // Are we doing a 2D or 3D copy?

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

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

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

@@ -104,10 +104,9 @@ gl::Error Buffer9::unmap(GLboolean *result)
     return gl::Error(GL_INVALID_OPERATION);
 }
 
-gl::Error Buffer9::markTransformFeedbackUsage()
+void 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 gl::Error markTransformFeedbackUsage();
+    virtual void markTransformFeedbackUsage();
 
   private:
     MemoryBuffer mMemory;
     size_t mSize;
 };
 
-}  // namespace rx
+}
 
 #endif // LIBANGLE_RENDERER_D3D_D3D9_BUFFER9_H_

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

@@ -1218,10 +1218,9 @@ gl::Error Renderer9::applyIndexBuffer(const gl::Data &data,
     return gl::Error(GL_NO_ERROR);
 }
 
-gl::Error Renderer9::applyTransformFeedbackBuffers(const gl::State &state)
+void 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;
 
-    gl::Error applyTransformFeedbackBuffers(const gl::State &state) override;
+    void applyTransformFeedbackBuffers(const gl::State &state) override;
 
     gl::Error clear(const ClearParameters &clearParams,
                     const gl::FramebufferAttachment *colorBuffer,

src/tests/gl_tests/D3D11EmulatedIndexedBufferTest.cpp

@@ -107,10 +107,9 @@ class D3D11EmulatedIndexedBufferTest : public ANGLETest
 
     void emulateAndCompare(rx::SourceIndexData *srcData)
     {
-        auto bufferOrError = mSourceBuffer->getEmulatedIndexedBuffer(srcData, mTranslatedAttribute);
-        ASSERT_FALSE(bufferOrError.isError());
-        ID3D11Buffer *emulatedBuffer = bufferOrError.getResult();
+        ID3D11Buffer* emulatedBuffer = mSourceBuffer->getEmulatedIndexedBuffer(srcData, &mTranslatedAttribute);
         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, gl::Error());
+    MOCK_METHOD0(markTransformFeedbackUsage, void());
 
     // inlined for speed
     bool supportsDirectBinding() const override { return false; }