[WebGL 2] primitive restart should be always enabled

gpu/command_buffer/service/buffer_manager.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/buffer_manager.h"
 
 #include <stdint.h>
 
 #include <limits>
 
@@ skipping 16 matching lines @@
 
 BufferManager::BufferManager(MemoryTracker* memory_tracker,
                              FeatureInfo* feature_info)
     : memory_type_tracker_(
           new MemoryTypeTracker(memory_tracker)),
       memory_tracker_(memory_tracker),
       feature_info_(feature_info),
       allow_buffers_on_multiple_targets_(false),
       allow_fixed_attribs_(false),
       buffer_count_(0),
+      primitive_restart_enabled_(false),
       have_context_(true),
       use_client_side_arrays_for_stream_buffers_(
           feature_info
               ? feature_info->workarounds()
                     .use_client_side_arrays_for_stream_buffers
               : 0) {
   // When created from InProcessCommandBuffer, we won't have a |memory_tracker_|
   // so don't register a dump provider.
   if (memory_tracker_) {
     base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
@@ skipping 145 matching lines @@
     return NULL;
   }
   return shadow_.get() + offset;
 }
 
 void Buffer::ClearCache() {
   range_set_.clear();
 }
 
 template <typename T>
-GLuint GetMaxValue(const void* data, GLuint offset, GLsizei count) {
+GLuint GetMaxValue(const void* data, GLuint offset, GLsizei count,
+    GLuint primitive_restart_index) {
   GLuint max_value = 0;
   const T* element =
       reinterpret_cast<const T*>(static_cast<const int8_t*>(data) + offset);
   const T* end = element + count;
   for (; element < end; ++element) {
     if (*element > max_value) {
+      if (*element == primitive_restart_index) {
+        continue;
+      }
       max_value = *element;
     }
   }
   return max_value;
 }
 
 bool Buffer::GetMaxValueForRange(
     GLuint offset, GLsizei count, GLenum type, GLuint* max_value) {
   Range range(offset, count, type);
   RangeToMaxValueMap::iterator it = range_set_.find(range);
   if (it != range_set_.end()) {
-    *max_value = it->second;
-    return true;
+    if (it->second.max_value_ == it->second.max_value_pr_enabled_ ||
+        (!manager_->primitive_restart_enabled_ && it->second.max_value_)) {
+      *max_value = it->second.max_value_;
+      return true;
+    }
+    if (!manager_->primitive_restart_enabled_ &&
+        it->second.max_value_pr_enabled_) {
+      *max_value = it->second.max_value_pr_enabled_;
+      return true;
+    }
   }
 
   uint32_t size;
   if (!SafeMultiplyUint32(
       count, GLES2Util::GetGLTypeSizeForBuffers(type), &size)) {
     return false;
   }
 
   if (!SafeAddUint32(offset, size, &size)) {
     return false;
   }
 
   if (size > static_cast<uint32_t>(size_)) {
     return false;
   }
 
   if (!shadowed_) {
     return false;
   }
 
   // Scan the range for the max value and store
+  bool index_buffer =
+      this->initial_target() == GL_ELEMENT_ARRAY_BUFFER ? true : false;
+  GLuint primitive_restart_index = 0;
+
   GLuint max_v = 0;
   switch (type) {
     case GL_UNSIGNED_BYTE:
-      max_v = GetMaxValue<uint8_t>(shadow_.get(), offset, count);
+      if (index_buffer && manager_->primitive_restart_enabled_) {
+        primitive_restart_index = 0xFF;
+      }
+      max_v = GetMaxValue<uint8_t>(shadow_.get(), offset, count,
+          primitive_restart_index);
       break;
     case GL_UNSIGNED_SHORT:
       // Check we are not accessing an odd byte for a 2 byte value.
       if ((offset & 1) != 0) {
         return false;
       }
-      max_v = GetMaxValue<uint16_t>(shadow_.get(), offset, count);
+      if (index_buffer && manager_->primitive_restart_enabled_) {
+        primitive_restart_index = 0xFFFF;
+      }
+      max_v = GetMaxValue<uint16_t>(shadow_.get(), offset, count,
+          primitive_restart_index);
       break;
     case GL_UNSIGNED_INT:
       // Check we are not accessing a non aligned address for a 4 byte value.
       if ((offset & 3) != 0) {
         return false;
       }
-      max_v = GetMaxValue<uint32_t>(shadow_.get(), offset, count);
+      if (index_buffer && manager_->primitive_restart_enabled_) {
+        primitive_restart_index = 0xFFFFFFFF;
+      }
+      max_v = GetMaxValue<uint32_t>(shadow_.get(), offset, count,
+          primitive_restart_index);
       break;
     default:
       NOTREACHED();  // should never get here by validation.
       break;
   }
-  range_set_.insert(std::make_pair(range, max_v));
+
+  if (it != range_set_.end()) {
+    if (manager_->primitive_restart_enabled_) {
+      it->second.max_value_ = max_v;
+    } else {
+      it->second.max_value_pr_enabled_ = max_v;
+    }
+  } else {
+    GLuint temp_max_value = 0, temp_max_value_pr_enabled = 0;
+    if (!index_buffer) {
+      temp_max_value = max_v;
+      temp_max_value_pr_enabled = max_v;
+    } else {
+      if (manager_->primitive_restart_enabled_) {
+        temp_max_value_pr_enabled = max_v;
+      } else {
+        temp_max_value = max_v;
+      }
+    }
+    struct MaxValue value(temp_max_value, temp_max_value_pr_enabled);
+    range_set_.insert(std::make_pair(range, value));
+  }
   *max_value = max_v;
   return true;
 }
 
 bool BufferManager::GetClientId(GLuint service_id, GLuint* client_id) const {
   // This doesn't need to be fast. It's only used during slow queries.
   for (BufferMap::const_iterator it = buffers_.begin();
        it != buffers_.end(); ++it) {
     if (it->second->service_id() == service_id) {
       *client_id = it->first;
@@ skipping 252 matching lines @@
     case GL_TRANSFORM_FEEDBACK_BUFFER:
       return state->bound_transform_feedback_buffer.get();
     case GL_UNIFORM_BUFFER:
       return state->bound_uniform_buffer.get();
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
+void BufferManager::SetPrimitiveRestartState(bool enabled) {
+  if (primitive_restart_enabled_ != enabled) {
+    primitive_restart_enabled_ = enabled;
+  }
+}
+
 bool BufferManager::OnMemoryDump(const base::trace_event::MemoryDumpArgs& args,
                                  base::trace_event::ProcessMemoryDump* pmd) {
   const int client_id = memory_tracker_->ClientId();
   for (const auto& buffer_entry : buffers_) {
     const auto& client_buffer_id = buffer_entry.first;
     const auto& buffer = buffer_entry.second;
 
     std::string dump_name = base::StringPrintf(
         "gpu/gl/buffers/client_%d/buffer_%d", client_id, client_buffer_id);
     base::trace_event::MemoryAllocatorDump* dump =
         pmd->CreateAllocatorDump(dump_name);
     dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
                     base::trace_event::MemoryAllocatorDump::kUnitsBytes,
                     static_cast<uint64_t>(buffer->size()));
 
     auto guid = gfx::GetGLBufferGUIDForTracing(
         memory_tracker_->ShareGroupTracingGUID(), client_buffer_id);
     pmd->CreateSharedGlobalAllocatorDump(guid);
     pmd->AddOwnershipEdge(dump->guid(), guid);
   }
   return true;
 }
 
 }  // namespace gles2
 }  // namespace gpu