blob: 91e8d008792f7efe2eb2dea53a535c11fc7c147a [file] [log] [blame]
// Copyright 2012 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 "cc/resources/resource_provider.h"
#include <algorithm>
#include "base/bind.h"
#include "base/logging.h"
#include "cc/base/scoped_ptr_deque.h"
#include "cc/base/scoped_ptr_hash_map.h"
#include "cc/output/output_surface.h"
#include "cc/test/fake_output_surface.h"
#include "cc/test/test_web_graphics_context_3d.h"
#include "gpu/GLES2/gl2extchromium.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/WebKit/Source/Platform/chromium/public/WebGraphicsContext3D.h"
#include "third_party/khronos/GLES2/gl2.h"
#include "third_party/khronos/GLES2/gl2ext.h"
#include "ui/gfx/rect.h"
using testing::Mock;
using testing::NiceMock;
using testing::Return;
using testing::SetArgPointee;
using testing::StrictMock;
using testing::_;
using WebKit::WGC3Dbyte;
using WebKit::WGC3Denum;
using WebKit::WGC3Dint;
using WebKit::WGC3Dsizei;
using WebKit::WGC3Duint;
using WebKit::WebGLId;
namespace cc {
namespace {
size_t TextureSize(gfx::Size size, WGC3Denum format) {
unsigned int components_per_pixel = 4;
unsigned int bytes_per_component = 1;
return size.width() * size.height() * components_per_pixel *
bytes_per_component;
}
struct Texture {
Texture() : format(0), filter(GL_NEAREST_MIPMAP_LINEAR) {}
void Reallocate(gfx::Size size, WGC3Denum format) {
this->size = size;
this->format = format;
this->data.reset(new uint8_t[TextureSize(size, format)]);
}
gfx::Size size;
WGC3Denum format;
WGC3Denum filter;
scoped_ptr<uint8_t[]> data;
};
// Shared data between multiple ResourceProviderContext. This contains mailbox
// contents as well as information about sync points.
class ContextSharedData {
public:
static scoped_ptr<ContextSharedData> Create() {
return make_scoped_ptr(new ContextSharedData());
}
unsigned InsertSyncPoint() { return next_sync_point_++; }
void GenMailbox(WGC3Dbyte* mailbox) {
memset(mailbox, 0, sizeof(WGC3Dbyte[64]));
memcpy(mailbox, &next_mailbox_, sizeof(next_mailbox_));
++next_mailbox_;
}
void ProduceTexture(const WGC3Dbyte* mailbox_name,
unsigned sync_point,
scoped_ptr<Texture> texture) {
unsigned mailbox = 0;
memcpy(&mailbox, mailbox_name, sizeof(mailbox));
ASSERT_TRUE(mailbox && mailbox < next_mailbox_);
textures_.set(mailbox, texture.Pass());
ASSERT_LT(sync_point_for_mailbox_[mailbox], sync_point);
sync_point_for_mailbox_[mailbox] = sync_point;
}
scoped_ptr<Texture> ConsumeTexture(const WGC3Dbyte* mailbox_name,
unsigned sync_point) {
unsigned mailbox = 0;
memcpy(&mailbox, mailbox_name, sizeof(mailbox));
DCHECK(mailbox && mailbox < next_mailbox_);
// If the latest sync point the context has waited on is before the sync
// point for when the mailbox was set, pretend we never saw that
// ProduceTexture.
if (sync_point_for_mailbox_[mailbox] > sync_point) {
NOTREACHED();
return scoped_ptr<Texture>();
}
return textures_.take(mailbox);
}
private:
ContextSharedData() : next_sync_point_(1), next_mailbox_(1) {}
unsigned next_sync_point_;
unsigned next_mailbox_;
typedef ScopedPtrHashMap<unsigned, Texture> TextureMap;
TextureMap textures_;
base::hash_map<unsigned, unsigned> sync_point_for_mailbox_;
};
class ResourceProviderContext : public TestWebGraphicsContext3D {
public:
static scoped_ptr<ResourceProviderContext> Create(
ContextSharedData* shared_data) {
return make_scoped_ptr(
new ResourceProviderContext(Attributes(), shared_data));
}
virtual unsigned insertSyncPoint() OVERRIDE {
unsigned sync_point = shared_data_->InsertSyncPoint();
// Commit the produceTextureCHROMIUM calls at this point, so that
// they're associated with the sync point.
for (PendingProduceTextureList::iterator it =
pending_produce_textures_.begin();
it != pending_produce_textures_.end();
++it) {
shared_data_->ProduceTexture(
(*it)->mailbox, sync_point, (*it)->texture.Pass());
}
pending_produce_textures_.clear();
return sync_point;
}
virtual void waitSyncPoint(unsigned sync_point) OVERRIDE {
last_waited_sync_point_ = std::max(sync_point, last_waited_sync_point_);
}
virtual void bindTexture(WGC3Denum target, WebGLId texture) OVERRIDE {
ASSERT_EQ(static_cast<unsigned>(GL_TEXTURE_2D), target);
ASSERT_TRUE(!texture || textures_.find(texture) != textures_.end());
current_texture_ = texture;
}
virtual WebGLId createTexture() OVERRIDE {
WebGLId id = TestWebGraphicsContext3D::createTexture();
textures_.add(id, make_scoped_ptr(new Texture));
return id;
}
virtual void deleteTexture(WebGLId id) OVERRIDE {
TextureMap::iterator it = textures_.find(id);
ASSERT_FALSE(it == textures_.end());
textures_.erase(it);
if (current_texture_ == id)
current_texture_ = 0;
}
virtual void texStorage2DEXT(WGC3Denum target,
WGC3Dint levels,
WGC3Duint internalformat,
WGC3Dint width,
WGC3Dint height) OVERRIDE {
ASSERT_TRUE(current_texture_);
ASSERT_EQ(static_cast<unsigned>(GL_TEXTURE_2D), target);
ASSERT_EQ(1, levels);
WGC3Denum format = GL_RGBA;
switch (internalformat) {
case GL_RGBA8_OES:
break;
case GL_BGRA8_EXT:
format = GL_BGRA_EXT;
break;
default:
NOTREACHED();
}
AllocateTexture(gfx::Size(width, height), format);
}
virtual void texImage2D(WGC3Denum target,
WGC3Dint level,
WGC3Denum internalformat,
WGC3Dsizei width,
WGC3Dsizei height,
WGC3Dint border,
WGC3Denum format,
WGC3Denum type,
const void* pixels) OVERRIDE {
ASSERT_TRUE(current_texture_);
ASSERT_EQ(static_cast<unsigned>(GL_TEXTURE_2D), target);
ASSERT_FALSE(level);
ASSERT_EQ(internalformat, format);
ASSERT_FALSE(border);
ASSERT_EQ(static_cast<unsigned>(GL_UNSIGNED_BYTE), type);
AllocateTexture(gfx::Size(width, height), format);
if (pixels)
SetPixels(0, 0, width, height, pixels);
}
virtual void texSubImage2D(WGC3Denum target,
WGC3Dint level,
WGC3Dint xoffset,
WGC3Dint yoffset,
WGC3Dsizei width,
WGC3Dsizei height,
WGC3Denum format,
WGC3Denum type,
const void* pixels) OVERRIDE {
ASSERT_TRUE(current_texture_);
ASSERT_EQ(static_cast<unsigned>(GL_TEXTURE_2D), target);
ASSERT_FALSE(level);
ASSERT_TRUE(textures_.get(current_texture_));
ASSERT_EQ(textures_.get(current_texture_)->format, format);
ASSERT_EQ(static_cast<unsigned>(GL_UNSIGNED_BYTE), type);
ASSERT_TRUE(pixels);
SetPixels(xoffset, yoffset, width, height, pixels);
}
virtual void texParameteri(WGC3Denum target, WGC3Denum param, WGC3Dint value)
OVERRIDE {
ASSERT_TRUE(current_texture_);
ASSERT_EQ(static_cast<unsigned>(GL_TEXTURE_2D), target);
Texture* texture = textures_.get(current_texture_);
ASSERT_TRUE(texture);
if (param != GL_TEXTURE_MIN_FILTER)
return;
texture->filter = value;
}
virtual void genMailboxCHROMIUM(WGC3Dbyte* mailbox) OVERRIDE {
return shared_data_->GenMailbox(mailbox);
}
virtual void produceTextureCHROMIUM(WGC3Denum target,
const WGC3Dbyte* mailbox) OVERRIDE {
ASSERT_TRUE(current_texture_);
ASSERT_EQ(static_cast<unsigned>(GL_TEXTURE_2D), target);
// Delay moving the texture into the mailbox until the next
// InsertSyncPoint, so that it is not visible to other contexts that
// haven't waited on that sync point.
scoped_ptr<PendingProduceTexture> pending(new PendingProduceTexture);
memcpy(pending->mailbox, mailbox, sizeof(pending->mailbox));
pending->texture = textures_.take(current_texture_);
textures_.set(current_texture_, scoped_ptr<Texture>());
pending_produce_textures_.push_back(pending.Pass());
}
virtual void consumeTextureCHROMIUM(WGC3Denum target,
const WGC3Dbyte* mailbox) OVERRIDE {
ASSERT_TRUE(current_texture_);
ASSERT_EQ(static_cast<unsigned>(GL_TEXTURE_2D), target);
textures_.set(
current_texture_,
shared_data_->ConsumeTexture(mailbox, last_waited_sync_point_));
}
void GetPixels(gfx::Size size, WGC3Denum format, uint8_t* pixels) {
ASSERT_TRUE(current_texture_);
Texture* texture = textures_.get(current_texture_);
ASSERT_TRUE(texture);
ASSERT_EQ(texture->size, size);
ASSERT_EQ(texture->format, format);
memcpy(pixels, texture->data.get(), TextureSize(size, format));
}
WGC3Denum GetTextureFilter() {
DCHECK(current_texture_);
Texture* texture = textures_.get(current_texture_);
DCHECK(texture);
return texture->filter;
}
int texture_count() { return textures_.size(); }
protected:
ResourceProviderContext(const Attributes& attrs,
ContextSharedData* shared_data)
: TestWebGraphicsContext3D(attrs),
shared_data_(shared_data),
current_texture_(0),
last_waited_sync_point_(0) {}
private:
void AllocateTexture(gfx::Size size, WGC3Denum format) {
ASSERT_TRUE(current_texture_);
Texture* texture = textures_.get(current_texture_);
ASSERT_TRUE(texture);
texture->Reallocate(size, format);
}
void SetPixels(int xoffset,
int yoffset,
int width,
int height,
const void* pixels) {
ASSERT_TRUE(current_texture_);
Texture* texture = textures_.get(current_texture_);
ASSERT_TRUE(texture);
ASSERT_TRUE(texture->data.get());
ASSERT_TRUE(xoffset >= 0 && xoffset + width <= texture->size.width());
ASSERT_TRUE(yoffset >= 0 && yoffset + height <= texture->size.height());
ASSERT_TRUE(pixels);
size_t in_pitch = TextureSize(gfx::Size(width, 1), texture->format);
size_t out_pitch =
TextureSize(gfx::Size(texture->size.width(), 1), texture->format);
uint8_t* dest = texture->data.get() + yoffset * out_pitch +
TextureSize(gfx::Size(xoffset, 1), texture->format);
const uint8_t* src = static_cast<const uint8_t*>(pixels);
for (int i = 0; i < height; ++i) {
memcpy(dest, src, in_pitch);
dest += out_pitch;
src += in_pitch;
}
}
typedef ScopedPtrHashMap<WebGLId, Texture> TextureMap;
struct PendingProduceTexture {
WGC3Dbyte mailbox[64];
scoped_ptr<Texture> texture;
};
typedef ScopedPtrDeque<PendingProduceTexture> PendingProduceTextureList;
ContextSharedData* shared_data_;
WebGLId current_texture_;
TextureMap textures_;
unsigned last_waited_sync_point_;
PendingProduceTextureList pending_produce_textures_;
};
class ResourceProviderTest
: public testing::TestWithParam<ResourceProvider::ResourceType> {
public:
ResourceProviderTest()
: shared_data_(ContextSharedData::Create()),
output_surface_(FakeOutputSurface::Create3d(
ResourceProviderContext::Create(shared_data_.get())
.PassAs<WebKit::WebGraphicsContext3D>())),
resource_provider_(ResourceProvider::Create(output_surface_.get(), 0)) {
resource_provider_->set_default_resource_type(GetParam());
}
ResourceProviderContext* context() {
return static_cast<ResourceProviderContext*>(output_surface_->context3d());
}
void GetResourcePixels(ResourceProvider::ResourceId id,
gfx::Size size,
WGC3Denum format,
uint8_t* pixels) {
if (GetParam() == ResourceProvider::GLTexture) {
ResourceProvider::ScopedReadLockGL lock_gl(resource_provider_.get(), id);
ASSERT_NE(0U, lock_gl.texture_id());
context()->bindTexture(GL_TEXTURE_2D, lock_gl.texture_id());
context()->GetPixels(size, format, pixels);
} else if (GetParam() == ResourceProvider::Bitmap) {
ResourceProvider::ScopedReadLockSoftware lock_software(
resource_provider_.get(), id);
memcpy(pixels,
lock_software.sk_bitmap()->getPixels(),
lock_software.sk_bitmap()->getSize());
}
}
void SetResourceFilter(ResourceProvider* resource_provider,
ResourceProvider::ResourceId id,
WGC3Denum filter) {
ResourceProvider::ScopedSamplerGL sampler(
resource_provider, id, GL_TEXTURE_2D, filter);
}
WGC3Denum GetResourceFilter(ResourceProvider* resource_provider,
ResourceProvider::ResourceId id) {
DCHECK_EQ(GetParam(), ResourceProvider::GLTexture);
ResourceProvider::ScopedReadLockGL lock_gl(resource_provider, id);
EXPECT_NE(0u, lock_gl.texture_id());
ResourceProviderContext* context = static_cast<ResourceProviderContext*>(
resource_provider->GraphicsContext3D());
context->bindTexture(GL_TEXTURE_2D, lock_gl.texture_id());
return context->GetTextureFilter();
}
void ExpectNumResources(int count) {
EXPECT_EQ(count, static_cast<int>(resource_provider_->num_resources()));
if (GetParam() == ResourceProvider::GLTexture)
EXPECT_EQ(count, context()->texture_count());
}
protected:
scoped_ptr<ContextSharedData> shared_data_;
scoped_ptr<OutputSurface> output_surface_;
scoped_ptr<ResourceProvider> resource_provider_;
};
TEST_P(ResourceProviderTest, Basic) {
gfx::Size size(1, 1);
WGC3Denum format = GL_RGBA;
size_t pixel_size = TextureSize(size, format);
ASSERT_EQ(4U, pixel_size);
ResourceProvider::ResourceId id = resource_provider_->CreateResource(
size, format, ResourceProvider::TextureUsageAny);
ExpectNumResources(1);
uint8_t data[4] = { 1, 2, 3, 4 };
gfx::Rect rect(size);
resource_provider_->SetPixels(id, data, rect, rect, gfx::Vector2d());
uint8_t result[4] = { 0 };
GetResourcePixels(id, size, format, result);
EXPECT_EQ(0, memcmp(data, result, pixel_size));
resource_provider_->DeleteResource(id);
ExpectNumResources(0);
}
TEST_P(ResourceProviderTest, Upload) {
gfx::Size size(2, 2);
WGC3Denum format = GL_RGBA;
size_t pixel_size = TextureSize(size, format);
ASSERT_EQ(16U, pixel_size);
ResourceProvider::ResourceId id = resource_provider_->CreateResource(
size, format, ResourceProvider::TextureUsageAny);
uint8_t image[16] = { 0 };
gfx::Rect image_rect(size);
resource_provider_->SetPixels(
id, image, image_rect, image_rect, gfx::Vector2d());
for (uint8_t i = 0; i < pixel_size; ++i)
image[i] = i;
uint8_t result[16] = { 0 };
{
gfx::Rect source_rect(0, 0, 1, 1);
gfx::Vector2d dest_offset(0, 0);
resource_provider_->SetPixels(
id, image, image_rect, source_rect, dest_offset);
uint8_t expected[16] = { 0, 1, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
GetResourcePixels(id, size, format, result);
EXPECT_EQ(0, memcmp(expected, result, pixel_size));
}
{
gfx::Rect source_rect(0, 0, 1, 1);
gfx::Vector2d dest_offset(1, 1);
resource_provider_->SetPixels(
id, image, image_rect, source_rect, dest_offset);
uint8_t expected[16] = { 0, 1, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 };
GetResourcePixels(id, size, format, result);
EXPECT_EQ(0, memcmp(expected, result, pixel_size));
}
{
gfx::Rect source_rect(1, 0, 1, 1);
gfx::Vector2d dest_offset(0, 1);
resource_provider_->SetPixels(
id, image, image_rect, source_rect, dest_offset);
uint8_t expected[16] = { 0, 1, 2, 3, 0, 0, 0, 0, 4, 5, 6, 7, 0, 1, 2, 3 };
GetResourcePixels(id, size, format, result);
EXPECT_EQ(0, memcmp(expected, result, pixel_size));
}
{
gfx::Rect offset_image_rect(gfx::Point(100, 100), size);
gfx::Rect source_rect(100, 100, 1, 1);
gfx::Vector2d dest_offset(1, 0);
resource_provider_->SetPixels(
id, image, offset_image_rect, source_rect, dest_offset);
uint8_t expected[16] = { 0, 1, 2, 3, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3 };
GetResourcePixels(id, size, format, result);
EXPECT_EQ(0, memcmp(expected, result, pixel_size));
}
resource_provider_->DeleteResource(id);
}
TEST_P(ResourceProviderTest, TransferResources) {
// Resource transfer is only supported with GL textures for now.
if (GetParam() != ResourceProvider::GLTexture)
return;
scoped_ptr<OutputSurface> child_output_surface(FakeOutputSurface::Create3d(
ResourceProviderContext::Create(shared_data_.get())
.PassAs<WebKit::WebGraphicsContext3D>()));
scoped_ptr<ResourceProvider> child_resource_provider(
ResourceProvider::Create(child_output_surface.get(), 0));
gfx::Size size(1, 1);
WGC3Denum format = GL_RGBA;
size_t pixel_size = TextureSize(size, format);
ASSERT_EQ(4U, pixel_size);
ResourceProvider::ResourceId id1 = child_resource_provider->CreateResource(
size, format, ResourceProvider::TextureUsageAny);
uint8_t data1[4] = { 1, 2, 3, 4 };
gfx::Rect rect(size);
child_resource_provider->SetPixels(id1, data1, rect, rect, gfx::Vector2d());
ResourceProvider::ResourceId id2 = child_resource_provider->CreateResource(
size, format, ResourceProvider::TextureUsageAny);
uint8_t data2[4] = { 5, 5, 5, 5 };
child_resource_provider->SetPixels(id2, data2, rect, rect, gfx::Vector2d());
int child_id = resource_provider_->CreateChild();
{
// Transfer some resources to the parent.
ResourceProvider::ResourceIdArray resource_ids_to_transfer;
resource_ids_to_transfer.push_back(id1);
resource_ids_to_transfer.push_back(id2);
TransferableResourceArray list;
child_resource_provider->PrepareSendToParent(resource_ids_to_transfer,
&list);
ASSERT_EQ(2u, list.size());
EXPECT_NE(0u, list[0].sync_point);
EXPECT_NE(0u, list[1].sync_point);
EXPECT_TRUE(child_resource_provider->InUseByConsumer(id1));
EXPECT_TRUE(child_resource_provider->InUseByConsumer(id2));
resource_provider_->ReceiveFromChild(child_id, list);
}
EXPECT_EQ(2u, resource_provider_->num_resources());
ResourceProvider::ResourceIdMap resource_map =
resource_provider_->GetChildToParentMap(child_id);
ResourceProvider::ResourceId mapped_id1 = resource_map[id1];
ResourceProvider::ResourceId mapped_id2 = resource_map[id2];
EXPECT_NE(0u, mapped_id1);
EXPECT_NE(0u, mapped_id2);
EXPECT_FALSE(resource_provider_->InUseByConsumer(id1));
EXPECT_FALSE(resource_provider_->InUseByConsumer(id2));
uint8_t result[4] = { 0 };
GetResourcePixels(mapped_id1, size, format, result);
EXPECT_EQ(0, memcmp(data1, result, pixel_size));
GetResourcePixels(mapped_id2, size, format, result);
EXPECT_EQ(0, memcmp(data2, result, pixel_size));
{
// Check that transfering again the same resource from the child to the
// parent is a noop.
ResourceProvider::ResourceIdArray resource_ids_to_transfer;
resource_ids_to_transfer.push_back(id1);
TransferableResourceArray list;
child_resource_provider->PrepareSendToParent(resource_ids_to_transfer,
&list);
EXPECT_EQ(0u, list.size());
}
{
// Transfer resources back from the parent to the child.
ResourceProvider::ResourceIdArray resource_ids_to_transfer;
resource_ids_to_transfer.push_back(mapped_id1);
resource_ids_to_transfer.push_back(mapped_id2);
TransferableResourceArray list;
resource_provider_->PrepareSendToChild(
child_id, resource_ids_to_transfer, &list);
ASSERT_EQ(2u, list.size());
EXPECT_NE(0u, list[0].sync_point);
EXPECT_NE(0u, list[1].sync_point);
child_resource_provider->ReceiveFromParent(list);
}
EXPECT_FALSE(child_resource_provider->InUseByConsumer(id1));
EXPECT_FALSE(child_resource_provider->InUseByConsumer(id2));
ResourceProviderContext* child_context =
static_cast<ResourceProviderContext*>(child_output_surface->context3d());
{
ResourceProvider::ScopedReadLockGL lock(child_resource_provider.get(), id1);
ASSERT_NE(0U, lock.texture_id());
child_context->bindTexture(GL_TEXTURE_2D, lock.texture_id());
child_context->GetPixels(size, format, result);
EXPECT_EQ(0, memcmp(data1, result, pixel_size));
}
{
ResourceProvider::ScopedReadLockGL lock(child_resource_provider.get(), id2);
ASSERT_NE(0U, lock.texture_id());
child_context->bindTexture(GL_TEXTURE_2D, lock.texture_id());
child_context->GetPixels(size, format, result);
EXPECT_EQ(0, memcmp(data2, result, pixel_size));
}
{
// Transfer resources to the parent again.
ResourceProvider::ResourceIdArray resource_ids_to_transfer;
resource_ids_to_transfer.push_back(id1);
resource_ids_to_transfer.push_back(id2);
TransferableResourceArray list;
child_resource_provider->PrepareSendToParent(resource_ids_to_transfer,
&list);
ASSERT_EQ(2u, list.size());
EXPECT_NE(0u, list[0].sync_point);
EXPECT_NE(0u, list[1].sync_point);
EXPECT_TRUE(child_resource_provider->InUseByConsumer(id1));
EXPECT_TRUE(child_resource_provider->InUseByConsumer(id2));
resource_provider_->ReceiveFromChild(child_id, list);
}
EXPECT_EQ(2u, resource_provider_->num_resources());
resource_provider_->DestroyChild(child_id);
EXPECT_EQ(0u, resource_provider_->num_resources());
}
TEST_P(ResourceProviderTest, DeleteTransferredResources) {
// Resource transfer is only supported with GL textures for now.
if (GetParam() != ResourceProvider::GLTexture)
return;
scoped_ptr<OutputSurface> child_output_surface(FakeOutputSurface::Create3d(
ResourceProviderContext::Create(shared_data_.get())
.PassAs<WebKit::WebGraphicsContext3D>()));
scoped_ptr<ResourceProvider> child_resource_provider(
ResourceProvider::Create(child_output_surface.get(), 0));
gfx::Size size(1, 1);
WGC3Denum format = GL_RGBA;
size_t pixel_size = TextureSize(size, format);
ASSERT_EQ(4U, pixel_size);
ResourceProvider::ResourceId id = child_resource_provider->CreateResource(
size, format, ResourceProvider::TextureUsageAny);
uint8_t data[4] = { 1, 2, 3, 4 };
gfx::Rect rect(size);
child_resource_provider->SetPixels(id, data, rect, rect, gfx::Vector2d());
int child_id = resource_provider_->CreateChild();
{
// Transfer some resource to the parent.
ResourceProvider::ResourceIdArray resource_ids_to_transfer;
resource_ids_to_transfer.push_back(id);
TransferableResourceArray list;
child_resource_provider->PrepareSendToParent(resource_ids_to_transfer,
&list);
ASSERT_EQ(1u, list.size());
EXPECT_NE(0u, list[0].sync_point);
EXPECT_TRUE(child_resource_provider->InUseByConsumer(id));
resource_provider_->ReceiveFromChild(child_id, list);
}
// Delete textures in the child, while they are transfered.
child_resource_provider->DeleteResource(id);
EXPECT_EQ(1u, child_resource_provider->num_resources());
{
// Transfer resources back from the parent to the child.
ResourceProvider::ResourceIdMap resource_map =
resource_provider_->GetChildToParentMap(child_id);
ResourceProvider::ResourceId mapped_id = resource_map[id];
EXPECT_NE(0u, mapped_id);
ResourceProvider::ResourceIdArray resource_ids_to_transfer;
resource_ids_to_transfer.push_back(mapped_id);
TransferableResourceArray list;
resource_provider_->PrepareSendToChild(
child_id, resource_ids_to_transfer, &list);
ASSERT_EQ(1u, list.size());
EXPECT_NE(0u, list[0].sync_point);
child_resource_provider->ReceiveFromParent(list);
}
EXPECT_EQ(0u, child_resource_provider->num_resources());
}
TEST_P(ResourceProviderTest, TextureFilters) {
// Resource transfer is only supported with GL textures for now.
if (GetParam() != ResourceProvider::GLTexture)
return;
scoped_ptr<OutputSurface> child_output_surface(FakeOutputSurface::Create3d(
ResourceProviderContext::Create(shared_data_.get())
.PassAs<WebKit::WebGraphicsContext3D>()));
scoped_ptr<ResourceProvider> child_resource_provider(
ResourceProvider::Create(child_output_surface.get(), 0));
gfx::Size size(1, 1);
WGC3Denum format = GL_RGBA;
size_t pixel_size = TextureSize(size, format);
ASSERT_EQ(4U, pixel_size);
ResourceProvider::ResourceId id = child_resource_provider->CreateResource(
size, format, ResourceProvider::TextureUsageAny);
uint8_t data[4] = { 1, 2, 3, 4 };
gfx::Rect rect(size);
child_resource_provider->SetPixels(id, data, rect, rect, gfx::Vector2d());
EXPECT_EQ(static_cast<unsigned>(GL_LINEAR),
GetResourceFilter(child_resource_provider.get(), id));
SetResourceFilter(child_resource_provider.get(), id, GL_NEAREST);
EXPECT_EQ(static_cast<unsigned>(GL_NEAREST),
GetResourceFilter(child_resource_provider.get(), id));
int child_id = resource_provider_->CreateChild();
{
// Transfer some resource to the parent.
ResourceProvider::ResourceIdArray resource_ids_to_transfer;
resource_ids_to_transfer.push_back(id);
TransferableResourceArray list;
child_resource_provider->PrepareSendToParent(resource_ids_to_transfer,
&list);
ASSERT_EQ(1u, list.size());
EXPECT_EQ(static_cast<unsigned>(GL_NEAREST), list[0].filter);
resource_provider_->ReceiveFromChild(child_id, list);
}
ResourceProvider::ResourceIdMap resource_map =
resource_provider_->GetChildToParentMap(child_id);
ResourceProvider::ResourceId mapped_id = resource_map[id];
EXPECT_NE(0u, mapped_id);
EXPECT_EQ(static_cast<unsigned>(GL_NEAREST),
GetResourceFilter(resource_provider_.get(), mapped_id));
SetResourceFilter(resource_provider_.get(), mapped_id, GL_LINEAR);
EXPECT_EQ(static_cast<unsigned>(GL_LINEAR),
GetResourceFilter(resource_provider_.get(), mapped_id));
{
// Transfer resources back from the parent to the child.
ResourceProvider::ResourceIdArray resource_ids_to_transfer;
resource_ids_to_transfer.push_back(mapped_id);
TransferableResourceArray list;
resource_provider_->PrepareSendToChild(
child_id, resource_ids_to_transfer, &list);
ASSERT_EQ(1u, list.size());
EXPECT_EQ(static_cast<unsigned>(GL_LINEAR), list[0].filter);
child_resource_provider->ReceiveFromParent(list);
}
EXPECT_EQ(static_cast<unsigned>(GL_LINEAR),
GetResourceFilter(child_resource_provider.get(), id));
SetResourceFilter(child_resource_provider.get(), id, GL_NEAREST);
EXPECT_EQ(static_cast<unsigned>(GL_NEAREST),
GetResourceFilter(child_resource_provider.get(), id));
}
void ReleaseTextureMailbox(unsigned* release_sync_point,
bool* release_lost_resource,
unsigned sync_point,
bool lost_resource) {
*release_sync_point = sync_point;
*release_lost_resource = lost_resource;
}
TEST_P(ResourceProviderTest, TransferMailboxResources) {
// Resource transfer is only supported with GL textures for now.
if (GetParam() != ResourceProvider::GLTexture)
return;
unsigned texture = context()->createTexture();
context()->bindTexture(GL_TEXTURE_2D, texture);
uint8_t data[4] = { 1, 2, 3, 4 };
context()->texImage2D(
GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, &data);
gpu::Mailbox mailbox;
context()->genMailboxCHROMIUM(mailbox.name);
context()->produceTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
unsigned sync_point = context()->insertSyncPoint();
// All the logic below assumes that the sync points are all positive.
EXPECT_LT(0u, sync_point);
unsigned release_sync_point = 0;
bool lost_resource = false;
TextureMailbox::ReleaseCallback callback =
base::Bind(ReleaseTextureMailbox, &release_sync_point, &lost_resource);
ResourceProvider::ResourceId resource =
resource_provider_->CreateResourceFromTextureMailbox(
TextureMailbox(mailbox, callback, sync_point));
EXPECT_EQ(1, context()->texture_count());
EXPECT_EQ(0u, release_sync_point);
{
// Transfer the resource, expect the sync points to be consistent.
ResourceProvider::ResourceIdArray resource_ids_to_transfer;
resource_ids_to_transfer.push_back(resource);
TransferableResourceArray list;
resource_provider_->PrepareSendToParent(resource_ids_to_transfer, &list);
ASSERT_EQ(1u, list.size());
EXPECT_LE(sync_point, list[0].sync_point);
EXPECT_EQ(0,
memcmp(mailbox.name, list[0].mailbox.name, sizeof(mailbox.name)));
EXPECT_EQ(0u, release_sync_point);
context()->waitSyncPoint(list[0].sync_point);
unsigned other_texture = context()->createTexture();
context()->bindTexture(GL_TEXTURE_2D, other_texture);
context()->consumeTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
uint8_t test_data[4] = { 0 };
context()->GetPixels(gfx::Size(1, 1), GL_RGBA, test_data);
EXPECT_EQ(0, memcmp(data, test_data, sizeof(data)));
context()->produceTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
context()->deleteTexture(other_texture);
list[0].sync_point = context()->insertSyncPoint();
EXPECT_LT(0u, list[0].sync_point);
// Receive the resource, then delete it, expect the sync points to be
// consistent.
resource_provider_->ReceiveFromParent(list);
EXPECT_EQ(1, context()->texture_count());
EXPECT_EQ(0u, release_sync_point);
resource_provider_->DeleteResource(resource);
EXPECT_LE(list[0].sync_point, release_sync_point);
EXPECT_FALSE(lost_resource);
}
// We're going to do the same thing as above, but testing the case where we
// delete the resource before we receive it back.
sync_point = release_sync_point;
EXPECT_LT(0u, sync_point);
release_sync_point = 0;
resource = resource_provider_->CreateResourceFromTextureMailbox(
TextureMailbox(mailbox, callback, sync_point));
EXPECT_EQ(1, context()->texture_count());
EXPECT_EQ(0u, release_sync_point);
{
// Transfer the resource, expect the sync points to be consistent.
ResourceProvider::ResourceIdArray resource_ids_to_transfer;
resource_ids_to_transfer.push_back(resource);
TransferableResourceArray list;
resource_provider_->PrepareSendToParent(resource_ids_to_transfer, &list);
ASSERT_EQ(1u, list.size());
EXPECT_LE(sync_point, list[0].sync_point);
EXPECT_EQ(0,
memcmp(mailbox.name, list[0].mailbox.name, sizeof(mailbox.name)));
EXPECT_EQ(0u, release_sync_point);
context()->waitSyncPoint(list[0].sync_point);
unsigned other_texture = context()->createTexture();
context()->bindTexture(GL_TEXTURE_2D, other_texture);
context()->consumeTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
uint8_t test_data[4] = { 0 };
context()->GetPixels(gfx::Size(1, 1), GL_RGBA, test_data);
EXPECT_EQ(0, memcmp(data, test_data, sizeof(data)));
context()->produceTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
context()->deleteTexture(other_texture);
list[0].sync_point = context()->insertSyncPoint();
EXPECT_LT(0u, list[0].sync_point);
// Delete the resource, which shouldn't do anything.
resource_provider_->DeleteResource(resource);
EXPECT_EQ(1, context()->texture_count());
EXPECT_EQ(0u, release_sync_point);
// Then receive the resource which should release the mailbox, expect the
// sync points to be consistent.
resource_provider_->ReceiveFromParent(list);
EXPECT_LE(list[0].sync_point, release_sync_point);
EXPECT_FALSE(lost_resource);
}
context()->waitSyncPoint(release_sync_point);
context()->bindTexture(GL_TEXTURE_2D, texture);
context()->consumeTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
context()->deleteTexture(texture);
}
TEST_P(ResourceProviderTest, Shutdown) {
// TextureMailbox callbacks only exist for GL textures for now.
if (GetParam() != ResourceProvider::GLTexture)
return;
unsigned texture = context()->createTexture();
context()->bindTexture(GL_TEXTURE_2D, texture);
gpu::Mailbox mailbox;
context()->genMailboxCHROMIUM(mailbox.name);
context()->produceTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
unsigned sync_point = context()->insertSyncPoint();
EXPECT_LT(0u, sync_point);
unsigned release_sync_point = 0;
bool lost_resource = false;
TextureMailbox::ReleaseCallback callback =
base::Bind(ReleaseTextureMailbox, &release_sync_point, &lost_resource);
resource_provider_->CreateResourceFromTextureMailbox(
TextureMailbox(mailbox, callback, sync_point));
EXPECT_EQ(0u, release_sync_point);
EXPECT_FALSE(lost_resource);
resource_provider_.reset();
EXPECT_LE(sync_point, release_sync_point);
EXPECT_FALSE(lost_resource);
}
TEST_P(ResourceProviderTest, ShutdownWithExportedResource) {
// TextureMailbox callbacks only exist for GL textures for now.
if (GetParam() != ResourceProvider::GLTexture)
return;
unsigned texture = context()->createTexture();
context()->bindTexture(GL_TEXTURE_2D, texture);
gpu::Mailbox mailbox;
context()->genMailboxCHROMIUM(mailbox.name);
context()->produceTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
unsigned sync_point = context()->insertSyncPoint();
EXPECT_LT(0u, sync_point);
unsigned release_sync_point = 0;
bool lost_resource = false;
TextureMailbox::ReleaseCallback callback =
base::Bind(ReleaseTextureMailbox, &release_sync_point, &lost_resource);
ResourceProvider::ResourceId resource =
resource_provider_->CreateResourceFromTextureMailbox(
TextureMailbox(mailbox, callback, sync_point));
// Transfer the resource, so we can't release it properly on shutdown.
ResourceProvider::ResourceIdArray resource_ids_to_transfer;
resource_ids_to_transfer.push_back(resource);
TransferableResourceArray list;
resource_provider_->PrepareSendToParent(resource_ids_to_transfer, &list);
EXPECT_EQ(0u, release_sync_point);
EXPECT_FALSE(lost_resource);
resource_provider_.reset();
// Since the resource is in the parent, the child considers it lost.
EXPECT_EQ(0u, release_sync_point);
EXPECT_TRUE(lost_resource);
}
TEST_P(ResourceProviderTest, LostContext) {
// TextureMailbox callbacks only exist for GL textures for now.
if (GetParam() != ResourceProvider::GLTexture)
return;
unsigned texture = context()->createTexture();
context()->bindTexture(GL_TEXTURE_2D, texture);
gpu::Mailbox mailbox;
context()->genMailboxCHROMIUM(mailbox.name);
context()->produceTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
unsigned sync_point = context()->insertSyncPoint();
EXPECT_LT(0u, sync_point);
unsigned release_sync_point = 0;
bool lost_resource = false;
TextureMailbox::ReleaseCallback callback =
base::Bind(ReleaseTextureMailbox, &release_sync_point, &lost_resource);
resource_provider_->CreateResourceFromTextureMailbox(
TextureMailbox(mailbox, callback, sync_point));
EXPECT_EQ(0u, release_sync_point);
EXPECT_FALSE(lost_resource);
resource_provider_->DidLoseOutputSurface();
resource_provider_.reset();
EXPECT_LE(sync_point, release_sync_point);
EXPECT_TRUE(lost_resource);
}
class TextureStateTrackingContext : public TestWebGraphicsContext3D {
public:
MOCK_METHOD2(bindTexture, void(WGC3Denum target, WebGLId texture));
MOCK_METHOD3(texParameteri,
void(WGC3Denum target, WGC3Denum pname, WGC3Dint param));
MOCK_METHOD1(waitSyncPoint, void(unsigned sync_point));
MOCK_METHOD0(insertSyncPoint, unsigned(void));
MOCK_METHOD2(produceTextureCHROMIUM, void(WGC3Denum target,
const WGC3Dbyte* mailbox));
MOCK_METHOD2(consumeTextureCHROMIUM, void(WGC3Denum target,
const WGC3Dbyte* mailbox));
// Force all textures to be "1" so we can test for them.
virtual WebKit::WebGLId NextTextureId() OVERRIDE { return 1; }
};
TEST_P(ResourceProviderTest, ScopedSampler) {
// Sampling is only supported for GL textures.
if (GetParam() != ResourceProvider::GLTexture)
return;
scoped_ptr<OutputSurface> output_surface(
FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(
new TextureStateTrackingContext)));
TextureStateTrackingContext* context =
static_cast<TextureStateTrackingContext*>(output_surface->context3d());
scoped_ptr<ResourceProvider> resource_provider(
ResourceProvider::Create(output_surface.get(), 0));
gfx::Size size(1, 1);
WGC3Denum format = GL_RGBA;
int texture_id = 1;
// Check that the texture gets created with the right sampler settings.
EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id))
.Times(2); // Once to create and once to allocate.
EXPECT_CALL(*context,
texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
EXPECT_CALL(*context,
texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
EXPECT_CALL(
*context,
texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
EXPECT_CALL(
*context,
texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
EXPECT_CALL(*context,
texParameteri(GL_TEXTURE_2D,
GL_TEXTURE_POOL_CHROMIUM,
GL_TEXTURE_POOL_UNMANAGED_CHROMIUM));
ResourceProvider::ResourceId id = resource_provider->CreateResource(
size, format, ResourceProvider::TextureUsageAny);
resource_provider->AllocateForTesting(id);
// Creating a sampler with the default filter should not change any texture
// parameters.
{
EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id));
ResourceProvider::ScopedSamplerGL sampler(
resource_provider.get(), id, GL_TEXTURE_2D, GL_LINEAR);
}
// Using a different filter should be reflected in the texture parameters.
{
EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id));
EXPECT_CALL(
*context,
texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST));
EXPECT_CALL(
*context,
texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST));
ResourceProvider::ScopedSamplerGL sampler(
resource_provider.get(), id, GL_TEXTURE_2D, GL_NEAREST);
}
// Test resetting to the default filter.
{
EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id));
EXPECT_CALL(*context,
texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
EXPECT_CALL(*context,
texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
ResourceProvider::ScopedSamplerGL sampler(
resource_provider.get(), id, GL_TEXTURE_2D, GL_LINEAR);
}
Mock::VerifyAndClearExpectations(context);
}
TEST_P(ResourceProviderTest, ManagedResource) {
// Sampling is only supported for GL textures.
if (GetParam() != ResourceProvider::GLTexture)
return;
scoped_ptr<OutputSurface> output_surface(
FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(
new TextureStateTrackingContext)));
TextureStateTrackingContext* context =
static_cast<TextureStateTrackingContext*>(output_surface->context3d());
scoped_ptr<ResourceProvider> resource_provider(
ResourceProvider::Create(output_surface.get(), 0));
gfx::Size size(1, 1);
WGC3Denum format = GL_RGBA;
int texture_id = 1;
// Check that the texture gets created with the right sampler settings.
EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id));
EXPECT_CALL(*context,
texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
EXPECT_CALL(*context,
texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
EXPECT_CALL(
*context,
texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
EXPECT_CALL(
*context,
texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
EXPECT_CALL(*context,
texParameteri(GL_TEXTURE_2D,
GL_TEXTURE_POOL_CHROMIUM,
GL_TEXTURE_POOL_MANAGED_CHROMIUM));
ResourceProvider::ResourceId id = resource_provider->CreateManagedResource(
size, format, ResourceProvider::TextureUsageAny);
EXPECT_NE(0u, id);
Mock::VerifyAndClearExpectations(context);
}
static void EmptyReleaseCallback(unsigned sync_point, bool lost_resource) {}
TEST_P(ResourceProviderTest, TextureMailbox_GLTexture2D) {
// Mailboxing is only supported for GL textures.
if (GetParam() != ResourceProvider::GLTexture)
return;
scoped_ptr<OutputSurface> output_surface(
FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(
new TextureStateTrackingContext)));
TextureStateTrackingContext* context =
static_cast<TextureStateTrackingContext*>(output_surface->context3d());
scoped_ptr<ResourceProvider> resource_provider(
ResourceProvider::Create(output_surface.get(), 0));
unsigned texture_id = 1;
unsigned sync_point = 30;
unsigned target = GL_TEXTURE_2D;
EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
EXPECT_CALL(*context, insertSyncPoint()).Times(0);
EXPECT_CALL(*context, produceTextureCHROMIUM(_, _)).Times(0);
EXPECT_CALL(*context, consumeTextureCHROMIUM(_, _)).Times(0);
gpu::Mailbox gpu_mailbox;
memcpy(gpu_mailbox.name, "Hello world", strlen("Hello world") + 1);
TextureMailbox::ReleaseCallback callback = base::Bind(&EmptyReleaseCallback);
TextureMailbox mailbox(gpu_mailbox,
callback,
sync_point);
ResourceProvider::ResourceId id =
resource_provider->CreateResourceFromTextureMailbox(mailbox);
EXPECT_NE(0u, id);
Mock::VerifyAndClearExpectations(context);
{
// Using the texture does a consume of the mailbox.
EXPECT_CALL(*context, bindTexture(target, texture_id));
EXPECT_CALL(*context, waitSyncPoint(sync_point));
EXPECT_CALL(*context, consumeTextureCHROMIUM(target, _));
EXPECT_CALL(*context, insertSyncPoint()).Times(0);
EXPECT_CALL(*context, produceTextureCHROMIUM(_, _)).Times(0);
ResourceProvider::ScopedReadLockGL lock(resource_provider.get(), id);
Mock::VerifyAndClearExpectations(context);
// When done with it, then it should be produced back to the mailbox.
EXPECT_CALL(*context, bindTexture(target, texture_id));
EXPECT_CALL(*context, insertSyncPoint());
EXPECT_CALL(*context, produceTextureCHROMIUM(target, _));
EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
EXPECT_CALL(*context, consumeTextureCHROMIUM(_, _)).Times(0);
}
}
TEST_P(ResourceProviderTest, TextureMailbox_GLTextureExternalOES) {
// Mailboxing is only supported for GL textures.
if (GetParam() != ResourceProvider::GLTexture)
return;
scoped_ptr<OutputSurface> output_surface(
FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(
new TextureStateTrackingContext)));
TextureStateTrackingContext* context =
static_cast<TextureStateTrackingContext*>(output_surface->context3d());
scoped_ptr<ResourceProvider> resource_provider(
ResourceProvider::Create(output_surface.get(), 0));
unsigned texture_id = 1;
unsigned sync_point = 30;
unsigned target = GL_TEXTURE_EXTERNAL_OES;
EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
EXPECT_CALL(*context, insertSyncPoint()).Times(0);
EXPECT_CALL(*context, produceTextureCHROMIUM(_, _)).Times(0);
EXPECT_CALL(*context, consumeTextureCHROMIUM(_, _)).Times(0);
gpu::Mailbox gpu_mailbox;
memcpy(gpu_mailbox.name, "Hello world", strlen("Hello world") + 1);
TextureMailbox::ReleaseCallback callback = base::Bind(&EmptyReleaseCallback);
TextureMailbox mailbox(gpu_mailbox,
callback,
target,
sync_point);
ResourceProvider::ResourceId id =
resource_provider->CreateResourceFromTextureMailbox(mailbox);
EXPECT_NE(0u, id);
Mock::VerifyAndClearExpectations(context);
{
// Using the texture does a consume of the mailbox.
EXPECT_CALL(*context, bindTexture(target, texture_id));
EXPECT_CALL(*context, waitSyncPoint(sync_point));
EXPECT_CALL(*context, consumeTextureCHROMIUM(target, _));
EXPECT_CALL(*context, insertSyncPoint()).Times(0);
EXPECT_CALL(*context, produceTextureCHROMIUM(_, _)).Times(0);
ResourceProvider::ScopedReadLockGL lock(resource_provider.get(), id);
Mock::VerifyAndClearExpectations(context);
// When done with it, then it should be produced back to the mailbox.
EXPECT_CALL(*context, bindTexture(target, texture_id));
EXPECT_CALL(*context, insertSyncPoint());
EXPECT_CALL(*context, produceTextureCHROMIUM(target, _));
EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
EXPECT_CALL(*context, consumeTextureCHROMIUM(_, _)).Times(0);
}
}
class AllocationTrackingContext3D : public TestWebGraphicsContext3D {
public:
MOCK_METHOD0(createTexture, WebGLId());
MOCK_METHOD1(deleteTexture, void(WebGLId texture_id));
MOCK_METHOD2(bindTexture, void(WGC3Denum target, WebGLId texture));
MOCK_METHOD9(texImage2D,
void(WGC3Denum target,
WGC3Dint level,
WGC3Denum internalformat,
WGC3Dsizei width,
WGC3Dsizei height,
WGC3Dint border,
WGC3Denum format,
WGC3Denum type,
const void* pixels));
MOCK_METHOD9(texSubImage2D,
void(WGC3Denum target,
WGC3Dint level,
WGC3Dint xoffset,
WGC3Dint yoffset,
WGC3Dsizei width,
WGC3Dsizei height,
WGC3Denum format,
WGC3Denum type,
const void* pixels));
MOCK_METHOD9(asyncTexImage2DCHROMIUM,
void(WGC3Denum target,
WGC3Dint level,
WGC3Denum internalformat,
WGC3Dsizei width,
WGC3Dsizei height,
WGC3Dint border,
WGC3Denum format,
WGC3Denum type,
const void* pixels));
MOCK_METHOD9(asyncTexSubImage2DCHROMIUM,
void(WGC3Denum target,
WGC3Dint level,
WGC3Dint xoffset,
WGC3Dint yoffset,
WGC3Dsizei width,
WGC3Dsizei height,
WGC3Denum format,
WGC3Denum type,
const void* pixels));
MOCK_METHOD1(waitAsyncTexImage2DCHROMIUM, void(WGC3Denum));
MOCK_METHOD3(createImageCHROMIUM, WGC3Duint(WGC3Dsizei, WGC3Dsizei,
WGC3Denum));
MOCK_METHOD1(destroyImageCHROMIUM, void(WGC3Duint));
MOCK_METHOD2(mapImageCHROMIUM, void*(WGC3Duint, WGC3Denum));
MOCK_METHOD3(getImageParameterivCHROMIUM, void(WGC3Duint, WGC3Denum,
GLint*));
MOCK_METHOD1(unmapImageCHROMIUM, void(WGC3Duint));
MOCK_METHOD2(bindTexImage2DCHROMIUM, void(WGC3Denum, WGC3Dint));
};
TEST_P(ResourceProviderTest, TextureAllocation) {
// Only for GL textures.
if (GetParam() != ResourceProvider::GLTexture)
return;
scoped_ptr<WebKit::WebGraphicsContext3D> mock_context(
static_cast<WebKit::WebGraphicsContext3D*>(
new NiceMock<AllocationTrackingContext3D>));
scoped_ptr<OutputSurface> output_surface(
FakeOutputSurface::Create3d(mock_context.Pass()));
gfx::Size size(2, 2);
gfx::Vector2d offset(0, 0);
gfx::Rect rect(0, 0, 2, 2);
WGC3Denum format = GL_RGBA;
ResourceProvider::ResourceId id = 0;
uint8_t pixels[16] = { 0 };
int texture_id = 123;
AllocationTrackingContext3D* context =
static_cast<AllocationTrackingContext3D*>(output_surface->context3d());
scoped_ptr<ResourceProvider> resource_provider(
ResourceProvider::Create(output_surface.get(), 0));
// Lazy allocation. Don't allocate when creating the resource.
EXPECT_CALL(*context, createTexture()).WillOnce(Return(texture_id));
EXPECT_CALL(*context, deleteTexture(texture_id)).Times(1);
EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(1);
EXPECT_CALL(*context, texImage2D(_, _, _, _, _, _, _, _, _)).Times(0);
EXPECT_CALL(*context, asyncTexImage2DCHROMIUM(_, _, _, _, _, _, _, _, _))
.Times(0);
id = resource_provider->CreateResource(
size, format, ResourceProvider::TextureUsageAny);
resource_provider->DeleteResource(id);
Mock::VerifyAndClearExpectations(context);
// Do allocate when we set the pixels.
EXPECT_CALL(*context, createTexture()).WillOnce(Return(texture_id));
EXPECT_CALL(*context, deleteTexture(texture_id)).Times(1);
EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(3);
EXPECT_CALL(*context, texImage2D(_, _, _, 2, 2, _, _, _, _)).Times(1);
EXPECT_CALL(*context, texSubImage2D(_, _, _, _, 2, 2, _, _, _)).Times(1);
id = resource_provider->CreateResource(
size, format, ResourceProvider::TextureUsageAny);
resource_provider->SetPixels(id, pixels, rect, rect, offset);
resource_provider->DeleteResource(id);
Mock::VerifyAndClearExpectations(context);
// Same for SetPixelsFromBuffer
EXPECT_CALL(*context, createTexture()).WillOnce(Return(texture_id));
EXPECT_CALL(*context, deleteTexture(texture_id)).Times(1);
EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(3);
EXPECT_CALL(*context, texImage2D(_, _, _, 2, 2, _, _, _, _)).Times(1);
EXPECT_CALL(*context, texSubImage2D(_, _, _, _, 2, 2, _, _, _)).Times(1);
id = resource_provider->CreateResource(
size, format, ResourceProvider::TextureUsageAny);
resource_provider->AcquirePixelBuffer(id);
resource_provider->SetPixelsFromBuffer(id);
resource_provider->ReleasePixelBuffer(id);
resource_provider->DeleteResource(id);
Mock::VerifyAndClearExpectations(context);
// Same for async version.
EXPECT_CALL(*context, createTexture()).WillOnce(Return(texture_id));
EXPECT_CALL(*context, deleteTexture(texture_id)).Times(1);
EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(2);
EXPECT_CALL(*context, asyncTexImage2DCHROMIUM(_, _, _, 2, 2, _, _, _, _))
.Times(1);
id = resource_provider->CreateResource(
size, format, ResourceProvider::TextureUsageAny);
resource_provider->AcquirePixelBuffer(id);
resource_provider->BeginSetPixels(id);
resource_provider->ReleasePixelBuffer(id);
resource_provider->DeleteResource(id);
Mock::VerifyAndClearExpectations(context);
}
TEST_P(ResourceProviderTest, ForcingAsyncUploadToComplete) {
// Only for GL textures.
if (GetParam() != ResourceProvider::GLTexture)
return;
scoped_ptr<WebKit::WebGraphicsContext3D> mock_context(
static_cast<WebKit::WebGraphicsContext3D*>(
new NiceMock<AllocationTrackingContext3D>));
scoped_ptr<OutputSurface> output_surface(
FakeOutputSurface::Create3d(mock_context.Pass()));
gfx::Size size(2, 2);
WGC3Denum format = GL_RGBA;
ResourceProvider::ResourceId id = 0;
int texture_id = 123;
AllocationTrackingContext3D* context =
static_cast<AllocationTrackingContext3D*>(output_surface->context3d());
scoped_ptr<ResourceProvider> resource_provider(
ResourceProvider::Create(output_surface.get(), 0));
EXPECT_CALL(*context, createTexture()).WillOnce(Return(texture_id));
EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(3);
EXPECT_CALL(*context, asyncTexImage2DCHROMIUM(_, _, _, 2, 2, _, _, _, _))
.Times(1);
EXPECT_CALL(*context, waitAsyncTexImage2DCHROMIUM(GL_TEXTURE_2D)).Times(1);
EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, 0)).Times(1);
id = resource_provider->CreateResource(
size, format, ResourceProvider::TextureUsageAny);
resource_provider->AcquirePixelBuffer(id);
resource_provider->BeginSetPixels(id);
resource_provider->ForceSetPixelsToComplete(id);
resource_provider->ReleasePixelBuffer(id);
Mock::VerifyAndClearExpectations(context);
}
TEST_P(ResourceProviderTest, AbortForcedAsyncUpload) {
// Only for GL textures.
if (GetParam() != ResourceProvider::GLTexture)
return;
scoped_ptr<WebKit::WebGraphicsContext3D> mock_context(
static_cast<WebKit::WebGraphicsContext3D*>(
new NiceMock<AllocationTrackingContext3D>));
scoped_ptr<OutputSurface> output_surface(
FakeOutputSurface::Create3d(mock_context.Pass()));
gfx::Size size(2, 2);
WGC3Denum format = GL_RGBA;
ResourceProvider::ResourceId id = 0;
int texture_id = 123;
AllocationTrackingContext3D* context =
static_cast<AllocationTrackingContext3D*>(output_surface->context3d());
scoped_ptr<ResourceProvider> resource_provider(
ResourceProvider::Create(output_surface.get(), 0));
EXPECT_CALL(*context, createTexture()).WillRepeatedly(Return(texture_id));
EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(4);
EXPECT_CALL(*context, asyncTexImage2DCHROMIUM(_, _, _, 2, 2, _, _, _, _))
.Times(1);
EXPECT_CALL(*context, waitAsyncTexImage2DCHROMIUM(GL_TEXTURE_2D)).Times(1);
EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, 0)).Times(1);
EXPECT_CALL(*context, deleteTexture(_)).Times(1);
id = resource_provider->CreateResource(
size, format, ResourceProvider::TextureUsageAny);
resource_provider->AcquirePixelBuffer(id);
resource_provider->BeginSetPixels(id);
resource_provider->ForceSetPixelsToComplete(id);
resource_provider->AbortSetPixels(id);
resource_provider->ReleasePixelBuffer(id);
Mock::VerifyAndClearExpectations(context);
}
TEST_P(ResourceProviderTest, PixelBufferLostContext) {
scoped_ptr<WebKit::WebGraphicsContext3D> mock_context(
static_cast<WebKit::WebGraphicsContext3D*>(
new NiceMock<AllocationTrackingContext3D>));
scoped_ptr<OutputSurface> output_surface(
FakeOutputSurface::Create3d(mock_context.Pass()));
gfx::Size size(2, 2);
WGC3Denum format = GL_RGBA;
ResourceProvider::ResourceId id = 0;
int texture_id = 123;
AllocationTrackingContext3D* context =
static_cast<AllocationTrackingContext3D*>(output_surface->context3d());
scoped_ptr<ResourceProvider> resource_provider(
ResourceProvider::Create(output_surface.get(), 0));
EXPECT_CALL(*context, createTexture()).WillRepeatedly(Return(texture_id));
id = resource_provider->CreateResource(
size, format, ResourceProvider::TextureUsageAny);
context->loseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB,
GL_INNOCENT_CONTEXT_RESET_ARB);
resource_provider->AcquirePixelBuffer(id);
uint8_t* buffer = resource_provider->MapPixelBuffer(id);
EXPECT_TRUE(buffer == NULL);
resource_provider->UnmapPixelBuffer(id);
resource_provider->ReleasePixelBuffer(id);
Mock::VerifyAndClearExpectations(context);
}
TEST_P(ResourceProviderTest, GpuMemoryBuffers) {
// Only for GL textures.
if (GetParam() != ResourceProvider::GLTexture)
return;
scoped_ptr<WebKit::WebGraphicsContext3D> mock_context(
static_cast<WebKit::WebGraphicsContext3D*>(
new StrictMock<AllocationTrackingContext3D>));
scoped_ptr<OutputSurface> output_surface(
FakeOutputSurface::Create3d(mock_context.Pass()));
const int kWidth = 2;
const int kHeight = 2;
gfx::Size size(kWidth, kHeight);
WGC3Denum format = GL_RGBA;
ResourceProvider::ResourceId id = 0;
const unsigned kTextureId = 123u;
const unsigned kImageId = 234u;
AllocationTrackingContext3D* context =
static_cast<AllocationTrackingContext3D*>(output_surface->context3d());
scoped_ptr<ResourceProvider> resource_provider(
ResourceProvider::Create(output_surface.get(), 0));
EXPECT_CALL(*context, createTexture())
.WillOnce(Return(kTextureId))
.RetiresOnSaturation();
EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, kTextureId))
.Times(1)
.RetiresOnSaturation();
id = resource_provider->CreateResource(
size, format, ResourceProvider::TextureUsageAny);
EXPECT_CALL(*context, createImageCHROMIUM(kWidth, kHeight, GL_RGBA8_OES))
.WillOnce(Return(kImageId))
.RetiresOnSaturation();
resource_provider->AcquireImage(id);
EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, kTextureId)).Times(1)
.RetiresOnSaturation();
EXPECT_CALL(*context, bindTexImage2DCHROMIUM(GL_TEXTURE_2D, kImageId))
.Times(1)
.RetiresOnSaturation();
resource_provider->BindImage(id);
void* dummy_mapped_buffer_address = NULL;
EXPECT_CALL(*context, mapImageCHROMIUM(kImageId, GL_READ_WRITE))
.WillOnce(Return(dummy_mapped_buffer_address))
.RetiresOnSaturation();
resource_provider->MapImage(id);
const int kStride = 4;
EXPECT_CALL(*context, getImageParameterivCHROMIUM(kImageId,
GL_IMAGE_ROWBYTES_CHROMIUM,
_))
.WillOnce(SetArgPointee<2>(kStride))
.RetiresOnSaturation();
int stride = resource_provider->GetImageStride(id);
EXPECT_EQ(kStride, stride);
EXPECT_CALL(*context, unmapImageCHROMIUM(kImageId))
.Times(1)
.RetiresOnSaturation();
resource_provider->UnmapImage(id);
EXPECT_CALL(*context, destroyImageCHROMIUM(kImageId))
.Times(1)
.RetiresOnSaturation();
resource_provider->ReleaseImage(id);
// Texture will be deleted when ResourceProvider destructor is
// called when it goes out of scope when this method returns.
EXPECT_CALL(*context, deleteTexture(kTextureId))
.Times(1)
.RetiresOnSaturation();
}
INSTANTIATE_TEST_CASE_P(
ResourceProviderTests,
ResourceProviderTest,
::testing::Values(ResourceProvider::GLTexture, ResourceProvider::Bitmap));
} // namespace
} // namespace cc