Home | History | Annotate | Download | only in compositor 
      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 <set>
      6 
      7 #include "cc/test/test_context_provider.h"
      8 #include "cc/test/test_web_graphics_context_3d.h"
      9 #include "content/browser/compositor/buffer_queue.h"
     10 #include "content/browser/compositor/gpu_surfaceless_browser_compositor_output_surface.h"
     11 #include "gpu/GLES2/gl2extchromium.h"
     12 #include "testing/gmock/include/gmock/gmock.h"
     13 #include "testing/gtest/include/gtest/gtest.h"
     14 #include "third_party/khronos/GLES2/gl2ext.h"
     15 
     16 using ::testing::_;
     17 using ::testing::Expectation;
     18 using ::testing::Ne;
     19 using ::testing::Return;
     20 
     21 namespace content {
     22 class MockBufferQueue : public BufferQueue {
     23  public:
     24   MockBufferQueue(scoped_refptr<cc::ContextProvider> context_provider,
     25                   unsigned int internalformat)
     26       : BufferQueue(context_provider, internalformat) {}
     27   MOCK_METHOD4(CopyBufferDamage,
     28                void(int, int, const gfx::Rect&, const gfx::Rect&));
     29 };
     30 
     31 class BufferQueueTest : public ::testing::Test {
     32  public:
     33   BufferQueueTest() : doublebuffering_(true), first_frame_(true) {}
     34 
     35   virtual void SetUp() OVERRIDE {
     36     scoped_refptr<cc::TestContextProvider> context_provider =
     37         cc::TestContextProvider::Create(cc::TestWebGraphicsContext3D::Create());
     38     context_provider->BindToCurrentThread();
     39     output_surface_.reset(new MockBufferQueue(context_provider, GL_RGBA8_OES));
     40     output_surface_->Initialize();
     41   }
     42 
     43   unsigned current_surface() { return output_surface_->current_surface_.image; }
     44   const std::vector<BufferQueue::AllocatedSurface>& available_surfaces() {
     45     return output_surface_->available_surfaces_;
     46   }
     47   const std::deque<BufferQueue::AllocatedSurface>& in_flight_surfaces() {
     48     return output_surface_->in_flight_surfaces_;
     49   }
     50 
     51   const BufferQueue::AllocatedSurface& last_frame() {
     52     return output_surface_->in_flight_surfaces_.back();
     53   }
     54   const BufferQueue::AllocatedSurface& next_frame() {
     55     return output_surface_->available_surfaces_.back();
     56   }
     57   const gfx::Size size() { return output_surface_->size_; }
     58 
     59   int CountBuffers() {
     60     int n = available_surfaces().size() + in_flight_surfaces().size();
     61     if (current_surface())
     62       n++;
     63     return n;
     64   }
     65 
     66   // Check that each buffer is unique if present.
     67   void CheckUnique() {
     68     std::set<unsigned> buffers;
     69     EXPECT_TRUE(InsertUnique(&buffers, current_surface()));
     70     for (size_t i = 0; i < available_surfaces().size(); i++)
     71       EXPECT_TRUE(InsertUnique(&buffers, available_surfaces()[i].image));
     72     for (std::deque<BufferQueue::AllocatedSurface>::const_iterator it =
     73              in_flight_surfaces().begin();
     74          it != in_flight_surfaces().end();
     75          ++it)
     76       EXPECT_TRUE(InsertUnique(&buffers, it->image));
     77   }
     78 
     79   void SwapBuffers() {
     80     output_surface_->SwapBuffers(gfx::Rect(output_surface_->size_));
     81   }
     82 
     83   void SendDamagedFrame(const gfx::Rect& damage) {
     84     // We don't care about the GL-level implementation here, just how it uses
     85     // damage rects.
     86     output_surface_->BindFramebuffer();
     87     output_surface_->SwapBuffers(damage);
     88     if (doublebuffering_ || !first_frame_)
     89       output_surface_->PageFlipComplete();
     90     first_frame_ = false;
     91   }
     92 
     93   void SendFullFrame() { SendDamagedFrame(gfx::Rect(output_surface_->size_)); }
     94 
     95  protected:
     96   bool InsertUnique(std::set<unsigned>* set, unsigned value) {
     97     if (!value)
     98       return true;
     99     if (set->find(value) != set->end())
    100       return false;
    101     set->insert(value);
    102     return true;
    103   }
    104 
    105   scoped_ptr<MockBufferQueue> output_surface_;
    106   bool doublebuffering_;
    107   bool first_frame_;
    108 };
    109 
    110 namespace {
    111 const gfx::Size screen_size = gfx::Size(30, 30);
    112 const gfx::Rect screen_rect = gfx::Rect(screen_size);
    113 const gfx::Rect small_damage = gfx::Rect(gfx::Size(10, 10));
    114 const gfx::Rect large_damage = gfx::Rect(gfx::Size(20, 20));
    115 const gfx::Rect overlapping_damage = gfx::Rect(gfx::Size(5, 20));
    116 
    117 class MockedContext : public cc::TestWebGraphicsContext3D {
    118  public:
    119   MOCK_METHOD2(bindFramebuffer, void(GLenum, GLuint));
    120   MOCK_METHOD2(bindTexture, void(GLenum, GLuint));
    121   MOCK_METHOD2(bindTexImage2DCHROMIUM, void(GLenum, GLint));
    122   MOCK_METHOD4(createImageCHROMIUM, GLuint(GLsizei, GLsizei, GLenum, GLenum));
    123   MOCK_METHOD1(destroyImageCHROMIUM, void(GLuint));
    124   MOCK_METHOD5(framebufferTexture2D,
    125                void(GLenum, GLenum, GLenum, GLuint, GLint));
    126 };
    127 
    128 scoped_ptr<BufferQueue> CreateOutputSurfaceWithMock(MockedContext** context) {
    129   *context = new MockedContext();
    130   scoped_refptr<cc::TestContextProvider> context_provider =
    131       cc::TestContextProvider::Create(
    132           scoped_ptr<cc::TestWebGraphicsContext3D>(*context));
    133   context_provider->BindToCurrentThread();
    134   scoped_ptr<BufferQueue> buffer_queue(
    135       new BufferQueue(context_provider, GL_RGBA8_OES));
    136   buffer_queue->Initialize();
    137   return buffer_queue.Pass();
    138 }
    139 
    140 TEST(BufferQueueStandaloneTest, FboInitialization) {
    141   MockedContext* context;
    142   scoped_ptr<BufferQueue> output_surface =
    143       CreateOutputSurfaceWithMock(&context);
    144 
    145   EXPECT_CALL(*context, bindFramebuffer(GL_FRAMEBUFFER, Ne(0U)));
    146   ON_CALL(*context, framebufferTexture2D(_, _, _, _, _))
    147       .WillByDefault(Return());
    148 
    149   output_surface->Reshape(gfx::Size(10, 20), 1.0f);
    150 }
    151 
    152 TEST(BufferQueueStandaloneTest, FboBinding) {
    153   MockedContext* context;
    154   scoped_ptr<BufferQueue> output_surface =
    155       CreateOutputSurfaceWithMock(&context);
    156   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, Ne(0U)));
    157   EXPECT_CALL(*context, destroyImageCHROMIUM(1));
    158   Expectation image =
    159       EXPECT_CALL(
    160           *context,
    161           createImageCHROMIUM(0, 0, GL_RGBA8_OES, GL_IMAGE_SCANOUT_CHROMIUM))
    162           .WillOnce(Return(1));
    163   Expectation fb =
    164       EXPECT_CALL(*context, bindFramebuffer(GL_FRAMEBUFFER, Ne(0U)));
    165   Expectation tex = EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, Ne(0U)));
    166   Expectation bind_tex =
    167       EXPECT_CALL(*context, bindTexImage2DCHROMIUM(GL_TEXTURE_2D, 1))
    168           .After(tex, image);
    169   EXPECT_CALL(
    170       *context,
    171       framebufferTexture2D(
    172           GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, Ne(0U), _))
    173       .After(fb, bind_tex);
    174 
    175   output_surface->BindFramebuffer();
    176 }
    177 
    178 TEST_F(BufferQueueTest, PartialSwapReuse) {
    179   // Check that
    180   output_surface_->Reshape(screen_size, 1.0f);
    181   ASSERT_TRUE(doublebuffering_);
    182   EXPECT_CALL(*output_surface_,
    183               CopyBufferDamage(_, _, small_damage, screen_rect)).Times(1);
    184   EXPECT_CALL(*output_surface_,
    185               CopyBufferDamage(_, _, small_damage, small_damage)).Times(1);
    186   EXPECT_CALL(*output_surface_,
    187               CopyBufferDamage(_, _, large_damage, small_damage)).Times(1);
    188   SendFullFrame();
    189   SendDamagedFrame(small_damage);
    190   SendDamagedFrame(small_damage);
    191   SendDamagedFrame(large_damage);
    192   // Verify that the damage has propagated.
    193   EXPECT_EQ(next_frame().damage, large_damage);
    194 }
    195 
    196 TEST_F(BufferQueueTest, PartialSwapFullFrame) {
    197   output_surface_->Reshape(screen_size, 1.0f);
    198   ASSERT_TRUE(doublebuffering_);
    199   EXPECT_CALL(*output_surface_,
    200               CopyBufferDamage(_, _, small_damage, screen_rect)).Times(1);
    201   SendFullFrame();
    202   SendDamagedFrame(small_damage);
    203   SendFullFrame();
    204   SendFullFrame();
    205   EXPECT_EQ(next_frame().damage, screen_rect);
    206 }
    207 
    208 TEST_F(BufferQueueTest, PartialSwapOverlapping) {
    209   output_surface_->Reshape(screen_size, 1.0f);
    210   ASSERT_TRUE(doublebuffering_);
    211   EXPECT_CALL(*output_surface_,
    212               CopyBufferDamage(_, _, small_damage, screen_rect)).Times(1);
    213   EXPECT_CALL(*output_surface_,
    214               CopyBufferDamage(_, _, overlapping_damage, small_damage))
    215       .Times(1);
    216 
    217   SendFullFrame();
    218   SendDamagedFrame(small_damage);
    219   SendDamagedFrame(overlapping_damage);
    220   EXPECT_EQ(next_frame().damage, overlapping_damage);
    221 }
    222 
    223 TEST_F(BufferQueueTest, MultipleBindCalls) {
    224   // Check that multiple bind calls do not create or change surfaces.
    225   output_surface_->BindFramebuffer();
    226   EXPECT_EQ(1, CountBuffers());
    227   unsigned int fb = current_surface();
    228   output_surface_->BindFramebuffer();
    229   EXPECT_EQ(1, CountBuffers());
    230   EXPECT_EQ(fb, current_surface());
    231 }
    232 
    233 TEST_F(BufferQueueTest, CheckDoubleBuffering) {
    234   // Check buffer flow through double buffering path.
    235   EXPECT_EQ(0, CountBuffers());
    236   output_surface_->BindFramebuffer();
    237   EXPECT_EQ(1, CountBuffers());
    238   EXPECT_NE(0U, current_surface());
    239   SwapBuffers();
    240   EXPECT_EQ(1U, in_flight_surfaces().size());
    241   output_surface_->PageFlipComplete();
    242   EXPECT_EQ(1U, in_flight_surfaces().size());
    243   output_surface_->BindFramebuffer();
    244   EXPECT_EQ(2, CountBuffers());
    245   CheckUnique();
    246   EXPECT_NE(0U, current_surface());
    247   EXPECT_EQ(1U, in_flight_surfaces().size());
    248   SwapBuffers();
    249   CheckUnique();
    250   EXPECT_EQ(2U, in_flight_surfaces().size());
    251   output_surface_->PageFlipComplete();
    252   CheckUnique();
    253   EXPECT_EQ(1U, in_flight_surfaces().size());
    254   EXPECT_EQ(1U, available_surfaces().size());
    255   output_surface_->BindFramebuffer();
    256   EXPECT_EQ(2, CountBuffers());
    257   CheckUnique();
    258   EXPECT_TRUE(available_surfaces().empty());
    259 }
    260 
    261 TEST_F(BufferQueueTest, CheckTripleBuffering) {
    262   // Check buffer flow through triple buffering path.
    263 
    264   // This bit is the same sequence tested in the doublebuffering case.
    265   output_surface_->BindFramebuffer();
    266   SwapBuffers();
    267   output_surface_->PageFlipComplete();
    268   output_surface_->BindFramebuffer();
    269   SwapBuffers();
    270 
    271   EXPECT_EQ(2, CountBuffers());
    272   CheckUnique();
    273   EXPECT_EQ(2U, in_flight_surfaces().size());
    274   output_surface_->BindFramebuffer();
    275   EXPECT_EQ(3, CountBuffers());
    276   CheckUnique();
    277   EXPECT_NE(0U, current_surface());
    278   EXPECT_EQ(2U, in_flight_surfaces().size());
    279   output_surface_->PageFlipComplete();
    280   EXPECT_EQ(3, CountBuffers());
    281   CheckUnique();
    282   EXPECT_NE(0U, current_surface());
    283   EXPECT_EQ(1U, in_flight_surfaces().size());
    284   EXPECT_EQ(1U, available_surfaces().size());
    285 }
    286 
    287 }  // namespace
    288 }  // namespace content
    289