Add command buffer support for GL_RGB CHROMIUM image emulation.

gpu/command_buffer/service/gles2_cmd_decoder_unittest_textures.cc

 // Copyright 2014 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 "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/command_line.h"
@@ skipping 31 matching lines @@
 using ::testing::Mock;
 using ::testing::Pointee;
 using ::testing::Return;
 using ::testing::SaveArg;
 using ::testing::SetArrayArgument;
 using ::testing::SetArgumentPointee;
 using ::testing::SetArgPointee;
 using ::testing::StrEq;
 using ::testing::StrictMock;
 
+namespace {
+class EmulatingRGBImageStub : public gl::GLImageStub {
+ protected:
+  ~EmulatingRGBImageStub() override {}
+  bool EmulatingRGB() const override {
+    return true;
+  }
+};
+}  // namespace
+
 namespace gpu {
 namespace gles2 {
 
 using namespace cmds;
 
 TEST_P(GLES2DecoderTest, GenerateMipmapWrongFormatsFails) {
   EXPECT_CALL(*gl_, GenerateMipmapEXT(_)).Times(0);
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(
       GL_TEXTURE_2D, 0, GL_RGBA, 16, 17, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
@@ skipping 3607 matching lines @@
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, BindTexture(kTarget, _))
       .Times(1)
       .RetiresOnSaturation();
 
   EXPECT_TRUE(decoder_->ClearLevel3D(
       texture, kTarget, kLevel, kFormat, kType, kWidth, kHeight, kDepth));
 }
 
+// Test that copyTexImage2D uses the emulated internal format, rather than the
+// real internal format.
+TEST_P(GLES2DecoderWithShaderTest, CHROMIUMImageEmulatingRGB) {
+  const GLuint kFBOClientTextureId = 4100;
+  const GLuint kFBOServiceTextureId = 4101;
+  GLenum target = GL_TEXTURE_2D;
+  GLint level = 0;
+  GLsizei width = 1;
+  GLsizei height = 1;
+
+  // Generate the source framebuffer.
+  EXPECT_CALL(*gl_, GenTextures(_, _))
+      .WillOnce(SetArgPointee<1>(kFBOServiceTextureId))
+      .RetiresOnSaturation();
+  GenHelper<GenTexturesImmediate>(kFBOClientTextureId);
+  DoBindFramebuffer(GL_FRAMEBUFFER, client_framebuffer_id_,
+                    kServiceFramebufferId);
+
+  GLenum destination_texture_formats[] = {GL_RGBA, GL_RGB};
+  for (int use_rgb_emulation = 0; use_rgb_emulation < 2; ++ use_rgb_emulation) {
+    for (size_t destination_texture_index = 0; destination_texture_index < 2;
+         ++destination_texture_index) {
+      // Generate and bind the source image. Making a new image for each set of
+      // parameters is easier than trying to reuse images. Obviously there's no
+      // performance penalty.
+      int image_id = use_rgb_emulation * 2 + destination_texture_index;
+      scoped_refptr<gl::GLImage> image;
+      if (use_rgb_emulation)
+        image = new EmulatingRGBImageStub;
+      else
+        image = new gl::GLImageStub;
+      GetImageManager()->AddImage(image.get(), image_id);
+      EXPECT_FALSE(GetImageManager()->LookupImage(image_id) == NULL);
+      DoBindTexture(GL_TEXTURE_2D, kFBOClientTextureId, kFBOServiceTextureId);
+
+      DoBindTexImage2DCHROMIUM(GL_TEXTURE_2D, image_id);
+      DoFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, target,
+                             kFBOClientTextureId, kFBOServiceTextureId, level,
+                             GL_NO_ERROR);
+
+      GLenum destination_texture_format =
+          destination_texture_formats[destination_texture_index];
+      bool should_succeed =
+          !use_rgb_emulation || (destination_texture_format == GL_RGB);
+      if (should_succeed) {
+        EXPECT_CALL(*gl_, GetError())
+            .WillOnce(Return(GL_NO_ERROR))
+            .RetiresOnSaturation();
+        EXPECT_CALL(*gl_,
+                    CopyTexImage2D(GL_TEXTURE_2D, 0, destination_texture_format,
+                                   0, 0, 1, 1, 0))
+            .Times(1)
+            .RetiresOnSaturation();
+        EXPECT_CALL(*gl_, GetError())
+            .WillOnce(Return(GL_NO_ERROR))
+            .RetiresOnSaturation();
+      }
+
+      if (destination_texture_index == 0 || !framebuffer_completeness_cache()) {
+        EXPECT_CALL(*gl_, CheckFramebufferStatusEXT(GL_FRAMEBUFFER))
+            .WillOnce(Return(GL_FRAMEBUFFER_COMPLETE))
+            .RetiresOnSaturation();
+      }
+
+      DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
+      CopyTexImage2D cmd;
+      cmd.Init(target, level, destination_texture_format, 0, 0, width, height);
+      EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+      GLenum expectation = should_succeed ? GL_NO_ERROR : GL_INVALID_OPERATION;
+      EXPECT_EQ(expectation, static_cast<GLenum>(GetGLError()));
+    }
+  }
+}
+
 // TODO(gman): Complete this test.
 // TEST_P(GLES2DecoderTest, CompressedTexImage2DGLError) {
 // }
 
 // TODO(gman): CompressedTexImage2D
 
 // TODO(gman): CompressedTexImage2DImmediate
 
 // TODO(gman): CompressedTexSubImage2DImmediate
 
 // TODO(gman): TexImage2D
 
 // TODO(gman): TexImage2DImmediate
 
 // TODO(gman): TexSubImage2DImmediate
 
 }  // namespace gles2
 }  // namespace gpu