Improve indexed gl state related GL commands.

gpu/command_buffer/service/indexed_buffer_binding_host.cc

 // Copyright (c) 2016 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/indexed_buffer_binding_host.h"
 
 #include "gpu/command_buffer/service/buffer_manager.h"
 
 namespace gpu {
 namespace gles2 {
@@ skipping 10 matching lines @@
     : type(other.type),
       buffer(other.buffer.get()),
       offset(other.offset),
       size(other.size),
       effective_full_buffer_size(other.effective_full_buffer_size) {
 }
 
 IndexedBufferBindingHost::IndexedBufferBinding::~IndexedBufferBinding() {
 }
 
+bool IndexedBufferBindingHost::IndexedBufferBinding::operator==(
+    const IndexedBufferBindingHost::IndexedBufferBinding& other) const {
+  if (type == kBindBufferNone && other.type == kBindBufferNone) {
+    // This should be the most common case so an early out.
+    return true;
+  }
+  return (type == other.type &&
+          buffer.get() == other.buffer.get() &&
+          offset == other.offset &&
+          size == other.size &&
+          effective_full_buffer_size == other.effective_full_buffer_size);
+}
+
 void IndexedBufferBindingHost::IndexedBufferBinding::SetBindBufferBase(
     Buffer* _buffer) {
   if (!_buffer) {
     Reset();
     return;
   }
   type = kBindBufferBase;
   buffer = _buffer;
   offset = 0;
   size = 0;
@@ skipping 17 matching lines @@
   type = kBindBufferNone;
   buffer = nullptr;
   offset = 0;
   size = 0;
   effective_full_buffer_size = 0;
 }
 
 
 IndexedBufferBindingHost::IndexedBufferBindingHost(
     uint32_t max_bindings, bool needs_emulation)
-    : needs_emulation_(needs_emulation) {
+    : needs_emulation_(needs_emulation),
+      max_non_null_binding_index_plus_one_(0u) {
   buffer_bindings_.resize(max_bindings);
 }
 
 IndexedBufferBindingHost::~IndexedBufferBindingHost() {
 }
 
 void IndexedBufferBindingHost::DoBindBufferBase(
     GLenum target, GLuint index, Buffer* buffer) {
   DCHECK_LT(index, buffer_bindings_.size());
   GLuint service_id = buffer ? buffer->service_id() : 0;
   glBindBufferBase(target, index, service_id);
 
   buffer_bindings_[index].SetBindBufferBase(buffer);
+  UpdateMaxNonNullBindingIndex(index);
 }
 
 void IndexedBufferBindingHost::DoBindBufferRange(
     GLenum target, GLuint index, Buffer* buffer, GLintptr offset,
     GLsizeiptr size) {
   DCHECK_LT(index, buffer_bindings_.size());
   GLuint service_id = buffer ? buffer->service_id() : 0;
   if (buffer && needs_emulation_) {
     DoAdjustedBindBufferRange(
         target, index, service_id, offset, size, buffer->size());
   } else {
     glBindBufferRange(target, index, service_id, offset, size);
   }
 
   buffer_bindings_[index].SetBindBufferRange(buffer, offset, size);
+  UpdateMaxNonNullBindingIndex(index);
 }
 
 // static
 void IndexedBufferBindingHost::DoAdjustedBindBufferRange(
     GLenum target, GLuint index, GLuint service_id, GLintptr offset,
     GLsizeiptr size, GLsizeiptr full_buffer_size) {
   GLsizeiptr adjusted_size = size;
   if (offset >= full_buffer_size) {
     // Situation 1: We can't really call glBindBufferRange with reasonable
     // offset/size without triggering a GL error because size == 0 isn't
@@ skipping 50 matching lines @@
         buffer_bindings_[ii].effective_full_buffer_size = buffer->size();
       }
     }
   }
 }
 
 void IndexedBufferBindingHost::RemoveBoundBuffer(Buffer* buffer) {
   for (size_t ii = 0; ii < buffer_bindings_.size(); ++ii) {
     if (buffer_bindings_[ii].buffer.get() == buffer) {
       buffer_bindings_[ii].Reset();
+      UpdateMaxNonNullBindingIndex(ii);
     }
   }
 }
 
 Buffer* IndexedBufferBindingHost::GetBufferBinding(GLuint index) const {
   DCHECK_LT(index, buffer_bindings_.size());
   return buffer_bindings_[index].buffer.get();
 }
 
 GLsizeiptr IndexedBufferBindingHost::GetBufferSize(GLuint index) const {
   DCHECK_LT(index, buffer_bindings_.size());
   return buffer_bindings_[index].size;
 }
 
 GLintptr IndexedBufferBindingHost::GetBufferStart(GLuint index) const {
   DCHECK_LT(index, buffer_bindings_.size());
   return buffer_bindings_[index].offset;
 }
 
+void IndexedBufferBindingHost::RestoreBindings(
+    IndexedBufferBindingHost* prev) {
+  size_t limit = max_non_null_binding_index_plus_one_;
+  if (prev && prev->max_non_null_binding_index_plus_one_ > limit) {
+    limit = prev->max_non_null_binding_index_plus_one_;
+  }
+  for (size_t ii = 0; ii < limit; ++ii) {
+    if (prev && buffer_bindings_[ii] == prev->buffer_bindings_[ii]) {
+      continue;
+    }
+    switch (buffer_bindings_[ii].type) {
+      case kBindBufferBase:
+      case kBindBufferNone:
+        DoBindBufferBase(
+            GL_UNIFORM_BUFFER, ii, buffer_bindings_[ii].buffer.get());
+        break;
+      case kBindBufferRange:
+        DoBindBufferRange(
+            GL_UNIFORM_BUFFER, ii, buffer_bindings_[ii].buffer.get(),
+            buffer_bindings_[ii].offset, buffer_bindings_[ii].size);
+        break;
+    }
+  }
+}
+
+void IndexedBufferBindingHost::UpdateMaxNonNullBindingIndex(
+    size_t changed_index) {
+  size_t plus_one = changed_index + 1;
+  DCHECK_LT(changed_index, buffer_bindings_.size());
+  if (buffer_bindings_[changed_index].buffer.get()) {
+    max_non_null_binding_index_plus_one_ =
+        std::max(max_non_null_binding_index_plus_one_, plus_one);
+  } else {
+    if (plus_one == max_non_null_binding_index_plus_one_) {
+      for (size_t ii = changed_index; ii > 0; --ii) {
+        if (buffer_bindings_[ii - 1].buffer.get()) {
+          max_non_null_binding_index_plus_one_ = ii;
+          break;
+        }
+      }
+    }
+  }
+}
+
 }  // namespace gles2
 }  // namespace gpu