Addition of GL_CHROMIUM_copy_texture extension.

gpu/command_buffer/client/gles2_implementation_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.
 
 // Tests for GLES2Implementation.
 
 #include "gpu/command_buffer/client/gles2_implementation.h"
 
 #include <GLES2/gl2ext.h>
 #include "gpu/command_buffer/client/client_test_helper.h"
@@ skipping 278 matching lines @@
 }
 
 void MockTransferBuffer::FreePendingToken(void* p, unsigned int /* token */) {
   EXPECT_EQ(last_alloc_, p);
   last_alloc_ = NULL;
 }
 
 class GLES2ImplementationTest : public testing::Test {
  protected:
   static const uint8 kInitialValue = 0xBD;
-  static const int32 kNumCommandEntries = 400;
+  static const int32 kNumCommandEntries = 500;
   static const int32 kCommandBufferSizeBytes =
       kNumCommandEntries * sizeof(CommandBufferEntry);
   static const size_t kTransferBufferSize = 256;
 
   static const GLint kMaxCombinedTextureImageUnits = 8;
   static const GLint kMaxCubeMapTextureSize = 64;
   static const GLint kMaxFragmentUniformVectors = 16;
   static const GLint kMaxRenderbufferSize = 64;
   static const GLint kMaxTextureImageUnits = 8;
   static const GLint kMaxTextureSize = 128;
@@ skipping 1593 matching lines @@
   expected.set_token.Init(GetNextToken());
   gl_->TexImage2D(
       kTarget, kLevel, kFormat, kWidth, kHeight, kBorder, kFormat, kType,
       pixels);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
   EXPECT_TRUE(CheckRect(
       kWidth, kHeight, kFormat, kType, kPixelStoreUnpackAlignment, false,
       pixels, mem1.ptr));
 
   ClearCommands();
+  gl_->PixelStorei(GL_UNPACK_FLIP_Y_CHROMIUM, GL_TRUE);
+
   ExpectedMemoryInfo mem2 = GetExpectedMemory(sizeof(pixels));
   Cmds2 expected2;
   expected2.tex_image_2d.Init(
       kTarget, kLevel, kFormat, kWidth, kHeight, kBorder, kFormat, kType,
       mem2.id, mem2.offset);
   expected2.set_token.Init(GetNextToken());
   const void* commands2 = GetPut();
-  gl_->PixelStorei(GL_UNPACK_FLIP_Y_CHROMIUM, GL_TRUE);
   gl_->TexImage2D(
       kTarget, kLevel, kFormat, kWidth, kHeight, kBorder, kFormat, kType,
       pixels);
   EXPECT_EQ(0, memcmp(&expected2, commands2, sizeof(expected2)));
   EXPECT_TRUE(CheckRect(
       kWidth, kHeight, kFormat, kType, kPixelStoreUnpackAlignment, true,
       pixels, mem2.ptr));
 }
 
 // Test TexImage2D with 2 writes
@@ skipping 59 matching lines @@
 
   gl_->TexImage2D(
       kTarget, kLevel, kFormat, kWidth, kHeight, kBorder, kFormat, kType,
       pixels.get());
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
   EXPECT_TRUE(CheckRect(
       kWidth, kHeight / 2, kFormat, kType, kPixelStoreUnpackAlignment, false,
       pixels.get() + kHeight / 2 * padded_row_size, mem2.ptr));
 
   ClearCommands();
+  gl_->PixelStorei(GL_UNPACK_FLIP_Y_CHROMIUM, GL_TRUE);
   const void* commands2 = GetPut();
   ExpectedMemoryInfo mem3 = GetExpectedMemory(half_size);
   ExpectedMemoryInfo mem4 = GetExpectedMemory(half_size);
   expected.tex_image_2d.Init(
       kTarget, kLevel, kFormat, kWidth, kHeight, kBorder, kFormat, kType,
       0, 0);
   expected.tex_sub_image_2d1.Init(
       kTarget, kLevel, 0, kHeight / 2, kWidth, kHeight / 2, kFormat, kType,
       mem3.id, mem3.offset, true);
   expected.set_token1.Init(GetNextToken());
   expected.tex_sub_image_2d2.Init(
       kTarget, kLevel, 0, 0, kWidth, kHeight / 2, kFormat, kType,
       mem4.id, mem4.offset, true);
   expected.set_token2.Init(GetNextToken());
 
   // TODO(gman): Make it possible to run this test
   // EXPECT_CALL(*command_buffer(), OnFlush())
   //     .WillOnce(CheckRectAction(
   //         kWidth, kHeight / 2, kFormat, kType, kPixelStoreUnpackAlignment,
   //         true, pixels.get(),
   //         GetExpectedTransferAddressFromOffsetAs<uint8>(offset3, half_size)))
   //     .RetiresOnSaturation();
 
-  gl_->PixelStorei(GL_UNPACK_FLIP_Y_CHROMIUM, GL_TRUE);
   gl_->TexImage2D(
       kTarget, kLevel, kFormat, kWidth, kHeight, kBorder, kFormat, kType,
       pixels.get());
   EXPECT_EQ(0, memcmp(&expected, commands2, sizeof(expected)));
   EXPECT_TRUE(CheckRect(
       kWidth, kHeight / 2, kFormat, kType, kPixelStoreUnpackAlignment, true,
       pixels.get() + kHeight / 2 * padded_row_size, mem4.ptr));
 }
 
 // Test TexSubImage2D with GL_PACK_FLIP_Y set and partial multirow transfers
 TEST_F(GLES2ImplementationTest, TexSubImage2DFlipY) {
   const GLsizei kTextureWidth = MaxTransferBufferSize() / 4;
   const GLsizei kTextureHeight = 7;
   const GLsizei kSubImageWidth = MaxTransferBufferSize() / 8;
   const GLsizei kSubImageHeight = 4;
   const GLint kSubImageXOffset = 1;
   const GLint kSubImageYOffset = 2;
   const GLenum kFormat = GL_RGBA;
   const GLenum kType = GL_UNSIGNED_BYTE;
   const GLenum kTarget = GL_TEXTURE_2D;
   const GLint kLevel = 0;
   const GLint kBorder = 0;
   const GLint kPixelStoreUnpackAlignment = 4;
 
   struct Cmds {
     PixelStorei pixel_store_i1;
     TexImage2D tex_image_2d;
+    PixelStorei pixel_store_i2;
     TexSubImage2D tex_sub_image_2d1;
     cmd::SetToken set_token1;
     TexSubImage2D tex_sub_image_2d2;
     cmd::SetToken set_token2;
   };
 
   uint32 sub_2_high_size = 0;
   ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
       kSubImageWidth, 2, kFormat, kType, kPixelStoreUnpackAlignment,
       &sub_2_high_size, NULL, NULL));
 
   ExpectedMemoryInfo mem1 = GetExpectedMemory(sub_2_high_size);
   ExpectedMemoryInfo mem2 = GetExpectedMemory(sub_2_high_size);
 
   Cmds expected;
   expected.pixel_store_i1.Init(GL_UNPACK_ALIGNMENT, kPixelStoreUnpackAlignment);
   expected.tex_image_2d.Init(
       kTarget, kLevel, kFormat, kTextureWidth, kTextureHeight, kBorder, kFormat,
       kType, 0, 0);
+  expected.pixel_store_i2.Init(GL_UNPACK_FLIP_Y_CHROMIUM, GL_TRUE);
   expected.tex_sub_image_2d1.Init(kTarget, kLevel, kSubImageXOffset,
       kSubImageYOffset + 2, kSubImageWidth, 2, kFormat, kType,
       mem1.id, mem1.offset, false);
   expected.set_token1.Init(GetNextToken());
   expected.tex_sub_image_2d2.Init(kTarget, kLevel, kSubImageXOffset,
       kSubImageYOffset, kSubImageWidth , 2, kFormat, kType,
       mem2.id, mem2.offset, false);
   expected.set_token2.Init(GetNextToken());
 
   gl_->PixelStorei(GL_UNPACK_ALIGNMENT, kPixelStoreUnpackAlignment);
   gl_->TexImage2D(
       kTarget, kLevel, kFormat, kTextureWidth, kTextureHeight, kBorder, kFormat,
       kType, NULL);
-  // this call should not emit commands (handled client-side)
   gl_->PixelStorei(GL_UNPACK_FLIP_Y_CHROMIUM, GL_TRUE);
   scoped_array<uint32> pixels(new uint32[kSubImageWidth * kSubImageHeight]);
   for (int y = 0; y < kSubImageHeight; ++y) {
     for (int x = 0; x < kSubImageWidth; ++x) {
-        pixels.get()[kSubImageWidth * y + x] = x | (y << 16);
+      pixels.get()[kSubImageWidth * y + x] = x | (y << 16);
     }
   }
   gl_->TexSubImage2D(
       GL_TEXTURE_2D, 0, kSubImageXOffset, kSubImageYOffset, kSubImageWidth,
       kSubImageHeight, GL_RGBA, GL_UNSIGNED_BYTE, pixels.get());
 
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
   EXPECT_TRUE(CheckRect(
       kSubImageWidth, 2, kFormat, kType, kPixelStoreUnpackAlignment, true,
       reinterpret_cast<uint8*>(pixels.get() + 2 * kSubImageWidth),
@@ skipping 19 matching lines @@
   static const GLint kSrcSubImageHeight = kSrcSubImageY1 - kSrcSubImageY0;
 
   // these are only used in the texsubimage tests
   static const GLint kTexWidth = 1023;
   static const GLint kTexHeight = 511;
   static const GLint kTexSubXOffset = 419;
   static const GLint kTexSubYOffset = 103;
 
   struct {
     PixelStorei pixel_store_i;
+    PixelStorei pixel_store_i2;
     TexImage2D tex_image_2d;
   } texImageExpected;
 
   struct  {
     PixelStorei pixel_store_i;
+    PixelStorei pixel_store_i2;
     TexImage2D tex_image_2d;
     TexSubImage2D tex_sub_image_2d;
   } texSubImageExpected;
 
   uint32 src_size;
   ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
       kSrcWidth, kSrcSubImageY1, kFormat, kType, 8, &src_size, NULL, NULL));
   scoped_array<uint8> src_pixels;
   src_pixels.reset(new uint8[src_size]);
   for (size_t i = 0; i < src_size; ++i) {
@@ skipping 22 matching lines @@
         if (sub) {
           gl_->TexImage2D(
               GL_TEXTURE_2D, kLevel, kFormat, kTexWidth, kTexHeight, kBorder,
               kFormat, kType, NULL);
           gl_->TexSubImage2D(
               GL_TEXTURE_2D, kLevel, kTexSubXOffset, kTexSubYOffset,
               kSrcSubImageWidth, kSrcSubImageHeight, kFormat, kType,
               src_pixels.get());
           texSubImageExpected.pixel_store_i.Init(
               GL_UNPACK_ALIGNMENT, alignment);
+          texSubImageExpected.pixel_store_i2.Init(
+              GL_UNPACK_FLIP_Y_CHROMIUM, flip_y);
           texSubImageExpected.tex_image_2d.Init(
               GL_TEXTURE_2D, kLevel, kFormat, kTexWidth, kTexHeight, kBorder,
               kFormat, kType, 0, 0);
           texSubImageExpected.tex_sub_image_2d.Init(
               GL_TEXTURE_2D, kLevel, kTexSubXOffset, kTexSubYOffset,
               kSrcSubImageWidth, kSrcSubImageHeight, kFormat, kType, mem.id,
               mem.offset, GL_FALSE);
           EXPECT_EQ(0, memcmp(
               &texSubImageExpected, commands, sizeof(texSubImageExpected)));
         } else {
           gl_->TexImage2D(
               GL_TEXTURE_2D, kLevel, kFormat,
               kSrcSubImageWidth, kSrcSubImageHeight, kBorder, kFormat, kType,
               src_pixels.get());
           texImageExpected.pixel_store_i.Init(GL_UNPACK_ALIGNMENT, alignment);
+          texImageExpected.pixel_store_i2.Init(
+              GL_UNPACK_FLIP_Y_CHROMIUM, flip_y);
           texImageExpected.tex_image_2d.Init(
               GL_TEXTURE_2D, kLevel, kFormat, kSrcSubImageWidth,
               kSrcSubImageHeight, kBorder, kFormat, kType, mem.id, mem.offset);
           EXPECT_EQ(0, memcmp(
               &texImageExpected, commands, sizeof(texImageExpected)));
         }
         uint32 src_padded_row_size;
         ASSERT_TRUE(GLES2Util::ComputeImagePaddedRowSize(
             kSrcWidth, kFormat, kType, alignment, &src_padded_row_size));
         uint32 bytes_per_group = GLES2Util::ComputeImageGroupSize(
@@ skipping 304 matching lines @@
   EXPECT_TRUE(NoCommandsWritten());
   EXPECT_EQ(0u, available);
 }
 
 #include "gpu/command_buffer/client/gles2_implementation_unittest_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu