[Command buffer] Enable primitive restart for WebGL 2

gpu/command_buffer/service/buffer_manager.h

 // 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.
 
 #ifndef GPU_COMMAND_BUFFER_SERVICE_BUFFER_MANAGER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_BUFFER_MANAGER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 45 matching lines @@
 
   GLenum usage() const {
     return usage_;
   }
 
   // Gets the maximum value in the buffer for the given range interpreted as
   // the given type. Returns false if offset and count are out of range.
   // offset is in bytes.
   // count is in elements of type.
   bool GetMaxValueForRange(GLuint offset, GLsizei count, GLenum type,
-                           GLuint* max_value);
+                           bool primitive_restart_enabled, GLuint* max_value);
 
   // Returns a pointer to shadowed data.
   const void* GetRange(GLintptr offset, GLsizeiptr size) const;
 
   bool IsDeleted() const {
     return deleted_;
   }
 
   bool IsValid() const {
     return initial_target() && !IsDeleted();
@@ skipping 17 matching lines @@
   }
 
  private:
   friend class BufferManager;
   friend class BufferManagerTestBase;
   friend class base::RefCounted<Buffer>;
 
   // Represents a range in a buffer.
   class Range {
    public:
-    Range(GLuint offset, GLsizei count, GLenum type)
+    Range(GLuint offset, GLsizei count, GLenum type,
+          bool primitive_restart_enabled)
         : offset_(offset),
           count_(count),
-          type_(type) {
+          type_(type),
+          primitive_restart_enabled_(primitive_restart_enabled) {
     }
 
     // A less functor provided for std::map so it can find ranges.
     struct Less {
       bool operator() (const Range& lhs, const Range& rhs) const {
         if (lhs.offset_ != rhs.offset_) {
           return lhs.offset_ < rhs.offset_;
         }
         if (lhs.count_ != rhs.count_) {
           return lhs.count_ < rhs.count_;
         }
-        return lhs.type_ < rhs.type_;
+        if (lhs.type_ != rhs.type_) {
+          return lhs.type_ < rhs.type_;
+        }
+        return lhs.primitive_restart_enabled_ < rhs.primitive_restart_enabled_;
       }
     };
 
    private:
     GLuint offset_;
     GLsizei count_;
     GLenum type_;
+    bool primitive_restart_enabled_;
   };
 
   ~Buffer();
 
   GLenum initial_target() const {
     return initial_target_;
   }
 
   void set_initial_target(GLenum target) {
     DCHECK_EQ(0u, initial_target_);
@@ skipping 125 matching lines @@
     return memory_type_tracker_->GetMemRepresented();
   }
 
   // Tells for a given usage if this would be a client side array.
   bool IsUsageClientSideArray(GLenum usage);
 
   // Tells whether a buffer that is emulated using client-side arrays should be
   // set to a non-zero size.
   bool UseNonZeroSizeForClientSideArrayBuffer();
 
+  void SetPrimitiveRestartFixedIndexIfNecessary(GLenum type);
+
   Buffer* GetBufferInfoForTarget(ContextState* state, GLenum target) const;
 
   // base::trace_event::MemoryDumpProvider implementation.
   bool OnMemoryDump(const base::trace_event::MemoryDumpArgs& args,
                     base::trace_event::ProcessMemoryDump* pmd) override;
 
  private:
   friend class Buffer;
   friend class TestHelper;  // Needs access to DoBufferData.
   friend class BufferManagerTestBase;  // Needs access to DoBufferSubData.
@@ skipping 37 matching lines @@
   // Whether or not buffers can be bound to multiple targets.
   bool allow_buffers_on_multiple_targets_;
 
   // Whether or not allow using GL_FIXED type for vertex attribs.
   bool allow_fixed_attribs_;
 
   // Counts the number of Buffer allocated with 'this' as its manager.
   // Allows to check no Buffer will outlive this.
   unsigned int buffer_count_;
 
+  GLuint primitive_restart_fixed_index_;
+
   bool have_context_;
   bool use_client_side_arrays_for_stream_buffers_;
 
   DISALLOW_COPY_AND_ASSIGN(BufferManager);
 };
 
 }  // namespace gles2
 }  // namespace gpu
 
 #endif  // GPU_COMMAND_BUFFER_SERVICE_BUFFER_MANAGER_H_