[Command buffer] Enable primitive restart for WebGL 2

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) {
-  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));
+  RunGetMaxValueForRangeUint8Test(false);
+}
+
+TEST_F(BufferManagerTest, GetMaxValueForRangeUint8PrimitiveRestart) {
+  RunGetMaxValueForRangeUint8Test(true);
 }
 
 TEST_F(BufferManagerTest, GetMaxValueForRangeUint16) {
-  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));
+  RunGetMaxValueForRangeUint16Test(false);
+}
+
+TEST_F(BufferManagerTest, GetMaxValueForRangeUint16PrimitiveRestart) {
+  RunGetMaxValueForRangeUint16Test(true);
 }
 
 TEST_F(BufferManagerTest, GetMaxValueForRangeUint32) {
-  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));
+  RunGetMaxValueForRangeUint32Test(false);
+}
+
+TEST_F(BufferManagerTest, GetMaxValueForRangeUint32PrimitiveRestart) {
+  RunGetMaxValueForRangeUint32Test(true);
 }
 
 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, &max_value));
+      buffer->GetMaxValueForRange(0, 10, GL_UNSIGNED_INT, false, &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, &max_value));
+      buffer->GetMaxValueForRange(0, 10, GL_UNSIGNED_INT, false, &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, &max_value));
+      buffer->GetMaxValueForRange(0, 3, GL_UNSIGNED_INT, false, &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