Enforce RGB even on buggy drivers.

gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.cc

 // Copyright (c) 2011 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_unittest_base.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/string_number_conversions.h"
@@ skipping 30 matching lines @@
       client_renderbuffer_id_(103),
       client_shader_id_(104),
       client_texture_id_(106),
       client_element_buffer_id_(107) {
   memset(immediate_buffer_, 0xEE, sizeof(immediate_buffer_));
 }
 
 GLES2DecoderTestBase::~GLES2DecoderTestBase() {}
 
 void GLES2DecoderTestBase::SetUp() {
-  InitDecoder("", true);
+  InitDecoder("", true, true, false, true, true, false);
 }
 
 void GLES2DecoderTestBase::InitDecoder(
-    const char* extensions, bool has_alpha_backbuffer) {
+    const char* extensions,
+    bool has_alpha,
+    bool has_depth,
+    bool has_stencil,
+    bool request_alpha,
+    bool request_depth,
+    bool request_stencil) {
   gl_.reset(new StrictMock<MockGLInterface>());
   ::gfx::GLInterface::SetGLInterface(gl_.get());
   surface_manager_.reset(new StrictMock<MockSurfaceManager>);
   group_ = ContextGroup::Ref(new ContextGroup());
 
   InSequence sequence;
 
   TestHelper::SetupContextGroupInitExpectations(gl_.get(),
       DisallowedExtensions(), extensions);
 
   EXPECT_TRUE(group_->Initialize(DisallowedExtensions(), extensions));
 
-  EXPECT_CALL(*gl_, GetIntegerv(GL_ALPHA_BITS, _))
-      .WillOnce(SetArgumentPointee<1>(has_alpha_backbuffer ? 8 : 0))
-      .RetiresOnSaturation();
   EXPECT_CALL(*gl_, EnableVertexAttribArray(0))
       .Times(1)
       .RetiresOnSaturation();
   static GLuint attrib_0_id[] = {
     kServiceAttrib0BufferId,
   };
   static GLuint fixed_attrib_buffer_id[] = {
     kServiceFixedAttribBufferId,
   };
   EXPECT_CALL(*gl_, GenBuffersARB(arraysize(attrib_0_id), _))
@@ skipping 25 matching lines @@
         .RetiresOnSaturation();
     EXPECT_CALL(*gl_, BindTexture(
         GL_TEXTURE_2D, TestHelper::kServiceDefaultTexture2dId))
         .Times(1)
         .RetiresOnSaturation();
   }
   EXPECT_CALL(*gl_, ActiveTexture(GL_TEXTURE0))
       .Times(1)
       .RetiresOnSaturation();
 
+  EXPECT_CALL(*gl_, GetIntegerv(GL_ALPHA_BITS, _))
+       .WillOnce(SetArgumentPointee<1>(has_alpha ? 8 : 0))
+       .RetiresOnSaturation();
+  EXPECT_CALL(*gl_, GetIntegerv(GL_DEPTH_BITS, _))
+       .WillOnce(SetArgumentPointee<1>(has_depth ? 24 : 0))
+       .RetiresOnSaturation();
+  EXPECT_CALL(*gl_, GetIntegerv(GL_STENCIL_BITS, _))
+       .WillOnce(SetArgumentPointee<1>(has_stencil ? 8 : 0))
+       .RetiresOnSaturation();
+
   EXPECT_CALL(*gl_, Enable(GL_VERTEX_PROGRAM_POINT_SIZE))
       .Times(1)
       .RetiresOnSaturation();
 
   EXPECT_CALL(*gl_, Enable(GL_POINT_SPRITE))
       .Times(1)
       .RetiresOnSaturation();
 
   engine_.reset(new StrictMock<MockCommandBufferEngine>());
   Buffer buffer = engine_->GetSharedMemoryBuffer(kSharedMemoryId);
   shared_memory_offset_ = kSharedMemoryOffset;
   shared_memory_address_ = reinterpret_cast<int8*>(buffer.ptr) +
       shared_memory_offset_;
   shared_memory_id_ = kSharedMemoryId;
   shared_memory_base_ = buffer.ptr;
 
   surface_ = new gfx::GLSurfaceStub;
   surface_->SetSize(gfx::Size(kBackBufferWidth, kBackBufferHeight));
 
   context_ = new gfx::GLContextStub;
 
