ChromeOS only version of r261563

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 374 matching lines @@
   static const GLuint kTexturesStartId = 1;
   static const GLuint kQueriesStartId = 1;
   static const GLuint kVertexArraysStartId = 1;
 
   typedef MockTransferBuffer::ExpectedMemoryInfo ExpectedMemoryInfo;
 
   class TestContext {
    public:
     TestContext() : commands_(NULL), token_(0) {}
 
+#if defined(OS_CHROMEOS)
+    bool Initialize(ShareGroup* share_group,
+                    bool bind_generates_resource,
+                    bool lose_context_when_out_of_memory) {
+#else
     void Initialize(ShareGroup* share_group,
                     bool bind_generates_resource,
                     bool lose_context_when_out_of_memory) {
+#endif
       command_buffer_.reset(new StrictMock<MockClientCommandBuffer>());
+#if defined(OS_CHROMEOS)
+      if (!command_buffer_->Initialize())
+        return false;
+#else
       ASSERT_TRUE(command_buffer_->Initialize());
+#endif
 
       transfer_buffer_.reset(
           new MockTransferBuffer(command_buffer_.get(),
                                  kTransferBufferSize,
                                  GLES2Implementation::kStartingOffset,
                                  GLES2Implementation::kAlignment));
 
       helper_.reset(new GLES2CmdHelper(command_buffer()));
       helper_->Initialize(kCommandBufferSizeBytes);
 
       gpu_control_.reset(new StrictMock<MockClientGpuControl>());
       EXPECT_CALL(*gpu_control_, GetCapabilities())
           .WillOnce(testing::Return(Capabilities()));
 
       GLES2Implementation::GLStaticState state;
       GLES2Implementation::GLStaticState::IntState& int_state = state.int_state;
       int_state.max_combined_texture_image_units =
           kMaxCombinedTextureImageUnits;
       int_state.max_cube_map_texture_size = kMaxCubeMapTextureSize;
       int_state.max_fragment_uniform_vectors = kMaxFragmentUniformVectors;
       int_state.max_renderbuffer_size = kMaxRenderbufferSize;
       int_state.max_texture_image_units = kMaxTextureImageUnits;
       int_state.max_texture_size = kMaxTextureSize;
       int_state.max_varying_vectors = kMaxVaryingVectors;
       int_state.max_vertex_attribs = kMaxVertexAttribs;
       int_state.max_vertex_texture_image_units = kMaxVertexTextureImageUnits;
       int_state.max_vertex_uniform_vectors = kMaxVertexUniformVectors;
       int_state.num_compressed_texture_formats = kNumCompressedTextureFormats;
       int_state.num_shader_binary_formats = kNumShaderBinaryFormats;
+#if defined(OS_CHROMEOS)
+      int_state.bind_generates_resource_chromium =
+          bind_generates_resource ? 1 : 0;
+#endif
 
       // This just happens to work for now because IntState has 1 GLint per
       // state.
       // If IntState gets more complicated this code will need to get more
       // complicated.
       ExpectedMemoryInfo mem1 = transfer_buffer_->GetExpectedMemory(
           sizeof(GLES2Implementation::GLStaticState::IntState) * 2 +
           sizeof(cmds::GetShaderPrecisionFormat::Result) * 12);
 
       {
         InSequence sequence;
 
         EXPECT_CALL(*command_buffer_, OnFlush())
             .WillOnce(SetMemory(mem1.ptr + sizeof(int_state), int_state))
             .RetiresOnSaturation();
         GetNextToken();  // eat the token that starting up will use.
 
         gl_.reset(new GLES2Implementation(helper_.get(),
                                           share_group,
                                           transfer_buffer_.get(),
                                           bind_generates_resource,
                                           lose_context_when_out_of_memory,
                                           gpu_control_.get()));
+#if defined(OS_CHROMEOS)
+        if (!gl_->Initialize(kTransferBufferSize,
+                             kTransferBufferSize,
+                             kTransferBufferSize,
+                             GLES2Implementation::kNoLimit))
+          return false;
+#else
         ASSERT_TRUE(gl_->Initialize(kTransferBufferSize,
                                     kTransferBufferSize,
                                     kTransferBufferSize,
                                     GLES2Implementation::kNoLimit));
+#endif
       }
 
       EXPECT_CALL(*command_buffer_, OnFlush()).Times(1).RetiresOnSaturation();
       helper_->CommandBufferHelper::Finish();
       ::testing::Mock::VerifyAndClearExpectations(gl_.get());
 
       scoped_refptr<Buffer> ring_buffer = helper_->get_ring_buffer();
       commands_ = static_cast<CommandBufferEntry*>(ring_buffer->memory()) +
                   command_buffer()->GetState().put_offset;
       ClearCommands();
       EXPECT_TRUE(transfer_buffer_->InSync());
 
       ::testing::Mock::VerifyAndClearExpectations(command_buffer());
+#if defined(OS_CHROMEOS)
+      return true;
+#endif
     }
 
     void TearDown() {
       Mock::VerifyAndClear(gl_.get());
       EXPECT_CALL(*command_buffer(), OnFlush()).Times(AnyNumber());
       // For command buffer.
       EXPECT_CALL(*command_buffer(), DestroyTransferBuffer(_))
           .Times(AtLeast(1));
       gl_.reset();
     }
@@ skipping 32 matching lines @@
         return false;
       }
     }
     return true;
   }
 
   QueryTracker::Query* GetQuery(GLuint id) {
     return gl_->query_tracker_->GetQuery(id);
   }
 
+#if !defined(OS_CHROMEOS)
   void Initialize(bool bind_generates_resource,
                   bool lose_context_when_out_of_memory) {
     share_group_ = new ShareGroup(bind_generates_resource);
 
     for (int i = 0; i < kNumTestContexts; i++)
       test_contexts_[i].Initialize(share_group_.get(),
                                    bind_generates_resource,
                                    lose_context_when_out_of_memory);
+#else
+  struct ContextInitOptions {
+    ContextInitOptions()
+        : bind_generates_resource_client(true),
+          bind_generates_resource_service(true),
+          lose_context_when_out_of_memory(false) {}
+
+    bool bind_generates_resource_client;
+    bool bind_generates_resource_service;
+    bool lose_context_when_out_of_memory;
+  };
+
+  bool Initialize(const ContextInitOptions& init_options) {
+    bool success = true;
+    share_group_ = new ShareGroup(init_options.bind_generates_resource_service);
+
+    for (int i = 0; i < kNumTestContexts; i++) {
+      if (!test_contexts_[i].Initialize(
+              share_group_.get(),
+              init_options.bind_generates_resource_client,
+              init_options.lose_context_when_out_of_memory))
+        success = false;
+    }
+#endif
 
     // Default to test context 0.
     gpu_control_ = test_contexts_[0].gpu_control_.get();
     helper_ = test_contexts_[0].helper_.get();
     transfer_buffer_ = test_contexts_[0].transfer_buffer_.get();
     gl_ = test_contexts_[0].gl_.get();
     commands_ = test_contexts_[0].commands_;
+#if defined(OS_CHROMEOS)
+    return success;
+#endif
   }
 
   MockClientCommandBuffer* command_buffer() const {
     return test_contexts_[0].command_buffer_.get();
   }
 
   int GetNextToken() { return test_contexts_[0].GetNextToken(); }
 
   const void* GetPut() {
     return helper_->GetSpace(0);
@@ skipping 39 matching lines @@
 
   scoped_refptr<ShareGroup> share_group_;
   MockClientGpuControl* gpu_control_;
   GLES2CmdHelper* helper_;
   MockTransferBuffer* transfer_buffer_;
   GLES2Implementation* gl_;
   CommandBufferEntry* commands_;
 };
 
 void GLES2ImplementationTest::SetUp() {
+#if defined(OS_CHROMEOS)
+  ContextInitOptions init_options;
+  ASSERT_TRUE(Initialize(init_options));
+#else
   bool bind_generates_resource = true;
   bool lose_context_when_out_of_memory = false;
   Initialize(bind_generates_resource, lose_context_when_out_of_memory);
+#endif
 }
 
 void GLES2ImplementationTest::TearDown() {
   for (int i = 0; i < kNumTestContexts; i++)
     test_contexts_[i].TearDown();
 }
 
 class GLES2ImplementationManualInitTest : public GLES2ImplementationTest {
  protected:
   virtual void SetUp() OVERRIDE {}
@@ skipping 82 matching lines @@
     EXPECT_NE(id1, id3);
 
     // Lazy release triggered by another Delete.  Should reuse id1.
     ResApi::Delete(gl1, 1, &id2);
     ResApi::Gen(gl2, 1, &id3);
     EXPECT_EQ(id1, id3);
   }
 };
 
 void GLES2ImplementationStrictSharedTest::SetUp() {
+#if defined(OS_CHROMEOS)
+  ContextInitOptions init_options;
+  init_options.bind_generates_resource_client = false;
+  init_options.bind_generates_resource_service = false;
+  ASSERT_TRUE(Initialize(init_options));
+#else
   bool bind_generates_resource = false;
   bool lose_context_when_out_of_memory = false;
   Initialize(bind_generates_resource, lose_context_when_out_of_memory);
+#endif
 }
 
 // GCC requires these declarations, but MSVC requires they not be present
 #ifndef _MSC_VER
 const uint8 GLES2ImplementationTest::kInitialValue;
 const int32 GLES2ImplementationTest::kNumCommandEntries;
 const int32 GLES2ImplementationTest::kCommandBufferSizeBytes;
 const size_t GLES2ImplementationTest::kTransferBufferSize;
 const GLint GLES2ImplementationTest::kMaxCombinedTextureImageUnits;
 const GLint GLES2ImplementationTest::kMaxCubeMapTextureSize;
