Do not share FBOs/VAOs/Transform feedback objects across contexts

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/gl2.h>
 #include <GLES2/gl2ext.h>
@@ skipping 227 matching lines @@
   util_.set_num_compressed_texture_formats(
       capabilities_.num_compressed_texture_formats);
   util_.set_num_shader_binary_formats(capabilities_.num_shader_binary_formats);
 
   texture_units_.reset(
       new TextureUnit[capabilities_.max_combined_texture_image_units]);
 
   query_tracker_.reset(new QueryTracker(mapped_memory_.get()));
   buffer_tracker_.reset(new BufferTracker(mapped_memory_.get()));
 
-  query_id_allocator_.reset(new IdAllocator());
+  for (int i = 0; i < static_cast<int>(IdNamespaces::kNumIdNamespaces); ++i)
+    id_allocators_[i].reset(new IdAllocator());
+
   if (support_client_side_arrays_) {
-    GetIdHandler(id_namespaces::kBuffers)->MakeIds(
-       this, kClientSideArrayId, arraysize(reserved_ids_), &reserved_ids_[0]);
+    GetIdHandler(SharedIdNamespaces::kBuffers)
+        ->MakeIds(this, kClientSideArrayId, arraysize(reserved_ids_),
+                  &reserved_ids_[0]);
   }
 
   vertex_array_object_manager_.reset(new VertexArrayObjectManager(
       capabilities_.max_vertex_attribs, reserved_ids_[0], reserved_ids_[1],
       support_client_side_arrays_));
 
   // GL_BIND_GENERATES_RESOURCE_CHROMIUM state must be the same
   // on Client & Service.
   if (capabilities_.bind_generates_resource_chromium !=
       (share_group_->bind_generates_resource() ? 1 : 0)) {
@@ skipping 34 matching lines @@
 
   // The gpu_control_ outlives this class, so clear the client on it before we
   // self-destruct.
   gpu_control_->SetGpuControlClient(nullptr);
 }
 
 GLES2CmdHelper* GLES2Implementation::helper() const {
   return helper_;
 }
 
-IdHandlerInterface* GLES2Implementation::GetIdHandler(int namespace_id) const {
+IdHandlerInterface* GLES2Implementation::GetIdHandler(
+    SharedIdNamespaces namespace_id) const {
   return share_group_->GetIdHandler(namespace_id);
 }
 
 RangeIdHandlerInterface* GLES2Implementation::GetRangeIdHandler(
     int namespace_id) const {
   return share_group_->GetRangeIdHandler(namespace_id);
 }
 
-IdAllocator* GLES2Implementation::GetIdAllocator(int namespace_id) const {
-  if (namespace_id == id_namespaces::kQueries)
-    return query_id_allocator_.get();
-  NOTREACHED();
-  return NULL;
+IdAllocator* GLES2Implementation::GetIdAllocator(
+    IdNamespaces namespace_id) const {
+  return id_allocators_[static_cast<int>(namespace_id)].get();
 }
 
 void GLES2Implementation::OnGpuControlLostContext() {
   // This should never occur more than once.
   DCHECK(!lost_context_callback_run_);
   lost_context_callback_run_ = true;
   share_group_->Lose();
   if (!lost_context_callback_.is_null())
     lost_context_callback_.Run();
 }
@@ skipping 1260 matching lines @@
   }
   GPU_CLIENT_LOG_CODE_BLOCK({
     for (int32_t i = 0; i < num_results; ++i) {
       GPU_CLIENT_LOG("  " << i << ": " << ptr[i]);
     }
   });
   CheckGLError();
 }
 
 bool GLES2Implementation::DeleteProgramHelper(GLuint program) {
-  if (!GetIdHandler(id_namespaces::kProgramsAndShaders)->FreeIds(
-      this, 1, &program, &GLES2Implementation::DeleteProgramStub)) {
+  if (!GetIdHandler(SharedIdNamespaces::kProgramsAndShaders)
+           ->FreeIds(this, 1, &program,
+                     &GLES2Implementation::DeleteProgramStub)) {
     SetGLError(
         GL_INVALID_VALUE,
         "glDeleteProgram", "id not created by this context.");
     return false;
   }
   if (program == current_program_) {
     current_program_ = 0;
   }
   return true;
 }
 
 void GLES2Implementation::DeleteProgramStub(
     GLsizei n, const GLuint* programs) {
   DCHECK_EQ(1, n);
   share_group_->program_info_manager()->DeleteInfo(programs[0]);
   helper_->DeleteProgram(programs[0]);
 }
 
 bool GLES2Implementation::DeleteShaderHelper(GLuint shader) {
-  if (!GetIdHandler(id_namespaces::kProgramsAndShaders)->FreeIds(
-      this, 1, &shader, &GLES2Implementation::DeleteShaderStub)) {
+  if (!GetIdHandler(SharedIdNamespaces::kProgramsAndShaders)
+           ->FreeIds(this, 1, &shader,
+                     &GLES2Implementation::DeleteShaderStub)) {
     SetGLError(
         GL_INVALID_VALUE,
         "glDeleteShader", "id not created by this context.");
     return false;
   }
   return true;
 }
 
 void GLES2Implementation::DeleteShaderStub(
     GLsizei n, const GLuint* shaders) {
   DCHECK_EQ(1, n);
   share_group_->program_info_manager()->DeleteInfo(shaders[0]);
   helper_->DeleteShader(shaders[0]);
 }
 
 void GLES2Implementation::DeleteSyncHelper(GLsync sync) {
   GLuint sync_uint = ToGLuint(sync);
-  if (!GetIdHandler(id_namespaces::kSyncs)->FreeIds(
-      this, 1, &sync_uint, &GLES2Implementation::DeleteSyncStub)) {
+  if (!GetIdHandler(SharedIdNamespaces::kSyncs)
+           ->FreeIds(this, 1, &sync_uint,
+                     &GLES2Implementation::DeleteSyncStub)) {
     SetGLError(
         GL_INVALID_VALUE,
         "glDeleteSync", "id not created by this context.");
   }
 }
 
 void GLES2Implementation::DeleteSyncStub(GLsizei n, const GLuint* syncs) {
   DCHECK_EQ(1, n);
   helper_->DeleteSync(syncs[0]);
 }
@@ skipping 2632 matching lines @@
         bound_uniform_buffer_ = buffer_id;
         changed = true;
       }
       break;
     default:
       changed = true;
       break;
   }
   // TODO(gman): See note #2 above.
   if (changed) {
-    GetIdHandler(id_namespaces::kBuffers)->MarkAsUsedForBind(
-        this, target, buffer_id, &GLES2Implementation::BindBufferStub);
+    GetIdHandler(SharedIdNamespaces::kBuffers)
+        ->MarkAsUsedForBind(this, target, buffer_id,
+                            &GLES2Implementation::BindBufferStub);
   }
 }
 
 void GLES2Implementation::BindBufferStub(GLenum target, GLuint buffer) {
   helper_->BindBuffer(target, buffer);
   if (share_group_->bind_generates_resource())
     helper_->CommandBufferHelper::OrderingBarrier();
 }
 
 void GLES2Implementation::BindBufferBaseHelper(
@@ skipping 21 matching lines @@
         return;
       }
       if (bound_uniform_buffer_ != buffer_id) {
         bound_uniform_buffer_ = buffer_id;
       }
       break;
     default:
       SetGLError(GL_INVALID_ENUM, "glBindBufferBase", "invalid target");
       return;
   }
-  GetIdHandler(id_namespaces::kBuffers)->MarkAsUsedForBind(
-      this, target, index, buffer_id, &GLES2Implementation::BindBufferBaseStub);
+  GetIdHandler(SharedIdNamespaces::kBuffers)
+      ->MarkAsUsedForBind(this, target, index, buffer_id,
+                          &GLES2Implementation::BindBufferBaseStub);
 }
 
 void GLES2Implementation::BindBufferBaseStub(
     GLenum target, GLuint index, GLuint buffer) {
   helper_->BindBufferBase(target, index, buffer);
   if (share_group_->bind_generates_resource())
     helper_->CommandBufferHelper::Flush();
 }
 
 void GLES2Implementation::BindBufferRangeHelper(
     GLenum target, GLuint index, GLuint buffer_id,
     GLintptr offset, GLsizeiptr size) {
   // TODO(zmo): See note #1 above.
   // TODO(zmo): See note #2 above.
-  GetIdHandler(id_namespaces::kBuffers)->MarkAsUsedForBind(
-      this, target, index, buffer_id, offset, size,
-      &GLES2Implementation::BindBufferRangeStub);
+  GetIdHandler(SharedIdNamespaces::kBuffers)
+      ->MarkAsUsedForBind(this, target, index, buffer_id, offset, size,
+                          &GLES2Implementation::BindBufferRangeStub);
 }
 
 void GLES2Implementation::BindBufferRangeStub(
     GLenum target, GLuint index, GLuint buffer,
     GLintptr offset, GLsizeiptr size) {
   helper_->BindBufferRange(target, index, buffer, offset, size);
   if (share_group_->bind_generates_resource())
     helper_->CommandBufferHelper::Flush();
 }
 
@@ skipping 25 matching lines @@
         bound_framebuffer_ = framebuffer;
         changed = true;
       }
       break;
     default:
       SetGLErrorInvalidEnum("glBindFramebuffer", target, "target");
       return;
   }
 
   if (changed) {
-    GetIdHandler(id_namespaces::kFramebuffers)->MarkAsUsedForBind(
-        this, target, framebuffer, &GLES2Implementation::BindFramebufferStub);
+    if (framebuffer != 0)
+      GetIdAllocator(IdNamespaces::kFramebuffers)->MarkAsUsed(framebuffer);
+    helper_->BindFramebuffer(target, framebuffer);
   }
 }
 
-void GLES2Implementation::BindFramebufferStub(GLenum target,
-                                              GLuint framebuffer) {
-  helper_->BindFramebuffer(target, framebuffer);
-  if (share_group_->bind_generates_resource())
-    helper_->CommandBufferHelper::OrderingBarrier();
-}
-
 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(zmo): See note #2 above.
   if (changed) {
-    GetIdHandler(id_namespaces::kRenderbuffers)->MarkAsUsedForBind(
-        this, target, renderbuffer,
-        &GLES2Implementation::BindRenderbufferStub);
+    GetIdHandler(SharedIdNamespaces::kRenderbuffers)
+        ->MarkAsUsedForBind(this, target, renderbuffer,
+                            &GLES2Implementation::BindRenderbufferStub);
   }
 }
 
 void GLES2Implementation::BindRenderbufferStub(GLenum target,
                                                GLuint renderbuffer) {
   helper_->BindRenderbuffer(target, renderbuffer);
   if (share_group_->bind_generates_resource())
     helper_->CommandBufferHelper::OrderingBarrier();
 }
 
@@ skipping 26 matching lines @@
         unit.bound_texture_external_oes = texture;
         changed = true;
       }
       break;
     default:
       changed = true;
       break;
   }
   // TODO(gman): See note #2 above.
   if (changed) {
-    GetIdHandler(id_namespaces::kTextures)->MarkAsUsedForBind(
-        this, target, texture, &GLES2Implementation::BindTextureStub);
+    GetIdHandler(SharedIdNamespaces::kTextures)
+        ->MarkAsUsedForBind(this, target, texture,
+                            &GLES2Implementation::BindTextureStub);
   }
 }
 
 void GLES2Implementation::BindTextureStub(GLenum target, GLuint texture) {
   helper_->BindTexture(target, texture);
   if (share_group_->bind_generates_resource())
     helper_->CommandBufferHelper::OrderingBarrier();
 }
 
 void GLES2Implementation::BindTransformFeedbackHelper(
@@ skipping 24 matching lines @@
     helper_->UseProgram(program);
   }
 }
 
 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)) {
+  if (!GetIdHandler(SharedIdNamespaces::kBuffers)
+           ->FreeIds(this, n, buffers,
+                     &GLES2Implementation::DeleteBuffersStub)) {
     SetGLError(
         GL_INVALID_VALUE,
         "glDeleteBuffers", "id not created by this context.");
     return;
   }
   for (GLsizei ii = 0; ii < n; ++ii) {
     if (buffers[ii] == bound_array_buffer_) {
       bound_array_buffer_ = 0;
     }
     if (buffers[ii] == bound_copy_read_buffer_) {
@@ skipping 29 matching lines @@
 }
 
 void GLES2Implementation::DeleteBuffersStub(
     GLsizei n, const GLuint* buffers) {
   helper_->DeleteBuffersImmediate(n, buffers);
 }
 
 
 void GLES2Implementation::DeleteFramebuffersHelper(
     GLsizei n, const GLuint* framebuffers) {
-  if (!GetIdHandler(id_namespaces::kFramebuffers)->FreeIds(
-      this, n, framebuffers, &GLES2Implementation::DeleteFramebuffersStub)) {
-    SetGLError(
-        GL_INVALID_VALUE,
-        "glDeleteFramebuffers", "id not created by this context.");
-    return;
-  }
+  helper_->DeleteFramebuffersImmediate(n, framebuffers);
+  IdAllocator* id_allocator = GetIdAllocator(IdNamespaces::kFramebuffers);
   for (GLsizei ii = 0; ii < n; ++ii) {
+    id_allocator->FreeID(framebuffers[ii]);
     if (framebuffers[ii] == bound_framebuffer_) {
       bound_framebuffer_ = 0;
     }
     if (framebuffers[ii] == bound_read_framebuffer_) {
       bound_read_framebuffer_ = 0;
     }
   }
 }
 
-void GLES2Implementation::DeleteFramebuffersStub(
-    GLsizei n, const GLuint* framebuffers) {
-  helper_->DeleteFramebuffersImmediate(n, framebuffers);
-}
-
 void GLES2Implementation::DeleteRenderbuffersHelper(
     GLsizei n, const GLuint* renderbuffers) {
-  if (!GetIdHandler(id_namespaces::kRenderbuffers)->FreeIds(
-      this, n, renderbuffers, &GLES2Implementation::DeleteRenderbuffersStub)) {
+  if (!GetIdHandler(SharedIdNamespaces::kRenderbuffers)
+           ->FreeIds(this, n, renderbuffers,
+                     &GLES2Implementation::DeleteRenderbuffersStub)) {
     SetGLError(
         GL_INVALID_VALUE,
         "glDeleteRenderbuffers", "id not created by this context.");
     return;
   }
   for (GLsizei ii = 0; ii < n; ++ii) {
     if (renderbuffers[ii] == bound_renderbuffer_) {
       bound_renderbuffer_ = 0;
     }
   }
 }
 
 void GLES2Implementation::DeleteRenderbuffersStub(
     GLsizei n, const GLuint* renderbuffers) {
   helper_->DeleteRenderbuffersImmediate(n, renderbuffers);
 }
 
 void GLES2Implementation::DeleteTexturesHelper(
     GLsizei n, const GLuint* textures) {
-  if (!GetIdHandler(id_namespaces::kTextures)->FreeIds(
-      this, n, textures, &GLES2Implementation::DeleteTexturesStub)) {
+  if (!GetIdHandler(SharedIdNamespaces::kTextures)
+           ->FreeIds(this, n, textures,
+                     &GLES2Implementation::DeleteTexturesStub)) {
     SetGLError(
         GL_INVALID_VALUE,
         "glDeleteTextures", "id not created by this context.");
     return;
   }
   for (GLsizei ii = 0; ii < n; ++ii) {
     for (GLint tt = 0; tt < capabilities_.max_combined_texture_image_units;
          ++tt) {
       TextureUnit& unit = texture_units_[tt];
       if (textures[ii] == unit.bound_texture_2d) {
@@ skipping 10 matching lines @@
 }
 
 void GLES2Implementation::DeleteTexturesStub(GLsizei n,
                                              const GLuint* textures) {
   helper_->DeleteTexturesImmediate(n, textures);
 }
 
 void GLES2Implementation::DeleteVertexArraysOESHelper(
     GLsizei n, const GLuint* arrays) {
   vertex_array_object_manager_->DeleteVertexArrays(n, arrays);
-  if (!GetIdHandler(id_namespaces::kVertexArrays)->FreeIds(
-      this, n, arrays, &GLES2Implementation::DeleteVertexArraysOESStub)) {
-    SetGLError(
-        GL_INVALID_VALUE,
-        "glDeleteVertexArraysOES", "id not created by this context.");
-    return;
-  }
-}
-
-void GLES2Implementation::DeleteVertexArraysOESStub(
-    GLsizei n, const GLuint* arrays) {
   helper_->DeleteVertexArraysOESImmediate(n, arrays);
+  IdAllocator* id_allocator = GetIdAllocator(IdNamespaces::kVertexArrays);
+  for (GLsizei ii = 0; ii < n; ++ii)
+    id_allocator->FreeID(arrays[ii]);
 }
 
 void GLES2Implementation::DeleteSamplersStub(
     GLsizei n, const GLuint* samplers) {
   helper_->DeleteSamplersImmediate(n, samplers);
 }
 
 void GLES2Implementation::DeleteSamplersHelper(
     GLsizei n, const GLuint* samplers) {
-  if (!GetIdHandler(id_namespaces::kSamplers)->FreeIds(
-      this, n, samplers, &GLES2Implementation::DeleteSamplersStub)) {
+  if (!GetIdHandler(SharedIdNamespaces::kSamplers)
+           ->FreeIds(this, n, samplers,
+                     &GLES2Implementation::DeleteSamplersStub)) {
     SetGLError(
         GL_INVALID_VALUE,
         "glDeleteSamplers", "id not created by this context.");
     return;
   }
 }
 
-void GLES2Implementation::DeleteTransformFeedbacksStub(
-    GLsizei n, const GLuint* transformfeedbacks) {
-  helper_->DeleteTransformFeedbacksImmediate(n, transformfeedbacks);
-}
-
 void GLES2Implementation::DeleteTransformFeedbacksHelper(
     GLsizei n, const GLuint* transformfeedbacks) {
-  if (!GetIdHandler(id_namespaces::kTransformFeedbacks)->FreeIds(
-      this, n, transformfeedbacks,
-      &GLES2Implementation::DeleteTransformFeedbacksStub)) {
-    SetGLError(
-        GL_INVALID_VALUE,
-        "glDeleteTransformFeedbacks", "id not created by this context.");
-    return;
-  }
+  helper_->DeleteTransformFeedbacksImmediate(n, transformfeedbacks);
+  IdAllocator* id_allocator = GetIdAllocator(IdNamespaces::kTransformFeedbacks);
+  for (GLsizei ii = 0; ii < n; ++ii)
+    id_allocator->FreeID(transformfeedbacks[ii]);
 }
 
 void GLES2Implementation::DisableVertexAttribArray(GLuint index) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG(
       "[" << GetLogPrefix() << "] glDisableVertexAttribArray(" << index << ")");
   vertex_array_object_manager_->SetAttribEnable(index, false);
   helper_->DisableVertexAttribArray(index);
   CheckGLError();
 }
@@ skipping 856 matching lines @@
   helper_->PostSubBufferCHROMIUM(x, y, width, height);
   helper_->CommandBufferHelper::Flush();
   if (swap_buffers_tokens_.size() > kMaxSwapBuffers + 1) {
     helper_->WaitForToken(swap_buffers_tokens_.front());
     swap_buffers_tokens_.pop();
   }
 }
 
 void GLES2Implementation::DeleteQueriesEXTHelper(
     GLsizei n, const GLuint* queries) {
+  IdAllocator* id_allocator = GetIdAllocator(IdNamespaces::kQueries);
   for (GLsizei ii = 0; ii < n; ++ii) {
     query_tracker_->RemoveQuery(queries[ii]);
-    query_id_allocator_->FreeID(queries[ii]);
+    id_allocator->FreeID(queries[ii]);
   }
 
   helper_->DeleteQueriesEXTImmediate(n, queries);
 }
 
 GLboolean GLES2Implementation::IsQueryEXT(GLuint id) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] IsQueryEXT(" << id << ")");
 
   // TODO(gman): To be spec compliant IDs from other contexts sharing
@@ skipping 62 matching lines @@
     SetGLError(
         GL_INVALID_OPERATION, "glBeginQueryEXT", "query already in progress");
     return;
   }
 
   if (id == 0) {
     SetGLError(GL_INVALID_OPERATION, "glBeginQueryEXT", "id is 0");
     return;
   }
 
-  if (!query_id_allocator_->InUse(id)) {
+  if (!GetIdAllocator(IdNamespaces::kQueries)->InUse(id)) {
     SetGLError(GL_INVALID_OPERATION, "glBeginQueryEXT", "invalid id");
     return;
   }
 
   // Extra setups some targets might need.
   switch (target) {
     case GL_TIME_ELAPSED_EXT:
       if (!query_tracker_->SetDisjointSync(this)) {
         SetGLError(GL_OUT_OF_MEMORY,
                    "glBeginQueryEXT",
@@ skipping 36 matching lines @@
       SetGLError(
           GL_INVALID_ENUM, "glQueryCounterEXT", "unknown query target");
       return;
   }
 
   if (id == 0) {
     SetGLError(GL_INVALID_OPERATION, "glQueryCounterEXT", "id is 0");
     return;
   }
 
-  if (!query_id_allocator_->InUse(id)) {
+  if (!GetIdAllocator(IdNamespaces::kQueries)->InUse(id)) {
     SetGLError(GL_INVALID_OPERATION, "glQueryCounterEXT", "invalid id");
     return;
   }
 
   // Extra setups some targets might need.
   switch (target) {
     case GL_TIMESTAMP_EXT:
       if (!query_tracker_->SetDisjointSync(this)) {
         SetGLError(GL_OUT_OF_MEMORY,
                    "glQueryCounterEXT",
@@ skipping 203 matching lines @@
 GLuint GLES2Implementation::CreateAndConsumeTextureCHROMIUM(
     GLenum target, const GLbyte* data) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glCreateAndConsumeTextureCHROMIUM("
                      << static_cast<const void*>(data) << ")");
   const Mailbox& mailbox = *reinterpret_cast<const Mailbox*>(data);
   DCHECK(mailbox.Verify()) << "CreateAndConsumeTextureCHROMIUM was passed a "
                               "mailbox that was not generated by "
                               "GenMailboxCHROMIUM.";
   GLuint client_id;
-  GetIdHandler(id_namespaces::kTextures)->MakeIds(this, 0, 1, &client_id);
+  GetIdHandler(SharedIdNamespaces::kTextures)->MakeIds(this, 0, 1, &client_id);
   helper_->CreateAndConsumeTextureINTERNALImmediate(target,
       client_id, data);
   if (share_group_->bind_generates_resource())
     helper_->CommandBufferHelper::Flush();
   CheckGLError();
   return client_id;
 }
 
 void GLES2Implementation::PushGroupMarkerEXT(
     GLsizei length, const GLchar* marker) {
@@ skipping 1126 matching lines @@
   CheckGLError();
 }
 
 // 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