Revert of Fix PRIMITIVE_RESTART_FIXED_INDEX handling in command buffer and WebGL 2.0.

gpu/command_buffer/service/buffer_manager_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "gpu/command_buffer/service/buffer_manager.h"
 #include "gpu/command_buffer/service/error_state_mock.h"
 #include "gpu/command_buffer/service/feature_info.h"
@@ skipping 56 matching lines @@
     } else if (!buffer->IsClientSideArray()) {
       EXPECT_CALL(*gl_, BufferSubData(target, offset, size, _))
           .Times(1)
           .RetiresOnSaturation();
     }
     manager_->DoBufferSubData(
         error_state_.get(), buffer, target, offset, size, data);
     return success;
   }
 
-  void RunGetMaxValueForRangeUint8Test(bool enable_primitive_restart)
-  {
-    const GLenum kTarget = GL_ELEMENT_ARRAY_BUFFER;
-    const GLuint kClientBufferId = 1;
-    const GLuint kServiceBufferId = 11;
-    const uint8_t data[] = {10, 9, 8, 7, 6, 0xFFu, 4, 3, 2, 1};
-    const uint8_t new_data[] = {100, 120, 110};
-    manager_->CreateBuffer(kClientBufferId, kServiceBufferId);
-    Buffer* buffer = manager_->GetBuffer(kClientBufferId);
-    ASSERT_TRUE(buffer != NULL);
-    manager_->SetTarget(buffer, kTarget);
-    DoBufferData(
-        buffer, kTarget, sizeof(data), GL_STATIC_DRAW, NULL, GL_NO_ERROR);
-    EXPECT_TRUE(DoBufferSubData(buffer, kTarget, 0, sizeof(data), data));
-    GLuint max_value;
-    // Check entire range succeeds.
-    EXPECT_TRUE(buffer->GetMaxValueForRange(
-        0, 10, GL_UNSIGNED_BYTE, enable_primitive_restart, &max_value));
-    if (enable_primitive_restart) {
-      EXPECT_EQ(10u, max_value);
-    } else {
-      EXPECT_EQ(0xFFu, max_value);
-    }
-    // Check sub range succeeds.
-    EXPECT_TRUE(buffer->GetMaxValueForRange(
-        4, 3, GL_UNSIGNED_BYTE, enable_primitive_restart, &max_value));
-    if (enable_primitive_restart) {
-      EXPECT_EQ(6u, max_value);
-    } else {
-      EXPECT_EQ(0xFFu, max_value);
-    }
-    // Check changing sub range succeeds.
-    EXPECT_TRUE(DoBufferSubData(buffer, kTarget, 4, sizeof(new_data),
-                                new_data));
-    EXPECT_TRUE(buffer->GetMaxValueForRange(
-        4, 3, GL_UNSIGNED_BYTE, enable_primitive_restart, &max_value));
-    EXPECT_EQ(120u, max_value);
-    max_value = 0;
-    EXPECT_TRUE(buffer->GetMaxValueForRange(
-        0, 10, GL_UNSIGNED_BYTE, enable_primitive_restart, &max_value));
-    EXPECT_EQ(120u, max_value);
-    // Check out of range fails.
-    EXPECT_FALSE(buffer->GetMaxValueForRange(
-        0, 11, GL_UNSIGNED_BYTE, enable_primitive_restart, &max_value));
-    EXPECT_FALSE(buffer->GetMaxValueForRange(
-        10, 1, GL_UNSIGNED_BYTE, enable_primitive_restart, &max_value));
-  }
-
-  void RunGetMaxValueForRangeUint16Test(bool enable_primitive_restart) {
-    const GLenum kTarget = GL_ELEMENT_ARRAY_BUFFER;
-    const GLuint kClientBufferId = 1;
-    const GLuint kServiceBufferId = 11;
-    const uint16_t data[] = {10, 9, 8, 7, 6, 0xFFFF, 4, 3, 2, 1};
-    const uint16_t new_data[] = {100, 120, 110};
-    manager_->CreateBuffer(kClientBufferId, kServiceBufferId);
-    Buffer* buffer = manager_->GetBuffer(kClientBufferId);
-    ASSERT_TRUE(buffer != NULL);
-    manager_->SetTarget(buffer, kTarget);
-    DoBufferData(
-        buffer, kTarget, sizeof(data), GL_STATIC_DRAW, NULL, GL_NO_ERROR);
-    EXPECT_TRUE(DoBufferSubData(buffer, kTarget, 0, sizeof(data), data));
-    GLuint max_value;
-    // Check entire range succeeds.
-    EXPECT_TRUE(buffer->GetMaxValueForRange(
-        0, 10, GL_UNSIGNED_SHORT, enable_primitive_restart, &max_value));
-    if (enable_primitive_restart) {
-      EXPECT_EQ(10u, max_value);
-    } else {
-      EXPECT_EQ(0xFFFFu, max_value);
-    }
-    // Check odd offset fails for GL_UNSIGNED_SHORT.
-    EXPECT_FALSE(buffer->GetMaxValueForRange(
-        1, 10, GL_UNSIGNED_SHORT, enable_primitive_restart, &max_value));
-    // Check sub range succeeds.
-    EXPECT_TRUE(buffer->GetMaxValueForRange(
-        8, 3, GL_UNSIGNED_SHORT, enable_primitive_restart, &max_value));
-    if (enable_primitive_restart) {
-      EXPECT_EQ(6u, max_value);
-    } else {
-      EXPECT_EQ(0xFFFFu, max_value);
-    }
-    // Check changing sub range succeeds.
-    EXPECT_TRUE(DoBufferSubData(buffer, kTarget, 8, sizeof(new_data),
-                                new_data));
-    EXPECT_TRUE(buffer->GetMaxValueForRange(
-        8, 3, GL_UNSIGNED_SHORT, enable_primitive_restart, &max_value));
-    EXPECT_EQ(120u, max_value);
-    max_value = 0;
-    EXPECT_TRUE(buffer->GetMaxValueForRange(
-        0, 10, GL_UNSIGNED_SHORT, enable_primitive_restart, &max_value));
-    EXPECT_EQ(120u, max_value);
-    // Check out of range fails.
-    EXPECT_FALSE(buffer->GetMaxValueForRange(
-        0, 11, GL_UNSIGNED_SHORT, enable_primitive_restart, &max_value));
-    EXPECT_FALSE(buffer->GetMaxValueForRange(
-        20, 1, GL_UNSIGNED_SHORT, enable_primitive_restart, &max_value));
-  }
-
-  void RunGetMaxValueForRangeUint32Test(bool enable_primitive_restart) {
-    const GLenum kTarget = GL_ELEMENT_ARRAY_BUFFER;
-    const GLuint kClientBufferId = 1;
-    const GLuint kServiceBufferId = 11;
-    const uint32_t data[] = {10, 9, 8, 7, 6, 0xFFFFFFFFu, 4, 3, 2, 1};
-    const uint32_t new_data[] = {100, 120, 110};
-    manager_->CreateBuffer(kClientBufferId, kServiceBufferId);
-    Buffer* buffer = manager_->GetBuffer(kClientBufferId);
-    ASSERT_TRUE(buffer != NULL);
-    manager_->SetTarget(buffer, kTarget);
-    DoBufferData(
-        buffer, kTarget, sizeof(data), GL_STATIC_DRAW, NULL, GL_NO_ERROR);
-    EXPECT_TRUE(DoBufferSubData(buffer, kTarget, 0, sizeof(data), data));
-    GLuint max_value;
-    // Check entire range succeeds.
-    EXPECT_TRUE(buffer->GetMaxValueForRange(
-        0, 10, GL_UNSIGNED_INT, enable_primitive_restart, &max_value));
-    if (enable_primitive_restart) {
-      EXPECT_EQ(10u, max_value);
-    } else {
-      EXPECT_EQ(0xFFFFFFFFu, max_value);
-    }
-    // Check non aligned offsets fails for GL_UNSIGNED_INT.
-    EXPECT_FALSE(buffer->GetMaxValueForRange(
-        1, 10, GL_UNSIGNED_INT, enable_primitive_restart, &max_value));
-    EXPECT_FALSE(buffer->GetMaxValueForRange(
-        2, 10, GL_UNSIGNED_INT, enable_primitive_restart, &max_value));
-    EXPECT_FALSE(buffer->GetMaxValueForRange(
-        3, 10, GL_UNSIGNED_INT, enable_primitive_restart, &max_value));
-    // Check sub range succeeds.
-    EXPECT_TRUE(buffer->GetMaxValueForRange(
-        16, 3, GL_UNSIGNED_INT, enable_primitive_restart, &max_value));
-    if (enable_primitive_restart) {
-      EXPECT_EQ(6u, max_value);
-    } else {
-      EXPECT_EQ(0xFFFFFFFFu, max_value);
-    }
-    // Check changing sub range succeeds.
-    EXPECT_TRUE(DoBufferSubData(buffer, kTarget, 16, sizeof(new_data),
-                                new_data));
-    EXPECT_TRUE(buffer->GetMaxValueForRange(
-        16, 3, GL_UNSIGNED_INT, enable_primitive_restart, &max_value));
-    EXPECT_EQ(120u, max_value);
-    max_value = 0;
-    EXPECT_TRUE(buffer->GetMaxValueForRange(
-        0, 10, GL_UNSIGNED_INT, enable_primitive_restart, &max_value));
-    EXPECT_EQ(120u, max_value);
-    // Check out of range fails.
-    EXPECT_FALSE(buffer->GetMaxValueForRange(
-        0, 11, GL_UNSIGNED_INT, enable_primitive_restart, &max_value));
-    EXPECT_FALSE(buffer->GetMaxValueForRange(
-        40, 1, GL_UNSIGNED_INT, enable_primitive_restart, &max_value));
-  }
-
   scoped_ptr<BufferManager> manager_;
   scoped_ptr<MockErrorState> error_state_;
 };
 
 class BufferManagerTest : public BufferManagerTestBase {
  protected:
   void SetUp() override { SetUpBase(NULL, NULL, ""); }
 };
 
 class BufferManagerMemoryTrackerTest : public BufferManagerTestBase {
@@ skipping 149 matching lines @@
   EXPECT_TRUE(buffer->GetRange(0, kDataSize + 1) == NULL);
   EXPECT_TRUE(buffer->GetRange(-1, kDataSize) == NULL);
   EXPECT_TRUE(buffer->GetRange(-0, -1) == NULL);
   const int size = 0x20000;
   DoBufferData(buffer, kTarget, 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);
 }
 
 TEST_F(BufferManagerTest, GetMaxValueForRangeUint8) {
-  RunGetMaxValueForRangeUint8Test(false);
-}
-
-TEST_F(BufferManagerTest, GetMaxValueForRangeUint8PrimitiveRestart) {
-  RunGetMaxValueForRangeUint8Test(true);
+  const GLenum kTarget = GL_ELEMENT_ARRAY_BUFFER;
+  const GLuint kClientBufferId = 1;
+  const GLuint kServiceBufferId = 11;
+  const uint8_t data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
+  const uint8_t new_data[] = {100, 120, 110};
+  manager_->CreateBuffer(kClientBufferId, kServiceBufferId);
+  Buffer* buffer = manager_->GetBuffer(kClientBufferId);
+  ASSERT_TRUE(buffer != NULL);
+  manager_->SetTarget(buffer, kTarget);
+  DoBufferData(
+      buffer, kTarget, sizeof(data), GL_STATIC_DRAW, NULL, GL_NO_ERROR);
+  EXPECT_TRUE(DoBufferSubData(buffer, kTarget, 0, sizeof(data), data));
+  GLuint max_value;
+  // Check entire range succeeds.
+  EXPECT_TRUE(buffer->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_EQ(6u, max_value);
+  // Check changing sub range succeeds.
+  EXPECT_TRUE(DoBufferSubData(buffer, kTarget, 4, sizeof(new_data), new_data));
+  EXPECT_TRUE(buffer->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_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));
 }
 
 TEST_F(BufferManagerTest, GetMaxValueForRangeUint16) {
-  RunGetMaxValueForRangeUint16Test(false);
-}
-
-TEST_F(BufferManagerTest, GetMaxValueForRangeUint16PrimitiveRestart) {
-  RunGetMaxValueForRangeUint16Test(true);
+  const GLenum kTarget = GL_ELEMENT_ARRAY_BUFFER;
+  const GLuint kClientBufferId = 1;
+  const GLuint kServiceBufferId = 11;
+  const uint16_t data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
+  const uint16_t new_data[] = {100, 120, 110};
+  manager_->CreateBuffer(kClientBufferId, kServiceBufferId);
+  Buffer* buffer = manager_->GetBuffer(kClientBufferId);
+  ASSERT_TRUE(buffer != NULL);
+  manager_->SetTarget(buffer, kTarget);
+  DoBufferData(
+      buffer, kTarget, sizeof(data), GL_STATIC_DRAW, NULL, GL_NO_ERROR);
+  EXPECT_TRUE(DoBufferSubData(buffer, kTarget, 0, sizeof(data), data));
+  GLuint max_value;
+  // Check entire range succeeds.
+  EXPECT_TRUE(buffer->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));
+  // Check sub range succeeds.
+  EXPECT_TRUE(buffer->GetMaxValueForRange(
+      8, 3, GL_UNSIGNED_SHORT, &max_value));
+  EXPECT_EQ(6u, max_value);
+  // Check changing sub range succeeds.
+  EXPECT_TRUE(DoBufferSubData(buffer, kTarget, 8, sizeof(new_data), new_data));
+  EXPECT_TRUE(buffer->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_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));
 }
 
 TEST_F(BufferManagerTest, GetMaxValueForRangeUint32) {
-  RunGetMaxValueForRangeUint32Test(false);
-}
-
-TEST_F(BufferManagerTest, GetMaxValueForRangeUint32PrimitiveRestart) {
-  RunGetMaxValueForRangeUint32Test(true);
+  const GLenum kTarget = GL_ELEMENT_ARRAY_BUFFER;
+  const GLuint kClientBufferId = 1;
+  const GLuint kServiceBufferId = 11;
+  const uint32_t data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
+  const uint32_t new_data[] = {100, 120, 110};
+  manager_->CreateBuffer(kClientBufferId, kServiceBufferId);
+  Buffer* buffer = manager_->GetBuffer(kClientBufferId);
+  ASSERT_TRUE(buffer != NULL);
+  manager_->SetTarget(buffer, kTarget);
+  DoBufferData(
+      buffer, kTarget, sizeof(data), GL_STATIC_DRAW, NULL, GL_NO_ERROR);
+  EXPECT_TRUE(DoBufferSubData(buffer, kTarget, 0, sizeof(data), data));
+  GLuint max_value;
+  // Check entire range succeeds.
+  EXPECT_TRUE(
+      buffer->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));
+  // Check sub range succeeds.
+  EXPECT_TRUE(buffer->GetMaxValueForRange(16, 3, GL_UNSIGNED_INT, &max_value));
+  EXPECT_EQ(6u, max_value);
+  // Check changing sub range succeeds.
+  EXPECT_TRUE(DoBufferSubData(buffer, kTarget, 16, sizeof(new_data), new_data));
+  EXPECT_TRUE(buffer->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_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));
 }
 
 TEST_F(BufferManagerTest, UseDeletedBuffer) {
   const GLenum kTarget = GL_ARRAY_BUFFER;
   const GLuint kClientBufferId = 1;
   const GLuint kServiceBufferId = 11;
   const GLsizeiptr kDataSize = 10;
   manager_->CreateBuffer(kClientBufferId, kServiceBufferId);
   scoped_refptr<Buffer> buffer = manager_->GetBuffer(kClientBufferId);
   ASSERT_TRUE(buffer.get() != NULL);
@@ skipping 39 matching lines @@
   manager_->CreateBuffer(kClientBufferId, kServiceBufferId);
   Buffer* buffer = manager_->GetBuffer(kClientBufferId);
   ASSERT_TRUE(buffer != NULL);
   manager_->SetTarget(buffer, kTarget);
   GLuint max_value;
   // Load the buffer with some initial data, and then get the maximum value for
   // a range, which has the side effect of caching it.
   DoBufferData(
       buffer, kTarget, sizeof(data1), GL_STATIC_DRAW, data1, GL_NO_ERROR);
   EXPECT_TRUE(
-      buffer->GetMaxValueForRange(0, 10, GL_UNSIGNED_INT, false, &max_value));
+      buffer->GetMaxValueForRange(0, 10, GL_UNSIGNED_INT, &max_value));
   EXPECT_EQ(10u, max_value);
   // Check that any cached values are invalidated if the buffer is reloaded
   // with the same amount of data (but different content)
   ASSERT_EQ(sizeof(data2), sizeof(data1));
   DoBufferData(
       buffer, kTarget, sizeof(data2), GL_STATIC_DRAW, data2, GL_NO_ERROR);
   EXPECT_TRUE(
-      buffer->GetMaxValueForRange(0, 10, GL_UNSIGNED_INT, false, &max_value));
+      buffer->GetMaxValueForRange(0, 10, GL_UNSIGNED_INT, &max_value));
   EXPECT_EQ(20u, max_value);
   // Check that any cached values are invalidated if the buffer is reloaded
   // with entirely different content.
   ASSERT_NE(sizeof(data3), sizeof(data1));
   DoBufferData(
       buffer, kTarget, sizeof(data3), GL_STATIC_DRAW, data3, GL_NO_ERROR);
   EXPECT_TRUE(
-      buffer->GetMaxValueForRange(0, 3, GL_UNSIGNED_INT, false, &max_value));
+      buffer->GetMaxValueForRange(0, 3, GL_UNSIGNED_INT, &max_value));
   EXPECT_EQ(30u, max_value);
 }
 
 TEST_F(BufferManagerTest, BindBufferConflicts) {
   manager_->set_allow_buffers_on_multiple_targets(false);
   GLuint client_id = 1;
   GLuint service_id = 101;
 
   {
     // Once a buffer is bound to ELEMENT_ARRAY_BUFFER, it can't be bound to
@@ skipping 61 matching lines @@
         EXPECT_TRUE(manager_->SetTarget(buffer, kTargets[jj]));
       }
     }
   }
 }
 
 }  // namespace gles2
 }  // namespace gpu