Implement TransformFeedbackManager in GPU command buffer.

gpu/command_buffer/service/gles2_cmd_decoder.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/gles2_cmd_decoder.h"
 
 #include <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
@@ skipping 38 matching lines @@
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
 #include "gpu/command_buffer/service/path_manager.h"
 #include "gpu/command_buffer/service/program_manager.h"
 #include "gpu/command_buffer/service/query_manager.h"
 #include "gpu/command_buffer/service/renderbuffer_manager.h"
 #include "gpu/command_buffer/service/sampler_manager.h"
 #include "gpu/command_buffer/service/shader_manager.h"
 #include "gpu/command_buffer/service/shader_translator.h"
 #include "gpu/command_buffer/service/texture_manager.h"
+#include "gpu/command_buffer/service/transform_feedback_manager.h"
 #include "gpu/command_buffer/service/vertex_array_manager.h"
 #include "gpu/command_buffer/service/vertex_attrib_manager.h"
 #include "third_party/smhasher/src/City.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/overlay_transform.h"
 #include "ui/gfx/transform.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
@@ skipping 554 matching lines @@
     state_.RestoreTextureUnitBindings(unit, NULL);
   }
   void RestoreFramebufferBindings() const override;
   void RestoreRenderbufferBindings() override;
   void RestoreTextureState(unsigned service_id) const override;
 
   void ClearAllAttributes() const override;
   void RestoreAllAttributes() const override;
 
   QueryManager* GetQueryManager() override { return query_manager_.get(); }
+  TransformFeedbackManager* GetTransformFeedbackManager() override {
+    return transform_feedback_manager_.get();
+  }
   VertexArrayManager* GetVertexArrayManager() override {
     return vertex_array_manager_.get();
   }
   ImageManager* GetImageManager() override { return image_manager_.get(); }
 
   bool HasPendingQueries() const override;
   void ProcessPendingQueries(bool did_finish) override;
 
   bool HasMoreIdleWork() const override;
   void PerformIdleWork() override;
@@ skipping 102 matching lines @@
   bool GenRenderbuffersHelper(GLsizei n, const GLuint* client_ids);
   void DeleteRenderbuffersHelper(GLsizei n, const GLuint* client_ids);
   bool GenQueriesEXTHelper(GLsizei n, const GLuint* client_ids);
   void DeleteQueriesEXTHelper(GLsizei n, const GLuint* client_ids);
   bool GenVertexArraysOESHelper(GLsizei n, const GLuint* client_ids);
   void DeleteVertexArraysOESHelper(GLsizei n, const GLuint* client_ids);
   bool GenPathsCHROMIUMHelper(GLuint first_client_id, GLsizei range);
   bool DeletePathsCHROMIUMHelper(GLuint first_client_id, GLsizei range);
   bool GenSamplersHelper(GLsizei n, const GLuint* client_ids);
   void DeleteSamplersHelper(GLsizei n, const GLuint* client_ids);
+  bool GenTransformFeedbacksHelper(GLsizei n, const GLuint* client_ids);
+  void DeleteTransformFeedbacksHelper(GLsizei n, const GLuint* client_ids);
 
   // Workarounds
   void OnFboChanged() const;
   void OnUseFramebuffer() const;
 
   error::ContextLostReason GetContextLostReasonFromResetStatus(
       GLenum reset_status) const;
 
   // TODO(gman): Cache these pointers?
   BufferManager* buffer_manager() {
@@ skipping 83 matching lines @@
   // Gets the sampler info for the given sampler. Returns NULL if none exists.
   Sampler* GetSampler(GLuint client_id) {
     return sampler_manager()->GetSampler(client_id);
   }
 
   // Deletes the sampler info for the given sampler.
   void RemoveSampler(GLuint client_id) {
     sampler_manager()->RemoveSampler(client_id);
   }
 
+  // Creates a TransformFeedback for the given transformfeedback.
+  TransformFeedback* CreateTransformFeedback(
+      GLuint client_id, GLuint service_id) {
+    return transform_feedback_manager_->CreateTransformFeedback(
+        client_id, service_id);
+  }
+
+  // Gets the TransformFeedback info for the given transformfeedback.
+  // Returns nullptr if none exists.
+  TransformFeedback* GetTransformFeedback(GLuint client_id) {
+    return transform_feedback_manager_->GetTransformFeedback(client_id);
+  }
+
+  // Deletes the TransformFeedback info for the given transformfeedback.
+  void RemoveTransformFeedback(GLuint client_id) {
+    transform_feedback_manager_->RemoveTransformFeedback(client_id);
+  }
+
   // Get the size (in pixels) of the currently bound frame buffer (either FBO
   // or regular back buffer).
   gfx::Size GetBoundReadFrameBufferSize();
 
   // Get the format/type of the currently bound frame buffer (either FBO or
   // regular back buffer).
   // If the color image is a renderbuffer, returns 0 for type.
   GLenum GetBoundReadFrameBufferTextureType();
   GLenum GetBoundReadFrameBufferInternalFormat();
 
@@ skipping 500 matching lines @@
 
   // Wrapper for glBindRenderbuffer since we need to track the current targets.
   void DoBindRenderbuffer(GLenum target, GLuint renderbuffer);
 
   // Wrapper for glBindTexture since we need to track the current targets.
   void DoBindTexture(GLenum target, GLuint texture);
 
   // Wrapper for glBindSampler since we need to track the current targets.
   void DoBindSampler(GLuint unit, GLuint sampler);
 
+  // Wrapper for glBindTransformFeedback since we need to emulate ES3 behaviors
+  // for BindBufferRange on Desktop GL lower than 4.2.
+  void DoBindTransformFeedback(GLenum target, GLuint transform_feedback);
+
+  // Wrapper for glBeginTransformFeedback.
+  void DoBeginTransformFeedback(GLenum primitive_mode);
+
+  // Wrapper for glEndTransformFeedback.
+  void DoEndTransformFeedback();
+
+  // Wrapper for glPauseTransformFeedback.
+  void DoPauseTransformFeedback();
+
+  // Wrapper for glResumeTransformFeedback.
+  void DoResumeTransformFeedback();
+
   // Wrapper for glBindVertexArrayOES
   void DoBindVertexArrayOES(GLuint array);
   void EmulateVertexArrayState();
 
   // Wrapper for glBlitFramebufferCHROMIUM.
   void DoBlitFramebufferCHROMIUM(
       GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
       GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
       GLbitfield mask, GLenum filter);
 
@@ skipping 155 matching lines @@
 
   // Wrappers for glIsXXX functions.
   bool DoIsEnabled(GLenum cap);
   bool DoIsBuffer(GLuint client_id);
   bool DoIsFramebuffer(GLuint client_id);
   bool DoIsProgram(GLuint client_id);
   bool DoIsRenderbuffer(GLuint client_id);
   bool DoIsShader(GLuint client_id);
   bool DoIsTexture(GLuint client_id);
   bool DoIsSampler(GLuint client_id);
+  bool DoIsTransformFeedback(GLuint client_id);
   bool DoIsVertexArrayOES(GLuint client_id);
   bool DoIsPathCHROMIUM(GLuint client_id);
 
   void DoLineWidth(GLfloat width);
 
   // Wrapper for glLinkProgram
   void DoLinkProgram(GLuint program);
 
   // Wrapper for glReadBuffer
   void DoReadBuffer(GLenum src);
@@ skipping 384 matching lines @@
 
   // The ContextGroup for this decoder uses to track resources.
   scoped_refptr<ContextGroup> group_;
 
   DebugMarkerManager debug_marker_manager_;
   Logger logger_;
 
   // All the state for this context.
   ContextState state_;
 
+  std::unique_ptr<TransformFeedbackManager> transform_feedback_manager_;
+
   // Current width and height of the offscreen frame buffer.
   gfx::Size offscreen_size_;
 
   // Util to help with GL.
   GLES2Util util_;
 
   // The buffer we bind to attrib 0 since OpenGL requires it (ES does not).
   GLuint attrib_0_buffer_id_;
 
   // The value currently in attrib_0.
@@ skipping 775 matching lines @@
     return false;
   }
 
   if (!group_->Initialize(this, attrib_parser.context_type,
                           disallowed_features)) {
     group_ = NULL;  // Must not destroy ContextGroup if it is not initialized.
     Destroy(true);
     return false;
   }
   CHECK_GL_ERROR();