+  // From <EGL/egl.h>.
+  const int32 EGL_ALPHA_SIZE = 0x3021;
+  const int32 EGL_DEPTH_SIZE = 0x3025;
+  const int32 EGL_STENCIL_SIZE = 0x3026;
+
+  int32 attributes[] = {
+    EGL_ALPHA_SIZE, request_alpha ? 8 : 0,
+    EGL_DEPTH_SIZE, request_depth ? 24 : 0,
+    EGL_STENCIL_SIZE, request_stencil ? 8 : 0,
+  };
+  std::vector<int32> attribs(attributes, attributes + arraysize(attributes));
+
   decoder_.reset(GLES2Decoder::Create(surface_manager_.get(), group_.get()));
   decoder_->Initialize(
       surface_, context_, surface_->GetSize(), DisallowedExtensions(),
-      NULL, std::vector<int32>(), NULL, 0);
+      NULL, attribs, NULL, 0);
   decoder_->set_engine(engine_.get());
 
   EXPECT_CALL(*gl_, GenBuffersARB(_, _))
       .WillOnce(SetArgumentPointee<1>(kServiceBufferId))
       .RetiresOnSaturation();
   GenHelper<GenBuffersImmediate>(client_buffer_id_);
   EXPECT_CALL(*gl_, GenFramebuffersEXT(_, _))
       .WillOnce(SetArgumentPointee<1>(kServiceFramebufferId))
       .RetiresOnSaturation();
   GenHelper<GenFramebuffersImmediate>(client_framebuffer_id_);
@@ skipping 105 matching lines @@
     ClearSharedMemory();
   }
 }
 
 void GLES2DecoderTestBase::SetupExpectationsForFramebufferAttachment(
     GLuint clear_bits,
     GLclampf restore_red,
     GLclampf restore_green,
     GLclampf restore_blue,
     GLclampf restore_alpha,
-    GLuint restore_color_mask,
     GLuint restore_stencil,
-    GLuint restore_stencil_front_mask,
-    GLuint restore_stencil_back_mask,
     GLclampf restore_depth,
-    GLboolean restore_depth_mask,
     bool restore_scissor_test) {
   InSequence sequence;
   EXPECT_CALL(*gl_, CheckFramebufferStatusEXT(GL_FRAMEBUFFER))
       .WillOnce(Return(GL_FRAMEBUFFER_COMPLETE))
       .RetiresOnSaturation();
   if ((clear_bits & GL_COLOR_BUFFER_BIT) != 0) {
     EXPECT_CALL(*gl_, ClearColor(0, 0, 0, 0))
         .Times(1)
         .RetiresOnSaturation();
     EXPECT_CALL(*gl_, ColorMask(1, 1, 1, 1))
@@ skipping 19 matching lines @@
   EXPECT_CALL(*gl_, Disable(GL_SCISSOR_TEST))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, Clear(clear_bits))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, ClearColor(
       restore_red, restore_green, restore_blue, restore_alpha))
       .Times(1)
       .RetiresOnSaturation();
-  EXPECT_CALL(*gl_, ColorMask(
-      ((restore_color_mask & 0x1000) != 0) ? 1 : 0,
-      ((restore_color_mask & 0x0100) != 0) ? 1 : 0,
-      ((restore_color_mask & 0x0010) != 0) ? 1 : 0,
-      ((restore_color_mask & 0x0001) != 0) ? 1 : 0))
-      .Times(1)
-      .RetiresOnSaturation();
   EXPECT_CALL(*gl_, ClearStencil(restore_stencil))
       .Times(1)
       .RetiresOnSaturation();
-  EXPECT_CALL(*gl_, StencilMaskSeparate(GL_FRONT, restore_stencil_front_mask))
-      .Times(1)
-      .RetiresOnSaturation();
-  EXPECT_CALL(*gl_, StencilMaskSeparate(GL_BACK, restore_stencil_back_mask))
-      .Times(1)
-      .RetiresOnSaturation();
   EXPECT_CALL(*gl_, ClearDepth(restore_depth))
       .Times(1)
       .RetiresOnSaturation();
-  EXPECT_CALL(*gl_, DepthMask(restore_depth_mask))
-      .Times(1)
-      .RetiresOnSaturation();
   if (restore_scissor_test) {
     EXPECT_CALL(*gl_, Enable(GL_SCISSOR_TEST))
         .Times(1)
         .RetiresOnSaturation();
   }
 }
 
 void GLES2DecoderTestBase::SetupShaderForUniform() {
   static AttribInfo attribs[] = {
     { "foo", 1, GL_FLOAT, 1, },
@@ skipping 36 matching lines @@
     GLuint client_id, GLuint service_id) {
   EXPECT_CALL(*gl_, DeleteBuffersARB(1, Pointee(service_id)))
       .Times(1)
       .RetiresOnSaturation();
   DeleteBuffers cmd;
   cmd.Init(1, shared_memory_id_, shared_memory_offset_);
   memcpy(shared_memory_address_, &client_id, sizeof(client_id));
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
+void GLES2DecoderTestBase::SetupExpectationsForApplyingDirtyState(
+    bool framebuffer_is_rgb,
+    bool framebuffer_has_depth,
+    bool framebuffer_has_stencil,
+    GLuint color_bits,
+    bool depth_mask,
+    GLuint front_stencil_mask,
+    GLuint back_stencil_mask) {
+  EXPECT_CALL(*gl_, ColorMask(
+      (color_bits & 0x1000) != 0,
+      (color_bits & 0x0100) != 0,
+      (color_bits & 0x0010) != 0,
+      (color_bits & 0x0001) && !framebuffer_is_rgb))
+      .Times(1)
+      .RetiresOnSaturation();
+  EXPECT_CALL(*gl_, DepthMask(depth_mask))
+      .Times(1)
+      .RetiresOnSaturation();
+  EXPECT_CALL(*gl_, StencilMaskSeparate(GL_FRONT, front_stencil_mask))
+      .Times(1)
+      .RetiresOnSaturation();
+  EXPECT_CALL(*gl_, StencilMaskSeparate(GL_BACK, back_stencil_mask))
+      .Times(1)
+      .RetiresOnSaturation();
+}
+
+void GLES2DecoderTestBase::SetupExpectationsForApplyingDefaultDirtyState() {
+  SetupExpectationsForApplyingDirtyState(
+      false,   // Framebuffer is RGB
+      false,   // Framebuffer has depth
+      false,   // Framebuffer has stencil
+      0x1111,  // color bits
+      true,    // depth mask
+      0,       // front stencil mask
+      0);      // back stencil mask
+}
+
 void GLES2DecoderTestBase::DoBindFramebuffer(
     GLenum target, GLuint client_id, GLuint service_id) {
   EXPECT_CALL(*gl_, BindFramebufferEXT(target, service_id))
       .Times(1)
       .RetiresOnSaturation();
   BindFramebuffer cmd;
   cmd.Init(target, client_id);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
@@ skipping 129 matching lines @@
 const uint32 GLES2DecoderTestBase::kNewClientId;
 const uint32 GLES2DecoderTestBase::kNewServiceId;
 const uint32 GLES2DecoderTestBase::kInvalidClientId;
 
 const int GLES2DecoderTestBase::kBackBufferWidth;
 const int GLES2DecoderTestBase::kBackBufferHeight;
 #endif
 
 void GLES2DecoderWithShaderTestBase::SetUp() {
   GLES2DecoderTestBase::SetUp();
+  SetupDefaultProgram();
+}
 
+void GLES2DecoderWithShaderTestBase::SetupDefaultProgram() {
   {
     static AttribInfo attribs[] = {
       { kAttrib1Name, kAttrib1Size, kAttrib1Type, kAttrib1Location, },
       { kAttrib2Name, kAttrib2Size, kAttrib2Type, kAttrib2Location, },
       { kAttrib3Name, kAttrib3Size, kAttrib3Type, kAttrib3Location, },
     };
     static UniformInfo uniforms[] = {
       { kUniform1Name, kUniform1Size, kUniform1Type, kUniform1Location, },
       { kUniform2Name, kUniform2Size, kUniform2Type, kUniform2Location, },
       { kUniform3Name, kUniform3Size, kUniform3Type, kUniform3Location, },
@@ skipping 258 matching lines @@
 
 const char* GLES2DecoderWithShaderTestBase::kAttrib1Name = "attrib1";
 const char* GLES2DecoderWithShaderTestBase::kAttrib2Name = "attrib2";
 const char* GLES2DecoderWithShaderTestBase::kAttrib3Name = "attrib3";
 const char* GLES2DecoderWithShaderTestBase::kUniform1Name = "uniform1";
 const char* GLES2DecoderWithShaderTestBase::kUniform2Name = "uniform2[0]";
 const char* GLES2DecoderWithShaderTestBase::kUniform3Name = "uniform3[0]";
 
 }  // namespace gles2
 }  // namespace gpu