Adds unit tests for glDrawArrays and glDrawBuffers...

gpu/command_buffer/service/gles2_cmd_decoder.cc

 // Copyright (c) 2009 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 <stdio.h>
 
 #include <vector>
 #include <string>
@@ skipping 82 matching lines @@
     sizeof(name) / sizeof(CommandBufferEntry) - 1, },  /* NOLINT */       \
 
   GLES2_COMMAND_LIST(GLES2_CMD_OP)
 
   #undef GLES2_CMD_OP
 };
 
 namespace GLErrorBit {
 enum GLErrorBit {
   kNoError = 0,
-  kInvalidEnum,
-  kInvalidValue,
-  kInvalidOperation,
-  kOutOfMemory,
-  kInvalidFrameBufferOperation,
+  kInvalidEnum = (1 << 0),
+  kInvalidValue = (1 << 1),
+  kInvalidOperation = (1 << 2),
+  kOutOfMemory = (1 << 3),
+  kInvalidFrameBufferOperation = (1 << 4),
 };
 }
 
 uint32 GLErrorToErrorBit(GLenum error) {
   switch (error) {
     case GL_INVALID_ENUM:
       return GLErrorBit::kInvalidEnum;
     case GL_INVALID_VALUE:
       return GLErrorBit::kInvalidValue;
     case GL_INVALID_OPERATION:
@@ skipping 39 matching lines @@
 GLES2Decoder::GLES2Decoder()
     : debug_(false),
       hwnd_(NULL) {
 #else
 GLES2Decoder::GLES2Decoder()
     : debug_(false) {
 #endif
 }
 
 // This class maps one set of ids to another.
-class IdMap {
+//
+// NOTE: To support shared resources an instance of this class will
+// need to be shared by multiple GLES2Decoders.
+class IdManager {
  public:
   // Maps a client_id to a service_id. Return false if the client_id or
   // service_id are already mapped to something else.
   bool AddMapping(GLuint client_id, GLuint service_id);
 
   // Unmaps a pair of ids. Returns false if the pair were not previously mapped.
   bool RemoveMapping(GLuint client_id, GLuint service_id);
 
   // Gets the corresponding service_id for the given client_id.
   // Returns false if there is no corresponding service_id.
   bool GetServiceId(GLuint client_id, GLuint* service_id);
 
   // Gets the corresponding client_id for the given service_id.
   // Returns false if there is no corresponding client_id.
   bool GetClientId(GLuint service_id, GLuint* client_id);
 
  private:
   // TODO(gman): Replace with faster implementation.
   typedef std::map<GLuint, GLuint> MapType;
   MapType id_map_;
 };
 
-bool IdMap::AddMapping(GLuint client_id, GLuint service_id) {
+bool IdManager::AddMapping(GLuint client_id, GLuint service_id) {
   std::pair<MapType::iterator, bool> result = id_map_.insert(
       std::make_pair(client_id, service_id));
   return result.second;
 }
 
-bool IdMap::RemoveMapping(GLuint client_id, GLuint service_id) {
+bool IdManager::RemoveMapping(GLuint client_id, GLuint service_id) {
   MapType::iterator iter = id_map_.find(client_id);
   if (iter != id_map_.end() && iter->second == service_id) {
     id_map_.erase(iter);
     return true;
   }
   return false;
 }
 
-bool IdMap::GetServiceId(GLuint client_id, GLuint* service_id) {
+bool IdManager::GetServiceId(GLuint client_id, GLuint* service_id) {
   DCHECK(service_id);
   MapType::iterator iter = id_map_.find(client_id);
   if (iter != id_map_.end()) {
     *service_id = iter->second;
     return true;
   }
   return false;
 }
 
-bool IdMap::GetClientId(GLuint service_id, GLuint* client_id) {
+bool IdManager::GetClientId(GLuint service_id, GLuint* client_id) {
   DCHECK(client_id);
   MapType::iterator end(id_map_.end());
   for (MapType::iterator iter(id_map_.begin());
        iter != end;
        ++iter) {
     if (iter->second == service_id) {
       *client_id = iter->first;
       return true;
     }
   }
   return false;
 }
 
+// This class keeps track of the buffers and their sizes so we can do
+// bounds checking.
+//
+// NOTE: To support shared resources an instance of this class will need to be
+// shared by multiple GLES2Decoders.
+class BufferManager {
+ public:
+  // Info about Buffers currently in the system.
+  class BufferInfo {
+   public:
+    BufferInfo()
+        : size_(0) {
+    }
+
+    explicit BufferInfo(GLsizeiptr size)
+        : size_(size) {
+    }
+
+    GLsizeiptr size() const {
+      return size_;
+    }
+
+    // Returns the maximum value in the buffer for the given range
+    // interpreted as the given type.
+    GLuint GetMaxValueForRange(GLuint offset, GLsizei count, GLenum type);
+
+   private:
+    GLsizeiptr size_;
+  };
+
+  // Removes any buffers in the VertexAtrribInfos and BufferInfos. This is used
+  // on glDeleteBuffers so we can make sure the user does not try to render
+  // with deleted buffers.
+  void RemoveBufferInfo(GLuint buffer_id);
+
+  // Gets the buffer info for the given buffer.
+  BufferInfo* GetBufferInfo(GLuint buffer);
+
+  // Sets the info for a buffer.
+  void SetBufferInfo(GLuint buffer, GLsizeiptr size);
+
+ private:
+  // Info for each buffer in the system.
+  // TODO(gman): Choose a faster container.
+  typedef std::map<GLuint, BufferInfo> BufferInfoMap;
+  BufferInfoMap buffer_infos_;
+};
+
+BufferManager::BufferInfo* BufferManager::GetBufferInfo(
+    GLuint buffer) {
+  BufferInfoMap::iterator it = buffer_infos_.find(buffer);
+  return it != buffer_infos_.end() ? &it->second : NULL;
+}
+
+void BufferManager::SetBufferInfo(GLuint buffer, GLsizeiptr size) {
+  buffer_infos_[buffer] = BufferInfo(size);
+}
+
+void BufferManager::RemoveBufferInfo(GLuint buffer_id) {
+  buffer_infos_.erase(buffer_id);
+}
+
+GLuint BufferManager::BufferInfo::GetMaxValueForRange(
+    GLuint offset, GLsizei count, GLenum type) {
+  // TODO(gman): Scan the values in the given range and cache their results.
+  return 0u;
+}
+
+// Tracks the Programs.
+//
+// NOTE: To support shared resources an instance of this class will
+// need to be shared by multiple GLES2Decoders.
+class ProgramManager {
+ public:
+  // This is used to track which attributes a particular program needs
+  // so we can verify at glDrawXXX time that every attribute is either disabled
+  // or if enabled that it points to a valid source.
+  class ProgramInfo {
+   public:
+    typedef std::vector<GLuint> AttribLocationVector;
+
+    ProgramInfo() {
+    }
+
+    void SetNumAttributes(int num_attribs) {
+      attrib_locations_.resize(num_attribs);
+    }
+
+    void SetAttributeLocation(GLuint index, int location) {
+      DCHECK(index < attrib_locations_.size());
+      attrib_locations_[index] = location;
+    }
+
+    const AttribLocationVector& GetAttribLocations() const {
+      return attrib_locations_;
+    }
+   private:
+    AttribLocationVector attrib_locations_;
+  };
+
+  ProgramInfo* GetProgramInfo(GLuint program);
+
+  // Updates the program info for the given program.
+  void UpdateProgramInfo(GLuint program);
+
+  // Deletes the program info for the given program.
+  void RemoveProgramInfo(GLuint program);
+
+ private:
+  // Info for each "successfully linked" program by service side program Id.
+  // TODO(gman): Choose a faster container.
+  typedef std::map<GLuint, ProgramInfo> ProgramInfoMap;
+  ProgramInfoMap program_infos_;
+};
+
+ProgramManager::ProgramInfo* ProgramManager::GetProgramInfo(GLuint program) {
+  ProgramInfoMap::iterator it = program_infos_.find(program);
+  return it != program_infos_.end() ? &it->second : NULL;
+}
+
+void ProgramManager::UpdateProgramInfo(GLuint program) {
+  ProgramInfo* info = GetProgramInfo(program);
+  if (!info) {
+    std::pair<ProgramInfoMap::iterator, bool> result =
+        program_infos_.insert(std::make_pair(program, ProgramInfo()));
+    DCHECK(result.second);
+    info = &result.first->second;
+  }
+  GLint num_attribs = 0;
+  GLint max_len = 0;
+  glGetProgramiv(program, GL_ACTIVE_ATTRIBUTES, &num_attribs);
+  info->SetNumAttributes(num_attribs);
+  glGetProgramiv(program, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &max_len);
+  // TODO(gman): Should we check for error?
+  scoped_array<char> name_buffer(new char[max_len + 1]);
+  for (GLint ii = 0; ii < num_attribs; ++ii) {
+    GLsizei length;
+    GLsizei size;
+    GLenum type;
+    glGetActiveAttrib(
+        program, ii, max_len + 1, &length, &size, &type, name_buffer.get());
+    // TODO(gman): Should we check for error?
+    GLint location = glGetAttribLocation(program, name_buffer.get());
+    info->SetAttributeLocation(ii, location);
+  }
+}
+
+void ProgramManager::RemoveProgramInfo(GLuint program) {
+  ProgramInfoMap::iterator it = program_infos_.find(program);
+  if (it != program_infos_.end()) {
+    program_infos_.erase(it);
+  }
+}
+
 // This class implements GLES2Decoder so we don't have to expose all the GLES2
 // cmd stuff to outside this class.
 class GLES2DecoderImpl : public GLES2Decoder {
  public:
   // Info about Vertex Attributes. This is used to track what the user currently
   // has bound on each Vertex Attribute so that checking can be done at
   // glDrawXXX time.
   class VertexAttribInfo {
    public:
     VertexAttribInfo()
@@ skipping 20 matching lines @@
     void Clear() {
       buffer_ = 0;
       SetBufferSize(0);
     }
 
     void SetBufferSize(GLsizeiptr buffer_size) {
       buffer_size_ = buffer_size;
       if (offset_ > buffer_size || real_stride_ == 0) {
         num_elements_ = 0;
       } else {
-        uint32 size = buffer_size - offset_;
-        num_elements_ = size / real_stride_ +
-            (size % real_stride_ >= GetGLTypeSize(type_) ? 1 : 0);
+        uint32 usable_size = buffer_size - offset_;
+        num_elements_ = usable_size / real_stride_ +
+            ((usable_size % real_stride_) >=
+             (GetGLTypeSize(type_) * size_) ? 1 : 0);
       }
     }
 
     void SetInfo(
         GLuint buffer,
         GLsizeiptr buffer_size,
         GLint size,
         GLenum type,
         GLsizei real_stride,
         GLsizei offset) {
@@ skipping 27 matching lines @@
     // The service side name of the buffer bound to this attribute. 0 = invalid
     GLuint buffer_;
 
     // The size of the buffer.
     GLsizeiptr buffer_size_;
 
     // The number of elements that can be accessed.
     GLuint num_elements_;
   };
 
-  // Info about Buffers currently in the system.
-  struct BufferInfo {
-    BufferInfo()
-        : size(0) {
-    }
-
-    explicit BufferInfo(GLsizeiptr _size)
-        : size(_size) {
-    }
-
-    GLsizeiptr size;
-  };
-
-  // This is used to track which attributes a particular program needs
-  // so we can verify at glDrawXXX time that every attribute is either disabled
-  // or if enabled that it points to a valid source.
-  class ProgramInfo {
-   public:
-    typedef std::vector<GLuint> AttribLocationVector;
-
-    ProgramInfo() {
-    }
-
-    void SetNumAttributes(int num_attribs) {
-      attrib_locations_.resize(num_attribs);
-    }
-
-    void SetAttributeLocation(GLuint index, int location) {
-      DCHECK(index < attrib_locations_.size());
-      attrib_locations_[index] = location;
-    }
-
-    const AttribLocationVector& GetAttribLocations() const {
-      return attrib_locations_;
-    }
-   private:
-    AttribLocationVector attrib_locations_;
-  };
-
   GLES2DecoderImpl();
 
   // Overridden from AsyncAPIInterface.
   virtual ParseError DoCommand(unsigned int command,
                                unsigned int arg_count,
                                const void* args);
 
   // Overridden from AsyncAPIInterface.
   virtual const char* GetCommandName(unsigned int command_id) const;
 
@@ skipping 46 matching lines @@
   bool RegisterObjects(
       GLsizei n, const GLuint* client_ids, const GLuint* service_ids);
 
   // Unregisters client ids with service ids.
   void UnregisterObjects(
     GLsizei n, const GLuint* client_ids, GLuint* service_ids);
 
   // Gets the program info for the given program. Returns NULL if none exists.
   // Programs that have no had glLinkProgram succesfully called on them will
   // not exist.
-  ProgramInfo* GetProgramInfo(GLuint program);
+  ProgramManager::ProgramInfo* GetProgramInfo(GLuint program) {
+    return program_manager_->GetProgramInfo(program);
+  }
 
   // Updates the program info for the given program.
-  void UpdateProgramInfo(GLuint program);
+  void UpdateProgramInfo(GLuint program) {
+    program_manager_->UpdateProgramInfo(program);
+  }
 
   // Deletes the program info for the given program.
-  void RemoveProgramInfo(GLuint program);
+  void RemoveProgramInfo(GLuint program) {
+    program_manager_->RemoveProgramInfo(program);
+  }
 
   // Gets the buffer info for the given buffer.
-  const BufferInfo* GetBufferInfo(GLuint buffer);
+  BufferManager::BufferInfo* GetBufferInfo(GLuint buffer) {
+    return buffer_manager_->GetBufferInfo(buffer);
+  }
 
   // Sets the info for a buffer.
   void SetBufferInfo(GLuint buffer, GLsizeiptr size);
 
   // Wrapper for glCreateProgram
   void CreateProgramHelper(GLuint client_id);
 
   // Wrapper for glCreateShader
   void CreateShaderHelper(GLenum type, GLuint client_id);
 
@@ skipping 48 matching lines @@
        const gles2::name& args);            \
 
   GLES2_COMMAND_LIST(GLES2_CMD_OP)
 
   #undef GLES2_CMD_OP
 
   // Current GL error bits.
   uint32 error_bits_;
 
   // Map of client ids to GL ids.
-  IdMap id_map_;
+  scoped_ptr<IdManager> id_manager_;
 
   // Util to help with GL.
   GLES2Util util_;
 
   // pack alignment as last set by glPixelStorei
   GLint pack_alignment_;
 
   // unpack alignment as last set by glPixelStorei
   GLint unpack_alignment_;
 
   // The currently bound array buffer. If this is 0 it is illegal to call
   // glVertexAttribPointer.
   GLuint bound_array_buffer_;
 
   // The currently bound element array buffer. If this is 0 it is illegal
   // to call glDrawElements.
   GLuint bound_element_array_buffer_;
 
   // The maximum vertex attributes.
   GLuint max_vertex_attribs_;
 
   // Info for each vertex attribute saved so we can check at glDrawXXX time
   // if it is safe to draw.
   scoped_array<VertexAttribInfo> vertex_attrib_infos_;
 
-  // Info for each buffer in the system.
-  // TODO(gman): Choose a faster container.
-  typedef std::map<GLuint, BufferInfo> BufferInfoMap;
-  BufferInfoMap buffer_infos_;
+  scoped_ptr<BufferManager> buffer_manager_;
 
-  // Info for each "successfully linked" program by service side program Id.
-  // TODO(gman): Choose a faster container.
-  typedef std::map<GLuint, ProgramInfo> ProgramInfoMap;
-  ProgramInfoMap program_infos_;
+  scoped_ptr<ProgramManager> program_manager_;
 
-  // The program in current use through glUseProgram.
-  ProgramInfo* current_program_info_;
+  // The program in use by glUseProgram
+  GLuint current_program_;
 
 #if defined(UNIT_TEST)
 #elif defined(OS_WIN)
   HDC device_context_;
   HGLRC gl_context_;
 #endif
 
   bool anti_aliased_;
 
   DISALLOW_COPY_AND_ASSIGN(GLES2DecoderImpl);
 };
 
 GLES2Decoder* GLES2Decoder::Create() {
   return new GLES2DecoderImpl();
 }
 
 GLES2DecoderImpl::GLES2DecoderImpl()
     : GLES2Decoder(),
       error_bits_(0),
       util_(0),  // TODO(gman): Set to actual num compress texture formats.
       pack_alignment_(4),
       unpack_alignment_(4),
       bound_array_buffer_(0),
       bound_element_array_buffer_(0),
       max_vertex_attribs_(0),
-      current_program_info_(NULL),
+      current_program_(0),
 #if defined(UNIT_TEST)
 #elif defined(OS_WIN)
       device_context_(NULL),
       gl_context_(NULL),
 #endif
       anti_aliased_(false) {
 }
 
 bool GLES2DecoderImpl::Initialize() {
+  id_manager_.reset(new IdManager());
+  buffer_manager_.reset(new BufferManager());
+  program_manager_.reset(new ProgramManager());
+
   if (!InitPlatformSpecific())
     return false;
   if (!InitGlew())
     return false;
   CHECK_GL_ERROR();
 
   // Lookup GL things we need to know.
   GLint value;
   glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &value);
   max_vertex_attribs_ = value;
@@ skipping 223 matching lines @@
 void GLDeleteTexturesHelper(
     GLES2DecoderImpl*, GLsizei n, GLuint* ids) {
   glDeleteTextures(n, ids);
 }
 
 }  // anonymous namespace
 
 uint32 GLES2DecoderImpl::GetServiceIdForTesting(uint32 client_id) {
 #if defined(UNIT_TEST)
   GLuint service_id;
-  bool result = id_map_.GetServiceId(client_id, &service_id);
+  bool result = id_manager_->GetServiceId(client_id, &service_id);
   return result ? service_id : 0u;
 #else
   DCHECK(false);
   return 0u;
 #endif
 }
 
 bool GLES2DecoderImpl::ValidateIdsAreUnused(
     GLsizei n, const GLuint* client_ids) {
   for (GLsizei ii = 0; ii < n; ++ii) {
     GLuint service_id;
-    if (id_map_.GetServiceId(client_ids[ii], &service_id)) {
+    if (id_manager_->GetServiceId(client_ids[ii], &service_id)) {
       return false;
     }
   }
   return true;
 }
 
 bool GLES2DecoderImpl::RegisterObjects(
     GLsizei n, const GLuint* client_ids, const GLuint* service_ids) {
   for (GLsizei ii = 0; ii < n; ++ii) {
-    if (!id_map_.AddMapping(client_ids[ii], service_ids[ii])) {
+    if (!id_manager_->AddMapping(client_ids[ii], service_ids[ii])) {
       NOTREACHED();
       return false;
     }
   }
   return true;
 }
 
 void GLES2DecoderImpl::UnregisterObjects(
     GLsizei n, const GLuint* client_ids, GLuint* service_ids) {
   for (GLsizei ii = 0; ii < n; ++ii) {
-    if (id_map_.GetServiceId(client_ids[ii], &service_ids[ii])) {
-      id_map_.RemoveMapping(client_ids[ii], service_ids[ii]);
+    if (id_manager_->GetServiceId(client_ids[ii], &service_ids[ii])) {
+      id_manager_->RemoveMapping(client_ids[ii], service_ids[ii]);
     } else {
       service_ids[ii] = 0;
     }
   }
 }
 
-void GLES2DecoderImpl::RemoveBufferInfo(GLuint buffer_id) {
-  for (GLuint ii = 0; ii < max_vertex_attribs_; ++ii) {
-    if (vertex_attrib_infos_[ii].buffer() == buffer_id) {
-      vertex_attrib_infos_[ii].Clear();
-    }
-  }
-  buffer_infos_.erase(buffer_id);
-}
-
 bool GLES2DecoderImpl::InitPlatformSpecific() {
 #if defined(UNIT_TEST)
 #elif defined(OS_WIN)
   device_context_ = ::GetDC(hwnd());
 
   int pixel_format;
 
   if (!GetWindowsPixelFormat(hwnd(),
                              anti_aliased_,
                              &pixel_format)) {
@@ skipping 145 matching lines @@
   } else {
     result = DoCommonCommand(command, arg_count, cmd_data);
   }
   return result;
 }
 
 void GLES2DecoderImpl::CreateProgramHelper(GLuint client_id) {
   // TODO(gman): verify client_id is unused.
   GLuint service_id = glCreateProgram();
   if (service_id) {
-    id_map_.AddMapping(client_id, service_id);
+    id_manager_->AddMapping(client_id, service_id);
   }
 }
 
 void GLES2DecoderImpl::CreateShaderHelper(GLenum type, GLuint client_id) {
   // TODO(gman): verify client_id is unused.
   GLuint service_id = glCreateShader(type);
   if (service_id) {
-    id_map_.AddMapping(client_id, service_id);
+    id_manager_->AddMapping(client_id, service_id);
   }
 }
 
 void GLES2DecoderImpl::DoBindBuffer(GLenum target, GLuint buffer) {
   switch (target) {
     case GL_ARRAY_BUFFER:
       bound_array_buffer_ = buffer;
       break;
     case GL_ELEMENT_ARRAY_BUFFER:
       bound_element_array_buffer_ = buffer;
@@ skipping 20 matching lines @@
     glEnableVertexAttribArray(index);
   } else {
     SetGLError(GL_INVALID_VALUE);
   }
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleDeleteShader(
     uint32 immediate_data_size, const gles2::DeleteShader& c) {
   GLuint shader = c.shader;
   GLuint service_id;
-  if (!id_map_.GetServiceId(shader, &service_id)) {
+  if (!id_manager_->GetServiceId(shader, &service_id)) {
     SetGLError(GL_INVALID_VALUE);
     return parse_error::kParseNoError;
   }
   glDeleteShader(service_id);
-  id_map_.RemoveMapping(shader, service_id);
+  id_manager_->RemoveMapping(shader, service_id);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleDeleteProgram(
     uint32 immediate_data_size, const gles2::DeleteProgram& c) {
   GLuint program = c.program;
   GLuint service_id;
-  if (!id_map_.GetServiceId(program, &service_id)) {
+  if (!id_manager_->GetServiceId(program, &service_id)) {
     SetGLError(GL_INVALID_VALUE);
     return parse_error::kParseNoError;
   }
-  RemoveProgramInfo(program);
+  RemoveProgramInfo(service_id);
   glDeleteProgram(service_id);
-  id_map_.RemoveMapping(program, service_id);
+  id_manager_->RemoveMapping(program, service_id);
   return parse_error::kParseNoError;
 }
 
 void GLES2DecoderImpl::DoDrawArrays(
     GLenum mode, GLint first, GLsizei count) {
   if (IsDrawValid(first + count - 1)) {
     glDrawArrays(mode, first, count);
   }
 }
 
@@ skipping 15 matching lines @@
 #if defined(UNIT_TEST)
 #elif defined(OS_WIN)
   ::SwapBuffers(device_context_);
 #elif defined(OS_LINUX)
   DCHECK(window());
   window()->SwapBuffers();
 #endif
 }
 
 void GLES2DecoderImpl::DoUseProgram(GLuint program) {
-  ProgramInfo* info = GetProgramInfo(program);
+  ProgramManager::ProgramInfo* info = GetProgramInfo(program);
   if (!info) {
     // Program was not linked successfully. (ie, glLinkProgram)
     SetGLError(GL_INVALID_OPERATION);
   } else {
-    current_program_info_ = info;
+    current_program_ = program;
     glUseProgram(program);
   }
 }
 
 GLenum GLES2DecoderImpl::GetGLError() {
   // Check the GL error first, then our wrapped error.
   GLenum error = glGetError();
   if (error == GL_NO_ERROR && error_bits_ != 0) {
     for (uint32 mask = 1; mask != 0; mask = mask << 1) {
       if ((error_bits_ & mask) != 0) {
@@ skipping 14 matching lines @@
   error_bits_ |= GLErrorToErrorBit(error);
 }
 
 void GLES2DecoderImpl::CopyRealGLErrorsToWrapper() {
   GLenum error;
   while ((error = glGetError()) != GL_NO_ERROR) {
     SetGLError(error);
   }
 }
 
-const GLES2DecoderImpl::BufferInfo* GLES2DecoderImpl::GetBufferInfo(
-    GLuint buffer) {
-  BufferInfoMap::iterator it = buffer_infos_.find(buffer);
-  return it != buffer_infos_.end() ? &it->second : NULL;
-}
-
 void GLES2DecoderImpl::SetBufferInfo(GLuint buffer, GLsizeiptr size) {
-  buffer_infos_[buffer] = BufferInfo(size);
+  buffer_manager_->SetBufferInfo(buffer, size);
 
   // Also go through VertexAttribInfo and update any info that references
   // the same buffer.
+  // TODO(gman): This code needs to change for shared resources.
   for (GLuint ii = 0; ii < max_vertex_attribs_; ++ii) {
     if (vertex_attrib_infos_[ii].buffer() == buffer) {
       vertex_attrib_infos_[ii].SetBufferSize(size);
     }
   }
 }
 
-GLES2DecoderImpl::ProgramInfo* GLES2DecoderImpl::GetProgramInfo(
-    GLuint program) {
-  ProgramInfoMap::iterator it = program_infos_.find(program);
-  return it != program_infos_.end() ? &it->second : NULL;
-}
-
-void GLES2DecoderImpl::UpdateProgramInfo(GLuint program) {
-  ProgramInfo* info = GetProgramInfo(program);
-  if (!info) {
-    std::pair<ProgramInfoMap::iterator, bool> result =
-        program_infos_.insert(std::make_pair(program, ProgramInfo()));
-    DCHECK(result.second);
-    info = &result.first->second;
+void GLES2DecoderImpl::RemoveBufferInfo(GLuint buffer_id) {
+  // TODO(gman): This code needs to change for shared resources.
+  for (GLuint ii = 0; ii < max_vertex_attribs_; ++ii) {
+    if (vertex_attrib_infos_[ii].buffer() == buffer_id) {
+      vertex_attrib_infos_[ii].Clear();
+    }
   }
-  GLint num_attribs = 0;
-  GLint max_len = 0;
-  glGetProgramiv(program, GL_ACTIVE_ATTRIBUTES, &num_attribs);
-  info->SetNumAttributes(num_attribs);
-  glGetProgramiv(program, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &max_len);
-  // TODO(gman): Should we check for error?
-  scoped_array<char> name_buffer(new char[max_len + 1]);
-  for (GLint ii = 0; ii < num_attribs; ++ii) {
-    GLsizei length;
-    GLsizei size;
-    GLenum type;
-    glGetActiveAttrib(
-        program, ii, max_len + 1, &length, &size, &type, name_buffer.get());
-    // TODO(gman): Should we check for error?
-    GLint location = glGetAttribLocation(program, name_buffer.get());
-    info->SetAttributeLocation(ii, location);
-  }
-}
-
-void GLES2DecoderImpl::RemoveProgramInfo(GLuint program) {
-  ProgramInfoMap::iterator it = program_infos_.find(program);
-  if (it != program_infos_.end()) {
-    if (current_program_info_ == &it->second) {
-      current_program_info_ = NULL;
-    }
-    program_infos_.erase(it);
-  }
+  buffer_manager_->RemoveBufferInfo(buffer_id);
 }
 
 bool GLES2DecoderImpl::VertexAttribInfo::CanAccess(GLuint index) {
   return !enabled_ || (buffer_ != 0 && index < num_elements_);
 }
 
 bool GLES2DecoderImpl::IsDrawValid(GLuint max_vertex_accessed) {
-  if (current_program_info_) {
+  if (current_program_) {
+    ProgramManager::ProgramInfo* info = GetProgramInfo(current_program_);
+    if (!info) {
+      // The program does not exist.
+      SetGLError(GL_INVALID_OPERATION);
+      return false;
+    }
     // Validate that all attribs current program needs are setup correctly.
-    const ProgramInfo::AttribLocationVector& locations =
-        current_program_info_->GetAttribLocations();
+    const ProgramManager::ProgramInfo::AttribLocationVector& locations =
+        info->GetAttribLocations();
     for (size_t ii = 0; ii < locations.size(); ++ii) {
       GLuint location = locations[ii];
       DCHECK_LT(location, max_vertex_attribs_);
       if (!vertex_attrib_infos_[location].CanAccess(max_vertex_accessed)) {
         SetGLError(GL_INVALID_OPERATION);
+        return false;
       }
     }
     return true;
   }
   // We do not set a GL error here because the GL spec says no error if the
   // program is invalid.
   return false;
 };
 
 parse_error::ParseError GLES2DecoderImpl::HandleDrawElements(
     uint32 immediate_data_size, const gles2::DrawElements& c) {
   if (bound_element_array_buffer_ != 0) {
     GLenum mode = c.mode;
     GLsizei count = c.count;
     GLenum type = c.type;
+    int32 offset = c.index_offset;
     if (!ValidateGLenumDrawMode(mode) ||
         !ValidateGLenumIndexType(type)) {
-      SetGLError(GL_INVALID_VALUE);
+      SetGLError(GL_INVALID_ENUM);
     } else {
-      const GLvoid* indices = reinterpret_cast<const GLvoid*>(c.index_offset);
-      // TODO(gman): Validate indices. Get maximum index.
-      //
-      // This value should be computed by walking the index buffer from 0 to
-      // count and finding the maximum vertex accessed.
-      // For now we'll special case 0 to not check.
-      GLuint max_vertex_accessed = 0;
-      if (IsDrawValid(max_vertex_accessed)) {
-        glDrawElements(mode, count, type, indices);
+      // TODO(gman): We could cache this lookup in glBindBuffer.
+      BufferManager::BufferInfo* info =
+          GetBufferInfo(bound_element_array_buffer_);
+      if (!info) {
+        SetGLError(GL_INVALID_OPERATION);
+      } else {
+        GLsizeiptr buffer_size = info->size();
+        if (offset > buffer_size) {
+          SetGLError(GL_INVALID_OPERATION);
+        } else {
+          GLsizei usable_size = buffer_size - offset;
+          GLsizei num_elements = usable_size / GetGLTypeSize(type);
+          if (count > num_elements) {
+            SetGLError(GL_INVALID_OPERATION);
+          } else {
+            const GLvoid* indices = reinterpret_cast<const GLvoid*>(offset);
+            // TODO(gman): Validate indices. Get maximum index.
+            //
+            // This value should be computed by walking the index buffer from 0
+            // to count and finding the maximum vertex accessed. For now we'll
+            // pass 0 so it should always pass.
+            GLuint max_vertex_accessed = info->GetMaxValueForRange(
+                offset, count, type);
+            if (IsDrawValid(max_vertex_accessed)) {
+              glDrawElements(mode, count, type, indices);
+            }
+          }
+        }
       }
     }
   } else {
     SetGLError(GL_INVALID_VALUE);
   }
   return parse_error::kParseNoError;
 }
 
 namespace {
 
@@ skipping 22 matching lines @@
 
   glShaderSource(shader, count, string_pointers.get(), NULL);
   return parse_error::kParseNoError;
 }
 
 }  // anonymous namespace.
 
 parse_error::ParseError GLES2DecoderImpl::HandleShaderSource(
     uint32 immediate_data_size, const gles2::ShaderSource& c) {
   GLuint shader;
-  if (!id_map_.GetServiceId(c.shader, &shader)) {
+  if (!id_manager_->GetServiceId(c.shader, &shader)) {
     SetGLError(GL_INVALID_VALUE);
     return parse_error::kParseNoError;
   }
   GLsizei count = c.count;
   uint32 data_size = c.data_size;
   const char** data = GetSharedMemoryAs<const char**>(
       c.data_shm_id, c.data_shm_offset, data_size);
   if (!data) {
     return parse_error::kParseOutOfBounds;
   }
   return ShaderSourceHelper(
       shader, count, reinterpret_cast<const char*>(data), data_size);
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleShaderSourceImmediate(
   uint32 immediate_data_size, const gles2::ShaderSourceImmediate& c) {
   GLuint shader;
-  if (!id_map_.GetServiceId(c.shader, &shader)) {
+  if (!id_manager_->GetServiceId(c.shader, &shader)) {
     SetGLError(GL_INVALID_VALUE);
     return parse_error::kParseNoError;
   }
   GLsizei count = c.count;
   uint32 data_size = c.data_size;
   const char** data = GetImmediateDataAs<const char**>(
       c, data_size, immediate_data_size);
   if (!data) {
     return parse_error::kParseOutOfBounds;
   }
@@ skipping 11 matching lines @@
     GLsizei stride = c.stride;
     GLsizei offset = c.offset;
     const void* ptr = reinterpret_cast<const void*>(offset);
     if (!ValidateGLenumVertexAttribType(type) ||
         !ValidateGLintVertexAttribSize(size) ||
         indx >= max_vertex_attribs_ ||
         stride < 0) {
       SetGLError(GL_INVALID_VALUE);
       return parse_error::kParseNoError;
     }
-    const BufferInfo* buffer_info = GetBufferInfo(bound_array_buffer_);
+    const BufferManager::BufferInfo* buffer_info =
+        GetBufferInfo(bound_array_buffer_);
     GLsizei component_size = GetGLTypeSize(type);
     GLsizei real_stride = stride != 0 ? stride : component_size * size;
     if (offset % component_size > 0) {
       SetGLError(GL_INVALID_VALUE);
       return parse_error::kParseNoError;
     }
     vertex_attrib_infos_[indx].SetInfo(
         bound_array_buffer_,
-        buffer_info ? buffer_info->size : 0,
+        buffer_info ? buffer_info->size() : 0,
         size,
         type,
         real_stride,
         offset);
     glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
   } else {
     SetGLError(GL_INVALID_VALUE);
   }
   return parse_error::kParseNoError;
 }
@@ skipping 43 matching lines @@
       // Validation should have prevented us from getting here.
       DCHECK(false);
       break;
   }
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleGetAttribLocation(
     uint32 immediate_data_size, const gles2::GetAttribLocation& c) {
   GLuint program;
-  if (!id_map_.GetServiceId(c.program, &program)) {
+  if (!id_manager_->GetServiceId(c.program, &program)) {
     SetGLError(GL_INVALID_VALUE);
     return parse_error::kParseNoError;
   }
   uint32 name_size = c.data_size;
   const char* name = GetSharedMemoryAs<const char*>(
       c.name_shm_id, c.name_shm_offset, name_size);
   GLint* location = GetSharedMemoryAs<GLint*>(
       c.location_shm_id, c.location_shm_offset, sizeof(GLint));
   if (!location || !name) {
     return parse_error::kParseOutOfBounds;
   }
   String name_str(name, name_size);
   *location = glGetAttribLocation(program, name_str.c_str());
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleGetAttribLocationImmediate(
     uint32 immediate_data_size, const gles2::GetAttribLocationImmediate& c) {
   GLuint program;
-  if (!id_map_.GetServiceId(c.program, &program)) {
+  if (!id_manager_->GetServiceId(c.program, &program)) {
     SetGLError(GL_INVALID_VALUE);
     return parse_error::kParseNoError;
   }
   uint32 name_size = c.data_size;
   const char* name = GetImmediateDataAs<const char*>(
       c, name_size, immediate_data_size);
   GLint* location = GetSharedMemoryAs<GLint*>(
       c.location_shm_id, c.location_shm_offset, sizeof(GLint));
   if (!location || !name) {
     return parse_error::kParseOutOfBounds;
   }
   String name_str(name, name_size);
   *location = glGetAttribLocation(program, name_str.c_str());
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleGetUniformLocation(
     uint32 immediate_data_size, const gles2::GetUniformLocation& c) {
   GLuint program;
-  if (!id_map_.GetServiceId(c.program, &program)) {
+  if (!id_manager_->GetServiceId(c.program, &program)) {
     SetGLError(GL_INVALID_VALUE);
     return parse_error::kParseNoError;
   }
   uint32 name_size = c.data_size;
   const char* name = GetSharedMemoryAs<const char*>(
       c.name_shm_id, c.name_shm_offset, name_size);
   GLint* location = GetSharedMemoryAs<GLint*>(
       c.location_shm_id, c.location_shm_offset, sizeof(GLint));
   if (!location || !name) {
     return parse_error::kParseOutOfBounds;
   }
   String name_str(name, name_size);
   *location = glGetUniformLocation(program, name_str.c_str());
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleGetUniformLocationImmediate(
     uint32 immediate_data_size, const gles2::GetUniformLocationImmediate& c) {
   GLuint program;
-  if (!id_map_.GetServiceId(c.program, &program)) {
+  if (!id_manager_->GetServiceId(c.program, &program)) {
     SetGLError(GL_INVALID_VALUE);
     return parse_error::kParseNoError;
   }
   uint32 name_size = c.data_size;
   const char* name = GetImmediateDataAs<const char*>(
       c, name_size, immediate_data_size);
   GLint* location = GetSharedMemoryAs<GLint*>(
       c.location_shm_id, c.location_shm_offset, sizeof(GLint));
   if (!location || !name) {
     return parse_error::kParseOutOfBounds;
@@ skipping 238 matching lines @@
   return parse_error::kParseNoError;
 }
 
 // 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/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu