Remove flip_y, premultiply_alpha, unmultiply_alpha support in command buffer.

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 <limits>
 
@@ skipping 2215 matching lines @@
       GetExpectedResultMemory(sizeof(cmds::GetError::Result));
 
   EXPECT_CALL(*command_buffer(), OnFlush())
       .WillOnce(SetMemory(result1.ptr, GLuint(GL_NO_ERROR)))
       .RetiresOnSaturation();
   EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), gl_->GetError());
 }
 
 static bool CheckRect(
     int width, int height, GLenum format, GLenum type, int alignment,
-    bool flip_y, const uint8* r1, const uint8* r2) {
+    const uint8* r1, const uint8* r2) {
   uint32 size = 0;
   uint32 unpadded_row_size = 0;
   uint32 padded_row_size = 0;
   if (!GLES2Util::ComputeImageDataSizes(
       width, height, 1, format, type, alignment, &size, &unpadded_row_size,
       &padded_row_size)) {
     return false;
   }
 
-  int r2_stride = flip_y ?
-      -static_cast<int>(padded_row_size) :
-      static_cast<int>(padded_row_size);
-  r2 = flip_y ? (r2 + (height - 1) * padded_row_size) : r2;
+  int r2_stride = static_cast<int>(padded_row_size);
 
   for (int y = 0; y < height; ++y) {
     if (memcmp(r1, r2, unpadded_row_size) != 0) {
       return false;
     }
     r1 += padded_row_size;
     r2 += r2_stride;
   }
   return true;
 }
 
-ACTION_P8(CheckRectAction, width, height, format, type, alignment, flip_y,
-          r1, r2) {
+ACTION_P7(CheckRectAction, width, height, format, type, alignment, r1, r2) {
   EXPECT_TRUE(CheckRect(
-      width, height, format, type, alignment, flip_y, r1, r2));
+      width, height, format, type, alignment, r1, r2));
 }
 
-// Test TexImage2D with and without flip_y
 TEST_F(GLES2ImplementationTest, TexImage2D) {
   struct Cmds {
     cmds::TexImage2D tex_image_2d;
     cmd::SetToken set_token;
   };
   struct Cmds2 {
     cmds::TexImage2D tex_image_2d;
     cmd::SetToken set_token;
   };
   const GLenum kTarget = GL_TEXTURE_2D;
@@ skipping 16 matching lines @@
   Cmds expected;
   expected.tex_image_2d.Init(
       kTarget, kLevel, kFormat, kWidth, kHeight, kFormat, kType,
       mem1.id, mem1.offset);
   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,
+      kWidth, kHeight, kFormat, kType, kPixelStoreUnpackAlignment,
       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, kFormat, kType,
-      mem2.id, mem2.offset);
-  expected2.set_token.Init(GetNextToken());
-  const void* commands2 = GetPut();
-  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_F(GLES2ImplementationTest, TexImage2DViaMappedMem) {
   struct Cmds {
     cmds::TexImage2D tex_image_2d;
     cmd::SetToken set_token;
   };
   const GLenum kTarget = GL_TEXTURE_2D;
   const GLint kLevel = 0;
   const GLenum kFormat = GL_RGB;
@@ skipping 24 matching lines @@
   Cmds expected;
   expected.tex_image_2d.Init(
       kTarget, kLevel, kFormat, kWidth, kHeight, kFormat, kType,
       mem1.id, mem1.offset);
   expected.set_token.Init(GetNextToken());
   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, kFormat, kType, kPixelStoreUnpackAlignment, false,
+      kWidth, kHeight, kFormat, kType, kPixelStoreUnpackAlignment,
       pixels.get(), mem1.ptr));
 }
 
 // Test TexImage2D with 2 writes
 TEST_F(GLES2ImplementationTest, TexImage2DViaTexSubImage2D) {
   // Set limit to 1 to effectively disable mapped memory.
   SetMappedMemoryLimit(1);
 
   struct Cmds {
     cmds::TexImage2D tex_image_2d;
@@ skipping 52 matching lines @@
   //         kWidth, kHeight / 2, kFormat, kType, kPixelStoreUnpackAlignment,
   //         false, pixels.get(),
   //         GetExpectedTransferAddressFromOffsetAs<uint8>(offset1, half_size)))
   //     .RetiresOnSaturation();
 
   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,
+      kWidth, kHeight / 2, kFormat, kType, kPixelStoreUnpackAlignment,
       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, 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_->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 {
-    cmds::PixelStorei pixel_store_i1;
-    cmds::TexImage2D tex_image_2d;
-    cmds::PixelStorei pixel_store_i2;
-    cmds::TexSubImage2D tex_sub_image_2d1;
-    cmd::SetToken set_token1;
-    cmds::TexSubImage2D tex_sub_image_2d2;
-    cmd::SetToken set_token2;
-  };
-
-  uint32 sub_2_high_size = 0;
-  ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
-      kSubImageWidth, 2, 1, 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, 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);
-  gl_->PixelStorei(GL_UNPACK_FLIP_Y_CHROMIUM, GL_TRUE);
-  scoped_ptr<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);
-    }
-  }
-  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),
-      mem2.ptr));
 }
 
 TEST_F(GLES2ImplementationTest, SubImageUnpack) {
   static const GLint unpack_alignments[] = { 1, 2, 4, 8 };
 
   static const GLenum kFormat = GL_RGB;
   static const GLenum kType = GL_UNSIGNED_BYTE;
   static const GLint kLevel = 0;
   static const GLint kBorder = 0;
   // We're testing using the unpack params to pull a subimage out of a larger
   // source of pixels. Here we specify the subimage by its border rows /
   // columns.
   static const GLint kSrcWidth = 33;
   static const GLint kSrcSubImageX0 = 11;
   static const GLint kSrcSubImageX1 = 20;
   static const GLint kSrcSubImageY0 = 18;
   static const GLint kSrcSubImageY1 = 23;
   static const GLint kSrcSubImageWidth = kSrcSubImageX1 - kSrcSubImageX0;
   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 {
     cmds::PixelStorei pixel_store_i;
-    cmds::PixelStorei pixel_store_i2;
     cmds::TexImage2D tex_image_2d;
   } texImageExpected;
 
   struct  {
     cmds::PixelStorei pixel_store_i;
-    cmds::PixelStorei pixel_store_i2;
     cmds::TexImage2D tex_image_2d;
     cmds::TexSubImage2D tex_sub_image_2d;
   } texSubImageExpected;
 
   uint32 src_size;
   ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
       kSrcWidth, kSrcSubImageY1, 1, kFormat, kType, 8, &src_size, NULL, NULL));
   scoped_ptr<uint8[]> src_pixels;
   src_pixels.reset(new uint8[src_size]);
   for (size_t i = 0; i < src_size; ++i) {
     src_pixels[i] = static_cast<int8>(i);
   }
 
   for (int sub = 0; sub < 2; ++sub) {
-    for (int flip_y = 0; flip_y < 2; ++flip_y) {
-      for (size_t a = 0; a < arraysize(unpack_alignments); ++a) {
-        GLint alignment = unpack_alignments[a];
-        uint32 size;
-        uint32 unpadded_row_size;
-        uint32 padded_row_size;
-        ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
-            kSrcSubImageWidth, kSrcSubImageHeight, 1, kFormat, kType, alignment,
-            &size, &unpadded_row_size, &padded_row_size));
-        ASSERT_TRUE(size <= MaxTransferBufferSize());
-        ExpectedMemoryInfo mem = GetExpectedMemory(size);
+    for (size_t a = 0; a < arraysize(unpack_alignments); ++a) {
+      GLint alignment = unpack_alignments[a];
+      uint32 size;
+      uint32 unpadded_row_size;
+      uint32 padded_row_size;
+      ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
+          kSrcSubImageWidth, kSrcSubImageHeight, 1, kFormat, kType, alignment,
+          &size, &unpadded_row_size, &padded_row_size));
+      ASSERT_TRUE(size <= MaxTransferBufferSize());
+      ExpectedMemoryInfo mem = GetExpectedMemory(size);
 
-        const void* commands = GetPut();
-        gl_->PixelStorei(GL_UNPACK_ALIGNMENT, alignment);
-        gl_->PixelStorei(GL_UNPACK_ROW_LENGTH_EXT, kSrcWidth);
-        gl_->PixelStorei(GL_UNPACK_SKIP_PIXELS_EXT, kSrcSubImageX0);
-        gl_->PixelStorei(GL_UNPACK_SKIP_ROWS_EXT, kSrcSubImageY0);
-        gl_->PixelStorei(GL_UNPACK_FLIP_Y_CHROMIUM, flip_y);
-        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,
-              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, 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(
-            kFormat, kType);
-        for (int y = 0; y < kSrcSubImageHeight; ++y) {
-          GLint src_sub_y = flip_y ? kSrcSubImageHeight - y - 1 : y;
-          const uint8* src_row = src_pixels.get() +
-              (kSrcSubImageY0 + src_sub_y) * src_padded_row_size +
-              bytes_per_group * kSrcSubImageX0;
-          const uint8* dst_row = mem.ptr + y * padded_row_size;
-          EXPECT_EQ(0, memcmp(src_row, dst_row, unpadded_row_size));
-        }
-        ClearCommands();
+      const void* commands = GetPut();
+      gl_->PixelStorei(GL_UNPACK_ALIGNMENT, alignment);
+      gl_->PixelStorei(GL_UNPACK_ROW_LENGTH_EXT, kSrcWidth);
+      gl_->PixelStorei(GL_UNPACK_SKIP_PIXELS_EXT, kSrcSubImageX0);
+      gl_->PixelStorei(GL_UNPACK_SKIP_ROWS_EXT, kSrcSubImageY0);
+      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.tex_image_2d.Init(
+            GL_TEXTURE_2D, kLevel, kFormat, kTexWidth, kTexHeight,
+            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.tex_image_2d.Init(
+            GL_TEXTURE_2D, kLevel, kFormat, kSrcSubImageWidth,
+            kSrcSubImageHeight, 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(
+          kFormat, kType);
+      for (int y = 0; y < kSrcSubImageHeight; ++y) {
+        const uint8* src_row = src_pixels.get() +
+            (kSrcSubImageY0 + y) * src_padded_row_size +
+            bytes_per_group * kSrcSubImageX0;
+        const uint8* dst_row = mem.ptr + y * padded_row_size;
+        EXPECT_EQ(0, memcmp(src_row, dst_row, unpadded_row_size));
+      }
+      ClearCommands();
     }
   }
 }
 
 // Test texture related calls with invalid arguments.
 TEST_F(GLES2ImplementationTest, TextureInvalidArguments) {
   struct Cmds {
     cmds::TexImage2D tex_image_2d;
     cmd::SetToken set_token;
   };
@@ skipping 20 matching lines @@
   Cmds expected;
   expected.tex_image_2d.Init(
       kTarget, kLevel, kFormat, kWidth, kHeight, kFormat, kType,
       mem1.id, mem1.offset);
   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,
+      kWidth, kHeight, kFormat, kType, kPixelStoreUnpackAlignment,
       pixels, mem1.ptr));
 
   ClearCommands();
 
   // Use invalid border.
   gl_->TexImage2D(
       kTarget, kLevel, kFormat, kWidth, kHeight, kInvalidBorder, kFormat, kType,
       pixels);
 
   EXPECT_TRUE(NoCommandsWritten());
@@ skipping 73 matching lines @@
       kTarget, kLevel, kFormat, kWidth, kHeight, kDepth,
       kFormat, kType, mem.id, mem.offset);
 
   gl_->TexImage3D(
       kTarget, kLevel, kFormat, kWidth, kHeight, kDepth, kBorder,
       kFormat, kType, pixels.get());
 
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
   EXPECT_TRUE(CheckRect(
       kWidth, kHeight * kDepth, kFormat, kType, kPixelStoreUnpackAlignment,
-      false, reinterpret_cast<uint8*>(pixels.get()), mem.ptr));
+      reinterpret_cast<uint8*>(pixels.get()), mem.ptr));
 }
 
 TEST_F(GLES2ImplementationTest, TexImage3DViaMappedMem) {
   struct Cmds {
     cmds::TexImage3D tex_image_3d;
   };
   const GLenum kTarget = GL_TEXTURE_3D;
   const GLint kLevel = 0;
   const GLint kBorder = 0;
   const GLenum kFormat = GL_RGB;
@@ skipping 27 matching lines @@
       kTarget, kLevel, kFormat, kWidth, kHeight, kDepth,
       kFormat, kType, mem.id, mem.offset);
 
   gl_->TexImage3D(
       kTarget, kLevel, kFormat, kWidth, kHeight, kDepth, kBorder,
       kFormat, kType, pixels.get());
 
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
   EXPECT_TRUE(CheckRect(
       kWidth, kHeight * kDepth, kFormat, kType, kPixelStoreUnpackAlignment,
-      false, reinterpret_cast<uint8*>(pixels.get()), mem.ptr));
+      reinterpret_cast<uint8*>(pixels.get()), mem.ptr));
 }
 
 TEST_F(GLES2ImplementationTest, TexImage3DViaTexSubImage3D) {
   // Set limit to 1 to effectively disable mapped memory.
   SetMappedMemoryLimit(1);
 
   struct Cmds {
     cmds::TexImage3D tex_image_3d;
     cmds::TexSubImage3D tex_sub_image_3d1;
     cmd::SetToken set_token;
@@ skipping 113 matching lines @@
   expected.set_token2.Init(GetNextToken());
   expected.set_token3.Init(GetNextToken());
 
   gl_->TexSubImage3D(
       kTarget, kLevel, kXOffset, kYOffset, kZOffset, kWidth, kHeight, kDepth,
       kFormat, kType, pixels.get());
 
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
   uint32 offset_to_last = first_size + second_size + third_size;
   EXPECT_TRUE(CheckRect(
-      kWidth, 2, kFormat, kType, kPixelStoreUnpackAlignment, false,
+      kWidth, 2, kFormat, kType, kPixelStoreUnpackAlignment,
       reinterpret_cast<uint8*>(pixels.get()) + offset_to_last, mem2_2.ptr));
 }
 
 // glGen* Ids must not be reused until glDelete* commands have been
 // flushed by glFlush.
 TEST_F(GLES2ImplementationStrictSharedTest, FlushGenerationTestBuffers) {
   FlushGenerationTest<GenBuffersAPI>();
 }
 TEST_F(GLES2ImplementationStrictSharedTest, FlushGenerationTestFramebuffers) {
   FlushGenerationTest<GenFramebuffersAPI>();
@@ skipping 38 matching lines @@
   CrossContextGenerationAutoFlushTest<GenRenderbuffersAPI>();
 }
 TEST_F(GLES2ImplementationStrictSharedTest,
        CrossContextGenerationAutoFlushTestTextures) {
   CrossContextGenerationAutoFlushTest<GenTexturesAPI>();
 }
 
 TEST_F(GLES2ImplementationTest, GetString) {
   const uint32 kBucketId = GLES2Implementation::kResultBucketId;
   const Str7 kString = {"foobar"};
-  // GL_CHROMIUM_map_sub GL_CHROMIUM_flipy are hard coded into
-  // GLES2Implementation.
+  // GL_CHROMIUM_map_sub is hard coded into GLES2Implementation.
   const char* expected_str =
       "foobar "
-      "GL_CHROMIUM_flipy "
       "GL_EXT_unpack_subimage "
       "GL_CHROMIUM_map_sub";
   const char kBad = 0x12;
   struct Cmds {
     cmd::SetBucketSize set_bucket_size1;
     cmds::GetString get_string;
     cmd::GetBucketStart get_bucket_start;
     cmd::SetToken set_token1;
     cmd::SetBucketSize set_bucket_size2;
   };
@@ skipping 886 matching lines @@
 TEST_F(GLES2ImplementationManualInitTest, FailInitOnTransferBufferFail) {
   ContextInitOptions init_options;
   init_options.transfer_buffer_initialize_fail = true;
   EXPECT_FALSE(Initialize(init_options));
 }
 
 #include "gpu/command_buffer/client/gles2_implementation_unittest_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu