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 1332 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, WebGLVertexArrayObjectBase::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