GPU: Flush in glBind* to avoid being executed after future glDelete*

gpu/command_buffer/client/gles2_implementation.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.
 
 // A class to emulate GLES2 over command buffers.
 
 #include "gpu/command_buffer/client/gles2_implementation.h"
 
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
@@ skipping 2276 matching lines @@
     const GLuint* /* valuebuffers */) {
 }
 
 // NOTE #1: On old versions of OpenGL, calling glBindXXX with an unused id
 // generates a new resource. On newer versions of OpenGL they don't. The code
 // related to binding below will need to change if we switch to the new OpenGL
 // model. Specifically it assumes a bind will succeed which is always true in
 // the old model but possibly not true in the new model if another context has
 // deleted the resource.
 
-bool GLES2Implementation::BindBufferHelper(
+void GLES2Implementation::BindBufferHelper(
     GLenum target, GLuint buffer_id) {
   // TODO(gman): See note #1 above.
   bool changed = false;
   switch (target) {
     case GL_ARRAY_BUFFER:
       if (bound_array_buffer_id_ != buffer_id) {
         bound_array_buffer_id_ = buffer_id;
         changed = true;
       }
       break;
     case GL_ELEMENT_ARRAY_BUFFER:
       changed = vertex_array_object_manager_->BindElementArray(buffer_id);
       break;
     case GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM:
       bound_pixel_pack_transfer_buffer_id_ = buffer_id;
       break;
     case GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM:
       bound_pixel_unpack_transfer_buffer_id_ = buffer_id;
       break;
     default:
       changed = true;
       break;
   }
   // TODO(gman): There's a bug here. If the target is invalid the ID will not be
   // used even though it's marked it as used here.
-  GetIdHandler(id_namespaces::kBuffers)->MarkAsUsedForBind(buffer_id);
-  return changed;
+  if (changed) {
+    GetIdHandler(id_namespaces::kBuffers)->MarkAsUsedForBind(
+        this, target, buffer_id, &GLES2Implementation::BindBufferStub);
+  }
 }
 
-bool GLES2Implementation::BindFramebufferHelper(
+void GLES2Implementation::BindBufferStub(GLenum target, GLuint buffer) {
+  helper_->BindBuffer(target, buffer);
+  if (share_group_->bind_generates_resource())
+    helper_->CommandBufferHelper::Flush();
+}
+
+void GLES2Implementation::BindFramebufferHelper(
     GLenum target, GLuint framebuffer) {
   // TODO(gman): See note #1 above.
   bool changed = false;
   switch (target) {
     case GL_FRAMEBUFFER:
       if (bound_framebuffer_ != framebuffer ||
           bound_read_framebuffer_ != framebuffer) {
         bound_framebuffer_ = framebuffer;
         bound_read_framebuffer_ = framebuffer;
         changed = true;
       }
       break;
     case GL_READ_FRAMEBUFFER:
       if (!IsChromiumFramebufferMultisampleAvailable()) {
         SetGLErrorInvalidEnum("glBindFramebuffer", target, "target");
-        return false;
+        return;
       }
       if (bound_read_framebuffer_ != framebuffer) {
         bound_read_framebuffer_ = framebuffer;
         changed = true;
       }
       break;
     case GL_DRAW_FRAMEBUFFER:
       if (!IsChromiumFramebufferMultisampleAvailable()) {
         SetGLErrorInvalidEnum("glBindFramebuffer", target, "target");
-        return false;
+        return;
       }
       if (bound_framebuffer_ != framebuffer) {
         bound_framebuffer_ = framebuffer;
         changed = true;
       }
       break;
     default:
       SetGLErrorInvalidEnum("glBindFramebuffer", target, "target");
-      return false;
+      return;
   }
-  GetIdHandler(id_namespaces::kFramebuffers)->MarkAsUsedForBind(framebuffer);
-  return changed;
+
+  if (changed) {
+    GetIdHandler(id_namespaces::kFramebuffers)->MarkAsUsedForBind(
+        this, target, framebuffer, &GLES2Implementation::BindFramebufferStub);
+  }
 }
 
-bool GLES2Implementation::BindRenderbufferHelper(
+void GLES2Implementation::BindFramebufferStub(GLenum target,
+                                              GLuint framebuffer) {
+  helper_->BindFramebuffer(target, framebuffer);
+  if (share_group_->bind_generates_resource())
+    helper_->CommandBufferHelper::Flush();
+}
+
+void GLES2Implementation::BindRenderbufferHelper(
     GLenum target, GLuint renderbuffer) {
   // TODO(gman): See note #1 above.
   bool changed = false;
   switch (target) {
     case GL_RENDERBUFFER:
       if (bound_renderbuffer_ != renderbuffer) {
         bound_renderbuffer_ = renderbuffer;
         changed = true;
       }
       break;
     default:
       changed = true;
       break;
   }
   // TODO(gman): There's a bug here. If the target is invalid the ID will not be
   // used even though it's marked it as used here.
-  GetIdHandler(id_namespaces::kRenderbuffers)->MarkAsUsedForBind(renderbuffer);
-  return changed;
+  if (changed) {
+    GetIdHandler(id_namespaces::kRenderbuffers)->MarkAsUsedForBind(
+        this, target, renderbuffer,
+        &GLES2Implementation::BindRenderbufferStub);
+  }
 }
 
-bool GLES2Implementation::BindTextureHelper(GLenum target, GLuint texture) {
+void GLES2Implementation::BindRenderbufferStub(GLenum target,
+                                               GLuint renderbuffer) {
+  helper_->BindRenderbuffer(target, renderbuffer);
+  if (share_group_->bind_generates_resource())
+    helper_->CommandBufferHelper::Flush();
+}
+
+void GLES2Implementation::BindTextureHelper(GLenum target, GLuint texture) {
   // TODO(gman): See note #1 above.
   // TODO(gman): Change this to false once we figure out why it's failing
   //     on daisy.
   bool changed = true;
   TextureUnit& unit = texture_units_[active_texture_unit_];
   switch (target) {
     case GL_TEXTURE_2D:
       if (unit.bound_texture_2d != texture) {
         unit.bound_texture_2d = texture;
         changed = true;
@@ skipping 10 matching lines @@
         unit.bound_texture_external_oes = texture;
         changed = true;
       }
       break;
     default:
       changed = true;
       break;
   }
   // TODO(gman): There's a bug here. If the target is invalid the ID will not be
   // used. even though it's marked it as used here.
-  GetIdHandler(id_namespaces::kTextures)->MarkAsUsedForBind(texture);
-  return changed;
+  if (changed) {
+    GetIdHandler(id_namespaces::kTextures)->MarkAsUsedForBind(
+        this, target, texture, &GLES2Implementation::BindTextureStub);
+  }
 }
 
-bool GLES2Implementation::BindVertexArrayOESHelper(GLuint array) {
+void GLES2Implementation::BindTextureStub(GLenum target, GLuint texture) {
+  helper_->BindTexture(target, texture);
+  if (share_group_->bind_generates_resource())
+    helper_->CommandBufferHelper::Flush();
+}
+
+void GLES2Implementation::BindVertexArrayOESHelper(GLuint array) {
   // TODO(gman): See note #1 above.
   bool changed = false;
-  if (!vertex_array_object_manager_->BindVertexArray(array, &changed)) {
+  if (vertex_array_object_manager_->BindVertexArray(array, &changed)) {
+    if (changed) {
+      // Unlike other BindXXXHelpers we don't call MarkAsUsedForBind
+      // because unlike other resources VertexArrayObject ids must
+      // be generated by GenVertexArrays. A random id to Bind will not
+      // generate a new object.
+      helper_->BindVertexArrayOES(array);
+    }
+  } else {
     SetGLError(
         GL_INVALID_OPERATION, "glBindVertexArrayOES",
         "id was not generated with glGenVertexArrayOES");
   }
-  // Unlike other BindXXXHelpers we don't call MarkAsUsedForBind
-  // because unlike other resources VertexArrayObject ids must
-  // be generated by GenVertexArrays. A random id to Bind will not
-  // generate a new object.
-  return changed;
 }
 
-bool GLES2Implementation::BindValuebufferCHROMIUMHelper(GLenum target,
+void GLES2Implementation::BindValuebufferCHROMIUMHelper(GLenum target,
                                                         GLuint valuebuffer) {
   bool changed = false;
   switch (target) {
     case GL_SUBSCRIBED_VALUES_BUFFER_CHROMIUM:
       if (bound_valuebuffer_ != valuebuffer) {
         bound_valuebuffer_ = valuebuffer;
         changed = true;
       }
       break;
     default:
       changed = true;
       break;
   }
   // TODO(gman): There's a bug here. If the target is invalid the ID will not be
   // used even though it's marked it as used here.
-  GetIdHandler(id_namespaces::kValuebuffers)->MarkAsUsedForBind(valuebuffer);
-  return changed;
+  if (changed) {
+    GetIdHandler(id_namespaces::kValuebuffers)->MarkAsUsedForBind(
+        this, target, valuebuffer,
+        &GLES2Implementation::BindValuebufferCHROMIUMStub);
+  }
 }
 
-bool GLES2Implementation::UseProgramHelper(GLuint program) {
-  bool changed = false;
+void GLES2Implementation::BindValuebufferCHROMIUMStub(GLenum target,
+                                                      GLuint valuebuffer) {
+  helper_->BindValuebufferCHROMIUM(target, valuebuffer);
+  if (share_group_->bind_generates_resource())
+    helper_->CommandBufferHelper::Flush();
+}
+
+void GLES2Implementation::UseProgramHelper(GLuint program) {
   if (current_program_ != program) {
     current_program_ = program;
-    changed = true;
+    helper_->UseProgram(program);
   }
-  return changed;
 }
 
 bool GLES2Implementation::IsBufferReservedId(GLuint id) {
   return vertex_array_object_manager_->IsReservedId(id);
 }
 
 void GLES2Implementation::DeleteBuffersHelper(
     GLsizei n, const GLuint* buffers) {
   if (!GetIdHandler(id_namespaces::kBuffers)->FreeIds(
       this, n, buffers, &GLES2Implementation::DeleteBuffersStub)) {
@@ skipping 1429 matching lines @@
   return true;
 }
 
 // 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 "gpu/command_buffer/client/gles2_implementation_impl_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu