Update WebGLVertexArrayObjectOES to WebGLVertexArrayObject for WebGL2

Source/core/html/canvas/WebGL2RenderingContextBase.cpp

 // Copyright 2015 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 "config.h"
 #include "core/html/canvas/WebGL2RenderingContextBase.h"
 
 #include "bindings/core/v8/WebGLAny.h"
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/HTMLImageElement.h"
 #include "core/html/HTMLVideoElement.h"
 #include "core/html/ImageData.h"
 #include "core/html/canvas/WebGLActiveInfo.h"
 #include "core/html/canvas/WebGLBuffer.h"
 #include "core/html/canvas/WebGLFenceSync.h"
 #include "core/html/canvas/WebGLFramebuffer.h"
 #include "core/html/canvas/WebGLProgram.h"
 #include "core/html/canvas/WebGLQuery.h"
 #include "core/html/canvas/WebGLSampler.h"
 #include "core/html/canvas/WebGLSync.h"
 #include "core/html/canvas/WebGLTexture.h"
 #include "core/html/canvas/WebGLTransformFeedback.h"
 #include "core/html/canvas/WebGLUniformLocation.h"
-#include "core/html/canvas/WebGLVertexArrayObjectOES.h"
+#include "core/html/canvas/WebGLVertexArrayObject.h"
 
 #include "platform/NotImplemented.h"
 
 namespace blink {
 
 namespace {
 
 const GLuint webGLTimeoutIgnored = 0xFFFFFFFF;
 
 WGC3Dsync syncObjectOrZero(const WebGLSync* object)
@@ skipping 20 matching lines @@
 {
     ASSERT(!isContextLost());
 
     m_readFramebufferBinding = nullptr;
 
     m_max3DTextureSize = 0;
     webContext()->getIntegerv(GL_MAX_3D_TEXTURE_SIZE, &m_max3DTextureSize);
     m_max3DTextureLevel = WebGLTexture::computeLevelCount(m_max3DTextureSize, m_max3DTextureSize, m_max3DTextureSize);
 
     WebGLRenderingContextBase::initializeNewContext();
+
+    // Release WebGLVertexArrayObjectOES which is initialized at WebGLRenderingContextBase.

[bajones, 2015/05/26 16:45:50]

Rather than allocate/release/allocate again could you move this allocation above
WebGLRenderingContextBase::initializeNewContext() and in that function check for
if (!m_defaultVertexArrayObject) before allocating? It's a minor change but it
feels cleaner.

[legend, 2015/05/27 02:05:46]

Done. Since m_defaultVertexArrayObject constructor depends on
m_maxVertexAttribs, the initialization of m_maxVertexAttrib needs to added
before.

+    // Then change to use WebGLVertexArrayObject for WebGL2RenderingContextBase only.
+    removeContextObject(m_defaultVertexArrayObject.get());
+    m_defaultVertexArrayObject = nullptr;
+    m_boundVertexArrayObject = nullptr;
+    m_defaultVertexArrayObject = WebGLVertexArrayObject::create(this, WebGLVertexArrayObjectImpl::VaoTypeDefault);
+    addContextObject(m_defaultVertexArrayObject.get());
+    m_boundVertexArrayObject = m_defaultVertexArrayObject;
 }
 
 void WebGL2RenderingContextBase::copyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
 {
     if (isContextLost())
         return;
 
     webContext()->copyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
 }
 
@@ skipping 1292 matching lines @@
 }
 
 void WebGL2RenderingContextBase::uniformBlockBinding(WebGLProgram* program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
 {
     if (isContextLost() || !validateWebGLObject("uniformBlockBinding", program))
         return;
 
     webContext()->uniformBlockBinding(objectOrZero(program), uniformBlockIndex, uniformBlockBinding);
 }
 
-PassRefPtrWillBeRawPtr<WebGLVertexArrayObjectOES> WebGL2RenderingContextBase::createVertexArray()
+PassRefPtrWillBeRawPtr<WebGLVertexArrayObject> WebGL2RenderingContextBase::createVertexArray()
 {
     if (isContextLost())
         return nullptr;
 
-    RefPtrWillBeRawPtr<WebGLVertexArrayObjectOES> o = WebGLVertexArrayObjectOES::create(this, WebGLVertexArrayObjectOES::VaoTypeUser);
+    RefPtrWillBeRawPtr<WebGLVertexArrayObject> o = WebGLVertexArrayObject::create(this, WebGLVertexArrayObjectImpl::VaoTypeUser);
     addContextObject(o.get());
     return o.release();
 }
 
-void WebGL2RenderingContextBase::deleteVertexArray(WebGLVertexArrayObjectOES* vertexArray)
+void WebGL2RenderingContextBase::deleteVertexArray(WebGLVertexArrayObject* vertexArray)
 {
     if (isContextLost() || !vertexArray)
         return;
 
     if (!vertexArray->isDefaultObject() && vertexArray == m_boundVertexArrayObject)
         setBoundVertexArrayObject(nullptr);
 
     vertexArray->deleteObject(webContext());
 }
 
-GLboolean WebGL2RenderingContextBase::isVertexArray(WebGLVertexArrayObjectOES* vertexArray)
+GLboolean WebGL2RenderingContextBase::isVertexArray(WebGLVertexArrayObject* vertexArray)
 {
     if (isContextLost() || !vertexArray)
         return 0;
 
     if (!vertexArray->hasEverBeenBound())
         return 0;
 
     return webContext()->isVertexArrayOES(vertexArray->object());
 }
 
-void WebGL2RenderingContextBase::bindVertexArray(WebGLVertexArrayObjectOES* vertexArray)
+void WebGL2RenderingContextBase::bindVertexArray(WebGLVertexArrayObject* vertexArray)
 {
     if (isContextLost())
         return;
 
     if (vertexArray && (vertexArray->isDeleted() || !vertexArray->validate(0, this))) {
         webContext()->synthesizeGLError(GL_INVALID_OPERATION);
         return;
     }
 
     if (vertexArray && !vertexArray->isDefaultObject() && vertexArray->object()) {
@@ skipping 412 matching lines @@
             GLfloat value = 0.f;
             webContext()->getTexParameterfv(target, pname, &value);
             return WebGLAny(scriptState, value);
         }
     default:
         return WebGLRenderingContextBase::getTexParameter(scriptState, target, pname);
     }
 }
 
 } // namespace blink