X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fthird_party%2Fangle%2Fsrc%2FlibGLESv2%2FvalidationES3.cpp;h=251c6ad2c4b2058b3aecc36a60c815de9d3892b2;hb=3545e9f2671f595d2a2f3ee75ca0393b01e35ef6;hp=66c41e61cfa3378e3f036ef1ff9566bc6efaa8ea;hpb=7d210d4c7e9ba36e635eabc5b5780495f8a63292;p=platform%2Fframework%2Fweb%2Fcrosswalk.git

diff --git a/src/third_party/angle/src/libGLESv2/validationES3.cpp b/src/third_party/angle/src/libGLESv2/validationES3.cpp
index 66c41e6..251c6ad 100644
--- a/src/third_party/angle/src/libGLESv2/validationES3.cpp
+++ b/src/third_party/angle/src/libGLESv2/validationES3.cpp
@@ -1,4 +1,3 @@
-#include "precompiled.h"
 //
 // Copyright (c) 2013-2014 The ANGLE Project Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
@@ -22,7 +21,6 @@
 namespace gl
 {
 
-// ES3 has a specific set of permutations of internal formats, formats and types which are acceptable.
 struct ES3FormatCombination
 {
     GLenum internalFormat;
@@ -225,7 +223,8 @@ static bool ValidateTexImageFormatCombination(gl::Context *context, GLenum inter
     const gl::InternalFormat &formatInfo = gl::GetInternalFormatInfo(internalFormat);
     if (!formatInfo.textureSupport(context->getClientVersion(), context->getExtensions()))
     {
-        return gl::error(GL_INVALID_ENUM, false);
+        context->recordError(Error(GL_INVALID_ENUM));
+        return false;
     }
 
     // The type and format are valid if any supported internal format has that type and format
@@ -258,7 +257,8 @@ static bool ValidateTexImageFormatCombination(gl::Context *context, GLenum inter
 
     if (!typeSupported || !formatSupported)
     {
-        return gl::error(GL_INVALID_ENUM, false);
+        context->recordError(Error(GL_INVALID_ENUM));
+        return false;
     }
 
     // Check if this is a valid format combination to load texture data
@@ -269,31 +269,35 @@ static bool ValidateTexImageFormatCombination(gl::Context *context, GLenum inter
 
     if (es3FormatSet.find(searchFormat) == es3FormatSet.end())
     {
-        return gl::error(GL_INVALID_OPERATION, false);
+        context->recordError(Error(GL_INVALID_OPERATION));
+        return false;
     }
 
     return true;
 }
 
-bool ValidateES3TexImageParameters(gl::Context *context, GLenum target, GLint level, GLenum internalformat, bool isCompressed, bool isSubImage,
+bool ValidateES3TexImageParameters(Context *context, GLenum target, GLint level, GLenum internalformat, bool isCompressed, bool isSubImage,
                                    GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
                                    GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
     if (!ValidTexture2DDestinationTarget(context, target))
     {
-        return gl::error(GL_INVALID_ENUM, false);
+        context->recordError(Error(GL_INVALID_ENUM));
+        return false;
     }
 
     // Validate image size
     if (!ValidImageSize(context, target, level, width, height, depth))
     {
-        return gl::error(GL_INVALID_VALUE, false);
+        context->recordError(Error(GL_INVALID_VALUE));
+        return false;
     }
 
     // Verify zero border
     if (border != 0)
     {
-        return gl::error(GL_INVALID_VALUE, false);
+        context->recordError(Error(GL_INVALID_VALUE));
+        return false;
     }
 
     if (xoffset < 0 || yoffset < 0 || zoffset < 0 ||
@@ -301,7 +305,8 @@ bool ValidateES3TexImageParameters(gl::Context *context, GLenum target, GLint le
         std::numeric_limits<GLsizei>::max() - yoffset < height ||
         std::numeric_limits<GLsizei>::max() - zoffset < depth)
     {
-        return gl::error(GL_INVALID_VALUE, false);
+        context->recordError(Error(GL_INVALID_VALUE));
+        return false;
     }
 
     const gl::Caps &caps = context->getCaps();
@@ -319,7 +324,8 @@ bool ValidateES3TexImageParameters(gl::Context *context, GLenum target, GLint le
             if (static_cast<GLuint>(width) > (caps.max2DTextureSize >> level) ||
                 static_cast<GLuint>(height) > (caps.max2DTextureSize >> level))
             {
-                return gl::error(GL_INVALID_VALUE, false);
+                context->recordError(Error(GL_INVALID_VALUE));
+                return false;
             }
 
             gl::Texture2D *texture2d = context->getTexture2D();
@@ -344,12 +350,14 @@ bool ValidateES3TexImageParameters(gl::Context *context, GLenum target, GLint le
         {
             if (!isSubImage && width != height)
             {
-                return gl::error(GL_INVALID_VALUE, false);
+                context->recordError(Error(GL_INVALID_VALUE));
+                return false;
             }
 
             if (static_cast<GLuint>(width) > (caps.maxCubeMapTextureSize >> level))
             {
-                return gl::error(GL_INVALID_VALUE, false);
+                context->recordError(Error(GL_INVALID_VALUE));
+                return false;
             }
 
             gl::TextureCubeMap *textureCube = context->getTextureCubeMap();
@@ -371,7 +379,8 @@ bool ValidateES3TexImageParameters(gl::Context *context, GLenum target, GLint le
                 static_cast<GLuint>(height) > (caps.max3DTextureSize >> level) ||
                 static_cast<GLuint>(depth) > (caps.max3DTextureSize >> level))
             {
-                return gl::error(GL_INVALID_VALUE, false);
+                context->recordError(Error(GL_INVALID_VALUE));
+                return false;
             }
 
             gl::Texture3D *texture3d = context->getTexture3D();
@@ -393,7 +402,8 @@ bool ValidateES3TexImageParameters(gl::Context *context, GLenum target, GLint le
                   static_cast<GLuint>(height) > (caps.max2DTextureSize >> level) ||
                   static_cast<GLuint>(depth) > (caps.maxArrayTextureLayers >> level))
               {
-                  return gl::error(GL_INVALID_VALUE, false);
+                  context->recordError(Error(GL_INVALID_VALUE));
+                  return false;
               }
 
               gl::Texture2DArray *texture2darray = context->getTexture2DArray();
@@ -410,17 +420,20 @@ bool ValidateES3TexImageParameters(gl::Context *context, GLenum target, GLint le
           break;
 
       default:
-        return gl::error(GL_INVALID_ENUM, false);
+        context->recordError(Error(GL_INVALID_ENUM));
+        return false;
     }
 
     if (!texture)
     {
-        return gl::error(GL_INVALID_OPERATION, false);
+        context->recordError(Error(GL_INVALID_OPERATION));
+        return false;
     }
 
     if (texture->isImmutable() && !isSubImage)
     {
-        return gl::error(GL_INVALID_OPERATION, false);
+        context->recordError(Error(GL_INVALID_OPERATION));
+        return false;
     }
 
     // Validate texture formats
@@ -430,17 +443,20 @@ bool ValidateES3TexImageParameters(gl::Context *context, GLenum target, GLint le
     {
         if (!ValidCompressedImageSize(context, actualInternalFormat, width, height))
         {
-            return gl::error(GL_INVALID_OPERATION, false);
+            context->recordError(Error(GL_INVALID_OPERATION));
+            return false;
         }
 
         if (!actualFormatInfo.compressed)
         {
-            return gl::error(GL_INVALID_ENUM, false);
+            context->recordError(Error(GL_INVALID_ENUM));
+            return false;
         }
 
         if (target == GL_TEXTURE_3D)
         {
-            return gl::error(GL_INVALID_OPERATION, false);
+            context->recordError(Error(GL_INVALID_OPERATION));
+            return false;
         }
     }
     else
@@ -452,7 +468,8 @@ bool ValidateES3TexImageParameters(gl::Context *context, GLenum target, GLint le
 
         if (target == GL_TEXTURE_3D && (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL))
         {
-            return gl::error(GL_INVALID_OPERATION, false);
+            context->recordError(Error(GL_INVALID_OPERATION));
+            return false;
         }
     }
 
@@ -461,7 +478,8 @@ bool ValidateES3TexImageParameters(gl::Context *context, GLenum target, GLint le
     {
         if (isCompressed != textureCompressed)
         {
-            return gl::error(GL_INVALID_OPERATION, false);
+            context->recordError(Error(GL_INVALID_OPERATION));
+            return false;
         }
 
         if (isCompressed)
@@ -469,7 +487,8 @@ bool ValidateES3TexImageParameters(gl::Context *context, GLenum target, GLint le
             if ((width % 4 != 0 && width != textureLevelWidth) ||
                 (height % 4 != 0 && height != textureLevelHeight))
             {
-                return gl::error(GL_INVALID_OPERATION, false);
+                context->recordError(Error(GL_INVALID_OPERATION));
+                return false;
             }
         }
 
@@ -480,21 +499,24 @@ bool ValidateES3TexImageParameters(gl::Context *context, GLenum target, GLint le
 
         if (xoffset < 0 || yoffset < 0 || zoffset < 0)
         {
-            return gl::error(GL_INVALID_VALUE, false);
+            context->recordError(Error(GL_INVALID_VALUE));
+            return false;
         }
 
         if (std::numeric_limits<GLsizei>::max() - xoffset < width ||
             std::numeric_limits<GLsizei>::max() - yoffset < height ||
             std::numeric_limits<GLsizei>::max() - zoffset < depth)
         {
-            return gl::error(GL_INVALID_VALUE, false);
+            context->recordError(Error(GL_INVALID_VALUE));
+            return false;
         }
 
         if (xoffset + width > textureLevelWidth ||
             yoffset + height > textureLevelHeight ||
             zoffset + depth > textureLevelDepth)
         {
-            return gl::error(GL_INVALID_VALUE, false);
+            context->recordError(Error(GL_INVALID_VALUE));
+            return false;
         }
     }
 
@@ -516,7 +538,8 @@ bool ValidateES3TexImageParameters(gl::Context *context, GLenum target, GLint le
             !rx::IsUnsignedMultiplicationSafe(widthSize * heightSize * depthSize, pixelBytes))
         {
             // Overflow past the end of the buffer
-            return gl::error(GL_INVALID_OPERATION, false);
+            context->recordError(Error(GL_INVALID_OPERATION));
+            return false;
         }
 
         size_t copyBytes = widthSize * heightSize * depthSize * pixelBytes;
@@ -526,7 +549,8 @@ bool ValidateES3TexImageParameters(gl::Context *context, GLenum target, GLint le
             ((offset + copyBytes) > static_cast<size_t>(pixelUnpackBuffer->getSize())))
         {
             // Overflow past the end of the buffer
-            return gl::error(GL_INVALID_OPERATION, false);
+            context->recordError(Error(GL_INVALID_OPERATION));
+            return false;
         }
 
         // ...data is not evenly divisible into the number of bytes needed to store in memory a datum
@@ -535,13 +559,15 @@ bool ValidateES3TexImageParameters(gl::Context *context, GLenum target, GLint le
 
         if ((offset % dataBytesPerPixel) != 0)
         {
-            return gl::error(GL_INVALID_OPERATION, false);
+            context->recordError(Error(GL_INVALID_OPERATION));
+            return false;
         }
 
         // ...the buffer object's data store is currently mapped.
         if (pixelUnpackBuffer->isMapped())
         {
-            return gl::error(GL_INVALID_OPERATION, false);
+            context->recordError(Error(GL_INVALID_OPERATION));
+            return false;
         }
     }
 
@@ -832,7 +858,7 @@ static bool IsValidES3CopyTexImageCombination(GLenum textureInternalFormat, GLen
     return false;
 }
 
-bool ValidateES3CopyTexImageParameters(gl::Context *context, GLenum target, GLint level, GLenum internalformat,
+bool ValidateES3CopyTexImageParameters(Context *context, GLenum target, GLint level, GLenum internalformat,
                                        bool isSubImage, GLint xoffset, GLint yoffset, GLint zoffset,
                                        GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 {
@@ -848,12 +874,14 @@ bool ValidateES3CopyTexImageParameters(gl::Context *context, GLenum target, GLin
 
     if (framebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE)
     {
-        return gl::error(GL_INVALID_FRAMEBUFFER_OPERATION, false);
+        context->recordError(Error(GL_INVALID_FRAMEBUFFER_OPERATION));
+        return false;
     }
 
     if (context->getState().getReadFramebuffer()->id() != 0 && framebuffer->getSamples() != 0)
     {
-        return gl::error(GL_INVALID_OPERATION, false);
+        context->recordError(Error(GL_INVALID_OPERATION));
+        return false;
     }
 
     gl::FramebufferAttachment *source = framebuffer->getReadColorbuffer();
@@ -864,7 +892,8 @@ bool ValidateES3CopyTexImageParameters(gl::Context *context, GLenum target, GLin
         if (!IsValidES3CopyTexImageCombination(textureInternalFormat, colorbufferInternalFormat,
                                                context->getState().getReadFramebuffer()->id()))
         {
-            return gl::error(GL_INVALID_OPERATION, false);
+            context->recordError(Error(GL_INVALID_OPERATION));
+            return false;
         }
     }
     else
@@ -872,7 +901,8 @@ bool ValidateES3CopyTexImageParameters(gl::Context *context, GLenum target, GLin
         if (!gl::IsValidES3CopyTexImageCombination(internalformat, colorbufferInternalFormat,
                                                 context->getState().getReadFramebuffer()->id()))
         {
-            return gl::error(GL_INVALID_OPERATION, false);
+            context->recordError(Error(GL_INVALID_OPERATION));
+            return false;
         }
     }
 
@@ -880,17 +910,19 @@ bool ValidateES3CopyTexImageParameters(gl::Context *context, GLenum target, GLin
     return (width > 0 && height > 0);
 }
 
-bool ValidateES3TexStorageParameters(gl::Context *context, GLenum target, GLsizei levels, GLenum internalformat,
+bool ValidateES3TexStorageParameters(Context *context, GLenum target, GLsizei levels, GLenum internalformat,
                                      GLsizei width, GLsizei height, GLsizei depth)
 {
     if (width < 1 || height < 1 || depth < 1 || levels < 1)
     {
-        return gl::error(GL_INVALID_VALUE, false);
+        context->recordError(Error(GL_INVALID_VALUE));
+        return false;
     }
 
     if (levels > gl::log2(std::max(std::max(width, height), depth)) + 1)
     {
-        return gl::error(GL_INVALID_OPERATION, false);
+        context->recordError(Error(GL_INVALID_OPERATION));
+        return false;
     }
 
     const gl::Caps &caps = context->getCaps();
@@ -905,7 +937,8 @@ bool ValidateES3TexStorageParameters(gl::Context *context, GLenum target, GLsize
             if (static_cast<GLuint>(width) > caps.max2DTextureSize ||
                 static_cast<GLuint>(height) > caps.max2DTextureSize)
             {
-                return gl::error(GL_INVALID_VALUE, false);
+                context->recordError(Error(GL_INVALID_VALUE));
+                return false;
             }
         }
         break;
@@ -916,12 +949,14 @@ bool ValidateES3TexStorageParameters(gl::Context *context, GLenum target, GLsize
 
             if (width != height)
             {
-                return gl::error(GL_INVALID_VALUE, false);
+                context->recordError(Error(GL_INVALID_VALUE));
+                return false;
             }
 
             if (static_cast<GLuint>(width) > caps.maxCubeMapTextureSize)
             {
-                return gl::error(GL_INVALID_VALUE, false);
+                context->recordError(Error(GL_INVALID_VALUE));
+                return false;
             }
         }
         break;
@@ -934,7 +969,8 @@ bool ValidateES3TexStorageParameters(gl::Context *context, GLenum target, GLsize
                 static_cast<GLuint>(height) > caps.max3DTextureSize ||
                 static_cast<GLuint>(depth) > caps.max3DTextureSize)
             {
-                return gl::error(GL_INVALID_VALUE, false);
+                context->recordError(Error(GL_INVALID_VALUE));
+                return false;
             }
         }
         break;
@@ -947,50 +983,58 @@ bool ValidateES3TexStorageParameters(gl::Context *context, GLenum target, GLsize
                 static_cast<GLuint>(height) > caps.max2DTextureSize ||
                 static_cast<GLuint>(depth) > caps.maxArrayTextureLayers)
             {
-                return gl::error(GL_INVALID_VALUE, false);
+                context->recordError(Error(GL_INVALID_VALUE));
+                return false;
             }
         }
         break;
 
       default:
-        return gl::error(GL_INVALID_ENUM, false);
+        context->recordError(Error(GL_INVALID_ENUM));
+        return false;
     }
 
     if (!texture || texture->id() == 0)
     {
-        return gl::error(GL_INVALID_OPERATION, false);
+        context->recordError(Error(GL_INVALID_OPERATION));
+        return false;
     }
 
     if (texture->isImmutable())
     {
-        return gl::error(GL_INVALID_OPERATION, false);
+        context->recordError(Error(GL_INVALID_OPERATION));
+        return false;
     }
 
     const gl::InternalFormat &formatInfo = gl::GetInternalFormatInfo(internalformat);
     if (!formatInfo.textureSupport(context->getClientVersion(), context->getExtensions()))
     {
-        return gl::error(GL_INVALID_ENUM, false);
+        context->recordError(Error(GL_INVALID_ENUM));
+        return false;
     }
 
     if (formatInfo.pixelBytes == 0)
     {
-        return gl::error(GL_INVALID_ENUM, false);
+        context->recordError(Error(GL_INVALID_ENUM));
+        return false;
     }
 
     return true;
 }
 
-bool ValidateFramebufferTextureLayer(const gl::Context *context, GLenum target, GLenum attachment,
+bool ValidateFramebufferTextureLayer(Context *context, GLenum target, GLenum attachment,
                                      GLuint texture, GLint level, GLint layer)
 {
     if (context->getClientVersion() < 3)
     {
-        return gl::error(GL_INVALID_OPERATION, false);
+        context->recordError(Error(GL_INVALID_OPERATION));
+        return false;
     }
 
     if (layer < 0)
     {
-        return gl::error(GL_INVALID_VALUE, false);
+        context->recordError(Error(GL_INVALID_VALUE));
+        return false;
     }
 
     if (!ValidateFramebufferTextureBase(context, target, attachment, texture, level))
@@ -1010,18 +1054,21 @@ bool ValidateFramebufferTextureLayer(const gl::Context *context, GLenum target,
             {
                 if (level > gl::log2(caps.max2DTextureSize))
                 {
-                    return gl::error(GL_INVALID_VALUE, false);
+                    context->recordError(Error(GL_INVALID_VALUE));
+                    return false;
                 }
 
                 if (static_cast<GLuint>(layer) >= caps.maxArrayTextureLayers)
                 {
-                    return gl::error(GL_INVALID_VALUE, false);
+                    context->recordError(Error(GL_INVALID_VALUE));
+                    return false;
                 }
 
                 gl::Texture2DArray *texArray = static_cast<gl::Texture2DArray *>(tex);
                 if (texArray->isCompressed(level))
                 {
-                    return gl::error(GL_INVALID_OPERATION, false);
+                    context->recordError(Error(GL_INVALID_OPERATION));
+                    return false;
                 }
             }
             break;
@@ -1030,31 +1077,35 @@ bool ValidateFramebufferTextureLayer(const gl::Context *context, GLenum target,
             {
                 if (level > gl::log2(caps.max3DTextureSize))
                 {
-                    return gl::error(GL_INVALID_VALUE, false);
+                    context->recordError(Error(GL_INVALID_VALUE));
+                    return false;
                 }
 
                 if (static_cast<GLuint>(layer) >= caps.max3DTextureSize)
                 {
-                    return gl::error(GL_INVALID_VALUE, false);
+                    context->recordError(Error(GL_INVALID_VALUE));
+                    return false;
                 }
 
                 gl::Texture3D *tex3d = static_cast<gl::Texture3D *>(tex);
                 if (tex3d->isCompressed(level))
                 {
-                    return gl::error(GL_INVALID_OPERATION, false);
+                    context->recordError(Error(GL_INVALID_OPERATION));
+                    return false;
                 }
             }
             break;
 
           default:
-            return gl::error(GL_INVALID_OPERATION, false);
+            context->recordError(Error(GL_INVALID_OPERATION));
+            return false;
         }
     }
 
     return true;
 }
 
-bool ValidES3ReadFormatType(gl::Context *context, GLenum internalFormat, GLenum format, GLenum type)
+bool ValidES3ReadFormatType(Context *context, GLenum internalFormat, GLenum format, GLenum type)
 {
     const gl::InternalFormat &internalFormatInfo = gl::GetInternalFormatInfo(internalFormat);
 
@@ -1131,7 +1182,7 @@ bool ValidES3ReadFormatType(gl::Context *context, GLenum internalFormat, GLenum
     return true;
 }
 
-bool ValidateInvalidateFramebufferParameters(gl::Context *context, GLenum target, GLsizei numAttachments,
+bool ValidateInvalidateFramebufferParameters(Context *context, GLenum target, GLsizei numAttachments,
                                              const GLenum* attachments)
 {
     bool defaultFramebuffer = false;
@@ -1146,7 +1197,8 @@ bool ValidateInvalidateFramebufferParameters(gl::Context *context, GLenum target
         defaultFramebuffer = context->getState().getReadFramebuffer()->id() == 0;
         break;
       default:
-        return gl::error(GL_INVALID_ENUM, false);
+          context->recordError(Error(GL_INVALID_ENUM));
+          return false;
     }
 
     for (int i = 0; i < numAttachments; ++i)
@@ -1155,12 +1207,14 @@ bool ValidateInvalidateFramebufferParameters(gl::Context *context, GLenum target
         {
             if (defaultFramebuffer)
             {
-                return gl::error(GL_INVALID_ENUM, false);
+                context->recordError(Error(GL_INVALID_ENUM));
+                return false;
             }
 
             if (attachments[i] >= GL_COLOR_ATTACHMENT0 + context->getCaps().maxColorAttachments)
             {
-                return gl::error(GL_INVALID_OPERATION, false);
+                context->recordError(Error(GL_INVALID_OPERATION));
+                return false;
             }
         }
         else
@@ -1172,7 +1226,8 @@ bool ValidateInvalidateFramebufferParameters(gl::Context *context, GLenum target
               case GL_DEPTH_STENCIL_ATTACHMENT:
                 if (defaultFramebuffer)
                 {
-                    return gl::error(GL_INVALID_ENUM, false);
+                    context->recordError(Error(GL_INVALID_ENUM));
+                    return false;
                 }
                 break;
               case GL_COLOR:
@@ -1180,11 +1235,13 @@ bool ValidateInvalidateFramebufferParameters(gl::Context *context, GLenum target
               case GL_STENCIL:
                 if (!defaultFramebuffer)
                 {
-                    return gl::error(GL_INVALID_ENUM, false);
+                    context->recordError(Error(GL_INVALID_ENUM));
+                    return false;
                 }
                 break;
               default:
-                return gl::error(GL_INVALID_ENUM, false);
+                context->recordError(Error(GL_INVALID_ENUM));
+                return false;
             }
         }
     }
@@ -1192,20 +1249,33 @@ bool ValidateInvalidateFramebufferParameters(gl::Context *context, GLenum target
     return true;
 }
 
-bool ValidateClearBuffer(const gl::Context *context)
+bool ValidateClearBuffer(Context *context)
 {
     if (context->getClientVersion() < 3)
     {
-        return gl::error(GL_INVALID_OPERATION, false);
+        context->recordError(Error(GL_INVALID_OPERATION));
+        return false;
     }
 
     const gl::Framebuffer *fbo = context->getState().getDrawFramebuffer();
     if (!fbo || fbo->completeness() != GL_FRAMEBUFFER_COMPLETE)
     {
-        return gl::error(GL_INVALID_FRAMEBUFFER_OPERATION, false);
+        context->recordError(Error(GL_INVALID_FRAMEBUFFER_OPERATION));
+        return false;
     }
 
     return true;
 }
 
+bool ValidateGetUniformuiv(Context *context, GLuint program, GLint location, GLuint* params)
+{
+    if (context->getClientVersion() < 3)
+    {
+        context->recordError(Error(GL_INVALID_OPERATION));
+        return false;
+    }
+
+    return ValidateGetUniformBase(context, program, location);
+}
+
 }