@@ skipping 2397 matching lines @@
   };
 
   Mailbox mailbox = Mailbox::Generate();
   Cmds expected;
   expected.cmd.Init(GL_TEXTURE_2D, mailbox.name);
   gl_->ProduceTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 
 TEST_F(GLES2ImplementationManualInitTest, LoseContextOnOOM) {
+#if defined(OS_CHROMEOS)
+  ContextInitOptions init_options;
+  init_options.lose_context_when_out_of_memory = true;
+  ASSERT_TRUE(Initialize(init_options));
+#else
   bool bind_generates_resource = false;
   bool lose_context_when_out_of_memory = true;
   Initialize(bind_generates_resource, lose_context_when_out_of_memory);
+#endif
 
   struct Cmds {
     cmds::LoseContextCHROMIUM cmd;
   };
 
   GLsizei max = std::numeric_limits<GLsizei>::max();
   EXPECT_CALL(*gpu_control_, CreateGpuMemoryBuffer(max, max, _, _))
       .WillOnce(Return(static_cast<gfx::GpuMemoryBuffer*>(NULL)));
   gl_->CreateImageCHROMIUM(max, max, 0);
   // The context should be lost.
   Cmds expected;
   expected.cmd.Init(GL_GUILTY_CONTEXT_RESET_ARB, GL_UNKNOWN_CONTEXT_RESET_ARB);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 
 TEST_F(GLES2ImplementationManualInitTest, NoLoseContextOnOOM) {
+#if defined(OS_CHROMEOS)
+  ContextInitOptions init_options;
+  ASSERT_TRUE(Initialize(init_options));
+#else
   bool bind_generates_resource = false;
   bool lose_context_when_out_of_memory = false;
   Initialize(bind_generates_resource, lose_context_when_out_of_memory);
-
+#endif
   struct Cmds {
     cmds::LoseContextCHROMIUM cmd;
   };
 
   GLsizei max = std::numeric_limits<GLsizei>::max();
   EXPECT_CALL(*gpu_control_, CreateGpuMemoryBuffer(max, max, _, _))
       .WillOnce(Return(static_cast<gfx::GpuMemoryBuffer*>(NULL)));
   gl_->CreateImageCHROMIUM(max, max, 0);
   // The context should not be lost.
   EXPECT_TRUE(NoCommandsWritten());
 }
 
+#if defined(OS_CHROMEOS)
+TEST_F(GLES2ImplementationManualInitTest, FailInitOnBGRMismatch1) {
+  ContextInitOptions init_options;
+  init_options.bind_generates_resource_client = false;
+  init_options.bind_generates_resource_service = true;
+  EXPECT_FALSE(Initialize(init_options));
+}
+
+TEST_F(GLES2ImplementationManualInitTest, FailInitOnBGRMismatch2) {
+  ContextInitOptions init_options;
+  init_options.bind_generates_resource_client = true;
+  init_options.bind_generates_resource_service = false;
+  EXPECT_FALSE(Initialize(init_options));
+}
+#endif
+
 #include "gpu/command_buffer/client/gles2_implementation_unittest_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu