Allow GL_TEXTURE_RECTANGLE_ARB to be the destination target for copyTextureCHROMIUM.

gpu/command_buffer/tests/gl_copy_texture_CHROMIUM_unittest.cc

 // Copyright (c) 2012 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.
 
 #ifndef GL_GLEXT_PROTOTYPES
 #define GL_GLEXT_PROTOTYPES
 #endif
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
@@ skipping 14 matching lines @@
     TexImage,
     TexSubImage,
 };
 }
 
 // A collection of tests that exercise the GL_CHROMIUM_copy_texture extension.
 class GLCopyTextureCHROMIUMTest
     : public testing::Test,
       public ::testing::WithParamInterface<CopyType> {
  protected:
+
+  void CreateAndBindDestinationTextureAndFBO(GLenum target) {
+    glGenTextures(2, textures_);
+    glBindTexture(target, textures_[1]);
+
+    // Some drivers (NVidia/SGX) require texture settings to be a certain way or
+    // they won't report FRAMEBUFFER_COMPLETE.
+    glTexParameterf(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameterf(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+
+    glGenFramebuffers(1, &framebuffer_id_);
+    glBindFramebuffer(GL_FRAMEBUFFER, framebuffer_id_);
+    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, target,
+                           textures_[1], 0);
+  }
+
   void SetUp() override {
     gl_.Initialize(GLManager::Options());
 
-    glGenTextures(2, textures_);
-    glBindTexture(GL_TEXTURE_2D, textures_[1]);
-
-    // Some drivers (NVidia/SGX) require texture settings to be a certain way or
-    // they won't report FRAMEBUFFER_COMPLETE.
-    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-
-    glGenFramebuffers(1, &framebuffer_id_);
-    glBindFramebuffer(GL_FRAMEBUFFER, framebuffer_id_);
-    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
-                           textures_[1], 0);
+    CreateAndBindDestinationTextureAndFBO(GL_TEXTURE_2D);
   }
 
   void TearDown() override {
     glDeleteTextures(2, textures_);
     glDeleteFramebuffers(1, &framebuffer_id_);
     gl_.Destroy();
   }
 
   GLManager gl_;
   GLuint textures_[2];
@@ skipping 81 matching lines @@
 
     GLTestHelper::CheckPixels(0, 0, 1, 1, 0, pixels);
     EXPECT_TRUE(GL_NO_ERROR == glGetError());
   }
 }
 
 TEST_P(GLCopyTextureCHROMIUMTest, InternalFormat) {
   CopyType copy_type = GetParam();
   GLint src_formats[] = {GL_ALPHA,     GL_RGB,             GL_RGBA,
                          GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_BGRA_EXT};
-  GLint dest_formats[] = {GL_RGB, GL_RGBA};
+  GLint dest_formats[] = {GL_RGB, GL_RGBA, GL_BGRA_EXT};
 
   for (size_t src_index = 0; src_index < arraysize(src_formats); src_index++) {
     for (size_t dest_index = 0; dest_index < arraysize(dest_formats);
          dest_index++) {
       glBindTexture(GL_TEXTURE_2D, textures_[0]);
       glTexImage2D(GL_TEXTURE_2D, 0, src_formats[src_index], 1, 1, 0,
                    src_formats[src_index], GL_UNSIGNED_BYTE, nullptr);
       EXPECT_TRUE(GL_NO_ERROR == glGetError());
 
       if (copy_type == TexImage) {
@@ skipping 570 matching lines @@
   uint8_t red[1 * 4] = {255u, 0u, 0u, 255u};
   uint8_t green[1 * 4] = {0u, 255u, 0u, 255u};
   uint8_t blue[1 * 4] = {0u, 0u, 255u, 255u};
   GLTestHelper::CheckPixels(0, 0, 1, 1, 0, transparent);
   GLTestHelper::CheckPixels(1, 1, 1, 1, 0, red);
   GLTestHelper::CheckPixels(1, 0, 1, 1, 0, green);
   GLTestHelper::CheckPixels(0, 1, 1, 1, 0, blue);
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 }
 
+TEST_F(GLCopyTextureCHROMIUMTest, CopyTextureBetweenTexture2DAndRectangleArb) {
+  if (!GLTestHelper::HasExtension("GL_ARB_texture_rectangle")) {
+    LOG(INFO) <<
+        "GL_ARB_texture_rectangle not supported. Skipping test...";
+    return;
+  }
+
+  GLenum src_targets[] = {GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_2D};
+  GLenum dest_targets[] = {GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_2D};
+  GLsizei width = 30;
+  GLsizei height = 14;
+  GLsizei dest_width = 15;
+  GLsizei dest_height = 13;
+  GLsizei copy_region_x = 1;
+  GLsizei copy_region_y = 1;
+  GLsizei copy_region_width = 5;
+  GLsizei copy_region_height = 3;
+  uint8_t red[1 * 4] = {255u, 0u, 0u, 255u};
+  uint8_t blue[1 * 4] = {0u, 0u, 255u, 255u};
+  uint8_t green[1 * 4] = {0u, 255u, 0, 255u};
+  uint8_t white[1 * 4] = {255u, 255u, 255u, 255u};
+  uint8_t grey[1 * 4] = {199u, 199u, 199u, 255u};
+
+  for (size_t src_index = 0; src_index < arraysize(src_targets); src_index++) {
+    GLenum src_target = src_targets[src_index];
+    for (size_t dest_index = 0; dest_index < arraysize(dest_targets);
+         dest_index++) {
+      GLenum dest_target = dest_targets[dest_index];
+
+      glDeleteTextures(2, textures_);
+      glDeleteFramebuffers(1, &framebuffer_id_);
+      CreateAndBindDestinationTextureAndFBO(dest_target);
+
+      // Allocate source and destination textures.
+      glBindTexture(src_target, textures_[0]);
+      glTexImage2D(src_target, 0, GL_RGBA, width, height, 0, GL_RGBA,
+                   GL_UNSIGNED_BYTE, nullptr);
+      glBindTexture(dest_target, textures_[1]);
+      glTexImage2D(dest_target, 0, GL_RGBA, dest_width, dest_height, 0, GL_RGBA,
+                   GL_UNSIGNED_BYTE, nullptr);
+
+      // The bottom left is red, bottom right is blue, top left is green, top
+      // right is white.
+      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, src_target,
+                             textures_[0], 0);
+      glBindTexture(src_target, textures_[0]);
+      for (GLint x = 0; x < width; ++x) {
+        for (GLint y = 0; y < height; ++y) {
+          uint8_t* data;
+          if (x < width / 2) {
+            data = y < height / 2 ? red : green;
+          } else {
+            data = y < height / 2 ? blue : white;
+          }
+          glTexSubImage2D(src_target, 0, x, y, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE,
+                          data);
+        }
+      }
+
+      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, dest_target,
+                             textures_[1], 0);
+      glBindTexture(dest_target, textures_[1]);
+
+      // Copy the subtexture x=[13,18) y=[6,9) to the destination.
+      glClearColor(grey[0] / 255.f, grey[1] / 255.f, grey[2] / 255.f, 1.0);
+      glClear(GL_COLOR_BUFFER_BIT);
+      glCopySubTextureCHROMIUM(textures_[0], textures_[1], copy_region_x,
+                               copy_region_y, 13, 6, copy_region_width,
+                               copy_region_height, false, false, false);
+      EXPECT_TRUE(GL_NO_ERROR == glGetError());
+
+      for (GLint x = 0; x < dest_width; ++x) {
+        for (GLint y = 0; y < dest_height; ++y) {
+          if (x < copy_region_x || x >= copy_region_x + copy_region_width ||
+              y < copy_region_y || y >= copy_region_y + copy_region_height) {
+            GLTestHelper::CheckPixels(x, y, 1, 1, 0, grey);
+            continue;
+          }
+
+          uint8_t* expected_color;
+          if (x < copy_region_x + 2) {
+            expected_color = y < copy_region_y + 1 ? red : green;
+          } else {
+            expected_color = y < copy_region_y + 1 ? blue : white;
+          }
+          GLTestHelper::CheckPixels(x, y, 1, 1, 0, expected_color);
+        }
+      }
+    }
+  }
+}
+
 }  // namespace gpu