Fixed expando-loss.html test.

third_party/WebKit/Source/modules/webgl/WebGLRenderingContextBase.cpp

 /*
  * Copyright (C) 2009 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 848 matching lines @@
     { GL_RGBA32UI, GL_RGBA_INTEGER, GL_UNSIGNED_INT },
     { GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT },
     { GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT },
     { GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT },
     { GL_DEPTH_COMPONENT32F, GL_DEPTH_COMPONENT, GL_FLOAT },
     { GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8 },
 };
 
 } // namespace anonymous
 
-WebGLRenderingContextBase::WebGLRenderingContextBase(HTMLCanvasElement* passedCanvas, PassOwnPtr<WebGraphicsContext3D> context, const WebGLContextAttributes& requestedAttributes)
+WebGLRenderingContextBase::WebGLRenderingContextBase(HTMLCanvasElement* passedCanvas, ScriptState* scriptState, PassOwnPtr<WebGraphicsContext3D> context, const WebGLContextAttributes& requestedAttributes)
     : CanvasRenderingContext(passedCanvas)
+    , m_scriptState(scriptState)
     , m_contextLostMode(NotLostContext)
     , m_autoRecoveryMethod(Manual)
     , m_dispatchContextLostEventTimer(this, &WebGLRenderingContextBase::dispatchContextLostEvent)
     , m_restoreAllowed(false)
     , m_restoreTimer(this, &WebGLRenderingContextBase::maybeRestoreContext)
     , m_generatedImageCache(4)
     , m_requestedAttributes(requestedAttributes)
     , m_synthesizedErrorsToConsole(true)
     , m_numGLErrorsToConsoleAllowed(maxGLErrorsAllowedToConsole)
     , m_multisamplingAllowed(false)
@@ skipping 105 matching lines @@
     m_backDrawBuffer = GL_BACK;
 
     m_readBufferOfDefaultFramebuffer = GL_BACK;
 
     if (isWebGL2OrHigher()) {
         m_defaultVertexArrayObject = WebGLVertexArrayObject::create(this, WebGLVertexArrayObjectBase::VaoTypeDefault);
     } else {
         m_defaultVertexArrayObject = WebGLVertexArrayObjectOES::create(this, WebGLVertexArrayObjectBase::VaoTypeDefault);
     }
     addContextObject(m_defaultVertexArrayObject.get());
+    // The default VAO is never exposed to JavaScript, but a wrapper is needed in order to link
+    // buffer objects' wrappers to it. The wrapper for the context itself might not have been
+    // created by this point.
+    toV8(this, m_scriptState->context()->Global(), m_scriptState->isolate());
+    toV8(m_defaultVertexArrayObject, m_scriptState->context()->Global(), m_scriptState->isolate());

[haraken, 2015/10/13 02:02:04]

Just for the record: We don't need to enter the ScriptState before calling these
toV8()s because we're already in a correct ScriptState when the
WebGLRenderingContextBase's constructor gets called (from JavaScript).

[Ken Russell (switch to Gerrit), 2015/10/13 06:11:44]

Actually, this code is called from a timer after the context is lost, so this
code as written is incorrect. It would have to enter m_scriptState.

+    preserveObjectWrapper(m_scriptState.get(), this, "defaultvao", 0, m_defaultVertexArrayObject);
     m_boundVertexArrayObject = m_defaultVertexArrayObject;
 
     m_vertexAttribValue.resize(m_maxVertexAttribs);
 
     createFallbackBlackTextures1x1();
 
     webContext()->viewport(0, 0, drawingBufferWidth(), drawingBufferHeight());
     webContext()->scissor(0, 0, drawingBufferWidth(), drawingBufferHeight());
 
     m_contextLostCallbackAdapter = WebGLRenderingContextLostCallback::create(this);
@@ skipping 351 matching lines @@
         synthesizeGLError(GL_INVALID_ENUM, "activeTexture", "texture unit out of range");
         return;
     }
     m_activeTextureUnit = texture - GL_TEXTURE0;
     webContext()->activeTexture(texture);
 
     drawingBuffer()->setActiveTextureUnit(texture);
 
 }
 
-void WebGLRenderingContextBase::attachShader(WebGLProgram* program, WebGLShader* shader)
+void WebGLRenderingContextBase::attachShader(ScriptState* scriptState, WebGLProgram* program, WebGLShader* shader)
 {
     if (isContextLost() || !validateWebGLObject("attachShader", program) || !validateWebGLObject("attachShader", shader))
         return;
     if (!program->attachShader(shader)) {
         synthesizeGLError(GL_INVALID_OPERATION, "attachShader", "shader attachment already has shader");
         return;
     }
     webContext()->attachShader(objectOrZero(program), objectOrZero(shader));
     shader->onAttached();
+    preserveObjectWrapper(scriptState, program, "shader", shader->type(), shader);
 }
 
 void WebGLRenderingContextBase::bindAttribLocation(WebGLProgram* program, GLuint index, const String& name)
 {
     if (isContextLost() || !validateWebGLObject("bindAttribLocation", program))
         return;
     if (!validateLocationLength("bindAttribLocation", name))
         return;
     if (!validateString("bindAttribLocation", name))
         return;
@@ skipping 43 matching lines @@
     default:
         ASSERT_NOT_REACHED();
         return false;
     }
 
     if (buffer && !buffer->getInitialTarget())
         buffer->setInitialTarget(target);
     return true;
 }
 
-void WebGLRenderingContextBase::bindBuffer(GLenum target, WebGLBuffer* buffer)
+void WebGLRenderingContextBase::bindBuffer(ScriptState* scriptState, GLenum target, WebGLBuffer* buffer)
 {
     bool deleted;
     if (!checkObjectToBeBound("bindBuffer", buffer, deleted))
         return;
     if (deleted)
         buffer = 0;
     if (!validateAndUpdateBufferBindTarget("bindBuffer", target, buffer))
         return;
 
     webContext()->bindBuffer(target, objectOrZero(buffer));
+    preserveObjectWrapper(scriptState, this, "buffer", target, buffer);
 }
 
-void WebGLRenderingContextBase::bindFramebuffer(GLenum target, WebGLFramebuffer* buffer)
+void WebGLRenderingContextBase::bindFramebuffer(ScriptState* scriptState, GLenum target, WebGLFramebuffer* buffer)
 {
     bool deleted;
     if (!checkObjectToBeBound("bindFramebuffer", buffer, deleted))
         return;
 
     if (deleted)
         buffer = 0;
 
     if (target != GL_FRAMEBUFFER) {
         synthesizeGLError(GL_INVALID_ENUM, "bindFramebuffer", "invalid target");
         return;
     }
 
     setFramebuffer(target, buffer);
+    if (scriptState)

[haraken, 2015/10/13 02:02:04]

It would be great if we could remove the null check. By replacing the 'nullptr'
with 'm_scriptState', I guess we can guarantee that scriptState is never null
here.

[Ken Russell (switch to Gerrit), 2015/10/13 06:11:44]

There's no need to do this work if we're calling this function internally. The
only time it's necessary to update the references between these wrappers is if
the user has called bindFramebuffer from JavaScript.

+        preserveObjectWrapper(scriptState, this, "framebuffer", 0, buffer);
 }
 
-void WebGLRenderingContextBase::bindRenderbuffer(GLenum target, WebGLRenderbuffer* renderBuffer)
+void WebGLRenderingContextBase::bindRenderbuffer(ScriptState* scriptState, GLenum target, WebGLRenderbuffer* renderBuffer)
 {
     bool deleted;
     if (!checkObjectToBeBound("bindRenderbuffer", renderBuffer, deleted))
         return;
     if (deleted)
         renderBuffer = 0;
     if (target != GL_RENDERBUFFER) {
         synthesizeGLError(GL_INVALID_ENUM, "bindRenderbuffer", "invalid target");
         return;
     }
     m_renderbufferBinding = renderBuffer;
     webContext()->bindRenderbuffer(target, objectOrZero(renderBuffer));
+    preserveObjectWrapper(scriptState, this, "renderbuffer", 0, renderBuffer);
     if (renderBuffer)
         renderBuffer->setHasEverBeenBound();
 }
 
-void WebGLRenderingContextBase::bindTexture(GLenum target, WebGLTexture* texture)
+void WebGLRenderingContextBase::bindTexture(ScriptState* scriptState, GLenum target, WebGLTexture* texture)
 {
     bool deleted;
     if (!checkObjectToBeBound("bindTexture", texture, deleted))
         return;
     if (deleted)
         texture = 0;
     if (texture && texture->getTarget() && texture->getTarget() != target) {
         synthesizeGLError(GL_INVALID_OPERATION, "bindTexture", "textures can not be used with multiple targets");
         return;
     }
+
+    const char* bindingPointName = nullptr;
     if (target == GL_TEXTURE_2D) {
         m_textureUnits[m_activeTextureUnit].m_texture2DBinding = texture;
 
         if (!m_activeTextureUnit)
             drawingBuffer()->setTexture2DBinding(objectOrZero(texture));
+        bindingPointName = "texture_2d";
     } else if (target == GL_TEXTURE_CUBE_MAP) {
         m_textureUnits[m_activeTextureUnit].m_textureCubeMapBinding = texture;
+        bindingPointName = "texture_cube_map";
     } else if (isWebGL2OrHigher() && target == GL_TEXTURE_2D_ARRAY) {
         m_textureUnits[m_activeTextureUnit].m_texture2DArrayBinding = texture;
+        bindingPointName = "texture_2d_array";
     } else if (isWebGL2OrHigher() && target == GL_TEXTURE_3D) {
         m_textureUnits[m_activeTextureUnit].m_texture3DBinding = texture;
+        bindingPointName = "texture_3d";
     } else {
         synthesizeGLError(GL_INVALID_ENUM, "bindTexture", "invalid target");
         return;
     }
 
     webContext()->bindTexture(target, objectOrZero(texture));
+    // This is called both internally and externally (from JavaScript). We only update which wrapper
+    // is preserved when it's called from JavaScript.
+    if (scriptState) {

[haraken, 2015/10/13 02:02:04]

Ditto.

[Ken Russell (switch to Gerrit), 2015/10/13 06:11:44]

Same answer.

+        preserveObjectWrapper(scriptState, this, bindingPointName, m_activeTextureUnit, texture);
+    }
     if (texture) {
         texture->setTarget(target, getMaxTextureLevelForTarget(target));
         m_onePlusMaxNonDefaultTextureUnit = max(m_activeTextureUnit + 1, m_onePlusMaxNonDefaultTextureUnit);
     } else {
         // If the disabled index is the current maximum, trace backwards to find the new max enabled texture index
         if (m_onePlusMaxNonDefaultTextureUnit == m_activeTextureUnit + 1) {
             findNewMaxNonDefaultTextureUnit();
         }
     }
 
@@ skipping 413 matching lines @@
     if (isContextLost())
         return nullptr;
     if (!renderbuffer->emulatedStencilBuffer()) {
         renderbuffer->setEmulatedStencilBuffer(createRenderbuffer());
         webContext()->bindRenderbuffer(target, objectOrZero(renderbuffer->emulatedStencilBuffer()));
         webContext()->bindRenderbuffer(target, objectOrZero(m_renderbufferBinding.get()));
     }
     return renderbuffer->emulatedStencilBuffer();
 }
 
+void WebGLRenderingContextBase::setBoundVertexArrayObject(ScriptState* scriptState, WebGLVertexArrayObjectBase* arrayObject)
+{
+    if (arrayObject)
+        m_boundVertexArrayObject = arrayObject;
+    else
+        m_boundVertexArrayObject = m_defaultVertexArrayObject;
+
+    preserveObjectWrapper(scriptState, this, "boundvao", 0, arrayObject);
+}
+
 WebGLShader* WebGLRenderingContextBase::createShader(GLenum type)
 {
     if (isContextLost())
         return nullptr;
     if (type != GL_VERTEX_SHADER && type != GL_FRAGMENT_SHADER) {
         synthesizeGLError(GL_INVALID_ENUM, "createShader", "invalid shader type");
         return nullptr;
     }
 
     WebGLShader* o = WebGLShader::create(this, type);
@@ skipping 136 matching lines @@
 {
     if (isContextLost())
         return;
     if (zNear > zFar) {
         synthesizeGLError(GL_INVALID_OPERATION, "depthRange", "zNear > zFar");
         return;
     }
     webContext()->depthRange(zNear, zFar);
 }
 
-void WebGLRenderingContextBase::detachShader(WebGLProgram* program, WebGLShader* shader)
+void WebGLRenderingContextBase::detachShader(ScriptState* scriptState, WebGLProgram* program, WebGLShader* shader)
 {
     if (isContextLost() || !validateWebGLObject("detachShader", program) || !validateWebGLObject("detachShader", shader))
         return;
     if (!program->detachShader(shader)) {
         synthesizeGLError(GL_INVALID_OPERATION, "detachShader", "shader not attached");
         return;
     }
     webContext()->detachShader(objectOrZero(program), objectOrZero(shader));
     shader->onDetached(webContext());
+    preserveObjectWrapper(scriptState, program, "shader", shader->type(), nullptr);
 }
 
 void WebGLRenderingContextBase::disable(GLenum cap)
 {
     if (isContextLost() || !validateCapability("disable", cap))
         return;
     if (cap == GL_STENCIL_TEST) {
         m_stencilEnabled = false;
         applyStencilTest();
         return;
@@ skipping 139 matching lines @@
     webContext()->flush(); // Intentionally a flush, not a finish.
 }
 
 void WebGLRenderingContextBase::flush()
 {
     if (isContextLost())
         return;
     webContext()->flush();
 }
 
-void WebGLRenderingContextBase::framebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, WebGLRenderbuffer* buffer)
+void WebGLRenderingContextBase::framebufferRenderbuffer(ScriptState* scriptState, GLenum target, GLenum attachment, GLenum renderbuffertarget, WebGLRenderbuffer* buffer)
 {
     if (isContextLost() || !validateFramebufferFuncParameters("framebufferRenderbuffer", target, attachment))
         return;
     if (renderbuffertarget != GL_RENDERBUFFER) {
         synthesizeGLError(GL_INVALID_ENUM, "framebufferRenderbuffer", "invalid target");
         return;
     }
     if (buffer && !buffer->validate(contextGroup(), this)) {
         synthesizeGLError(GL_INVALID_OPERATION, "framebufferRenderbuffer", "no buffer or buffer not from this context");
         return;
@@ skipping 27 matching lines @@
     }
     if (isWebGL2OrHigher() && attachment == GL_DEPTH_STENCIL_ATTACHMENT) {
         // On ES3, DEPTH_STENCIL_ATTACHMENT is like an alias for DEPTH_ATTACHMENT + STENCIL_ATTACHMENT.
         // We divide it here so in WebGLFramebuffer, we don't have to handle DEPTH_STENCIL_ATTACHMENT in WebGL 2.
         framebufferBinding->setAttachmentForBoundFramebuffer(target, GL_DEPTH_ATTACHMENT, buffer);
         framebufferBinding->setAttachmentForBoundFramebuffer(target, GL_STENCIL_ATTACHMENT, buffer);
     } else {
         framebufferBinding->setAttachmentForBoundFramebuffer(target, attachment, buffer);
     }
     applyStencilTest();
+    preserveObjectWrapper(scriptState, framebufferBinding, "renderbuffer", attachment, buffer);
 }
 
-void WebGLRenderingContextBase::framebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, WebGLTexture* texture, GLint level)
+void WebGLRenderingContextBase::framebufferTexture2D(ScriptState* scriptState, GLenum target, GLenum attachment, GLenum textarget, WebGLTexture* texture, GLint level)
 {
     if (isContextLost() || !validateFramebufferFuncParameters("framebufferTexture2D", target, attachment))
         return;
     if (isWebGL2OrHigher()) {
         if (!validateTexFuncLevel("framebufferTexture2D", textarget, level))
             return;
     } else if (level) {
         synthesizeGLError(GL_INVALID_VALUE, "framebufferTexture2D", "level not 0");
         return;
     }
@@ skipping 19 matching lines @@
         webContext()->framebufferTexture2D(target, attachment, textarget, textureObject, level);
         break;
     case GL_STENCIL_ATTACHMENT:
         webContext()->framebufferTexture2D(target, attachment, textarget, textureObject, level);
         break;
     default:
         webContext()->framebufferTexture2D(target, attachment, textarget, textureObject, level);
     }
     framebufferBinding->setAttachmentForBoundFramebuffer(target, attachment, textarget, texture, level);
     applyStencilTest();
+    preserveObjectWrapper(scriptState, framebufferBinding, "texture2d", attachment, texture);
 }
 
 void WebGLRenderingContextBase::frontFace(GLenum mode)
 {
     if (isContextLost())
         return;
     switch (mode) {
     case GL_CW:
     case GL_CCW:
         break;
@@ skipping 184 matching lines @@
     if (tracker->draft() && !RuntimeEnabledFeatures::webGLDraftExtensionsEnabled())
         return false;
     if (!tracker->supported(this))
         return false;
     return true;
 }
 
 ScriptValue WebGLRenderingContextBase::getExtension(ScriptState* scriptState, const String& name)
 {
     WebGLExtension* extension = nullptr;
+    bool linkContextToExtension = false;
 
     if (!isContextLost()) {
         for (size_t i = 0; i < m_extensions.size(); ++i) {
             ExtensionTracker* tracker = m_extensions[i];
             if (tracker->matchesNameWithPrefixes(name)) {
                 if (extensionSupportedAndAllowed(tracker)) {
                     extension = tracker->getExtension(this);
-                    if (extension)
-                        m_extensionEnabled[extension->name()] = true;
+                    if (extension) {
+                        if (!m_extensionEnabled[extension->name()]) {
+                            linkContextToExtension = true;
+                            m_extensionEnabled[extension->name()] = true;
+                        }
+                    }
                 }
                 break;
             }
         }
     }
 
-    return ScriptValue(scriptState, toV8(extension, scriptState->context()->Global(), scriptState->isolate()));
+    v8::Local<v8::Value> wrappedExtension = toV8(extension, scriptState->context()->Global(), scriptState->isolate());

[haraken, 2015/10/13 02:02:04]

toV8 does ScriptState-dependent operations, so we must enter a correct
ScriptState before calling toV8. I guess we need the following code:

if (!scriptState->contextIsValid())
  return ScriptValue();

ScriptState::Scope scope(scriptState);
...; // You can call toV8 here.

[Ken Russell (switch to Gerrit), 2015/10/13 06:11:44]

This function is always called from JavaScript, so the incoming ScriptState is
always valid.

+
+    if (linkContextToExtension) {
+        // Keep the extension's JavaScript wrapper alive as long as the context is alive, so that
+        // expando properties that are added to the extension persist.
+        preserveObjectWrapper(scriptState, this, "extension", static_cast<unsigned long>(extension->name()), extension);
+    }
+
+    return ScriptValue(scriptState, wrappedExtension);
 }
 
 ScriptValue WebGLRenderingContextBase::getFramebufferAttachmentParameter(ScriptState* scriptState, GLenum target, GLenum attachment, GLenum pname)
 {
     if (isContextLost() || !validateFramebufferFuncParameters("getFramebufferAttachmentParameter", target, attachment))
         return ScriptValue::createNull(scriptState);
 
     if (!m_framebufferBinding || !m_framebufferBinding->object()) {
         synthesizeGLError(GL_INVALID_OPERATION, "getFramebufferAttachmentParameter", "no framebuffer bound");
         return ScriptValue::createNull(scriptState);
@@ skipping 2257 matching lines @@
     webContext()->uniformMatrix4fv(location->location(), v->length() >> 4, transpose, v->data());
 }
 
 void WebGLRenderingContextBase::uniformMatrix4fv(const WebGLUniformLocation* location, GLboolean transpose, Vector<GLfloat>& v)
 {
     if (isContextLost() || !validateUniformMatrixParameters("uniformMatrix4fv", location, transpose, v.data(), v.size(), 16))
         return;
     webContext()->uniformMatrix4fv(location->location(), v.size() >> 4, transpose, v.data());
 }
 
-void WebGLRenderingContextBase::useProgram(WebGLProgram* program)
+void WebGLRenderingContextBase::useProgram(ScriptState* scriptState, WebGLProgram* program)
 {
     bool deleted;
     if (!checkObjectToBeBound("useProgram", program, deleted))
         return;
     if (deleted)
         program = 0;
     if (program && !program->linkStatus()) {
         synthesizeGLError(GL_INVALID_OPERATION, "useProgram", "program not valid");
         return;
     }
     if (m_currentProgram != program) {
         if (m_currentProgram)
             m_currentProgram->onDetached(webContext());
         m_currentProgram = program;
         webContext()->useProgram(objectOrZero(program));
         if (program)
             program->onAttached();
+        preserveObjectWrapper(scriptState, this, "program", 0, program);
     }
 }
 
 void WebGLRenderingContextBase::validateProgram(WebGLProgram* program)
 {
     if (isContextLost() || !validateWebGLObject("validateProgram", program))
         return;
     webContext()->validateProgram(objectOrZero(program));
 }
 
@@ skipping 50 matching lines @@
 void WebGLRenderingContextBase::vertexAttrib4fv(GLuint index, const DOMFloat32Array* v)
 {
     vertexAttribfvImpl("vertexAttrib4fv", index, v, 4);
 }
 
 void WebGLRenderingContextBase::vertexAttrib4fv(GLuint index, const Vector<GLfloat>& v)
 {
     vertexAttribfvImpl("vertexAttrib4fv", index, v.data(), v.size(), 4);
 }
 
-void WebGLRenderingContextBase::vertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, long long offset)
+void WebGLRenderingContextBase::vertexAttribPointer(ScriptState* scriptState, GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, long long offset)
 {
     if (isContextLost())
         return;
     switch (type) {
     case GL_BYTE:
     case GL_UNSIGNED_BYTE:
     case GL_SHORT:
     case GL_UNSIGNED_SHORT:
     case GL_FLOAT:
         break;
@@ skipping 18 matching lines @@
     unsigned typeSize = sizeInBytes(type);
     ASSERT((typeSize & (typeSize - 1)) == 0); // Ensure that the value is POT.
     if ((stride & (typeSize - 1)) || (static_cast<GLintptr>(offset) & (typeSize - 1))) {
         synthesizeGLError(GL_INVALID_OPERATION, "vertexAttribPointer", "stride or offset not valid for type");
         return;
     }
     GLsizei bytesPerElement = size * typeSize;
 
     m_boundVertexArrayObject->setVertexAttribState(index, bytesPerElement, size, type, normalized, stride, static_cast<GLintptr>(offset), m_boundArrayBuffer);
     webContext()->vertexAttribPointer(index, size, type, normalized, stride, static_cast<GLintptr>(offset));
+    preserveObjectWrapper(scriptState, m_boundVertexArrayObject, "arraybuffer", index, m_boundArrayBuffer);
 }
 
 void WebGLRenderingContextBase::vertexAttribDivisorANGLE(GLuint index, GLuint divisor)
 {
     if (isContextLost())
         return;
 
     if (index >= m_maxVertexAttribs) {
         synthesizeGLError(GL_INVALID_VALUE, "vertexAttribDivisorANGLE", "index out of range");
         return;
@@ skipping 1642 matching lines @@
     if (!buffer) {
         // Instead of binding fb 0, bind the drawing buffer.
         drawingBuffer()->bind(target);
     } else {
         webContext()->bindFramebuffer(target, buffer->object());
     }
 }
 
 void WebGLRenderingContextBase::restoreCurrentFramebuffer()
 {
-    bindFramebuffer(GL_FRAMEBUFFER, m_framebufferBinding.get());
+    bindFramebuffer(nullptr, GL_FRAMEBUFFER, m_framebufferBinding.get());

[haraken, 2015/10/13 02:02:04]

I'm wondering why we can't use m_scriptState.

[Ken Russell (switch to Gerrit), 2015/10/13 06:11:44]

There's no need to update the references between the JavaScript wrappers when
this is called internally; we're temporarily modifying the bound framebuffer and
restoring its state before returning to JavaScript.

 }
 
 void WebGLRenderingContextBase::restoreCurrentTexture2D()
 {
-    bindTexture(GL_TEXTURE_2D, m_textureUnits[m_activeTextureUnit].m_texture2DBinding.get());
+    bindTexture(nullptr, GL_TEXTURE_2D, m_textureUnits[m_activeTextureUnit].m_texture2DBinding.get());

[haraken, 2015/10/13 02:02:04]

Ditto.

[Ken Russell (switch to Gerrit), 2015/10/13 06:11:44]

Same thing for the TEXTURE_2D binding on the active texture unit. We don't want
to modify the references between the context's objects when doing some temporary
internal modifications.

 }
 
 void WebGLRenderingContextBase::multisamplingChanged(bool enabled)
 {
     if (m_multisamplingAllowed != enabled) {
         m_multisamplingAllowed = enabled;
         forceLostContext(WebGLRenderingContextBase::SyntheticLostContext, WebGLRenderingContextBase::Auto);
     }
 }
 
 void WebGLRenderingContextBase::findNewMaxNonDefaultTextureUnit()
 {
     // Trace backwards from the current max to find the new max non-default texture unit
     int startIndex = m_onePlusMaxNonDefaultTextureUnit - 1;
     for (int i = startIndex; i >= 0; --i) {
         if (m_textureUnits[i].m_texture2DBinding
             || m_textureUnits[i].m_textureCubeMapBinding) {
             m_onePlusMaxNonDefaultTextureUnit = i + 1;
             return;
         }
     }
     m_onePlusMaxNonDefaultTextureUnit = 0;
 }
 
+void WebGLRenderingContextBase::preserveObjectWrapper(ScriptState* scriptState, ScriptWrappable* sourceObject, const char* baseName, unsigned long index, ScriptWrappable* targetObject)

[haraken, 2015/10/13 02:02:04]

Actually preserveObjectWrapper doesn't need to take ScriptState (it is doing
nothing ScriptState-dependent). Passing an Isolate* would be enough.

[Ken Russell (switch to Gerrit), 2015/10/13 06:11:43]

Thanks for that hint. I'll change its signature.

+{
+    v8::Local<v8::Value> value;
+
+    StringBuilder builder;

[haraken, 2015/10/13 02:02:04]

Add a TODO: This logic should be moved to V8HiddenValue.

[Ken Russell (switch to Gerrit), 2015/10/13 06:11:44]

OK.

+    builder.append(baseName);
+    builder.appendNumber(static_cast<unsigned>(index));
+    CString name = builder.toString().utf8();
+    v8::Local<v8::String> jsName = v8::String::NewFromUtf8(
+        scriptState->isolate(),
+        name.data(),
+        v8::NewStringType::kNormal,
+        name.length()).ToLocalChecked();
+    if (targetObject) {
+        V8HiddenValue::setHiddenValue(
+            scriptState->isolate(),
+            sourceObject->newLocalWrapper(scriptState->isolate()),
+            jsName,
+            targetObject->newLocalWrapper(scriptState->isolate()));
+    } else {
+        V8HiddenValue::deleteHiddenValue(
+            scriptState->isolate(),
+            sourceObject->newLocalWrapper(scriptState->isolate()),
+            jsName);
+    }
+}
+
 DEFINE_TRACE(WebGLRenderingContextBase::TextureUnitState)
 {
     visitor->trace(m_texture2DBinding);
     visitor->trace(m_textureCubeMapBinding);
     visitor->trace(m_texture3DBinding);
     visitor->trace(m_texture2DArrayBinding);
 }
 
 DEFINE_TRACE(WebGLRenderingContextBase)
 {
@@ skipping 42 matching lines @@
 
     return totalBytesPerPixel;
 }
 
 DrawingBuffer* WebGLRenderingContextBase::drawingBuffer() const
 {
     return m_drawingBuffer.get();
 }
 
 } // namespace blink