[Command buffer] Enable primitive restart for WebGL 2

gpu/command_buffer/service/gles2_cmd_decoder.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 "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
 #include <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
@@ skipping 6228 matching lines @@
     framebuffer->AttachRenderbuffer(attachment, renderbuffer);
   }
   if (framebuffer == framebuffer_state_.bound_draw_framebuffer.get()) {
     framebuffer_state_.clear_state_dirty = true;
   }
   OnFboChanged();
 }
 
 void GLES2DecoderImpl::DoDisable(GLenum cap) {
   if (SetCapabilityState(cap, false)) {
+    if (cap == GL_PRIMITIVE_RESTART_FIXED_INDEX &&
+        feature_info_->feature_flags().emulate_primitive_restart_fixed_index) {
+      // Enable and Disable PRIMITIVE_RESTART only before and after
+      // DrawElements* for old desktop GL.
+      return;
+    }
     glDisable(cap);
   }
 }
 
 void GLES2DecoderImpl::DoEnable(GLenum cap) {
   if (SetCapabilityState(cap, true)) {
+    if (cap == GL_PRIMITIVE_RESTART_FIXED_INDEX &&
+        feature_info_->feature_flags().emulate_primitive_restart_fixed_index) {
+      // Enable and Disable PRIMITIVE_RESTART only before and after
+      // DrawElements* for old desktop GL.
+      return;
+    }
     glEnable(cap);
   }
 }
 
 void GLES2DecoderImpl::DoDepthRangef(GLclampf znear, GLclampf zfar) {
   state_.z_near = std::min(1.0f, std::max(0.0f, znear));
   state_.z_far = std::min(1.0f, std::max(0.0f, zfar));
   glDepthRange(znear, zfar);
 }
 
@@ skipping 2003 matching lines @@
       // it in each draw call, and attrib 0 generic data queries use cached
       // values instead of passing down to the underlying driver.
       RestoreStateForAttrib(0, false);
     }
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDrawArrays(uint32_t immediate_data_size,
                                                 const void* cmd_data) {
-  // TODO(zmo): crbug.com/481184
-  // On Desktop GL with versions lower than 4.3, we need to emulate
-  // GL_PRIMITIVE_RESTART_FIXED_INDEX using glPrimitiveRestartIndex().
   const cmds::DrawArrays& c = *static_cast<const cmds::DrawArrays*>(cmd_data);
   return DoDrawArrays("glDrawArrays",
                       false,
                       static_cast<GLenum>(c.mode),
                       static_cast<GLint>(c.first),
                       static_cast<GLsizei>(c.count),
                       1);
 }
 
 error::Error GLES2DecoderImpl::HandleDrawArraysInstancedANGLE(
@@ skipping 55 matching lines @@
 
   if (count == 0 || primcount == 0) {
     return error::kNoError;
   }
 
   GLuint max_vertex_accessed;
   Buffer* element_array_buffer =
       state_.vertex_attrib_manager->element_array_buffer();
 
   if (!element_array_buffer->GetMaxValueForRange(
-      offset, count, type, &max_vertex_accessed)) {
+          offset, count, type,
+          state_.enable_flags.primitive_restart_fixed_index,
+          &max_vertex_accessed)) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION, function_name, "range out of bounds for buffer");
     return error::kNoError;
   }
 
   if (IsDrawValid(function_name, max_vertex_accessed, instanced, primcount)) {
     if (!ClearUnclearedTextures()) {
       LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, function_name, "out of memory");
       return error::kNoError;
     }
@@ skipping 11 matching lines @@
       // TODO(gman): Refactor to hide these details in BufferManager or
       // VertexAttribManager.
       const GLvoid* indices = reinterpret_cast<const GLvoid*>(offset);
       bool used_client_side_array = false;
       if (element_array_buffer->IsClientSideArray()) {
         used_client_side_array = true;
         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
         indices = element_array_buffer->GetRange(offset, 0);
       }
 
+      if (state_.enable_flags.primitive_restart_fixed_index &&
+          feature_info_->feature_flags().
+              emulate_primitive_restart_fixed_index) {
+        glEnable(GL_PRIMITIVE_RESTART);
+        buffer_manager()->SetPrimitiveRestartFixedIndexIfNecessary(type);
+      }
+
       if (!instanced) {
         glDrawElements(mode, count, type, indices);
       } else {
         glDrawElementsInstancedANGLE(mode, count, type, indices, primcount);
       }
 
+      if (state_.enable_flags.primitive_restart_fixed_index &&
+          feature_info_->feature_flags().
+              emulate_primitive_restart_fixed_index) {
+        glDisable(GL_PRIMITIVE_RESTART);
+      }
+
       if (used_client_side_array) {
         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,
                      element_array_buffer->service_id());
       }
 
       if (textures_set) {
         RestoreStateForTextures();
       }
       if (simulated_fixed_attribs) {
         RestoreStateForSimulatedFixedAttribs();
       }
     }
     if (simulated_attrib_0) {
       // We don't have to restore attrib 0 generic data at the end of this
       // function even if it is simulated. This is because we will simulate
       // it in each draw call, and attrib 0 generic data queries use cached
       // values instead of passing down to the underlying driver.
       RestoreStateForAttrib(0, false);
     }
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDrawElements(uint32_t immediate_data_size,
                                                   const void* cmd_data) {
-  // TODO(zmo): crbug.com/481184
-  // On Desktop GL with versions lower than 4.3, we need to emulate
-  // GL_PRIMITIVE_RESTART_FIXED_INDEX using glPrimitiveRestartIndex().
   const gles2::cmds::DrawElements& c =
       *static_cast<const gles2::cmds::DrawElements*>(cmd_data);
   return DoDrawElements("glDrawElements", false, static_cast<GLenum>(c.mode),
                         static_cast<GLsizei>(c.count),
                         static_cast<GLenum>(c.type),
                         static_cast<int32_t>(c.index_offset), 1);
 }
 
 error::Error GLES2DecoderImpl::HandleDrawElementsInstancedANGLE(
     uint32_t immediate_data_size,
@@ skipping 11 matching lines @@
 
 GLuint GLES2DecoderImpl::DoGetMaxValueInBufferCHROMIUM(
     GLuint buffer_id, GLsizei count, GLenum type, GLuint offset) {
   GLuint max_vertex_accessed = 0;
   Buffer* buffer = GetBuffer(buffer_id);
   if (!buffer) {
     // TODO(gman): Should this be a GL error or a command buffer error?
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE, "GetMaxValueInBufferCHROMIUM", "unknown buffer");
   } else {
+    // The max value is used here to emulate client-side vertex
+    // arrays, by uploading enough vertices into buffer objects to
+    // cover the DrawElements call. Baking the primitive restart bit
+    // into this result isn't strictly correct in all cases; the
+    // client side code should pass down the bit and decide how to use
+    // the result. However, the only caller makes the draw call
+    // immediately afterward, so the state won't change between this
+    // query and the draw call.
     if (!buffer->GetMaxValueForRange(
-        offset, count, type, &max_vertex_accessed)) {
+            offset, count, type,
+            state_.enable_flags.primitive_restart_fixed_index,
+            &max_vertex_accessed)) {
       // TODO(gman): Should this be a GL error or a command buffer error?
       LOCAL_SET_GL_ERROR(
           GL_INVALID_OPERATION,
           "GetMaxValueInBufferCHROMIUM", "range out of bounds for buffer");
     }
   }
   return max_vertex_accessed;
 }
 
 void GLES2DecoderImpl::DoShaderSource(
@@ skipping 7880 matching lines @@
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "base/macros.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu