Add gl tests to make sure when a buffer is unmapped, all access path generates an INVALID_OPERATION.

gpu/command_buffer/tests/gl_map_buffer_range_unittest.cc

+// Copyright 2016 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 <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+#include <GLES2/gl2extchromium.h>
+#include <GLES3/gl3.h>
+#include <stdint.h>
+
+#include "base/command_line.h"
+#include "gpu/command_buffer/service/context_group.h"
+#include "gpu/command_buffer/tests/gl_manager.h"
+#include "gpu/command_buffer/tests/gl_test_utils.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gl/gl_switches.h"
+
+#define SHADER(Src) #Src
+
+namespace gpu {
+
+class ES3MapBufferRangeTest : public testing::Test {
+ protected:
+  static const GLsizei kCanvasSize = 4;
+
+  void SetUp() override {
+    GLManager::Options options;
+    options.size = gfx::Size(kCanvasSize, kCanvasSize);
+    options.context_type = gles2::CONTEXT_TYPE_OPENGLES3;
+
+    base::CommandLine cmd_line(base::CommandLine::NO_PROGRAM);
+    cmd_line.AppendSwitch(switches::kEnableUnsafeES3APIs);
+    gl_.InitializeWithCommandLine(options, cmd_line);
+  }
+
+  void TearDown() override { gl_.Destroy(); }
+
+  GLuint SetupSimpleProgram(GLint* ret_position_loc) {
+    static const char* v_shader_src =
+        SHADER(attribute vec2 a_position;
+               void main() { gl_Position = vec4(a_position, 0.0, 1.0); });
+    static const char* f_shader_src =
+        SHADER(precision mediump float;
+               void main() { gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); });
+    GLuint program = GLTestHelper::LoadProgram(v_shader_src, f_shader_src);
+    EXPECT_LT(0u, program);
+    glUseProgram(program);
+    *ret_position_loc = glGetAttribLocation(program, "a_position");
+    EXPECT_LE(0, *ret_position_loc);
+    return program;
+  }
+
+  GLuint SetupTransformFeedbackProgram(GLint* ret_position_loc) {
+    static const char* v_shader_src =
+        "#version 300 es\n"
+        "in vec2 a_position;\n"
+        "out vec3 var0;\n"
+        "out vec2 var1;\n"
+        "void main() {\n"
+        "  var0 = vec3(a_position, 0.5);\n"
+        "  var1 = a_position;\n"
+        "  gl_Position = vec4(a_position, 0.0, 1.0);\n"
+        "}";
+    static const char* f_shader_src =
+        "#version 300 es\n"
+        "precision mediump float;\n"
+        "out vec4 color;\n"
+        "in vec3 var0;\n"
+        "in vec2 var1;\n"
+        "void main() {\n"
+        "  color = vec4(0.0, 1.0, 0.0, 1.0);\n"
+        "}";
+    static const char* varyings[] = {"var0", "var1"};
+    GLuint program = GLTestHelper::LoadProgram(v_shader_src, f_shader_src);
+    EXPECT_LT(0u, program);
+    glTransformFeedbackVaryings(program, 2, varyings, GL_SEPARATE_ATTRIBS);
+    glLinkProgram(program);
+    GLint link_status = GL_FALSE;
+    glGetProgramiv(program, GL_LINK_STATUS, &link_status);
+    EXPECT_EQ(GL_TRUE, link_status);
+    glUseProgram(program);
+    *ret_position_loc = glGetAttribLocation(program, "a_position");
+    EXPECT_LE(0, *ret_position_loc);
+    return program;
+  }
+
+  GLManager gl_;
+};
+
+TEST_F(ES3MapBufferRangeTest, DrawArraysAndInstanced) {
+  const uint8_t kRedColor[] = {255, 0, 0, 255};
+  const uint8_t kBlackColor[] = {0, 0, 0, 255};
+  const GLsizei kPrimCount = 4;
+
+  GLint position_loc = 0;
+  SetupSimpleProgram(&position_loc);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+
+  GLuint buffer = GLTestHelper::SetupUnitQuad(position_loc);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+  EXPECT_LT(0u, buffer);
+
+  glClearColor(0.0, 0.0, 0.0, 1.0);
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  glDrawArrays(GL_TRIANGLES, 0, 6);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+  EXPECT_TRUE(
+      GLTestHelper::CheckPixels(0, 0, kCanvasSize, kCanvasSize, 1, kRedColor));
+
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  glDrawArraysInstancedANGLE(GL_TRIANGLES, 0, 6, kPrimCount);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+  EXPECT_TRUE(
+      GLTestHelper::CheckPixels(0, 0, kCanvasSize, kCanvasSize, 1, kRedColor));
+
+  glMapBufferRange(GL_ARRAY_BUFFER, 0, 6, GL_MAP_READ_BIT);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  glDrawArrays(GL_TRIANGLES, 0, 6);
+  EXPECT_EQ(static_cast<GLenum>(GL_INVALID_OPERATION), glGetError());
+  EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, kCanvasSize, kCanvasSize, 1,
+                                        kBlackColor));
+
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  glDrawArraysInstancedANGLE(GL_TRIANGLES, 0, 6, kPrimCount);
+  EXPECT_EQ(static_cast<GLenum>(GL_INVALID_OPERATION), glGetError());
+  EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, kCanvasSize, kCanvasSize, 1,
+                                        kBlackColor));
+
+  glUnmapBuffer(GL_ARRAY_BUFFER);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  glDrawArrays(GL_TRIANGLES, 0, 6);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+  EXPECT_TRUE(
+      GLTestHelper::CheckPixels(0, 0, kCanvasSize, kCanvasSize, 1, kRedColor));
+
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  glDrawArraysInstancedANGLE(GL_TRIANGLES, 0, 6, kPrimCount);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+  EXPECT_TRUE(
+      GLTestHelper::CheckPixels(0, 0, kCanvasSize, kCanvasSize, 1, kRedColor));
+}
+
+TEST_F(ES3MapBufferRangeTest, DrawElementsAndInstanced) {
+  const uint8_t kRedColor[] = {255, 0, 0, 255};
+  const uint8_t kBlackColor[] = {0, 0, 0, 255};
+  const GLsizei kPrimCount = 4;
+
+  GLint position_loc = 0;
+  SetupSimpleProgram(&position_loc);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+
+  std::vector<GLuint> buffers =
+      GLTestHelper::SetupIndexedUnitQuad(position_loc);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+  EXPECT_EQ(2u, buffers.size());
+  EXPECT_LT(0u, buffers[0]);
+  EXPECT_LT(0u, buffers[1]);
+
+  glClearColor(0.0, 0.0, 0.0, 1.0);
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, 0);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+  EXPECT_TRUE(
+      GLTestHelper::CheckPixels(0, 0, kCanvasSize, kCanvasSize, 1, kRedColor));
+
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  glDrawElementsInstancedANGLE(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, 0,
+                               kPrimCount);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+  EXPECT_TRUE(
+      GLTestHelper::CheckPixels(0, 0, kCanvasSize, kCanvasSize, 1, kRedColor));
+
+  glMapBufferRange(GL_ARRAY_BUFFER, 0, 6, GL_MAP_READ_BIT);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  glDrawArrays(GL_TRIANGLES, 0, 6);
+  EXPECT_EQ(static_cast<GLenum>(GL_INVALID_OPERATION), glGetError());
+  EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, kCanvasSize, kCanvasSize, 1,
+                                        kBlackColor));
+
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  glDrawElementsInstancedANGLE(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, 0,
+                               kPrimCount);
+  EXPECT_EQ(static_cast<GLenum>(GL_INVALID_OPERATION), glGetError());
+  EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, kCanvasSize, kCanvasSize, 1,
+                                        kBlackColor));
+
+  glUnmapBuffer(GL_ARRAY_BUFFER);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, 0);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+  EXPECT_TRUE(
+      GLTestHelper::CheckPixels(0, 0, kCanvasSize, kCanvasSize, 1, kRedColor));
+
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  glDrawElementsInstancedANGLE(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, 0,
+                               kPrimCount);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+  EXPECT_TRUE(
+      GLTestHelper::CheckPixels(0, 0, kCanvasSize, kCanvasSize, 1, kRedColor));
+
+  glMapBufferRange(GL_ELEMENT_ARRAY_BUFFER, 0, 6, GL_MAP_READ_BIT);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, 0);
+  EXPECT_EQ(static_cast<GLenum>(GL_INVALID_OPERATION), glGetError());
+  EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, kCanvasSize, kCanvasSize, 1,
+                                        kBlackColor));
+
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  glDrawElementsInstancedANGLE(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, 0,
+                               kPrimCount);
+  EXPECT_EQ(static_cast<GLenum>(GL_INVALID_OPERATION), glGetError());
+  EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, kCanvasSize, kCanvasSize, 1,
+                                        kBlackColor));
+
+  glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, 0);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+  EXPECT_TRUE(
+      GLTestHelper::CheckPixels(0, 0, kCanvasSize, kCanvasSize, 1, kRedColor));
+
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  glDrawElementsInstancedANGLE(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, 0,
+                               kPrimCount);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+  EXPECT_TRUE(
+      GLTestHelper::CheckPixels(0, 0, kCanvasSize, kCanvasSize, 1, kRedColor));
+}
+
+TEST_F(ES3MapBufferRangeTest, ReadPixels) {
+  GLuint buffer = 0;
+  glGenBuffers(1, &buffer);
+  EXPECT_LT(0u, buffer);
+  glBindBuffer(GL_PIXEL_PACK_BUFFER, buffer);
+  glBufferData(GL_PIXEL_PACK_BUFFER, 4 * kCanvasSize * kCanvasSize, 0,
+               GL_STATIC_READ);
+
+  glReadPixels(0, 0, kCanvasSize, kCanvasSize, GL_RGBA, GL_UNSIGNED_BYTE, 0);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+
+  glMapBufferRange(GL_PIXEL_PACK_BUFFER, 0, 6, GL_MAP_WRITE_BIT);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+
+  glReadPixels(0, 0, kCanvasSize, kCanvasSize, GL_RGBA, GL_UNSIGNED_BYTE, 0);
+  EXPECT_EQ(static_cast<GLenum>(GL_INVALID_OPERATION), glGetError());
+
+  glUnmapBuffer(GL_PIXEL_PACK_BUFFER);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+
+  glReadPixels(0, 0, kCanvasSize, kCanvasSize, GL_RGBA, GL_UNSIGNED_BYTE, 0);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+}
+
+TEST_F(ES3MapBufferRangeTest, TexImageAndSubImage2D) {
+  const GLsizei kTextureSize = 4;
+  GLuint buffer = 0;
+  glGenBuffers(1, &buffer);
+  EXPECT_LT(0u, buffer);
+  glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buffer);
+  glBufferData(GL_PIXEL_UNPACK_BUFFER, 4 * kTextureSize * kTextureSize, 0,
+               GL_STATIC_READ);
+
+  GLuint tex = 0;
+  glGenTextures(1, &tex);
+  EXPECT_LT(0u, tex);
+  glBindTexture(GL_TEXTURE_2D, tex);
+  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, kTextureSize, kTextureSize, 0,
+               GL_RGBA, GL_UNSIGNED_BYTE, 0);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+  glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, kTextureSize, kTextureSize, GL_RGBA,
+                  GL_UNSIGNED_BYTE, 0);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+
+  glMapBufferRange(GL_PIXEL_UNPACK_BUFFER, 0, 6, GL_MAP_READ_BIT);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+
+  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, kTextureSize, kTextureSize, 0,
+               GL_RGBA, GL_UNSIGNED_BYTE, 0);
+  EXPECT_EQ(static_cast<GLenum>(GL_INVALID_OPERATION), glGetError());
+  glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, kTextureSize, kTextureSize, GL_RGBA,
+                  GL_UNSIGNED_BYTE, 0);
+  EXPECT_EQ(static_cast<GLenum>(GL_INVALID_OPERATION), glGetError());
+
+  glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+
+  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, kTextureSize, kTextureSize, 0,
+               GL_RGBA, GL_UNSIGNED_BYTE, 0);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+  glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, kTextureSize, kTextureSize, GL_RGBA,
+                  GL_UNSIGNED_BYTE, 0);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+}
+
+TEST_F(ES3MapBufferRangeTest, TexImageAndSubImage3D) {
+  const GLsizei kTextureSize = 4;
+  GLuint buffer = 0;
+  glGenBuffers(1, &buffer);
+  EXPECT_LT(0u, buffer);
+  glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buffer);
+  glBufferData(GL_PIXEL_UNPACK_BUFFER,
+               4 * kTextureSize * kTextureSize * kTextureSize, 0,
+               GL_STATIC_READ);
+
+  GLuint tex = 0;
+  glGenTextures(1, &tex);
+  EXPECT_LT(0u, tex);
+  glBindTexture(GL_TEXTURE_3D, tex);
+  glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA8, kTextureSize, kTextureSize,
+               kTextureSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+  glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, kTextureSize, kTextureSize,
+                  kTextureSize, GL_RGBA, GL_UNSIGNED_BYTE, 0);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+
+  glMapBufferRange(GL_PIXEL_UNPACK_BUFFER, 0, 6, GL_MAP_READ_BIT);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+
+  glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA8, kTextureSize, kTextureSize,
+               kTextureSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
+  EXPECT_EQ(static_cast<GLenum>(GL_INVALID_OPERATION), glGetError());
+  glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, kTextureSize, kTextureSize,
+                  kTextureSize, GL_RGBA, GL_UNSIGNED_BYTE, 0);
+  EXPECT_EQ(static_cast<GLenum>(GL_INVALID_OPERATION), glGetError());
+
+  glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+
+  glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA8, kTextureSize, kTextureSize,
+               kTextureSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+  glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, kTextureSize, kTextureSize,
+                  kTextureSize, GL_RGBA, GL_UNSIGNED_BYTE, 0);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+}
+
+// TODO(zmo): Add tests for CompressedTex* functions.
+
+TEST_F(ES3MapBufferRangeTest, TransformFeedback) {
+  GLuint transform_feedback_buffer[2];
+  glGenBuffers(2, transform_feedback_buffer);
+  EXPECT_LT(0u, transform_feedback_buffer[0]);
+  EXPECT_LT(0u, transform_feedback_buffer[1]);
+  glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0,
+                   transform_feedback_buffer[0]);
+  glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 3 * 6 * sizeof(float), 0,
+               GL_STATIC_READ);
+  glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 1,
+                   transform_feedback_buffer[1]);
+  glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 2 * 6 * sizeof(float), 0,
+               GL_STATIC_READ);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+
+  GLint position_loc = 0;
+  SetupTransformFeedbackProgram(&position_loc);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+
+  GLuint buffer = GLTestHelper::SetupUnitQuad(position_loc);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+  EXPECT_LT(0u, buffer);
+
+  GLuint transform_feedback = 0;
+  glGenTransformFeedbacks(1, &transform_feedback);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+
+  glMapBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 6, GL_MAP_WRITE_BIT);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+
+  glBeginTransformFeedback(GL_TRIANGLES);
+  EXPECT_EQ(static_cast<GLenum>(GL_INVALID_OPERATION), glGetError());
+
+  glUnmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+
+  glBeginTransformFeedback(GL_TRIANGLES);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+
+  glMapBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 6, GL_MAP_WRITE_BIT);
+  EXPECT_EQ(static_cast<GLenum>(GL_INVALID_OPERATION), glGetError());
+
+  glDrawArrays(GL_TRIANGLES, 0, 6);
+  glEndTransformFeedback();
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+
+  glMapBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 6, GL_MAP_WRITE_BIT);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+
+  glUnmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER);
+  GLTestHelper::CheckGLError("no errors", __LINE__);
+}
+
+// TODO(zmo): add tests for uniform buffer mapping.
+

[vmiura, 2016/10/10 18:20:48]

These look good.  Could you also add a TODO for CopyBufferSubData?

[Zhenyao Mo, 2016/10/10 21:02:07]

Done.

+}  // namespace gpu