src/ppapi/shared_impl/media_stream_buffer_manager_unittest.cc

   1 // Copyright 2014 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 #include "base/memory/scoped_ptr.h"
   6 #include "base/memory/shared_memory.h"
   7 #include "ppapi/c/pp_errors.h"
   8 #include "ppapi/shared_impl/media_stream_buffer_manager.h"
   9 #include "testing/gtest/include/gtest/gtest.h"
  10
  11 using base::SharedMemory;
  12 using base::SharedMemoryCreateOptions;
  13
  14 namespace {
  15
  16 scoped_ptr<SharedMemory> CreateSharedMemory(int32_t buffer_size,
  17                                             int32_t number_of_buffers) {
  18   scoped_ptr<SharedMemory> shared_memory(new SharedMemory());
  19   SharedMemoryCreateOptions options;
  20   options.size = buffer_size * number_of_buffers;
  21   options.executable = false;
  22   EXPECT_TRUE(shared_memory->Create(options));
  23   return shared_memory.Pass();
  24 }
  25
  26 }  // namespace
  27
  28 namespace ppapi {
  29
  30 class MockDelegate : public MediaStreamBufferManager::Delegate {
  31  public:
  32   MockDelegate() : new_buffer_enqueue_counter_(0) {}
  33   virtual void OnNewBufferEnqueued() OVERRIDE {
  34     new_buffer_enqueue_counter_++;
  35   }
  36
  37   int32_t new_buffer_enqueue_counter_;
  38 };
  39
  40 TEST(MediaStreamBufferManager, General) {
  41   {
  42     const int32_t kNumberOfBuffers = 5;
  43     const int32_t kBufferSize = 128;
  44     MockDelegate delegate;
  45     MediaStreamBufferManager manager(&delegate);
  46     scoped_ptr<SharedMemory> shared_memory =
  47         CreateSharedMemory(kBufferSize, kNumberOfBuffers);
  48     // SetBuffers with enqueue_all_buffers = true;
  49     EXPECT_TRUE(manager.SetBuffers(kNumberOfBuffers,
  50                                    kBufferSize,
  51                                    shared_memory.Pass(),
  52                                    true));
  53
  54     int8_t* memory = reinterpret_cast<int8_t*>(manager.GetBufferPointer(0));
  55     EXPECT_NE(static_cast<int8_t*>(NULL), memory);
  56
  57     EXPECT_EQ(kNumberOfBuffers, manager.number_of_buffers());
  58     EXPECT_EQ(kBufferSize, manager.buffer_size());
  59
  60     // Test DequeueBuffer() and GetBufferPointer()
  61     for (int32_t i = 0; i < kNumberOfBuffers; ++i) {
  62       EXPECT_EQ(i, manager.DequeueBuffer());
  63       EXPECT_EQ(reinterpret_cast<MediaStreamBuffer*>(memory + i * kBufferSize),
  64                 manager.GetBufferPointer(i));
  65     }
  66
  67     manager.EnqueueBuffer(0);
  68     manager.EnqueueBuffer(4);
  69     manager.EnqueueBuffer(3);
  70     manager.EnqueueBuffer(1);
  71     manager.EnqueueBuffer(2);
  72     EXPECT_EQ(5, delegate.new_buffer_enqueue_counter_);
  73
  74     EXPECT_EQ(0, manager.DequeueBuffer());
  75     EXPECT_EQ(4, manager.DequeueBuffer());
  76     EXPECT_EQ(3, manager.DequeueBuffer());
  77     EXPECT_EQ(1, manager.DequeueBuffer());
  78     EXPECT_EQ(2, manager.DequeueBuffer());
  79     EXPECT_EQ(PP_ERROR_FAILED, manager.DequeueBuffer());
  80     EXPECT_EQ(PP_ERROR_FAILED, manager.DequeueBuffer());
  81
  82     // Test crash for passing invalid index to GetBufferPointer()
  83     EXPECT_DEATH(manager.GetBufferPointer(-1),
  84                  ".*Check failed: index >= 0.*");
  85     EXPECT_DEATH(manager.GetBufferPointer(kNumberOfBuffers),
  86                  ".*Check failed: index < number_of_buffers_.*");
  87
  88     // Test crash for passing invalid index to EnqueueBuffer().
  89     EXPECT_DEATH(manager.EnqueueBuffer(-1),
  90                  ".*Check failed: index >= 0.*");
  91     EXPECT_DEATH(manager.EnqueueBuffer(kNumberOfBuffers),
  92                  ".*Check failed: index < number_of_buffers_.*");
  93   }
  94
  95   {
  96     const int32_t kNumberOfBuffers = 5;
  97     const int32_t kBufferSize = 128;
  98     MockDelegate delegate;
  99     MediaStreamBufferManager manager(&delegate);
 100     scoped_ptr<SharedMemory> shared_memory =
 101         CreateSharedMemory(kBufferSize, kNumberOfBuffers);
 102     // SetBuffers with enqueue_all_buffers = false;
 103     EXPECT_TRUE(manager.SetBuffers(kNumberOfBuffers,
 104                                    kBufferSize,
 105                                    shared_memory.Pass(),
 106                                    false));
 107
 108     int8_t* memory = reinterpret_cast<int8_t*>(manager.GetBufferPointer(0));
 109     EXPECT_NE(static_cast<int8_t*>(NULL), memory);
 110
 111     EXPECT_EQ(kNumberOfBuffers, manager.number_of_buffers());
 112     EXPECT_EQ(kBufferSize, manager.buffer_size());
 113
 114     // Test DequeueBuffer() and GetBufferPointer()
 115     for (int32_t i = 0; i < kNumberOfBuffers; ++i) {
 116       EXPECT_EQ(PP_ERROR_FAILED, manager.DequeueBuffer());
 117       EXPECT_EQ(reinterpret_cast<MediaStreamBuffer*>(memory + i * kBufferSize),
 118                 manager.GetBufferPointer(i));
 119     }
 120   }
 121 }
 122
 123 TEST(MediaStreamBufferManager, ResetBuffers) {
 124   const int32_t kNumberOfBuffers1 = 5;
 125   const int32_t kBufferSize1 = 128;
 126   const int32_t kNumberOfBuffers2 = 8;
 127   const int32_t kBufferSize2 = 256;
 128   MockDelegate delegate;
 129   MediaStreamBufferManager manager(&delegate);
 130   {
 131     scoped_ptr<SharedMemory> shared_memory(new SharedMemory());
 132     SharedMemoryCreateOptions options;
 133     options.size = kBufferSize1 * kNumberOfBuffers1;
 134     options.executable = false;
 135
 136     EXPECT_TRUE(shared_memory->Create(options));
 137
 138     // SetBuffers with enqueue_all_buffers = true;
 139     EXPECT_TRUE(manager.SetBuffers(kNumberOfBuffers1,
 140                                    kBufferSize1,
 141                                    shared_memory.Pass(),
 142                                    true));
 143
 144     int8_t* memory = reinterpret_cast<int8_t*>(manager.GetBufferPointer(0));
 145     EXPECT_NE(static_cast<int8_t*>(NULL), memory);
 146
 147     EXPECT_EQ(kNumberOfBuffers1, manager.number_of_buffers());
 148     EXPECT_EQ(kBufferSize1, manager.buffer_size());
 149
 150     // Test DequeueBuffer() and GetBufferPointer()
 151     for (int32_t i = 0; i < kNumberOfBuffers1; ++i) {
 152       EXPECT_EQ(i, manager.DequeueBuffer());
 153       EXPECT_EQ(reinterpret_cast<MediaStreamBuffer*>(memory + i * kBufferSize1),
 154                 manager.GetBufferPointer(i));
 155     }
 156   }
 157
 158   {
 159     scoped_ptr<SharedMemory> shared_memory =
 160         CreateSharedMemory(kBufferSize2, kNumberOfBuffers2);
 161     // SetBuffers with enqueue_all_buffers = true;
 162     EXPECT_TRUE(manager.SetBuffers(kNumberOfBuffers2,
 163                                    kBufferSize2,
 164                                    shared_memory.Pass(),
 165                                    true));
 166
 167     int8_t* memory = reinterpret_cast<int8_t*>(manager.GetBufferPointer(0));
 168     EXPECT_NE(static_cast<int8_t*>(NULL), memory);
 169
 170     EXPECT_EQ(kNumberOfBuffers2, manager.number_of_buffers());
 171     EXPECT_EQ(kBufferSize2, manager.buffer_size());
 172
 173     // Test DequeueBuffer() and GetBufferPointer()
 174     for (int32_t i = 0; i < kNumberOfBuffers2; ++i) {
 175       EXPECT_EQ(i, manager.DequeueBuffer());
 176       EXPECT_EQ(reinterpret_cast<MediaStreamBuffer*>(memory + i * kBufferSize2),
 177                 manager.GetBufferPointer(i));
 178     }
 179   }
 180 }
 181
 182 }  // namespace ppapi