gpu/command_buffer/service/buffer_manager_unittest.cc

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