OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "gpu/command_buffer/service/buffer_manager.h" | 5 #include "gpu/command_buffer/service/buffer_manager.h" |
6 #include "gpu/command_buffer/service/feature_info.h" | |
7 #include "gpu/command_buffer/service/gles2_cmd_decoder_mock.h" | |
8 #include "gpu/command_buffer/service/mocks.h" | 6 #include "gpu/command_buffer/service/mocks.h" |
9 #include "gpu/command_buffer/service/test_helper.h" | |
10 #include "testing/gtest/include/gtest/gtest.h" | 7 #include "testing/gtest/include/gtest/gtest.h" |
11 #include "ui/gl/gl_mock.h" | 8 #include "ui/gl/gl_mock.h" |
12 | 9 |
13 using ::testing::_; | |
14 using ::testing::Return; | |
15 using ::testing::StrictMock; | 10 using ::testing::StrictMock; |
16 | 11 |
17 namespace gpu { | 12 namespace gpu { |
18 namespace gles2 { | 13 namespace gles2 { |
19 | 14 |
20 class BufferManagerTestBase : public testing::Test { | 15 class BufferManagerTestBase : public testing::Test { |
21 protected: | 16 protected: |
22 void SetUpBase( | 17 void SetUpBase(MemoryTracker* memory_tracker) { |
23 MemoryTracker* memory_tracker, | |
24 FeatureInfo* feature_info, | |
25 const char* extensions, | |
26 const char* vendor, | |
27 const char* renderer) { | |
28 gl_.reset(new ::testing::StrictMock< ::gfx::MockGLInterface>()); | 18 gl_.reset(new ::testing::StrictMock< ::gfx::MockGLInterface>()); |
29 ::gfx::GLInterface::SetGLInterface(gl_.get()); | 19 ::gfx::GLInterface::SetGLInterface(gl_.get()); |
30 if (feature_info) { | 20 manager_.reset(new BufferManager(memory_tracker)); |
31 TestHelper::SetupFeatureInfoInitExpectationsWithVendor( | |
32 gl_.get(), extensions, vendor, renderer); | |
33 feature_info->Initialize(NULL); | |
34 } | |
35 decoder_.reset(new MockGLES2Decoder()); | |
36 manager_.reset(new BufferManager(memory_tracker, feature_info)); | |
37 } | 21 } |
38 | 22 |
39 virtual void TearDown() { | 23 virtual void TearDown() { |
40 manager_->Destroy(false); | 24 manager_->Destroy(false); |
41 manager_.reset(); | 25 manager_.reset(); |
42 ::gfx::GLInterface::SetGLInterface(NULL); | 26 ::gfx::GLInterface::SetGLInterface(NULL); |
43 decoder_.reset(); | |
44 gl_.reset(); | 27 gl_.reset(); |
45 } | 28 } |
46 | 29 |
47 GLenum GetTarget(const Buffer* buffer) const { | 30 GLenum GetTarget(const Buffer* info) const { |
48 return buffer->target(); | 31 return info->target(); |
49 } | |
50 | |
51 void DoBufferData( | |
52 Buffer* buffer, GLsizeiptr size, GLenum usage, const GLvoid* data, | |
53 GLenum error) { | |
54 TestHelper::DoBufferData( | |
55 gl_.get(), decoder_.get(), manager_.get(), | |
56 buffer, size, usage, data, error); | |
57 } | |
58 | |
59 bool DoBufferSubData( | |
60 Buffer* buffer, GLintptr offset, GLsizeiptr size, | |
61 const GLvoid* data) { | |
62 bool success = true; | |
63 if (!buffer->CheckRange(offset, size)) { | |
64 EXPECT_CALL(*decoder_, SetGLError(GL_INVALID_VALUE, _, _)) | |
65 .Times(1) | |
66 .RetiresOnSaturation(); | |
67 success = false; | |
68 } else if (!buffer->IsClientSideArray()) { | |
69 EXPECT_CALL(*gl_, BufferSubData( | |
70 buffer->target(), offset, size, _)) | |
71 .Times(1) | |
72 .RetiresOnSaturation(); | |
73 } | |
74 manager_->DoBufferSubData( | |
75 decoder_.get(), buffer, offset, size, data); | |
76 return success; | |
77 } | 32 } |
78 | 33 |
79 // Use StrictMock to make 100% sure we know how GL will be called. | 34 // Use StrictMock to make 100% sure we know how GL will be called. |
80 scoped_ptr< ::testing::StrictMock< ::gfx::MockGLInterface> > gl_; | 35 scoped_ptr< ::testing::StrictMock< ::gfx::MockGLInterface> > gl_; |
81 scoped_ptr<BufferManager> manager_; | 36 scoped_ptr<BufferManager> manager_; |
82 scoped_ptr<MockGLES2Decoder> decoder_; | |
83 }; | 37 }; |
84 | 38 |
85 class BufferManagerTest : public BufferManagerTestBase { | 39 class BufferManagerTest : public BufferManagerTestBase { |
86 protected: | 40 protected: |
87 virtual void SetUp() { | 41 virtual void SetUp() { |
88 SetUpBase(NULL, NULL, "", "", ""); | 42 SetUpBase(NULL); |
89 } | 43 } |
90 }; | 44 }; |
91 | 45 |
92 class BufferManagerMemoryTrackerTest : public BufferManagerTestBase { | 46 class BufferManagerMemoryTrackerTest : public BufferManagerTestBase { |
93 protected: | 47 protected: |
94 virtual void SetUp() { | 48 virtual void SetUp() { |
95 mock_memory_tracker_ = new StrictMock<MockMemoryTracker>(); | 49 mock_memory_tracker_ = new StrictMock<MockMemoryTracker>(); |
96 SetUpBase(mock_memory_tracker_.get(), NULL, "", "", ""); | 50 SetUpBase(mock_memory_tracker_.get()); |
97 } | 51 } |
98 | 52 |
99 scoped_refptr<MockMemoryTracker> mock_memory_tracker_; | 53 scoped_refptr<MockMemoryTracker> mock_memory_tracker_; |
100 }; | 54 }; |
101 | 55 |
102 class BufferManagerClientSideArraysTest : public BufferManagerTestBase { | |
103 protected: | |
104 virtual void SetUp() { | |
105 feature_info_ = new FeatureInfo(); | |
106 SetUpBase(NULL, feature_info_.get(), "", "Imagination Technologies", ""); | |
107 } | |
108 | |
109 scoped_refptr<FeatureInfo> feature_info_; | |
110 }; | |
111 | |
112 #define EXPECT_MEMORY_ALLOCATION_CHANGE(old_size, new_size, pool) \ | 56 #define EXPECT_MEMORY_ALLOCATION_CHANGE(old_size, new_size, pool) \ |
113 EXPECT_CALL(*mock_memory_tracker_, \ | 57 EXPECT_CALL(*mock_memory_tracker_, \ |
114 TrackMemoryAllocatedChange(old_size, new_size, pool)) \ | 58 TrackMemoryAllocatedChange(old_size, new_size, pool)) \ |
115 .Times(1) \ | 59 .Times(1) \ |
116 .RetiresOnSaturation() \ | 60 .RetiresOnSaturation() \ |
117 | 61 |
118 TEST_F(BufferManagerTest, Basic) { | 62 TEST_F(BufferManagerTest, Basic) { |
119 const GLuint kClientBuffer1Id = 1; | 63 const GLuint kClientBuffer1Id = 1; |
120 const GLuint kServiceBuffer1Id = 11; | 64 const GLuint kServiceBuffer1Id = 11; |
121 const GLsizeiptr kBuffer1Size = 123; | 65 const GLsizeiptr kBuffer1Size = 123; |
122 const GLuint kClientBuffer2Id = 2; | 66 const GLuint kClientBuffer2Id = 2; |
123 // Check we can create buffer. | 67 // Check we can create buffer. |
124 manager_->CreateBuffer(kClientBuffer1Id, kServiceBuffer1Id); | 68 manager_->CreateBuffer(kClientBuffer1Id, kServiceBuffer1Id); |
125 // Check buffer got created. | 69 // Check buffer got created. |
126 Buffer* buffer1 = manager_->GetBuffer(kClientBuffer1Id); | 70 Buffer* info1 = manager_->GetBuffer(kClientBuffer1Id); |
127 ASSERT_TRUE(buffer1 != NULL); | 71 ASSERT_TRUE(info1 != NULL); |
128 EXPECT_EQ(0u, GetTarget(buffer1)); | 72 EXPECT_EQ(0u, GetTarget(info1)); |
129 EXPECT_EQ(0, buffer1->size()); | 73 EXPECT_EQ(0, info1->size()); |
130 EXPECT_EQ(static_cast<GLenum>(GL_STATIC_DRAW), buffer1->usage()); | 74 EXPECT_EQ(static_cast<GLenum>(GL_STATIC_DRAW), info1->usage()); |
131 EXPECT_FALSE(buffer1->IsDeleted()); | 75 EXPECT_FALSE(info1->IsDeleted()); |
132 EXPECT_FALSE(buffer1->IsClientSideArray()); | 76 EXPECT_EQ(kServiceBuffer1Id, info1->service_id()); |
133 EXPECT_EQ(kServiceBuffer1Id, buffer1->service_id()); | |
134 GLuint client_id = 0; | 77 GLuint client_id = 0; |
135 EXPECT_TRUE(manager_->GetClientId(buffer1->service_id(), &client_id)); | 78 EXPECT_TRUE(manager_->GetClientId(info1->service_id(), &client_id)); |
136 EXPECT_EQ(kClientBuffer1Id, client_id); | 79 EXPECT_EQ(kClientBuffer1Id, client_id); |
137 manager_->SetTarget(buffer1, GL_ELEMENT_ARRAY_BUFFER); | 80 manager_->SetTarget(info1, GL_ELEMENT_ARRAY_BUFFER); |
138 EXPECT_EQ(static_cast<GLenum>(GL_ELEMENT_ARRAY_BUFFER), GetTarget(buffer1)); | 81 EXPECT_EQ(static_cast<GLenum>(GL_ELEMENT_ARRAY_BUFFER), GetTarget(info1)); |
139 // Check we and set its size. | 82 // Check we and set its size. |
140 DoBufferData(buffer1, kBuffer1Size, GL_DYNAMIC_DRAW, NULL, GL_NO_ERROR); | 83 manager_->SetInfo(info1, kBuffer1Size, GL_DYNAMIC_DRAW); |
141 EXPECT_EQ(kBuffer1Size, buffer1->size()); | 84 EXPECT_EQ(kBuffer1Size, info1->size()); |
142 EXPECT_EQ(static_cast<GLenum>(GL_DYNAMIC_DRAW), buffer1->usage()); | 85 EXPECT_EQ(static_cast<GLenum>(GL_DYNAMIC_DRAW), info1->usage()); |
143 // Check we get nothing for a non-existent buffer. | 86 // Check we get nothing for a non-existent buffer. |
144 EXPECT_TRUE(manager_->GetBuffer(kClientBuffer2Id) == NULL); | 87 EXPECT_TRUE(manager_->GetBuffer(kClientBuffer2Id) == NULL); |
145 // Check trying to a remove non-existent buffers does not crash. | 88 // Check trying to a remove non-existent buffers does not crash. |
146 manager_->RemoveBuffer(kClientBuffer2Id); | 89 manager_->RemoveBuffer(kClientBuffer2Id); |
147 // Check that it gets deleted when the last reference is released. | 90 // Check that it gets deleted when the last reference is released. |
148 EXPECT_CALL(*gl_, DeleteBuffersARB(1, ::testing::Pointee(kServiceBuffer1Id))) | 91 EXPECT_CALL(*gl_, DeleteBuffersARB(1, ::testing::Pointee(kServiceBuffer1Id))) |
149 .Times(1) | 92 .Times(1) |
150 .RetiresOnSaturation(); | 93 .RetiresOnSaturation(); |
151 // Check we can't get the buffer after we remove it. | 94 // Check we can't get the buffer after we remove it. |
152 manager_->RemoveBuffer(kClientBuffer1Id); | 95 manager_->RemoveBuffer(kClientBuffer1Id); |
153 EXPECT_TRUE(manager_->GetBuffer(kClientBuffer1Id) == NULL); | 96 EXPECT_TRUE(manager_->GetBuffer(kClientBuffer1Id) == NULL); |
154 } | 97 } |
155 | 98 |
156 TEST_F(BufferManagerMemoryTrackerTest, Basic) { | 99 TEST_F(BufferManagerMemoryTrackerTest, Basic) { |
157 const GLuint kClientBuffer1Id = 1; | 100 const GLuint kClientBuffer1Id = 1; |
158 const GLuint kServiceBuffer1Id = 11; | 101 const GLuint kServiceBuffer1Id = 11; |
159 const GLsizeiptr kBuffer1Size1 = 123; | 102 const GLsizeiptr kBuffer1Size1 = 123; |
160 const GLsizeiptr kBuffer1Size2 = 456; | 103 const GLsizeiptr kBuffer1Size2 = 456; |
161 // Check we can create buffer. | 104 // Check we can create buffer. |
162 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0, MemoryTracker::kManaged); | 105 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0, MemoryTracker::kManaged); |
163 manager_->CreateBuffer(kClientBuffer1Id, kServiceBuffer1Id); | 106 manager_->CreateBuffer(kClientBuffer1Id, kServiceBuffer1Id); |
164 // Check buffer got created. | 107 // Check buffer got created. |
165 Buffer* buffer1 = manager_->GetBuffer(kClientBuffer1Id); | 108 Buffer* info1 = manager_->GetBuffer(kClientBuffer1Id); |
166 ASSERT_TRUE(buffer1 != NULL); | 109 ASSERT_TRUE(info1 != NULL); |
167 manager_->SetTarget(buffer1, GL_ELEMENT_ARRAY_BUFFER); | 110 manager_->SetTarget(info1, GL_ELEMENT_ARRAY_BUFFER); |
168 // Check we and set its size. | 111 // Check we and set its size. |
169 EXPECT_MEMORY_ALLOCATION_CHANGE(0, kBuffer1Size1, MemoryTracker::kManaged); | 112 EXPECT_MEMORY_ALLOCATION_CHANGE(0, kBuffer1Size1, MemoryTracker::kManaged); |
170 DoBufferData(buffer1, kBuffer1Size1, GL_DYNAMIC_DRAW, NULL, GL_NO_ERROR); | 113 manager_->SetInfo(info1, kBuffer1Size1, GL_DYNAMIC_DRAW); |
171 EXPECT_MEMORY_ALLOCATION_CHANGE(kBuffer1Size1, 0, MemoryTracker::kManaged); | 114 EXPECT_MEMORY_ALLOCATION_CHANGE(kBuffer1Size1, 0, MemoryTracker::kManaged); |
172 EXPECT_MEMORY_ALLOCATION_CHANGE(0, kBuffer1Size2, MemoryTracker::kManaged); | 115 EXPECT_MEMORY_ALLOCATION_CHANGE(0, kBuffer1Size2, MemoryTracker::kManaged); |
173 DoBufferData(buffer1, kBuffer1Size2, GL_DYNAMIC_DRAW, NULL, GL_NO_ERROR); | 116 manager_->SetInfo(info1, kBuffer1Size2, GL_DYNAMIC_DRAW); |
174 // On delete it will get freed. | 117 // On delete it will get freed. |
175 EXPECT_MEMORY_ALLOCATION_CHANGE(kBuffer1Size2, 0, MemoryTracker::kManaged); | 118 EXPECT_MEMORY_ALLOCATION_CHANGE(kBuffer1Size2, 0, MemoryTracker::kManaged); |
176 } | 119 } |
177 | 120 |
178 TEST_F(BufferManagerTest, Destroy) { | 121 TEST_F(BufferManagerTest, Destroy) { |
179 const GLuint kClient1Id = 1; | 122 const GLuint kClient1Id = 1; |
180 const GLuint kService1Id = 11; | 123 const GLuint kService1Id = 11; |
181 // Check we can create buffer. | 124 // Check we can create buffer. |
182 manager_->CreateBuffer(kClient1Id, kService1Id); | 125 manager_->CreateBuffer(kClient1Id, kService1Id); |
183 // Check buffer got created. | 126 // Check buffer got created. |
184 Buffer* buffer1 = manager_->GetBuffer(kClient1Id); | 127 Buffer* info1 = |
185 ASSERT_TRUE(buffer1 != NULL); | 128 manager_->GetBuffer(kClient1Id); |
| 129 ASSERT_TRUE(info1 != NULL); |
186 EXPECT_CALL(*gl_, DeleteBuffersARB(1, ::testing::Pointee(kService1Id))) | 130 EXPECT_CALL(*gl_, DeleteBuffersARB(1, ::testing::Pointee(kService1Id))) |
187 .Times(1) | 131 .Times(1) |
188 .RetiresOnSaturation(); | 132 .RetiresOnSaturation(); |
189 manager_->Destroy(true); | 133 manager_->Destroy(true); |
190 // Check the resources were released. | 134 // Check the resources were released. |
191 buffer1 = manager_->GetBuffer(kClient1Id); | 135 info1 = manager_->GetBuffer(kClient1Id); |
192 ASSERT_TRUE(buffer1 == NULL); | 136 ASSERT_TRUE(info1 == NULL); |
193 } | 137 } |
194 | 138 |
195 TEST_F(BufferManagerTest, DoBufferSubData) { | 139 TEST_F(BufferManagerTest, SetRange) { |
196 const GLuint kClientBufferId = 1; | 140 const GLuint kClientBufferId = 1; |
197 const GLuint kServiceBufferId = 11; | 141 const GLuint kServiceBufferId = 11; |
198 const uint8 data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1}; | 142 const uint8 data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1}; |
199 manager_->CreateBuffer(kClientBufferId, kServiceBufferId); | 143 manager_->CreateBuffer(kClientBufferId, kServiceBufferId); |
200 Buffer* buffer = manager_->GetBuffer(kClientBufferId); | 144 Buffer* info = manager_->GetBuffer(kClientBufferId); |
201 ASSERT_TRUE(buffer != NULL); | 145 ASSERT_TRUE(info != NULL); |
202 manager_->SetTarget(buffer, GL_ELEMENT_ARRAY_BUFFER); | 146 manager_->SetTarget(info, GL_ELEMENT_ARRAY_BUFFER); |
203 DoBufferData(buffer, sizeof(data), GL_STATIC_DRAW, NULL, GL_NO_ERROR); | 147 manager_->SetInfo(info, sizeof(data), GL_STATIC_DRAW); |
204 EXPECT_TRUE(DoBufferSubData(buffer, 0, sizeof(data), data)); | 148 EXPECT_TRUE(info->SetRange(0, sizeof(data), data)); |
205 EXPECT_TRUE(DoBufferSubData(buffer, sizeof(data), 0, data)); | 149 EXPECT_TRUE(info->SetRange(sizeof(data), 0, data)); |
206 EXPECT_FALSE(DoBufferSubData(buffer, sizeof(data), 1, data)); | 150 EXPECT_FALSE(info->SetRange(sizeof(data), 1, data)); |
207 EXPECT_FALSE(DoBufferSubData(buffer, 0, sizeof(data) + 1, data)); | 151 EXPECT_FALSE(info->SetRange(0, sizeof(data) + 1, data)); |
208 EXPECT_FALSE(DoBufferSubData(buffer, -1, sizeof(data), data)); | 152 EXPECT_FALSE(info->SetRange(-1, sizeof(data), data)); |
209 EXPECT_FALSE(DoBufferSubData(buffer, 0, -1, data)); | 153 EXPECT_FALSE(info->SetRange(0, -1, data)); |
210 DoBufferData(buffer, 1, GL_STATIC_DRAW, NULL, GL_NO_ERROR); | 154 manager_->SetInfo(info, 1, GL_STATIC_DRAW); |
211 const int size = 0x20000; | 155 const int size = 0x20000; |
212 scoped_array<uint8> temp(new uint8[size]); | 156 scoped_array<uint8> temp(new uint8[size]); |
213 EXPECT_FALSE(DoBufferSubData(buffer, 0 - size, size, temp.get())); | 157 EXPECT_FALSE(info->SetRange(0 - size, size, temp.get())); |
214 EXPECT_FALSE(DoBufferSubData(buffer, 1, size / 2, temp.get())); | 158 EXPECT_FALSE(info->SetRange(1, size / 2, temp.get())); |
215 } | 159 } |
216 | 160 |
217 TEST_F(BufferManagerTest, GetRange) { | 161 TEST_F(BufferManagerTest, GetRange) { |
218 const GLuint kClientBufferId = 1; | 162 const GLuint kClientBufferId = 1; |
219 const GLuint kServiceBufferId = 11; | 163 const GLuint kServiceBufferId = 11; |
220 const uint8 data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1}; | 164 const uint8 data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1}; |
221 manager_->CreateBuffer(kClientBufferId, kServiceBufferId); | 165 manager_->CreateBuffer(kClientBufferId, kServiceBufferId); |
222 Buffer* buffer = manager_->GetBuffer(kClientBufferId); | 166 Buffer* info = manager_->GetBuffer(kClientBufferId); |
223 ASSERT_TRUE(buffer != NULL); | 167 ASSERT_TRUE(info != NULL); |
224 manager_->SetTarget(buffer, GL_ELEMENT_ARRAY_BUFFER); | 168 manager_->SetTarget(info, GL_ELEMENT_ARRAY_BUFFER); |
225 DoBufferData(buffer, sizeof(data), GL_STATIC_DRAW, NULL, GL_NO_ERROR); | 169 manager_->SetInfo(info, sizeof(data), GL_STATIC_DRAW); |
226 const char* buf = | 170 const char* buf = static_cast<const char*>(info->GetRange(0, sizeof(data))); |
227 static_cast<const char*>(buffer->GetRange(0, sizeof(data))); | |
228 ASSERT_TRUE(buf != NULL); | 171 ASSERT_TRUE(buf != NULL); |
229 const char* buf1 = | 172 const char* buf1 = |
230 static_cast<const char*>(buffer->GetRange(1, sizeof(data) - 1)); | 173 static_cast<const char*>(info->GetRange(1, sizeof(data) - 1)); |
231 EXPECT_EQ(buf + 1, buf1); | 174 EXPECT_EQ(buf + 1, buf1); |
232 EXPECT_TRUE(buffer->GetRange(sizeof(data), 1) == NULL); | 175 EXPECT_TRUE(info->GetRange(sizeof(data), 1) == NULL); |
233 EXPECT_TRUE(buffer->GetRange(0, sizeof(data) + 1) == NULL); | 176 EXPECT_TRUE(info->GetRange(0, sizeof(data) + 1) == NULL); |
234 EXPECT_TRUE(buffer->GetRange(-1, sizeof(data)) == NULL); | 177 EXPECT_TRUE(info->GetRange(-1, sizeof(data)) == NULL); |
235 EXPECT_TRUE(buffer->GetRange(-0, -1) == NULL); | 178 EXPECT_TRUE(info->GetRange(-0, -1) == NULL); |
236 const int size = 0x20000; | 179 const int size = 0x20000; |
237 DoBufferData(buffer, size / 2, GL_STATIC_DRAW, NULL, GL_NO_ERROR); | 180 manager_->SetInfo(info, size / 2, GL_STATIC_DRAW); |
238 EXPECT_TRUE(buffer->GetRange(0 - size, size) == NULL); | 181 EXPECT_TRUE(info->GetRange(0 - size, size) == NULL); |
239 EXPECT_TRUE(buffer->GetRange(1, size / 2) == NULL); | 182 EXPECT_TRUE(info->GetRange(1, size / 2) == NULL); |
240 } | 183 } |
241 | 184 |
242 TEST_F(BufferManagerTest, GetMaxValueForRangeUint8) { | 185 TEST_F(BufferManagerTest, GetMaxValueForRangeUint8) { |
243 const GLuint kClientBufferId = 1; | 186 const GLuint kClientBufferId = 1; |
244 const GLuint kServiceBufferId = 11; | 187 const GLuint kServiceBufferId = 11; |
245 const uint8 data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1}; | 188 const uint8 data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1}; |
246 const uint8 new_data[] = {100, 120, 110}; | 189 const uint8 new_data[] = {100, 120, 110}; |
247 manager_->CreateBuffer(kClientBufferId, kServiceBufferId); | 190 manager_->CreateBuffer(kClientBufferId, kServiceBufferId); |
248 Buffer* buffer = manager_->GetBuffer(kClientBufferId); | 191 Buffer* info = manager_->GetBuffer(kClientBufferId); |
249 ASSERT_TRUE(buffer != NULL); | 192 ASSERT_TRUE(info != NULL); |
250 manager_->SetTarget(buffer, GL_ELEMENT_ARRAY_BUFFER); | 193 manager_->SetTarget(info, GL_ELEMENT_ARRAY_BUFFER); |
251 DoBufferData(buffer, sizeof(data), GL_STATIC_DRAW, NULL, GL_NO_ERROR); | 194 manager_->SetInfo(info, sizeof(data), GL_STATIC_DRAW); |
252 EXPECT_TRUE(DoBufferSubData(buffer, 0, sizeof(data), data)); | 195 EXPECT_TRUE(info->SetRange(0, sizeof(data), data)); |
253 GLuint max_value; | 196 GLuint max_value; |
254 // Check entire range succeeds. | 197 // Check entire range succeeds. |
255 EXPECT_TRUE(buffer->GetMaxValueForRange( | 198 EXPECT_TRUE(info->GetMaxValueForRange(0, 10, GL_UNSIGNED_BYTE, &max_value)); |
256 0, 10, GL_UNSIGNED_BYTE, &max_value)); | |
257 EXPECT_EQ(10u, max_value); | 199 EXPECT_EQ(10u, max_value); |
258 // Check sub range succeeds. | 200 // Check sub range succeeds. |
259 EXPECT_TRUE(buffer->GetMaxValueForRange( | 201 EXPECT_TRUE(info->GetMaxValueForRange(4, 3, GL_UNSIGNED_BYTE, &max_value)); |
260 4, 3, GL_UNSIGNED_BYTE, &max_value)); | |
261 EXPECT_EQ(6u, max_value); | 202 EXPECT_EQ(6u, max_value); |
262 // Check changing sub range succeeds. | 203 // Check changing sub range succeeds. |
263 EXPECT_TRUE(DoBufferSubData(buffer, 4, sizeof(new_data), new_data)); | 204 EXPECT_TRUE(info->SetRange(4, sizeof(new_data), new_data)); |
264 EXPECT_TRUE(buffer->GetMaxValueForRange( | 205 EXPECT_TRUE(info->GetMaxValueForRange(4, 3, GL_UNSIGNED_BYTE, &max_value)); |
265 4, 3, GL_UNSIGNED_BYTE, &max_value)); | |
266 EXPECT_EQ(120u, max_value); | 206 EXPECT_EQ(120u, max_value); |
267 max_value = 0; | 207 max_value = 0; |
268 EXPECT_TRUE(buffer->GetMaxValueForRange( | 208 EXPECT_TRUE(info->GetMaxValueForRange(0, 10, GL_UNSIGNED_BYTE, &max_value)); |
269 0, 10, GL_UNSIGNED_BYTE, &max_value)); | |
270 EXPECT_EQ(120u, max_value); | 209 EXPECT_EQ(120u, max_value); |
271 // Check out of range fails. | 210 // Check out of range fails. |
272 EXPECT_FALSE(buffer->GetMaxValueForRange( | 211 EXPECT_FALSE(info->GetMaxValueForRange(0, 11, GL_UNSIGNED_BYTE, &max_value)); |
273 0, 11, GL_UNSIGNED_BYTE, &max_value)); | 212 EXPECT_FALSE(info->GetMaxValueForRange(10, 1, GL_UNSIGNED_BYTE, &max_value)); |
274 EXPECT_FALSE(buffer->GetMaxValueForRange( | |
275 10, 1, GL_UNSIGNED_BYTE, &max_value)); | |
276 } | 213 } |
277 | 214 |
278 TEST_F(BufferManagerTest, GetMaxValueForRangeUint16) { | 215 TEST_F(BufferManagerTest, GetMaxValueForRangeUint16) { |
279 const GLuint kClientBufferId = 1; | 216 const GLuint kClientBufferId = 1; |
280 const GLuint kServiceBufferId = 11; | 217 const GLuint kServiceBufferId = 11; |
281 const uint16 data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1}; | 218 const uint16 data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1}; |
282 const uint16 new_data[] = {100, 120, 110}; | 219 const uint16 new_data[] = {100, 120, 110}; |
283 manager_->CreateBuffer(kClientBufferId, kServiceBufferId); | 220 manager_->CreateBuffer(kClientBufferId, kServiceBufferId); |
284 Buffer* buffer = manager_->GetBuffer(kClientBufferId); | 221 Buffer* info = manager_->GetBuffer(kClientBufferId); |
285 ASSERT_TRUE(buffer != NULL); | 222 ASSERT_TRUE(info != NULL); |
286 manager_->SetTarget(buffer, GL_ELEMENT_ARRAY_BUFFER); | 223 manager_->SetTarget(info, GL_ELEMENT_ARRAY_BUFFER); |
287 DoBufferData(buffer, sizeof(data), GL_STATIC_DRAW, NULL, GL_NO_ERROR); | 224 manager_->SetInfo(info, sizeof(data), GL_STATIC_DRAW); |
288 EXPECT_TRUE(DoBufferSubData(buffer, 0, sizeof(data), data)); | 225 EXPECT_TRUE(info->SetRange(0, sizeof(data), data)); |
289 GLuint max_value; | 226 GLuint max_value; |
290 // Check entire range succeeds. | 227 // Check entire range succeeds. |
291 EXPECT_TRUE(buffer->GetMaxValueForRange( | 228 EXPECT_TRUE(info->GetMaxValueForRange(0, 10, GL_UNSIGNED_SHORT, &max_value)); |
292 0, 10, GL_UNSIGNED_SHORT, &max_value)); | |
293 EXPECT_EQ(10u, max_value); | 229 EXPECT_EQ(10u, max_value); |
294 // Check odd offset fails for GL_UNSIGNED_SHORT. | 230 // Check odd offset fails for GL_UNSIGNED_SHORT. |
295 EXPECT_FALSE(buffer->GetMaxValueForRange( | 231 EXPECT_FALSE(info->GetMaxValueForRange(1, 10, GL_UNSIGNED_SHORT, &max_value)); |
296 1, 10, GL_UNSIGNED_SHORT, &max_value)); | |
297 // Check sub range succeeds. | 232 // Check sub range succeeds. |
298 EXPECT_TRUE(buffer->GetMaxValueForRange( | 233 EXPECT_TRUE(info->GetMaxValueForRange(8, 3, GL_UNSIGNED_SHORT, &max_value)); |
299 8, 3, GL_UNSIGNED_SHORT, &max_value)); | |
300 EXPECT_EQ(6u, max_value); | 234 EXPECT_EQ(6u, max_value); |
301 // Check changing sub range succeeds. | 235 // Check changing sub range succeeds. |
302 EXPECT_TRUE(DoBufferSubData(buffer, 8, sizeof(new_data), new_data)); | 236 EXPECT_TRUE(info->SetRange(8, sizeof(new_data), new_data)); |
303 EXPECT_TRUE(buffer->GetMaxValueForRange( | 237 EXPECT_TRUE(info->GetMaxValueForRange(8, 3, GL_UNSIGNED_SHORT, &max_value)); |
304 8, 3, GL_UNSIGNED_SHORT, &max_value)); | |
305 EXPECT_EQ(120u, max_value); | 238 EXPECT_EQ(120u, max_value); |
306 max_value = 0; | 239 max_value = 0; |
307 EXPECT_TRUE(buffer->GetMaxValueForRange( | 240 EXPECT_TRUE(info->GetMaxValueForRange(0, 10, GL_UNSIGNED_SHORT, &max_value)); |
308 0, 10, GL_UNSIGNED_SHORT, &max_value)); | |
309 EXPECT_EQ(120u, max_value); | 241 EXPECT_EQ(120u, max_value); |
310 // Check out of range fails. | 242 // Check out of range fails. |
311 EXPECT_FALSE(buffer->GetMaxValueForRange( | 243 EXPECT_FALSE(info->GetMaxValueForRange(0, 11, GL_UNSIGNED_SHORT, &max_value)); |
312 0, 11, GL_UNSIGNED_SHORT, &max_value)); | 244 EXPECT_FALSE(info->GetMaxValueForRange(20, 1, GL_UNSIGNED_SHORT, &max_value)); |
313 EXPECT_FALSE(buffer->GetMaxValueForRange( | |
314 20, 1, GL_UNSIGNED_SHORT, &max_value)); | |
315 } | 245 } |
316 | 246 |
317 TEST_F(BufferManagerTest, GetMaxValueForRangeUint32) { | 247 TEST_F(BufferManagerTest, GetMaxValueForRangeUint32) { |
318 const GLuint kClientBufferId = 1; | 248 const GLuint kClientBufferId = 1; |
319 const GLuint kServiceBufferId = 11; | 249 const GLuint kServiceBufferId = 11; |
320 const uint32 data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1}; | 250 const uint32 data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1}; |
321 const uint32 new_data[] = {100, 120, 110}; | 251 const uint32 new_data[] = {100, 120, 110}; |
322 manager_->CreateBuffer(kClientBufferId, kServiceBufferId); | 252 manager_->CreateBuffer(kClientBufferId, kServiceBufferId); |
323 Buffer* buffer = manager_->GetBuffer(kClientBufferId); | 253 Buffer* info = manager_->GetBuffer(kClientBufferId); |
324 ASSERT_TRUE(buffer != NULL); | 254 ASSERT_TRUE(info != NULL); |
325 manager_->SetTarget(buffer, GL_ELEMENT_ARRAY_BUFFER); | 255 manager_->SetTarget(info, GL_ELEMENT_ARRAY_BUFFER); |
326 DoBufferData(buffer, sizeof(data), GL_STATIC_DRAW, NULL, GL_NO_ERROR); | 256 manager_->SetInfo(info, sizeof(data), GL_STATIC_DRAW); |
327 EXPECT_TRUE(DoBufferSubData(buffer, 0, sizeof(data), data)); | 257 EXPECT_TRUE(info->SetRange(0, sizeof(data), data)); |
328 GLuint max_value; | 258 GLuint max_value; |
329 // Check entire range succeeds. | 259 // Check entire range succeeds. |
330 EXPECT_TRUE( | 260 EXPECT_TRUE(info->GetMaxValueForRange(0, 10, GL_UNSIGNED_INT, &max_value)); |
331 buffer->GetMaxValueForRange(0, 10, GL_UNSIGNED_INT, &max_value)); | |
332 EXPECT_EQ(10u, max_value); | 261 EXPECT_EQ(10u, max_value); |
333 // Check non aligned offsets fails for GL_UNSIGNED_INT. | 262 // Check non aligned offsets fails for GL_UNSIGNED_INT. |
334 EXPECT_FALSE( | 263 EXPECT_FALSE(info->GetMaxValueForRange(1, 10, GL_UNSIGNED_INT, &max_value)); |
335 buffer->GetMaxValueForRange(1, 10, GL_UNSIGNED_INT, &max_value)); | 264 EXPECT_FALSE(info->GetMaxValueForRange(2, 10, GL_UNSIGNED_INT, &max_value)); |
336 EXPECT_FALSE( | 265 EXPECT_FALSE(info->GetMaxValueForRange(3, 10, GL_UNSIGNED_INT, &max_value)); |
337 buffer->GetMaxValueForRange(2, 10, GL_UNSIGNED_INT, &max_value)); | |
338 EXPECT_FALSE( | |
339 buffer->GetMaxValueForRange(3, 10, GL_UNSIGNED_INT, &max_value)); | |
340 // Check sub range succeeds. | 266 // Check sub range succeeds. |
341 EXPECT_TRUE(buffer->GetMaxValueForRange(16, 3, GL_UNSIGNED_INT, &max_value)); | 267 EXPECT_TRUE(info->GetMaxValueForRange(16, 3, GL_UNSIGNED_INT, &max_value)); |
342 EXPECT_EQ(6u, max_value); | 268 EXPECT_EQ(6u, max_value); |
343 // Check changing sub range succeeds. | 269 // Check changing sub range succeeds. |
344 EXPECT_TRUE(DoBufferSubData(buffer, 16, sizeof(new_data), new_data)); | 270 EXPECT_TRUE(info->SetRange(16, sizeof(new_data), new_data)); |
345 EXPECT_TRUE(buffer->GetMaxValueForRange(16, 3, GL_UNSIGNED_INT, &max_value)); | 271 EXPECT_TRUE(info->GetMaxValueForRange(16, 3, GL_UNSIGNED_INT, &max_value)); |
346 EXPECT_EQ(120u, max_value); | 272 EXPECT_EQ(120u, max_value); |
347 max_value = 0; | 273 max_value = 0; |
348 EXPECT_TRUE(buffer->GetMaxValueForRange(0, 10, GL_UNSIGNED_INT, &max_value)); | 274 EXPECT_TRUE(info->GetMaxValueForRange(0, 10, GL_UNSIGNED_INT, &max_value)); |
349 EXPECT_EQ(120u, max_value); | 275 EXPECT_EQ(120u, max_value); |
350 // Check out of range fails. | 276 // Check out of range fails. |
351 EXPECT_FALSE( | 277 EXPECT_FALSE(info->GetMaxValueForRange(0, 11, GL_UNSIGNED_INT, &max_value)); |
352 buffer->GetMaxValueForRange(0, 11, GL_UNSIGNED_INT, &max_value)); | 278 EXPECT_FALSE(info->GetMaxValueForRange(40, 1, GL_UNSIGNED_INT, &max_value)); |
353 EXPECT_FALSE( | |
354 buffer->GetMaxValueForRange(40, 1, GL_UNSIGNED_INT, &max_value)); | |
355 } | 279 } |
356 | 280 |
357 TEST_F(BufferManagerTest, UseDeletedBuffer) { | 281 TEST_F(BufferManagerTest, UseDeletedBuffer) { |
358 const GLuint kClientBufferId = 1; | 282 const GLuint kClientBufferId = 1; |
359 const GLuint kServiceBufferId = 11; | 283 const GLuint kServiceBufferId = 11; |
360 const uint32 data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1}; | 284 const uint32 data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1}; |
361 manager_->CreateBuffer(kClientBufferId, kServiceBufferId); | 285 manager_->CreateBuffer(kClientBufferId, kServiceBufferId); |
362 scoped_refptr<Buffer> buffer = manager_->GetBuffer(kClientBufferId); | 286 scoped_refptr<Buffer> info = |
363 ASSERT_TRUE(buffer != NULL); | 287 manager_->GetBuffer(kClientBufferId); |
364 manager_->SetTarget(buffer, GL_ARRAY_BUFFER); | 288 ASSERT_TRUE(info != NULL); |
| 289 manager_->SetTarget(info, GL_ARRAY_BUFFER); |
365 // Remove buffer | 290 // Remove buffer |
366 manager_->RemoveBuffer(kClientBufferId); | 291 manager_->RemoveBuffer(kClientBufferId); |
367 // Use it after removing | 292 // Use it after removing |
368 DoBufferData(buffer, sizeof(data), GL_STATIC_DRAW, NULL, GL_NO_ERROR); | 293 manager_->SetInfo(info, sizeof(data), GL_STATIC_DRAW); |
369 // Check that it gets deleted when the last reference is released. | 294 // Check that it gets deleted when the last reference is released. |
370 EXPECT_CALL(*gl_, DeleteBuffersARB(1, ::testing::Pointee(kServiceBufferId))) | 295 EXPECT_CALL(*gl_, DeleteBuffersARB(1, ::testing::Pointee(kServiceBufferId))) |
371 .Times(1) | 296 .Times(1) |
372 .RetiresOnSaturation(); | 297 .RetiresOnSaturation(); |
373 buffer = NULL; | 298 info = NULL; |
374 } | |
375 | |
376 // Test buffers get shadowed when they are supposed to be. | |
377 TEST_F(BufferManagerClientSideArraysTest, StreamBuffersAreShadowed) { | |
378 const GLuint kClientBufferId = 1; | |
379 const GLuint kServiceBufferId = 11; | |
380 static const uint32 data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1}; | |
381 manager_->CreateBuffer(kClientBufferId, kServiceBufferId); | |
382 Buffer* buffer = manager_->GetBuffer(kClientBufferId); | |
383 ASSERT_TRUE(buffer != NULL); | |
384 manager_->SetTarget(buffer, GL_ARRAY_BUFFER); | |
385 DoBufferData(buffer, sizeof(data), GL_STREAM_DRAW, data, GL_NO_ERROR); | |
386 EXPECT_TRUE(buffer->IsClientSideArray()); | |
387 EXPECT_EQ(0, memcmp(data, buffer->GetRange(0, sizeof(data)), sizeof(data))); | |
388 DoBufferData(buffer, sizeof(data), GL_DYNAMIC_DRAW, data, GL_NO_ERROR); | |
389 EXPECT_FALSE(buffer->IsClientSideArray()); | |
390 } | 299 } |
391 | 300 |
392 } // namespace gles2 | 301 } // namespace gles2 |
393 } // namespace gpu | 302 } // namespace gpu |
394 | 303 |
395 | 304 |
OLD | NEW |