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;

[Jeff Timanus, 2012/04/17 01:27:34]

I had to boost the size because GLES2ImplementationTest. SubImageUnpack was
causing an overflow of the command buffer.  An unexpected flush in the command
stream causes the test to fail expectations match.

This is because assigning the pixel-store flip parameter is now sending a
command.

[greggman, 2012/04/17 04:58:06]

As long as the rest of the tests pass this is fine.

   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