+
+  bool needs_emulation = feature_info_->gl_version_info().IsLowerThanGL(4, 2);
+  transform_feedback_manager_.reset(new TransformFeedbackManager(
+      group_->max_transform_feedback_separate_attribs(), needs_emulation));
+
   if (feature_info_->context_type() == CONTEXT_TYPE_WEBGL2 ||
       feature_info_->context_type() == CONTEXT_TYPE_OPENGLES3) {
     if (!feature_info_->IsES3Capable()) {
       LOG(ERROR) << "Underlying driver does not support ES3.";
       Destroy(true);
       return false;
     }
     feature_info_->EnableES3Validators();
     set_unsafe_es3_apis_enabled(true);
 
     frag_depth_explicitly_enabled_ = true;
     draw_buffers_explicitly_enabled_ = true;
     // TODO(zmo): Look into shader_texture_lod_explicitly_enabled_ situation.
+
+    // Create a fake default transform feedback and bind to it.
+    GLuint default_transform_feedback = 0;
+    glGenTransformFeedbacks(1, &default_transform_feedback);
+    state_.default_transform_feedback =
+        transform_feedback_manager_->CreateTransformFeedback(
+            0, default_transform_feedback);
+    glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, default_transform_feedback);
+    state_.bound_transform_feedback = state_.default_transform_feedback.get();
   }
 
   state_.attrib_values.resize(group_->max_vertex_attribs());
   vertex_array_manager_.reset(new VertexArrayManager());
 
   GLuint default_vertex_attrib_service_id = 0;
   if (features().native_vertex_array_object) {
     glGenVertexArraysOES(1, &default_vertex_attrib_service_id);
     glBindVertexArrayOES(default_vertex_attrib_service_id);
   }
@@ skipping 723 matching lines @@
     }
   }
   std::unique_ptr<GLuint[]> service_ids(new GLuint[n]);
   glGenSamplers(n, service_ids.get());
   for (GLsizei ii = 0; ii < n; ++ii) {
     CreateSampler(client_ids[ii], service_ids[ii]);
   }
   return true;
 }
 
+bool GLES2DecoderImpl::GenTransformFeedbacksHelper(
+    GLsizei n, const GLuint* client_ids) {
+  for (GLsizei ii = 0; ii < n; ++ii) {
+    if (GetTransformFeedback(client_ids[ii])) {
+      return false;
+    }
+  }
+  std::unique_ptr<GLuint[]> service_ids(new GLuint[n]);
+  glGenTransformFeedbacks(n, service_ids.get());
+  for (GLsizei ii = 0; ii < n; ++ii) {
+    CreateTransformFeedback(client_ids[ii], service_ids[ii]);
+  }
+  return true;
+}
+
 bool GLES2DecoderImpl::GenPathsCHROMIUMHelper(GLuint first_client_id,
                                               GLsizei range) {
   GLuint last_client_id;
   if (!SafeAddUint32(first_client_id, range - 1, &last_client_id))
     return false;
 
   if (path_manager()->HasPathsInRange(first_client_id, last_client_id))
     return false;
 
   GLuint first_service_id = glGenPathsNV(range);
@@ skipping 23 matching lines @@
   return true;
 }
 
 void GLES2DecoderImpl::DeleteBuffersHelper(
     GLsizei n, const GLuint* client_ids) {
   for (GLsizei ii = 0; ii < n; ++ii) {
     Buffer* buffer = GetBuffer(client_ids[ii]);
     if (buffer && !buffer->IsDeleted()) {
       buffer->RemoveMappedRange();
       state_.RemoveBoundBuffer(buffer);
+      transform_feedback_manager_->RemoveBoundBuffer(buffer);
       RemoveBuffer(client_ids[ii]);
     }
   }
 }
 
 void GLES2DecoderImpl::DeleteFramebuffersHelper(
     GLsizei n, const GLuint* client_ids) {
   bool supports_separate_framebuffer_binds =
      features().chromium_framebuffer_multisample;
 
@@ skipping 105 matching lines @@
     Sampler* sampler = GetSampler(client_ids[ii]);
     if (sampler && !sampler->IsDeleted()) {
       // Unbind from current sampler units.
       state_.UnbindSampler(sampler);
 
       RemoveSampler(client_ids[ii]);
     }
   }
 }
 
-// }  // anonymous namespace
+void GLES2DecoderImpl::DeleteTransformFeedbacksHelper(
+    GLsizei n, const GLuint* client_ids) {
+  for (GLsizei ii = 0; ii < n; ++ii) {
+    TransformFeedback* transform_feedback = GetTransformFeedback(
+        client_ids[ii]);
+    if (transform_feedback) {
+      if (state_.bound_transform_feedback.get() == transform_feedback) {
+        // Bind to the default transform feedback.
+        DCHECK(state_.default_transform_feedback.get());
+        state_.default_transform_feedback->DoBindTransformFeedback(
+            GL_TRANSFORM_FEEDBACK);
+        state_.bound_transform_feedback =
+            state_.default_transform_feedback.get();
+      }
+      RemoveTransformFeedback(client_ids[ii]);
+    }
+  }
+}
 
 bool GLES2DecoderImpl::MakeCurrent() {
   if (!context_.get())
     return false;
 
   if (WasContextLost()) {
     LOG(ERROR) << "  GLES2DecoderImpl: Trying to make lost context current.";
     return false;
   }
 
@@ skipping 381 matching lines @@
 }
 
 void GLES2DecoderImpl::AddProcessingCommandsTime(base::TimeDelta time) {
   total_processing_commands_time_ += time;
 }
 
 void GLES2DecoderImpl::Destroy(bool have_context) {
   if (!initialized())
     return;
 
-  DCHECK(!have_context || context_->IsCurrent(NULL));
+  DCHECK(!have_context || context_->IsCurrent(nullptr));
 
   // Unbind everything.
-  state_.vertex_attrib_manager = NULL;
-  state_.default_vertex_attrib_manager = NULL;
+  state_.vertex_attrib_manager = nullptr;
+  state_.default_vertex_attrib_manager = nullptr;
   state_.texture_units.clear();
   state_.sampler_units.clear();
-  state_.bound_array_buffer = NULL;
-  state_.bound_copy_read_buffer = NULL;
-  state_.bound_copy_write_buffer = NULL;
-  state_.bound_pixel_pack_buffer = NULL;
-  state_.bound_pixel_unpack_buffer = NULL;
-  state_.bound_transform_feedback_buffer = NULL;
-  state_.bound_uniform_buffer = NULL;
-  framebuffer_state_.bound_read_framebuffer = NULL;
-  framebuffer_state_.bound_draw_framebuffer = NULL;
-  state_.bound_renderbuffer = NULL;
+  state_.bound_array_buffer = nullptr;
+  state_.bound_copy_read_buffer = nullptr;
+  state_.bound_copy_write_buffer = nullptr;
+  state_.bound_pixel_pack_buffer = nullptr;
+  state_.bound_pixel_unpack_buffer = nullptr;
+  state_.bound_transform_feedback_buffer = nullptr;
+  state_.bound_uniform_buffer = nullptr;
+  framebuffer_state_.bound_read_framebuffer = nullptr;
+  framebuffer_state_.bound_draw_framebuffer = nullptr;
+  state_.bound_renderbuffer = nullptr;
+  state_.bound_transform_feedback = nullptr;
+  state_.default_transform_feedback = nullptr;
 
   if (offscreen_saved_color_texture_info_.get()) {
     DCHECK(offscreen_target_color_texture_);
     DCHECK_EQ(offscreen_saved_color_texture_info_->service_id(),
               offscreen_saved_color_texture_->id());
     offscreen_saved_color_texture_->Invalidate();
     offscreen_saved_color_texture_info_ = NULL;
   }
   ReleaseAllBackTextures();
   if (have_context) {
@@ skipping 74 matching lines @@
   if (query_manager_.get()) {
     query_manager_->Destroy(have_context);
     query_manager_.reset();
   }
 
   if (vertex_array_manager_ .get()) {
     vertex_array_manager_->Destroy(have_context);
     vertex_array_manager_.reset();
   }
 
+  if (transform_feedback_manager_.get()) {
+    if (!have_context) {
+      transform_feedback_manager_->MarkContextLost();
+    }
+    transform_feedback_manager_->Destroy();
+    transform_feedback_manager_.reset();
+  }
+
   if (image_manager_.get()) {
     image_manager_->Destroy(have_context);
     image_manager_.reset();
   }
 
   offscreen_target_frame_buffer_.reset();
   offscreen_target_color_texture_.reset();
   offscreen_target_color_render_buffer_.reset();
   offscreen_target_depth_render_buffer_.reset();
   offscreen_target_stencil_render_buffer_.reset();
@@ skipping 508 matching lines @@
     GLenum target, GLuint index, GLuint client_id,
     GLintptr offset, GLsizeiptr size,
     BindIndexedBufferFunctionType function_type, const char* function_name) {
   switch (target) {
     case GL_TRANSFORM_FEEDBACK_BUFFER: {
       if (index >= group_->max_transform_feedback_separate_attribs()) {
         LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, function_name,
                            "index out of range");
         return;
       }
-      // TODO(zmo): Check transform feedback isn't currently active.
+      DCHECK(state_.bound_transform_feedback.get());
+      if (state_.bound_transform_feedback->active()) {
+        LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
+                           "bound transform feedback is active");
+        return;
+      }
       break;
     }
     case GL_UNIFORM_BUFFER: {
       if (index >= group_->max_uniform_buffer_bindings()) {
         LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, function_name,
                            "index out of range");
         return;
       }
       break;
     }
@@ skipping 50 matching lines @@
       // It's a new id so make a buffer for it.
       glGenBuffersARB(1, &service_id);
       CreateBuffer(client_id, service_id);
       buffer = GetBuffer(client_id);
       DCHECK(buffer);
     }
     service_id = buffer->service_id();
   }
   LogClientServiceForInfo(buffer, client_id, function_name);
 
-  switch (function_type) {
-    case kBindBufferBase:
-      glBindBufferBase(target, index, service_id);
+  switch (target) {
+    case GL_TRANSFORM_FEEDBACK_BUFFER:
+      DCHECK(state_.bound_transform_feedback.get());
+      switch (function_type) {
+        case kBindBufferBase:
+          state_.bound_transform_feedback->DoBindBufferBase(
+              target, index, buffer);
+          break;
+        case kBindBufferRange:
+          state_.bound_transform_feedback->DoBindBufferRange(
+              target, index, buffer, offset, size);
+          break;
+      }
       break;
-    case kBindBufferRange:
-      // TODO(zmo): On Desktop GL 4.1 or lower, clamp the offset/size not to
-      // exceed the size of the buffer. crbug.com/604436.
-      glBindBufferRange(target, index, service_id, offset, size);
+    case GL_UNIFORM_BUFFER:
+      // TODO(zmo): emulate Desktop GL 4.1 or lower behavior and keep track of
+      // indexed buffer bindings.
+      switch (function_type) {
+        case kBindBufferBase:
+          glBindBufferBase(target, index, service_id);
+          break;
+        case kBindBufferRange:
+          glBindBufferRange(target, index, service_id, offset, size);
+          break;
+      }
+      break;
+    default:
+      NOTREACHED();
       break;
   }
-  // TODO(kbr): track indexed bound buffers.
 }
 
 void GLES2DecoderImpl::DoBindBufferBase(GLenum target, GLuint index,
                                         GLuint client_id) {
   BindIndexedBufferImpl(target, index, client_id, 0, 0,
                         kBindBufferBase, "glBindBufferBase");
 }
 
 void GLES2DecoderImpl::DoBindBufferRange(GLenum target, GLuint index,
                                          GLuint client_id,
@@ skipping 305 matching lines @@
   if (sampler) {
     LogClientServiceForInfo(sampler, client_id, "glBindSampler");
     glBindSampler(unit, sampler->service_id());
   } else {
     glBindSampler(unit, 0);
   }
 
   state_.sampler_units[unit] = sampler;
 }
 
+void GLES2DecoderImpl::DoBindTransformFeedback(
+    GLenum target, GLuint client_id) {
+  const char* function_name = "glBindTransformFeedback";
+  if (!validators_->transform_feedback_bind_target.IsValid(target)) {
+    LOCAL_SET_GL_ERROR_INVALID_ENUM(function_name, target, "target");
+    return;
+  }
+
+  TransformFeedback* transform_feedback = nullptr;
+  if (client_id != 0) {
+    transform_feedback = GetTransformFeedback(client_id);
+    if (!transform_feedback) {
+      LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
+                         "id not generated by glGenTransformFeedbacks");
+      return;
+    }
+  } else {
+    transform_feedback = state_.default_transform_feedback.get();
+  }
+  DCHECK(transform_feedback);
+  if (transform_feedback == state_.bound_transform_feedback.get())
+    return;
+  if (state_.bound_transform_feedback->active() &&
+      !state_.bound_transform_feedback->paused()) {
+    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
+                       "currently bound transform feedback is active");
+    return;
+  }
+  LogClientServiceForInfo(transform_feedback, client_id, function_name);
+  transform_feedback->DoBindTransformFeedback(target);
+  state_.bound_transform_feedback = transform_feedback;
+}
+
+void GLES2DecoderImpl::DoBeginTransformFeedback(GLenum primitive_mode) {
+  const char* function_name = "glBeginTransformFeedback";
+  DCHECK(state_.bound_transform_feedback.get());
+  if (!validators_->transform_feedback_primitive_mode.IsValid(primitive_mode)) {
+    LOCAL_SET_GL_ERROR_INVALID_ENUM(
+        function_name, primitive_mode, "primitiveMode");
+    return;
+  }
+  if (state_.bound_transform_feedback->active()) {
+    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
+                       "transform feedback is already active");
+    return;
+  }
+  state_.bound_transform_feedback->DoBeginTransformFeedback(primitive_mode);
+}
+
+void GLES2DecoderImpl::DoEndTransformFeedback() {
+  const char* function_name = "glEndTransformFeedback";
+  DCHECK(state_.bound_transform_feedback.get());
+  if (!state_.bound_transform_feedback->active()) {
+    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
+                       "transform feedback is not active");
+    return;
+  }
+  // TODO(zmo): Validate binding points.
+  state_.bound_transform_feedback->DoEndTransformFeedback();
+}
+
+void GLES2DecoderImpl::DoPauseTransformFeedback() {
+  DCHECK(state_.bound_transform_feedback.get());
+  if (!state_.bound_transform_feedback->active() ||
+      state_.bound_transform_feedback->paused()) {
+    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glPauseTransformFeedback",
+                       "transform feedback is not active or already paused");
+    return;
+  }
+  state_.bound_transform_feedback->DoPauseTransformFeedback();
+}
+
+void GLES2DecoderImpl::DoResumeTransformFeedback() {
+  DCHECK(state_.bound_transform_feedback.get());
+  if (!state_.bound_transform_feedback->active() ||
+      !state_.bound_transform_feedback->paused()) {
+    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glResumeTransformFeedback",
+                       "transform feedback is not active or not paused");
+    return;
+  }
+  state_.bound_transform_feedback->DoResumeTransformFeedback();
+}
+
 void GLES2DecoderImpl::DoDisableVertexAttribArray(GLuint index) {
   if (state_.vertex_attrib_manager->Enable(index, false)) {
     if (index != 0 || feature_info_->gl_version_info().BehavesLikeGLES()) {
       glDisableVertexAttribArray(index);
     }
   } else {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE,
         "glDisableVertexAttribArray", "index out of range");
   }
@@ skipping 3683 matching lines @@
 bool GLES2DecoderImpl::DoIsTexture(GLuint client_id) {
   const TextureRef* texture_ref = GetTexture(client_id);
   return texture_ref && texture_ref->texture()->IsValid();
 }
 
 bool GLES2DecoderImpl::DoIsSampler(GLuint client_id) {
   const Sampler* sampler = GetSampler(client_id);
   return sampler && !sampler->IsDeleted();
 }
 
+bool GLES2DecoderImpl::DoIsTransformFeedback(GLuint client_id) {
+  const TransformFeedback* transform_feedback =
+      GetTransformFeedback(client_id);
+  return transform_feedback && transform_feedback->has_been_bound();
+}
+
 void GLES2DecoderImpl::DoAttachShader(
     GLuint program_client_id, GLint shader_client_id) {
   Program* program = GetProgramInfoNotShader(
       program_client_id, "glAttachShader");
   if (!program) {
     return;
   }
   Shader* shader = GetShaderInfoNotProgram(shader_client_id, "glAttachShader");
   if (!shader) {
     return;
@@ skipping 4410 matching lines @@
 
 void GLES2DecoderImpl::MarkContextLost(error::ContextLostReason reason) {
   // Only lose the context once.
   if (WasContextLost())
     return;
 
   // Don't make GL calls in here, the context might not be current.
   context_lost_reason_ = reason;
   current_decoder_error_ = error::kLostContext;
   context_was_lost_ = true;
+
+  if (transform_feedback_manager_.get()) {
+    transform_feedback_manager_->MarkContextLost();
+  }
 }
 
 bool GLES2DecoderImpl::CheckResetStatus() {
   DCHECK(!WasContextLost());
   DCHECK(context_->IsCurrent(NULL));
 
   if (IsRobustnessSupported()) {
     // If the reason for the call was a GL error, we can try to determine the
     // reset status more accurately.
     GLenum driver_status = glGetGraphicsResetStatusARB();
@@ skipping 3227 matching lines @@
 }
 
 // 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 "base/macros.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu