gpu: Mailbox emulation with EGLImage

gpu/command_buffer/service/mailbox_manager_unittest.cc

 // Copyright 2013 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/mailbox_manager.h"
 
+#include "gpu/command_buffer/service/mailbox_synchronizer.h"
 #include "gpu/command_buffer/service/texture_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gl/gl_mock.h"
 
 namespace gpu {
 namespace gles2 {
 
+using namespace ::testing;
+
 class MailboxManagerTest : public testing::Test {
  public:
-  MailboxManagerTest() : manager_(new MailboxManager()) {}
+  MailboxManagerTest() {}
   virtual ~MailboxManagerTest() {}
 
  protected:
+  virtual void SetUp() {
+    testing::Test::SetUp();
+    manager_ = new MailboxManager;
+  }
+
   Texture* CreateTexture() {
     return new Texture(0);
   }
 
+  void SetTarget(Texture* texture, GLenum target, GLuint max_level) {
+    texture->SetTarget(NULL, target, max_level);
+  }
+
+  void SetLevelInfo(
+      Texture* texture,
+      GLenum target,
+      GLint level,
+      GLenum internal_format,
+      GLsizei width,
+      GLsizei height,
+      GLsizei depth,
+      GLint border,
+      GLenum format,
+      GLenum type,
+      bool cleared) {
+    texture->SetLevelInfo(NULL,
+                          target,
+                          level,
+                          internal_format,
+                          width,
+                          height,
+                          depth,
+                          border,
+                          format,
+                          type,
+                          cleared);
+  }
+
   void DestroyTexture(Texture* texture) {
     delete texture;
   }
 
   scoped_refptr<MailboxManager> manager_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MailboxManagerTest);
 };
 
@@ skipping 86 matching lines @@
 
   // Destroy texture1, shouldn't affect name2.
   DestroyTexture(texture1);
   EXPECT_EQ(NULL, manager_->ConsumeTexture(0, name1));
   EXPECT_EQ(texture2, manager_->ConsumeTexture(0, name2));
 
   DestroyTexture(texture2);
   EXPECT_EQ(NULL, manager_->ConsumeTexture(0, name2));
 }
 
+const GLsizei kMaxTextureWidth = 64;
+const GLsizei kMaxTextureHeight = 64;
+const GLsizei kMaxTextureDepth = 1;
+
+class MailboxManagerSyncTest : public MailboxManagerTest {
+ public:
+  MailboxManagerSyncTest() {}
+  virtual ~MailboxManagerSyncTest() {}
+
+ protected:
+  virtual void SetUp() {
+    MailboxSynchronizer::Initialize();
+    MailboxManagerTest::SetUp();
+    manager2_ = new MailboxManager;
+    gl_.reset(new ::testing::StrictMock< ::gfx::MockGLInterface>());
+    ::gfx::MockGLInterface::SetGLInterface(gl_.get());
+  }
+
+  Texture* DefineTexture() {
+    Texture* texture = CreateTexture();
+    const GLsizei levels_needed = TextureManager::ComputeMipMapCount(
+        GL_TEXTURE_2D, kMaxTextureWidth, kMaxTextureHeight, kMaxTextureDepth);
+    SetTarget(texture, GL_TEXTURE_2D, levels_needed);
+    SetLevelInfo(texture,
+                 GL_TEXTURE_2D,
+                 0,
+                 GL_RGBA,
+                 1,
+                 1,
+                 1,
+                 0,
+                 GL_RGBA,
+                 GL_UNSIGNED_BYTE,
+                 true);
+    return texture;
+  }
+
+  virtual void TearDown() {
+    MailboxManagerTest::TearDown();
+    MailboxSynchronizer::Terminate();
+    ::gfx::MockGLInterface::SetGLInterface(NULL);
+    gl_.reset();
+  }
+
+  scoped_ptr< ::testing::StrictMock< ::gfx::MockGLInterface> > gl_;
+  scoped_refptr<MailboxManager> manager2_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MailboxManagerSyncTest);
+};
+
+TEST_F(MailboxManagerSyncTest, ProduceDestroy) {
+  Texture* texture = DefineTexture();
+  Mailbox name = Mailbox::Generate();
+
+  InSequence sequence;
+  manager_->ProduceTexture(GL_TEXTURE_2D, name, texture);
+  EXPECT_EQ(texture, manager_->ConsumeTexture(GL_TEXTURE_2D, name));
+
+  DestroyTexture(texture);
+  EXPECT_EQ(NULL, manager_->ConsumeTexture(GL_TEXTURE_2D, name));
+  EXPECT_EQ(NULL, manager2_->ConsumeTexture(GL_TEXTURE_2D, name));
+}
+
+TEST_F(MailboxManagerSyncTest, ProduceSyncDestroy) {
+  const EGLDisplay kDisplay = 0;
+  const EGLContext kContext = 0;
+  const EGLImageKHR kEglImage = reinterpret_cast<EGLImageKHR>(0xFEFEFEFE);
+  InSequence sequence;
+
+  Texture* texture = DefineTexture();
+  Mailbox name = Mailbox::Generate();
+
+  manager_->ProduceTexture(GL_TEXTURE_2D, name, texture);
+  EXPECT_EQ(texture, manager_->ConsumeTexture(GL_TEXTURE_2D, name));
+
+  // Synchronize
+  EXPECT_CALL(*gl_, EGLGetCurrentContext()).WillOnce(Return(kContext));
+  EXPECT_CALL(*gl_, EGLCreateImageKHR(_, _, _, _, _))
+      .WillOnce(Return(kEglImage));
+  manager_->PushTextureUpdates();
+  manager2_->PullTextureUpdates();
+
+  EXPECT_CALL(*gl_, EGLDestroyImageKHR(kDisplay, kEglImage))
+      .WillOnce(Return(EGL_TRUE));
+  DestroyTexture(texture);
+  EXPECT_EQ(NULL, manager_->ConsumeTexture(GL_TEXTURE_2D, name));
+  EXPECT_EQ(NULL, manager2_->ConsumeTexture(GL_TEXTURE_2D, name));
+}
+
+TEST_F(MailboxManagerSyncTest, ProduceConsume) {
+  const EGLDisplay kDisplay = 0;
+  const EGLContext kContext = 0;
+  const EGLImageKHR kEglImage = reinterpret_cast<EGLImageKHR>(0xFEFEFEFE);
+  InSequence sequence;
+
+  Texture* texture = DefineTexture();
+  Mailbox name = Mailbox::Generate();
+
+  manager_->ProduceTexture(GL_TEXTURE_2D, name, texture);
+  EXPECT_EQ(texture, manager_->ConsumeTexture(GL_TEXTURE_2D, name));
+
+  // Synchronize
+  EXPECT_CALL(*gl_, EGLGetCurrentContext()).WillOnce(Return(kContext));
+  EXPECT_CALL(*gl_, EGLCreateImageKHR(_, _, _, _, _))
+      .WillOnce(Return(kEglImage));
+  manager_->PushTextureUpdates();
+  manager2_->PullTextureUpdates();
+
+  Texture* new_texture = manager2_->ConsumeTexture(GL_TEXTURE_2D, name);
+  EXPECT_FALSE(new_texture == NULL);
+  EXPECT_NE(texture, new_texture);
+
+  DestroyTexture(texture);
+  // Should be still around since there is a ref from manager2.
+  EXPECT_EQ(new_texture, manager2_->ConsumeTexture(GL_TEXTURE_2D, name));
+
+  EXPECT_CALL(*gl_, EGLDestroyImageKHR(kDisplay, kEglImage))
+      .WillOnce(Return(EGL_TRUE));
+  DestroyTexture(new_texture);
+  EXPECT_EQ(NULL, manager_->ConsumeTexture(GL_TEXTURE_2D, name));
+  EXPECT_EQ(NULL, manager2_->ConsumeTexture(GL_TEXTURE_2D, name));
+}
+
+TEST_F(MailboxManagerSyncTest, Resize) {
+  const EGLDisplay kDisplay = 0;
+  const EGLContext kContext = 0;
+  const EGLImageKHR kEglImage = reinterpret_cast<EGLImageKHR>(0xFEFEFEFE);
+  const EGLImageKHR kEglImage2 = reinterpret_cast<EGLImageKHR>(0xBABABABA);
+
+  Texture* texture = DefineTexture();
+  Mailbox name = Mailbox::Generate();
+
+  InSequence sequence;
+  manager_->ProduceTexture(GL_TEXTURE_2D, name, texture);
+
+  // Synchronize
+  EXPECT_CALL(*gl_, EGLGetCurrentContext()).WillOnce(Return(kContext));
+  EXPECT_CALL(*gl_, EGLCreateImageKHR(_, _, _, _, _))
+      .WillOnce(Return(kEglImage));
+  manager_->PushTextureUpdates();
+  manager2_->PullTextureUpdates();
+
+  // Resize
+  SetLevelInfo(texture,
+               GL_TEXTURE_2D,
+               0,
+               GL_RGBA,
+               16,
+               32,
+               1,
+               0,
+               GL_RGBA,
+               GL_UNSIGNED_BYTE,
+               true);
+  // Should have been orphaned
+  EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 0) == NULL);
+
+  // This should match the state from the last sync before we resized.
+  Texture* new_texture = manager2_->ConsumeTexture(GL_TEXTURE_2D, name);
+  GLsizei width, height;
+  new_texture->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height);
+  EXPECT_EQ(1, width);
+  EXPECT_EQ(1, height);
+
+  // Synchronize
+  EXPECT_CALL(*gl_, EGLGetCurrentContext()).WillOnce(Return(kContext));
+  EXPECT_CALL(*gl_, EGLCreateImageKHR(_, _, _, _, _))
+      .WillOnce(Return(kEglImage2));
+  EXPECT_CALL(*gl_, EGLDestroyImageKHR(kDisplay, kEglImage))
+      .WillOnce(Return(EGL_TRUE));
+  manager_->PushTextureUpdates();
+  manager2_->PullTextureUpdates();
+
+  new_texture->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height);
+  EXPECT_EQ(16, width);
+  EXPECT_EQ(32, height);
+
+  EXPECT_CALL(*gl_, EGLDestroyImageKHR(kDisplay, kEglImage2))
+      .WillOnce(Return(EGL_TRUE));
+  DestroyTexture(texture);
+  DestroyTexture(new_texture);
+  EXPECT_EQ(NULL, manager_->ConsumeTexture(GL_TEXTURE_2D, name));
+  EXPECT_EQ(NULL, manager2_->ConsumeTexture(GL_TEXTURE_2D, name));
+}
+
+// TODO: different texture into same mailbox
+
+// TODO: same texture, multiple mailboxes
+
+// TODO: Produce incomplete texture
+
+// TODO: Texture::level_infos_[][].size()
+
+// TODO: unsupported targets and formats
+
 }  // namespace gles2
 }  // namespace gpu