Fix blink side WebGL2 sync object related behaviors.

third_party/WebKit/Source/modules/webgl/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 "modules/webgl/WebGL2RenderingContextBase.h"
 
 #include "bindings/modules/v8/WebGLAny.h"
 #include "core/dom/DOMException.h"
 #include "core/frame/ImageBitmap.h"
 #include "core/html/HTMLCanvasElement.h"
@@ skipping 20 matching lines @@
 #include "wtf/PtrUtil.h"
 #include "wtf/text/WTFString.h"
 #include <memory>
 
 using WTF::String;
 
 namespace blink {
 
 namespace {
 
+const GLuint64 kMaxClientWaitTimeout = 0u;
+
 GLsync syncObjectOrZero(const WebGLSync* object) {
   return object ? object->object() : nullptr;
 }
 
 // TODO(kainino): Change outByteLength to GLuint and change the associated
 // range checking (and all uses) - overflow becomes possible in cases below
 bool validateSubSourceAndGetData(DOMArrayBufferView* view,
                                  GLuint subOffset,
                                  GLuint subLength,
                                  void** outBaseAddress,
@@ skipping 3028 matching lines @@
 
   return contextGL()->IsSync(sync->object());
 }
 
 void WebGL2RenderingContextBase::deleteSync(WebGLSync* sync) {
   deleteObject(sync);
 }
 
 GLenum WebGL2RenderingContextBase::clientWaitSync(WebGLSync* sync,
                                                   GLbitfield flags,
-                                                  GLint64 timeout) {
+                                                  GLuint64 timeout) {
   if (isContextLost() || !validateWebGLObject("clientWaitSync", sync))
     return GL_WAIT_FAILED;
 
-  if (timeout < -1) {
-    synthesizeGLError(GL_INVALID_VALUE, "clientWaitSync", "timeout < -1");
+  if (timeout > kMaxClientWaitTimeout) {
+    synthesizeGLError(GL_INVALID_OPERATION, "clientWaitSync",
+                      "timeout > MAX_CLIENT_WAIT_TIMEOUT_WEBGL");
     return GL_WAIT_FAILED;
   }
 
-  GLuint64 timeout64 =
-      timeout == -1 ? GL_TIMEOUT_IGNORED : static_cast<GLuint64>(timeout);
-  return contextGL()->ClientWaitSync(syncObjectOrZero(sync), flags, timeout64);
+  return contextGL()->ClientWaitSync(syncObjectOrZero(sync), flags, timeout);
 }
 
 void WebGL2RenderingContextBase::waitSync(WebGLSync* sync,
                                           GLbitfield flags,
                                           GLint64 timeout) {
   if (isContextLost() || !validateWebGLObject("waitSync", sync))
     return;
 
-  if (timeout < -1) {
-    synthesizeGLError(GL_INVALID_VALUE, "waitSync", "timeout < -1");
+  if (flags) {
+    synthesizeGLError(GL_INVALID_VALUE, "waitSync", "invalid flags");
     return;
   }
 
-  GLuint64 timeout64 =
-      timeout == -1 ? GL_TIMEOUT_IGNORED : static_cast<GLuint64>(timeout);
-  contextGL()->WaitSync(syncObjectOrZero(sync), flags, timeout64);
+  if (timeout != -1) {
+    synthesizeGLError(GL_INVALID_VALUE, "waitSync", "invalid timeout");
+    return;
+  }
+
+  // This is intentionally changed to an no-op in WebGL2.
 }
 
 ScriptValue WebGL2RenderingContextBase::getSyncParameter(
     ScriptState* scriptState,
     WebGLSync* sync,
     GLenum pname) {
   if (isContextLost() || !validateWebGLObject("getSyncParameter", sync))
     return ScriptValue::createNull(scriptState);
 
   switch (pname) {
@@ skipping 652 matching lines @@
       return WebGLAny(scriptState, m_boundCopyWriteBuffer.get());
     case GL_DRAW_FRAMEBUFFER_BINDING:
       return WebGLAny(scriptState, m_framebufferBinding.get());
     case GL_FRAGMENT_SHADER_DERIVATIVE_HINT:
       return getUnsignedIntParameter(scriptState, pname);
     case GL_MAX_3D_TEXTURE_SIZE:
       return getIntParameter(scriptState, pname);
     case GL_MAX_ARRAY_TEXTURE_LAYERS:
       return getIntParameter(scriptState, pname);
     case GC3D_MAX_CLIENT_WAIT_TIMEOUT_WEBGL:
-      return WebGLAny(scriptState, 0u);
+      return WebGLAny(scriptState, kMaxClientWaitTimeout);
     case GL_MAX_COLOR_ATTACHMENTS:
       return getIntParameter(scriptState, pname);
     case GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS:
       return getInt64Parameter(scriptState, pname);
     case GL_MAX_COMBINED_UNIFORM_BLOCKS:
       return getIntParameter(scriptState, pname);
     case GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS:
       return getInt64Parameter(scriptState, pname);
     case GL_MAX_DRAW_BUFFERS:
       return getIntParameter(scriptState, pname);
@@ skipping 1005 matching lines @@
 
 void WebGL2RenderingContextBase::
     DrawingBufferClientRestorePixelUnpackBufferBinding() {
   if (!contextGL())
     return;
   contextGL()->BindBuffer(GL_PIXEL_UNPACK_BUFFER,
                           objectOrZero(m_boundPixelUnpackBuffer.get()));
 }
 
 }  // namespace blink