GPU client side changes for GpuMemoryBuffers

gpu/command_buffer/tests/gl_gpu_memory_buffer_unittests.cc

+// Copyright (c) 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 <GLES2/gl2.h>
+#include <GLES2/gl2chromium.h>
+#include <GLES2/gl2ext.h>
+#include <GLES2/gl2extchromium.h>
+
+#include "base/bind.h"
+#include "base/memory/ref_counted.h"
+#include "gpu/command_buffer/client/gles2_implementation.h"
+#include "gpu/command_buffer/client/gpu_memory_buffer_factory.h"
+#include "gpu/command_buffer/client/gpu_memory_buffer_mock.h"
+#include "gpu/command_buffer/client/gpu_memory_buffer_tracker_mock.h"
+#include "gpu/command_buffer/client/image_factory_mock.h"
+#include "gpu/command_buffer/service/image_manager.h"
+#include "gpu/command_buffer/tests/gl_manager.h"
+#include "gpu/command_buffer/tests/gl_test_utils.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/native_widget_types.h"
+#include "ui/gl/gl_image.h"
+#include "ui/gl/gl_image_mock.h"
+
+using testing::_;
+using testing::Return;
+using testing::SetArgPointee;
+using testing::StrictMock;
+
+namespace gpu {
+namespace gles2 {
+
+static const int kGpuMemoryBufferWidth = 256;
+static const int kGpuMemoryBufferHeight = 256;
+static const int kGpuMemoryBufferBytesPerPixel = 4;
+
+class GLGpuMemoryBufferTest : public testing::Test {
+ protected:
+  virtual void SetUp() {
+    GLManager::Options options;
+    image_manager_ = new ImageManager;
+    options.image_manager = image_manager_;
+
+    scoped_ptr<StrictMock<ImageFactoryMock> > image_factory(
+        new StrictMock<ImageFactoryMock>(image_manager_));
+    image_factory_ = image_factory.get();

[reveman, 2013/05/10 02:06:16]

Saving a pointer and passing ownership to a different object is not great. I
think all this would be much cleaner if GLES2Implementation didn't take
ownership of the ImageFactory.

[kaanb, 2013/05/13 23:00:36]

Done.

+
+    scoped_ptr<StrictMock<GpuMemoryBufferTrackerMock> >
+        gpu_memory_buffer_tracker(
+            new StrictMock<GpuMemoryBufferTrackerMock>(image_factory_));
+    gpu_memory_buffer_tracker_ = gpu_memory_buffer_tracker.get();
+
+    gl_.Initialize(options);
+
+    // GLES2Implementation will take ownership of ImageFactory and
+    // GpuMemoryBufferTracker.
+    gl_.gles2_implementation()->SetImageFactory(
+        image_factory.PassAs<ImageFactory>());
+    gl_.gles2_implementation()->SetGpuMemoryBufferTracker(
+        gpu_memory_buffer_tracker.PassAs<GpuMemoryBufferTracker>());
+    gl_.MakeCurrent();
+    mapped_buffer_.reset(new uint8[
+        kGpuMemoryBufferWidth * kGpuMemoryBufferHeight
+        * kGpuMemoryBufferBytesPerPixel]);
+
+    gpu_memory_buffer_.reset(
+        new StrictMock<GpuMemoryBufferMock>(kGpuMemoryBufferWidth,
+                                            kGpuMemoryBufferHeight));
+  }
+
+  virtual void TearDown() {
+    gl_.Destroy();
+  }
+
+  // TODO(kaanb): do I need the ImageFactory mock?
+  StrictMock<ImageFactoryMock>* image_factory_;
+  scoped_refptr<ImageManager> image_manager_;
+  scoped_ptr<uint8[]> mapped_buffer_;
+  StrictMock<GpuMemoryBufferTrackerMock>* gpu_memory_buffer_tracker_;
+  scoped_ptr<StrictMock<GpuMemoryBufferMock> > gpu_memory_buffer_;
+  GLManager gl_;
+};
+
+// An end to end test that tests the whole GpuMemoryBuffer lifecycle.
+TEST_F(GLGpuMemoryBufferTest, Lifecycle) {
+  // Create a client texture id.
+
+  GLuint texture_id;
+  glGenTextures(1, &texture_id);
+
+  // Create the GLImage and insert it into the ImageManager.
+  EXPECT_CALL(*gpu_memory_buffer_tracker_, CreateBuffer(_, _))
+      .Times(1)
+      .WillOnce(Return(1))
+      .RetiresOnSaturation();
+  GLuint image_id =
+      glCreateImageCHROMIUM(kGpuMemoryBufferWidth, kGpuMemoryBufferHeight);
+  gfx::Size size(kGpuMemoryBufferWidth, kGpuMemoryBufferHeight);
+  gfx::GLImageMock* gl_image = new gfx::GLImageMock(NULL, size);
+  image_manager_->AddImage(gl_image, image_id);
+
+  EXPECT_CALL(*gpu_memory_buffer_.get(), IsMapped())
+      .WillOnce(Return(false))  // before Map()
+      .WillOnce(Return(true))   // after Map() and before Unmap()
+      .RetiresOnSaturation();
+
+  EXPECT_CALL(*gpu_memory_buffer_tracker_, GetBuffer(image_id))
+      .WillOnce(Return(gpu_memory_buffer_.get()))  // Map()
+      .WillOnce(Return(gpu_memory_buffer_.get()))  // UnMap()
+      .WillOnce(Return(gpu_memory_buffer_.get()))  // DestroyImage()
+      .RetiresOnSaturation();
+
+  EXPECT_CALL(*gpu_memory_buffer_.get(), Map(_, _))
+      .Times(1)
+      .WillOnce(SetArgPointee<1>(mapped_buffer_.get()))
+      .RetiresOnSaturation();
+  void* mapped_buffer =
+      glMapImageCHROMIUM(image_id, GL_WRITE_ONLY);
+  EXPECT_EQ(mapped_buffer_.get(), mapped_buffer);
+
+  // Unmap the image.
+  EXPECT_CALL(*gpu_memory_buffer_.get(), Unmap())
+      .Times(1)
+      .RetiresOnSaturation();
+  glUnmapImageCHROMIUM(image_id);
+
+  // Bind the texture and the image.
+  glBindTexture(GL_TEXTURE_2D, texture_id);
+  EXPECT_CALL(*gl_image, BindTexImage())
+      .Times(1)
+      .WillOnce(Return(true))
+      .RetiresOnSaturation();
+  EXPECT_CALL(*gl_image, GetSize())
+      .Times(1)
+      .WillOnce(Return(size))
+      .RetiresOnSaturation();
+  glBindTexImage2DCHROMIUM(GL_TEXTURE_2D, image_id);
+
+  // Destroy the image.
+  EXPECT_CALL(*gpu_memory_buffer_tracker_, RemoveBuffer(image_id))
+      .Times(1)
+      .RetiresOnSaturation();
+  EXPECT_CALL(*gpu_memory_buffer_.get(), Die())
+      .Times(1)
+      .RetiresOnSaturation();
+  glDestroyImageCHROMIUM(image_id);
+
+  // Delete the texture.
+  glDeleteTextures(1, &texture_id);
+}
+
+}  // namespace gles2
+}  // namespace gpu