Index: gpu/command_buffer/service/buffer_manager_unittest.cc |
=================================================================== |
--- gpu/command_buffer/service/buffer_manager_unittest.cc (revision 186458) |
+++ gpu/command_buffer/service/buffer_manager_unittest.cc (working copy) |
@@ -3,15 +3,10 @@ |
// found in the LICENSE file. |
#include "gpu/command_buffer/service/buffer_manager.h" |
-#include "gpu/command_buffer/service/feature_info.h" |
-#include "gpu/command_buffer/service/gles2_cmd_decoder_mock.h" |
#include "gpu/command_buffer/service/mocks.h" |
-#include "gpu/command_buffer/service/test_helper.h" |
#include "testing/gtest/include/gtest/gtest.h" |
#include "ui/gl/gl_mock.h" |
-using ::testing::_; |
-using ::testing::Return; |
using ::testing::StrictMock; |
namespace gpu { |
@@ -19,73 +14,32 @@ |
class BufferManagerTestBase : public testing::Test { |
protected: |
- void SetUpBase( |
- MemoryTracker* memory_tracker, |
- FeatureInfo* feature_info, |
- const char* extensions, |
- const char* vendor, |
- const char* renderer) { |
+ void SetUpBase(MemoryTracker* memory_tracker) { |
gl_.reset(new ::testing::StrictMock< ::gfx::MockGLInterface>()); |
::gfx::GLInterface::SetGLInterface(gl_.get()); |
- if (feature_info) { |
- TestHelper::SetupFeatureInfoInitExpectationsWithVendor( |
- gl_.get(), extensions, vendor, renderer); |
- feature_info->Initialize(NULL); |
- } |
- decoder_.reset(new MockGLES2Decoder()); |
- manager_.reset(new BufferManager(memory_tracker, feature_info)); |
+ manager_.reset(new BufferManager(memory_tracker)); |
} |
virtual void TearDown() { |
manager_->Destroy(false); |
manager_.reset(); |
::gfx::GLInterface::SetGLInterface(NULL); |
- decoder_.reset(); |
gl_.reset(); |
} |
- GLenum GetTarget(const Buffer* buffer) const { |
- return buffer->target(); |
+ GLenum GetTarget(const Buffer* info) const { |
+ return info->target(); |
} |
- void DoBufferData( |
- Buffer* buffer, GLsizeiptr size, GLenum usage, const GLvoid* data, |
- GLenum error) { |
- TestHelper::DoBufferData( |
- gl_.get(), decoder_.get(), manager_.get(), |
- buffer, size, usage, data, error); |
- } |
- |
- bool DoBufferSubData( |
- Buffer* buffer, GLintptr offset, GLsizeiptr size, |
- const GLvoid* data) { |
- bool success = true; |
- if (!buffer->CheckRange(offset, size)) { |
- EXPECT_CALL(*decoder_, SetGLError(GL_INVALID_VALUE, _, _)) |
- .Times(1) |
- .RetiresOnSaturation(); |
- success = false; |
- } else if (!buffer->IsClientSideArray()) { |
- EXPECT_CALL(*gl_, BufferSubData( |
- buffer->target(), offset, size, _)) |
- .Times(1) |
- .RetiresOnSaturation(); |
- } |
- manager_->DoBufferSubData( |
- decoder_.get(), buffer, offset, size, data); |
- return success; |
- } |
- |
// Use StrictMock to make 100% sure we know how GL will be called. |
scoped_ptr< ::testing::StrictMock< ::gfx::MockGLInterface> > gl_; |
scoped_ptr<BufferManager> manager_; |
- scoped_ptr<MockGLES2Decoder> decoder_; |
}; |
class BufferManagerTest : public BufferManagerTestBase { |
protected: |
virtual void SetUp() { |
- SetUpBase(NULL, NULL, "", "", ""); |
+ SetUpBase(NULL); |
} |
}; |
@@ -93,22 +47,12 @@ |
protected: |
virtual void SetUp() { |
mock_memory_tracker_ = new StrictMock<MockMemoryTracker>(); |
- SetUpBase(mock_memory_tracker_.get(), NULL, "", "", ""); |
+ SetUpBase(mock_memory_tracker_.get()); |
} |
scoped_refptr<MockMemoryTracker> mock_memory_tracker_; |
}; |
-class BufferManagerClientSideArraysTest : public BufferManagerTestBase { |
- protected: |
- virtual void SetUp() { |
- feature_info_ = new FeatureInfo(); |
- SetUpBase(NULL, feature_info_.get(), "", "Imagination Technologies", ""); |
- } |
- |
- scoped_refptr<FeatureInfo> feature_info_; |
-}; |
- |
#define EXPECT_MEMORY_ALLOCATION_CHANGE(old_size, new_size, pool) \ |
EXPECT_CALL(*mock_memory_tracker_, \ |
TrackMemoryAllocatedChange(old_size, new_size, pool)) \ |
@@ -123,23 +67,22 @@ |
// Check we can create buffer. |
manager_->CreateBuffer(kClientBuffer1Id, kServiceBuffer1Id); |
// Check buffer got created. |
- Buffer* buffer1 = manager_->GetBuffer(kClientBuffer1Id); |
- ASSERT_TRUE(buffer1 != NULL); |
- EXPECT_EQ(0u, GetTarget(buffer1)); |
- EXPECT_EQ(0, buffer1->size()); |
- EXPECT_EQ(static_cast<GLenum>(GL_STATIC_DRAW), buffer1->usage()); |
- EXPECT_FALSE(buffer1->IsDeleted()); |
- EXPECT_FALSE(buffer1->IsClientSideArray()); |
- EXPECT_EQ(kServiceBuffer1Id, buffer1->service_id()); |
+ Buffer* info1 = manager_->GetBuffer(kClientBuffer1Id); |
+ ASSERT_TRUE(info1 != NULL); |
+ EXPECT_EQ(0u, GetTarget(info1)); |
+ EXPECT_EQ(0, info1->size()); |
+ EXPECT_EQ(static_cast<GLenum>(GL_STATIC_DRAW), info1->usage()); |
+ EXPECT_FALSE(info1->IsDeleted()); |
+ EXPECT_EQ(kServiceBuffer1Id, info1->service_id()); |
GLuint client_id = 0; |
- EXPECT_TRUE(manager_->GetClientId(buffer1->service_id(), &client_id)); |
+ EXPECT_TRUE(manager_->GetClientId(info1->service_id(), &client_id)); |
EXPECT_EQ(kClientBuffer1Id, client_id); |
- manager_->SetTarget(buffer1, GL_ELEMENT_ARRAY_BUFFER); |
- EXPECT_EQ(static_cast<GLenum>(GL_ELEMENT_ARRAY_BUFFER), GetTarget(buffer1)); |
+ manager_->SetTarget(info1, GL_ELEMENT_ARRAY_BUFFER); |
+ EXPECT_EQ(static_cast<GLenum>(GL_ELEMENT_ARRAY_BUFFER), GetTarget(info1)); |
// Check we and set its size. |
- DoBufferData(buffer1, kBuffer1Size, GL_DYNAMIC_DRAW, NULL, GL_NO_ERROR); |
- EXPECT_EQ(kBuffer1Size, buffer1->size()); |
- EXPECT_EQ(static_cast<GLenum>(GL_DYNAMIC_DRAW), buffer1->usage()); |
+ manager_->SetInfo(info1, kBuffer1Size, GL_DYNAMIC_DRAW); |
+ EXPECT_EQ(kBuffer1Size, info1->size()); |
+ EXPECT_EQ(static_cast<GLenum>(GL_DYNAMIC_DRAW), info1->usage()); |
// Check we get nothing for a non-existent buffer. |
EXPECT_TRUE(manager_->GetBuffer(kClientBuffer2Id) == NULL); |
// Check trying to a remove non-existent buffers does not crash. |
@@ -162,15 +105,15 @@ |
EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0, MemoryTracker::kManaged); |
manager_->CreateBuffer(kClientBuffer1Id, kServiceBuffer1Id); |
// Check buffer got created. |
- Buffer* buffer1 = manager_->GetBuffer(kClientBuffer1Id); |
- ASSERT_TRUE(buffer1 != NULL); |
- manager_->SetTarget(buffer1, GL_ELEMENT_ARRAY_BUFFER); |
+ Buffer* info1 = manager_->GetBuffer(kClientBuffer1Id); |
+ ASSERT_TRUE(info1 != NULL); |
+ manager_->SetTarget(info1, GL_ELEMENT_ARRAY_BUFFER); |
// Check we and set its size. |
EXPECT_MEMORY_ALLOCATION_CHANGE(0, kBuffer1Size1, MemoryTracker::kManaged); |
- DoBufferData(buffer1, kBuffer1Size1, GL_DYNAMIC_DRAW, NULL, GL_NO_ERROR); |
+ manager_->SetInfo(info1, kBuffer1Size1, GL_DYNAMIC_DRAW); |
EXPECT_MEMORY_ALLOCATION_CHANGE(kBuffer1Size1, 0, MemoryTracker::kManaged); |
EXPECT_MEMORY_ALLOCATION_CHANGE(0, kBuffer1Size2, MemoryTracker::kManaged); |
- DoBufferData(buffer1, kBuffer1Size2, GL_DYNAMIC_DRAW, NULL, GL_NO_ERROR); |
+ manager_->SetInfo(info1, kBuffer1Size2, GL_DYNAMIC_DRAW); |
// On delete it will get freed. |
EXPECT_MEMORY_ALLOCATION_CHANGE(kBuffer1Size2, 0, MemoryTracker::kManaged); |
} |
@@ -181,37 +124,38 @@ |
// Check we can create buffer. |
manager_->CreateBuffer(kClient1Id, kService1Id); |
// Check buffer got created. |
- Buffer* buffer1 = manager_->GetBuffer(kClient1Id); |
- ASSERT_TRUE(buffer1 != NULL); |
+ Buffer* info1 = |
+ manager_->GetBuffer(kClient1Id); |
+ ASSERT_TRUE(info1 != NULL); |
EXPECT_CALL(*gl_, DeleteBuffersARB(1, ::testing::Pointee(kService1Id))) |
.Times(1) |
.RetiresOnSaturation(); |
manager_->Destroy(true); |
// Check the resources were released. |
- buffer1 = manager_->GetBuffer(kClient1Id); |
- ASSERT_TRUE(buffer1 == NULL); |
+ info1 = manager_->GetBuffer(kClient1Id); |
+ ASSERT_TRUE(info1 == NULL); |
} |
-TEST_F(BufferManagerTest, DoBufferSubData) { |
+TEST_F(BufferManagerTest, SetRange) { |
const GLuint kClientBufferId = 1; |
const GLuint kServiceBufferId = 11; |
const uint8 data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1}; |
manager_->CreateBuffer(kClientBufferId, kServiceBufferId); |
- Buffer* buffer = manager_->GetBuffer(kClientBufferId); |
- ASSERT_TRUE(buffer != NULL); |
- manager_->SetTarget(buffer, GL_ELEMENT_ARRAY_BUFFER); |
- DoBufferData(buffer, sizeof(data), GL_STATIC_DRAW, NULL, GL_NO_ERROR); |
- EXPECT_TRUE(DoBufferSubData(buffer, 0, sizeof(data), data)); |
- EXPECT_TRUE(DoBufferSubData(buffer, sizeof(data), 0, data)); |
- EXPECT_FALSE(DoBufferSubData(buffer, sizeof(data), 1, data)); |
- EXPECT_FALSE(DoBufferSubData(buffer, 0, sizeof(data) + 1, data)); |
- EXPECT_FALSE(DoBufferSubData(buffer, -1, sizeof(data), data)); |
- EXPECT_FALSE(DoBufferSubData(buffer, 0, -1, data)); |
- DoBufferData(buffer, 1, GL_STATIC_DRAW, NULL, GL_NO_ERROR); |
+ Buffer* info = manager_->GetBuffer(kClientBufferId); |
+ ASSERT_TRUE(info != NULL); |
+ manager_->SetTarget(info, GL_ELEMENT_ARRAY_BUFFER); |
+ manager_->SetInfo(info, sizeof(data), GL_STATIC_DRAW); |
+ EXPECT_TRUE(info->SetRange(0, sizeof(data), data)); |
+ EXPECT_TRUE(info->SetRange(sizeof(data), 0, data)); |
+ EXPECT_FALSE(info->SetRange(sizeof(data), 1, data)); |
+ EXPECT_FALSE(info->SetRange(0, sizeof(data) + 1, data)); |
+ EXPECT_FALSE(info->SetRange(-1, sizeof(data), data)); |
+ EXPECT_FALSE(info->SetRange(0, -1, data)); |
+ manager_->SetInfo(info, 1, GL_STATIC_DRAW); |
const int size = 0x20000; |
scoped_array<uint8> temp(new uint8[size]); |
- EXPECT_FALSE(DoBufferSubData(buffer, 0 - size, size, temp.get())); |
- EXPECT_FALSE(DoBufferSubData(buffer, 1, size / 2, temp.get())); |
+ EXPECT_FALSE(info->SetRange(0 - size, size, temp.get())); |
+ EXPECT_FALSE(info->SetRange(1, size / 2, temp.get())); |
} |
TEST_F(BufferManagerTest, GetRange) { |
@@ -219,24 +163,23 @@ |
const GLuint kServiceBufferId = 11; |
const uint8 data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1}; |
manager_->CreateBuffer(kClientBufferId, kServiceBufferId); |
- Buffer* buffer = manager_->GetBuffer(kClientBufferId); |
- ASSERT_TRUE(buffer != NULL); |
- manager_->SetTarget(buffer, GL_ELEMENT_ARRAY_BUFFER); |
- DoBufferData(buffer, sizeof(data), GL_STATIC_DRAW, NULL, GL_NO_ERROR); |
- const char* buf = |
- static_cast<const char*>(buffer->GetRange(0, sizeof(data))); |
+ Buffer* info = manager_->GetBuffer(kClientBufferId); |
+ ASSERT_TRUE(info != NULL); |
+ manager_->SetTarget(info, GL_ELEMENT_ARRAY_BUFFER); |
+ manager_->SetInfo(info, sizeof(data), GL_STATIC_DRAW); |
+ const char* buf = static_cast<const char*>(info->GetRange(0, sizeof(data))); |
ASSERT_TRUE(buf != NULL); |
const char* buf1 = |
- static_cast<const char*>(buffer->GetRange(1, sizeof(data) - 1)); |
+ static_cast<const char*>(info->GetRange(1, sizeof(data) - 1)); |
EXPECT_EQ(buf + 1, buf1); |
- EXPECT_TRUE(buffer->GetRange(sizeof(data), 1) == NULL); |
- EXPECT_TRUE(buffer->GetRange(0, sizeof(data) + 1) == NULL); |
- EXPECT_TRUE(buffer->GetRange(-1, sizeof(data)) == NULL); |
- EXPECT_TRUE(buffer->GetRange(-0, -1) == NULL); |
+ EXPECT_TRUE(info->GetRange(sizeof(data), 1) == NULL); |
+ EXPECT_TRUE(info->GetRange(0, sizeof(data) + 1) == NULL); |
+ EXPECT_TRUE(info->GetRange(-1, sizeof(data)) == NULL); |
+ EXPECT_TRUE(info->GetRange(-0, -1) == NULL); |
const int size = 0x20000; |
- DoBufferData(buffer, size / 2, GL_STATIC_DRAW, NULL, GL_NO_ERROR); |
- EXPECT_TRUE(buffer->GetRange(0 - size, size) == NULL); |
- EXPECT_TRUE(buffer->GetRange(1, size / 2) == NULL); |
+ manager_->SetInfo(info, size / 2, GL_STATIC_DRAW); |
+ EXPECT_TRUE(info->GetRange(0 - size, size) == NULL); |
+ EXPECT_TRUE(info->GetRange(1, size / 2) == NULL); |
} |
TEST_F(BufferManagerTest, GetMaxValueForRangeUint8) { |
@@ -245,34 +188,28 @@ |
const uint8 data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1}; |
const uint8 new_data[] = {100, 120, 110}; |
manager_->CreateBuffer(kClientBufferId, kServiceBufferId); |
- Buffer* buffer = manager_->GetBuffer(kClientBufferId); |
- ASSERT_TRUE(buffer != NULL); |
- manager_->SetTarget(buffer, GL_ELEMENT_ARRAY_BUFFER); |
- DoBufferData(buffer, sizeof(data), GL_STATIC_DRAW, NULL, GL_NO_ERROR); |
- EXPECT_TRUE(DoBufferSubData(buffer, 0, sizeof(data), data)); |
+ Buffer* info = manager_->GetBuffer(kClientBufferId); |
+ ASSERT_TRUE(info != NULL); |
+ manager_->SetTarget(info, GL_ELEMENT_ARRAY_BUFFER); |
+ manager_->SetInfo(info, sizeof(data), GL_STATIC_DRAW); |
+ EXPECT_TRUE(info->SetRange(0, sizeof(data), data)); |
GLuint max_value; |
// Check entire range succeeds. |
- EXPECT_TRUE(buffer->GetMaxValueForRange( |
- 0, 10, GL_UNSIGNED_BYTE, &max_value)); |
+ EXPECT_TRUE(info->GetMaxValueForRange(0, 10, GL_UNSIGNED_BYTE, &max_value)); |
EXPECT_EQ(10u, max_value); |
// Check sub range succeeds. |
- EXPECT_TRUE(buffer->GetMaxValueForRange( |
- 4, 3, GL_UNSIGNED_BYTE, &max_value)); |
+ EXPECT_TRUE(info->GetMaxValueForRange(4, 3, GL_UNSIGNED_BYTE, &max_value)); |
EXPECT_EQ(6u, max_value); |
// Check changing sub range succeeds. |
- EXPECT_TRUE(DoBufferSubData(buffer, 4, sizeof(new_data), new_data)); |
- EXPECT_TRUE(buffer->GetMaxValueForRange( |
- 4, 3, GL_UNSIGNED_BYTE, &max_value)); |
+ EXPECT_TRUE(info->SetRange(4, sizeof(new_data), new_data)); |
+ EXPECT_TRUE(info->GetMaxValueForRange(4, 3, GL_UNSIGNED_BYTE, &max_value)); |
EXPECT_EQ(120u, max_value); |
max_value = 0; |
- EXPECT_TRUE(buffer->GetMaxValueForRange( |
- 0, 10, GL_UNSIGNED_BYTE, &max_value)); |
+ EXPECT_TRUE(info->GetMaxValueForRange(0, 10, GL_UNSIGNED_BYTE, &max_value)); |
EXPECT_EQ(120u, max_value); |
// Check out of range fails. |
- EXPECT_FALSE(buffer->GetMaxValueForRange( |
- 0, 11, GL_UNSIGNED_BYTE, &max_value)); |
- EXPECT_FALSE(buffer->GetMaxValueForRange( |
- 10, 1, GL_UNSIGNED_BYTE, &max_value)); |
+ EXPECT_FALSE(info->GetMaxValueForRange(0, 11, GL_UNSIGNED_BYTE, &max_value)); |
+ EXPECT_FALSE(info->GetMaxValueForRange(10, 1, GL_UNSIGNED_BYTE, &max_value)); |
} |
TEST_F(BufferManagerTest, GetMaxValueForRangeUint16) { |
@@ -281,37 +218,30 @@ |
const uint16 data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1}; |
const uint16 new_data[] = {100, 120, 110}; |
manager_->CreateBuffer(kClientBufferId, kServiceBufferId); |
- Buffer* buffer = manager_->GetBuffer(kClientBufferId); |
- ASSERT_TRUE(buffer != NULL); |
- manager_->SetTarget(buffer, GL_ELEMENT_ARRAY_BUFFER); |
- DoBufferData(buffer, sizeof(data), GL_STATIC_DRAW, NULL, GL_NO_ERROR); |
- EXPECT_TRUE(DoBufferSubData(buffer, 0, sizeof(data), data)); |
+ Buffer* info = manager_->GetBuffer(kClientBufferId); |
+ ASSERT_TRUE(info != NULL); |
+ manager_->SetTarget(info, GL_ELEMENT_ARRAY_BUFFER); |
+ manager_->SetInfo(info, sizeof(data), GL_STATIC_DRAW); |
+ EXPECT_TRUE(info->SetRange(0, sizeof(data), data)); |
GLuint max_value; |
// Check entire range succeeds. |
- EXPECT_TRUE(buffer->GetMaxValueForRange( |
- 0, 10, GL_UNSIGNED_SHORT, &max_value)); |
+ EXPECT_TRUE(info->GetMaxValueForRange(0, 10, GL_UNSIGNED_SHORT, &max_value)); |
EXPECT_EQ(10u, max_value); |
// Check odd offset fails for GL_UNSIGNED_SHORT. |
- EXPECT_FALSE(buffer->GetMaxValueForRange( |
- 1, 10, GL_UNSIGNED_SHORT, &max_value)); |
+ EXPECT_FALSE(info->GetMaxValueForRange(1, 10, GL_UNSIGNED_SHORT, &max_value)); |
// Check sub range succeeds. |
- EXPECT_TRUE(buffer->GetMaxValueForRange( |
- 8, 3, GL_UNSIGNED_SHORT, &max_value)); |
+ EXPECT_TRUE(info->GetMaxValueForRange(8, 3, GL_UNSIGNED_SHORT, &max_value)); |
EXPECT_EQ(6u, max_value); |
// Check changing sub range succeeds. |
- EXPECT_TRUE(DoBufferSubData(buffer, 8, sizeof(new_data), new_data)); |
- EXPECT_TRUE(buffer->GetMaxValueForRange( |
- 8, 3, GL_UNSIGNED_SHORT, &max_value)); |
+ EXPECT_TRUE(info->SetRange(8, sizeof(new_data), new_data)); |
+ EXPECT_TRUE(info->GetMaxValueForRange(8, 3, GL_UNSIGNED_SHORT, &max_value)); |
EXPECT_EQ(120u, max_value); |
max_value = 0; |
- EXPECT_TRUE(buffer->GetMaxValueForRange( |
- 0, 10, GL_UNSIGNED_SHORT, &max_value)); |
+ EXPECT_TRUE(info->GetMaxValueForRange(0, 10, GL_UNSIGNED_SHORT, &max_value)); |
EXPECT_EQ(120u, max_value); |
// Check out of range fails. |
- EXPECT_FALSE(buffer->GetMaxValueForRange( |
- 0, 11, GL_UNSIGNED_SHORT, &max_value)); |
- EXPECT_FALSE(buffer->GetMaxValueForRange( |
- 20, 1, GL_UNSIGNED_SHORT, &max_value)); |
+ EXPECT_FALSE(info->GetMaxValueForRange(0, 11, GL_UNSIGNED_SHORT, &max_value)); |
+ EXPECT_FALSE(info->GetMaxValueForRange(20, 1, GL_UNSIGNED_SHORT, &max_value)); |
} |
TEST_F(BufferManagerTest, GetMaxValueForRangeUint32) { |
@@ -320,38 +250,32 @@ |
const uint32 data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1}; |
const uint32 new_data[] = {100, 120, 110}; |
manager_->CreateBuffer(kClientBufferId, kServiceBufferId); |
- Buffer* buffer = manager_->GetBuffer(kClientBufferId); |
- ASSERT_TRUE(buffer != NULL); |
- manager_->SetTarget(buffer, GL_ELEMENT_ARRAY_BUFFER); |
- DoBufferData(buffer, sizeof(data), GL_STATIC_DRAW, NULL, GL_NO_ERROR); |
- EXPECT_TRUE(DoBufferSubData(buffer, 0, sizeof(data), data)); |
+ Buffer* info = manager_->GetBuffer(kClientBufferId); |
+ ASSERT_TRUE(info != NULL); |
+ manager_->SetTarget(info, GL_ELEMENT_ARRAY_BUFFER); |
+ manager_->SetInfo(info, sizeof(data), GL_STATIC_DRAW); |
+ EXPECT_TRUE(info->SetRange(0, sizeof(data), data)); |
GLuint max_value; |
// Check entire range succeeds. |
- EXPECT_TRUE( |
- buffer->GetMaxValueForRange(0, 10, GL_UNSIGNED_INT, &max_value)); |
+ EXPECT_TRUE(info->GetMaxValueForRange(0, 10, GL_UNSIGNED_INT, &max_value)); |
EXPECT_EQ(10u, max_value); |
// Check non aligned offsets fails for GL_UNSIGNED_INT. |
- EXPECT_FALSE( |
- buffer->GetMaxValueForRange(1, 10, GL_UNSIGNED_INT, &max_value)); |
- EXPECT_FALSE( |
- buffer->GetMaxValueForRange(2, 10, GL_UNSIGNED_INT, &max_value)); |
- EXPECT_FALSE( |
- buffer->GetMaxValueForRange(3, 10, GL_UNSIGNED_INT, &max_value)); |
+ EXPECT_FALSE(info->GetMaxValueForRange(1, 10, GL_UNSIGNED_INT, &max_value)); |
+ EXPECT_FALSE(info->GetMaxValueForRange(2, 10, GL_UNSIGNED_INT, &max_value)); |
+ EXPECT_FALSE(info->GetMaxValueForRange(3, 10, GL_UNSIGNED_INT, &max_value)); |
// Check sub range succeeds. |
- EXPECT_TRUE(buffer->GetMaxValueForRange(16, 3, GL_UNSIGNED_INT, &max_value)); |
+ EXPECT_TRUE(info->GetMaxValueForRange(16, 3, GL_UNSIGNED_INT, &max_value)); |
EXPECT_EQ(6u, max_value); |
// Check changing sub range succeeds. |
- EXPECT_TRUE(DoBufferSubData(buffer, 16, sizeof(new_data), new_data)); |
- EXPECT_TRUE(buffer->GetMaxValueForRange(16, 3, GL_UNSIGNED_INT, &max_value)); |
+ EXPECT_TRUE(info->SetRange(16, sizeof(new_data), new_data)); |
+ EXPECT_TRUE(info->GetMaxValueForRange(16, 3, GL_UNSIGNED_INT, &max_value)); |
EXPECT_EQ(120u, max_value); |
max_value = 0; |
- EXPECT_TRUE(buffer->GetMaxValueForRange(0, 10, GL_UNSIGNED_INT, &max_value)); |
+ EXPECT_TRUE(info->GetMaxValueForRange(0, 10, GL_UNSIGNED_INT, &max_value)); |
EXPECT_EQ(120u, max_value); |
// Check out of range fails. |
- EXPECT_FALSE( |
- buffer->GetMaxValueForRange(0, 11, GL_UNSIGNED_INT, &max_value)); |
- EXPECT_FALSE( |
- buffer->GetMaxValueForRange(40, 1, GL_UNSIGNED_INT, &max_value)); |
+ EXPECT_FALSE(info->GetMaxValueForRange(0, 11, GL_UNSIGNED_INT, &max_value)); |
+ EXPECT_FALSE(info->GetMaxValueForRange(40, 1, GL_UNSIGNED_INT, &max_value)); |
} |
TEST_F(BufferManagerTest, UseDeletedBuffer) { |
@@ -359,36 +283,21 @@ |
const GLuint kServiceBufferId = 11; |
const uint32 data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1}; |
manager_->CreateBuffer(kClientBufferId, kServiceBufferId); |
- scoped_refptr<Buffer> buffer = manager_->GetBuffer(kClientBufferId); |
- ASSERT_TRUE(buffer != NULL); |
- manager_->SetTarget(buffer, GL_ARRAY_BUFFER); |
+ scoped_refptr<Buffer> info = |
+ manager_->GetBuffer(kClientBufferId); |
+ ASSERT_TRUE(info != NULL); |
+ manager_->SetTarget(info, GL_ARRAY_BUFFER); |
// Remove buffer |
manager_->RemoveBuffer(kClientBufferId); |
// Use it after removing |
- DoBufferData(buffer, sizeof(data), GL_STATIC_DRAW, NULL, GL_NO_ERROR); |
+ manager_->SetInfo(info, sizeof(data), GL_STATIC_DRAW); |
// Check that it gets deleted when the last reference is released. |
EXPECT_CALL(*gl_, DeleteBuffersARB(1, ::testing::Pointee(kServiceBufferId))) |
.Times(1) |
.RetiresOnSaturation(); |
- buffer = NULL; |
+ info = NULL; |
} |
-// Test buffers get shadowed when they are supposed to be. |
-TEST_F(BufferManagerClientSideArraysTest, StreamBuffersAreShadowed) { |
- const GLuint kClientBufferId = 1; |
- const GLuint kServiceBufferId = 11; |
- static const uint32 data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1}; |
- manager_->CreateBuffer(kClientBufferId, kServiceBufferId); |
- Buffer* buffer = manager_->GetBuffer(kClientBufferId); |
- ASSERT_TRUE(buffer != NULL); |
- manager_->SetTarget(buffer, GL_ARRAY_BUFFER); |
- DoBufferData(buffer, sizeof(data), GL_STREAM_DRAW, data, GL_NO_ERROR); |
- EXPECT_TRUE(buffer->IsClientSideArray()); |
- EXPECT_EQ(0, memcmp(data, buffer->GetRange(0, sizeof(data)), sizeof(data))); |
- DoBufferData(buffer, sizeof(data), GL_DYNAMIC_DRAW, data, GL_NO_ERROR); |
- EXPECT_FALSE(buffer->IsClientSideArray()); |
-} |
- |
} // namespace gles2 |
} // namespace gpu |