src/gpu/command_buffer/client/buffer_tracker_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // Tests for the BufferTracker.
   6
   7 #include "gpu/command_buffer/client/buffer_tracker.h"
   8
   9 #include <GLES2/gl2ext.h>
  10 #include "base/memory/scoped_ptr.h"
  11 #include "gpu/command_buffer/client/client_test_helper.h"
  12 #include "gpu/command_buffer/client/gles2_cmd_helper.h"
  13 #include "gpu/command_buffer/client/mapped_memory.h"
  14 #include "gpu/command_buffer/common/command_buffer.h"
  15 #include "testing/gmock/include/gmock/gmock.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17
  18 namespace gpu {
  19 namespace gles2 {
  20
  21 class MockClientCommandBufferImpl : public MockClientCommandBuffer {
  22  public:
  23   MockClientCommandBufferImpl()
  24       : MockClientCommandBuffer(),
  25         context_lost_(false) {}
  26   virtual ~MockClientCommandBufferImpl() {}
  27
  28   virtual scoped_refptr<gpu::Buffer> CreateTransferBuffer(size_t size,
  29                                                           int32* id) OVERRIDE {
  30     if (context_lost_) {
  31       *id = -1;
  32       return NULL;
  33     }
  34     return MockClientCommandBuffer::CreateTransferBuffer(size, id);
  35   }
  36
  37   void set_context_lost(bool context_lost) {
  38     context_lost_ = context_lost;
  39   }
  40
  41  private:
  42   bool context_lost_;
  43 };
  44
  45 class BufferTrackerTest : public testing::Test {
  46  protected:
  47   static const int32 kNumCommandEntries = 400;
  48   static const int32 kCommandBufferSizeBytes =
  49       kNumCommandEntries * sizeof(CommandBufferEntry);
  50
  51   virtual void SetUp() {
  52     command_buffer_.reset(new MockClientCommandBufferImpl());
  53     helper_.reset(new GLES2CmdHelper(command_buffer_.get()));
  54     helper_->Initialize(kCommandBufferSizeBytes);
  55     mapped_memory_.reset(new MappedMemoryManager(
  56         helper_.get(), MappedMemoryManager::kNoLimit));
  57     buffer_tracker_.reset(new BufferTracker(mapped_memory_.get()));
  58   }
  59
  60   virtual void TearDown() {
  61     buffer_tracker_.reset();
  62     mapped_memory_.reset();
  63     helper_.reset();
  64     command_buffer_.reset();
  65   }
  66
  67   scoped_ptr<MockClientCommandBufferImpl> command_buffer_;
  68   scoped_ptr<GLES2CmdHelper> helper_;
  69   scoped_ptr<MappedMemoryManager> mapped_memory_;
  70   scoped_ptr<BufferTracker> buffer_tracker_;
  71 };
  72
  73 TEST_F(BufferTrackerTest, Basic) {
  74   const GLuint kId1 = 123;
  75   const GLuint kId2 = 124;
  76   const GLsizeiptr size = 64;
  77
  78   // Check we can create a Buffer.
  79   BufferTracker::Buffer* buffer = buffer_tracker_->CreateBuffer(kId1, size);
  80   ASSERT_TRUE(buffer != NULL);
  81   // Check we can get the same Buffer.
  82   EXPECT_EQ(buffer, buffer_tracker_->GetBuffer(kId1));
  83   // Check mapped memory address.
  84   EXPECT_TRUE(buffer->address() != NULL);
  85   // Check shared memory was allocated.
  86   EXPECT_EQ(1lu, mapped_memory_->num_chunks());
  87   // Check we get nothing for a non-existent buffer.
  88   EXPECT_TRUE(buffer_tracker_->GetBuffer(kId2) == NULL);
  89   // Check we can delete the buffer.
  90   buffer_tracker_->RemoveBuffer(kId1);
  91   // Check shared memory was freed.
  92   mapped_memory_->FreeUnused();
  93   EXPECT_EQ(0lu, mapped_memory_->num_chunks());
  94   // Check we get nothing for a non-existent buffer.
  95   EXPECT_TRUE(buffer_tracker_->GetBuffer(kId1) == NULL);
  96 }
  97
  98 TEST_F(BufferTrackerTest, ZeroSize) {
  99   const GLuint kId = 123;
 100
 101   // Check we can create a Buffer with zero size.
 102   BufferTracker::Buffer* buffer = buffer_tracker_->CreateBuffer(kId, 0);
 103   ASSERT_TRUE(buffer != NULL);
 104   // Check mapped memory address.
 105   EXPECT_TRUE(buffer->address() == NULL);
 106   // Check no shared memory was allocated.
 107   EXPECT_EQ(0lu, mapped_memory_->num_chunks());
 108   // Check we can delete the buffer.
 109   buffer_tracker_->RemoveBuffer(kId);
 110 }
 111
 112 TEST_F(BufferTrackerTest, LostContext) {
 113   const GLuint kId = 123;
 114   const GLsizeiptr size = 64;
 115
 116   command_buffer_->set_context_lost(true);
 117   // Check we can create a Buffer when after losing context.
 118   BufferTracker::Buffer* buffer = buffer_tracker_->CreateBuffer(kId, size);
 119   ASSERT_TRUE(buffer != NULL);
 120   // Check mapped memory address.
 121   EXPECT_EQ(64u, buffer->size());
 122   // Check mapped memory address.
 123   EXPECT_TRUE(buffer->address() == NULL);
 124   // Check no shared memory was allocated.
 125   EXPECT_EQ(0lu, mapped_memory_->num_chunks());
 126   // Check we can delete the buffer.
 127   buffer_tracker_->RemoveBuffer(kId);
 128 }
 129
 130 }  // namespace gles2
 131 }  // namespace gpu