#include "cc/test/test_shared_bitmap_manager.h"
#include "cc/test/test_texture.h"
#include "cc/test/test_web_graphics_context_3d.h"
+#include "cc/trees/blocking_task_runner.h"
#include "gpu/GLES2/gl2extchromium.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace cc {
namespace {
-static void EmptyReleaseCallback(uint32 sync_point, bool lost_resource) {}
-
-static void SharedMemoryReleaseCallback(scoped_ptr<base::SharedMemory> memory,
- uint32 sync_point,
- bool lost_resource) {}
+static void EmptyReleaseCallback(uint32 sync_point,
+ bool lost_resource,
+ BlockingTaskRunner* main_thread_task_runner) {
+}
-static void ReleaseTextureMailbox(uint32* release_sync_point,
- bool* release_lost_resource,
- uint32 sync_point,
- bool lost_resource) {
+static void ReleaseCallback(
+ uint32* release_sync_point,
+ bool* release_lost_resource,
+ BlockingTaskRunner** release_main_thread_task_runner,
+ uint32 sync_point,
+ bool lost_resource,
+ BlockingTaskRunner* main_thread_task_runner) {
*release_sync_point = sync_point;
*release_lost_resource = lost_resource;
+ *release_main_thread_task_runner = main_thread_task_runner;
+}
+
+static void SharedMemoryReleaseCallback(
+ scoped_ptr<base::SharedMemory> memory,
+ uint32 sync_point,
+ bool lost_resource,
+ BlockingTaskRunner* main_thread_task_runner) {
}
static void ReleaseSharedMemoryCallback(
uint32* release_sync_point,
bool* lost_resource_result,
uint32 sync_point,
- bool lost_resource) {
+ bool lost_resource,
+ BlockingTaskRunner* main_thread_task_runner) {
*release_called = true;
*release_sync_point = sync_point;
*lost_resource_result = lost_resource;
const gfx::Size& size,
ResourceFormat format,
uint8_t* pixels) {
+ resource_provider->WaitSyncPointIfNeeded(id);
switch (resource_provider->default_resource_type()) {
case ResourceProvider::GLTexture: {
ResourceProvider::ScopedReadLockGL lock_gl(resource_provider, id);
ResourceProviderTest()
: shared_data_(ContextSharedData::Create()),
context3d_(NULL),
- child_context_(NULL) {
+ child_context_(NULL),
+ main_thread_task_runner_(BlockingTaskRunner::Create(NULL)) {
switch (GetParam()) {
case ResourceProvider::GLTexture: {
scoped_ptr<ResourceProviderContext> context3d(
shared_bitmap_manager_.reset(new TestSharedBitmapManager());
- resource_provider_ = ResourceProvider::Create(
- output_surface_.get(), shared_bitmap_manager_.get(), 0, false, 1,
- false);
- child_resource_provider_ = ResourceProvider::Create(
- child_output_surface_.get(),
- shared_bitmap_manager_.get(),
- 0,
- false,
- 1,
- false);
+ resource_provider_ =
+ ResourceProvider::Create(output_surface_.get(),
+ shared_bitmap_manager_.get(),
+ main_thread_task_runner_.get(),
+ 0,
+ false,
+ 1,
+ false);
+ child_resource_provider_ =
+ ResourceProvider::Create(child_output_surface_.get(),
+ shared_bitmap_manager_.get(),
+ main_thread_task_runner_.get(),
+ 0,
+ false,
+ 1,
+ false);
}
static void CollectResources(ReturnedResourceArray* array,
- const ReturnedResourceArray& returned) {
+ const ReturnedResourceArray& returned,
+ BlockingTaskRunner* main_thread_task_runner) {
array->insert(array->end(), returned.begin(), returned.end());
}
EXPECT_LT(0u, *sync_point);
scoped_ptr<base::SharedMemory> shared_memory;
- scoped_ptr<SingleReleaseCallback> callback =
- SingleReleaseCallback::Create(base::Bind(ReleaseSharedMemoryCallback,
- base::Passed(&shared_memory),
- release_called,
- release_sync_point,
- lost_resource));
+ scoped_ptr<SingleReleaseCallbackImpl> callback =
+ SingleReleaseCallbackImpl::Create(
+ base::Bind(ReleaseSharedMemoryCallback,
+ base::Passed(&shared_memory),
+ release_called,
+ release_sync_point,
+ lost_resource));
return child_resource_provider_->CreateResourceFromTextureMailbox(
TextureMailbox(gpu_mailbox, GL_TEXTURE_2D, *sync_point),
callback.Pass());
CreateAndFillSharedMemory(size, 0));
base::SharedMemory* shared_memory_ptr = shared_memory.get();
- scoped_ptr<SingleReleaseCallback> callback =
- SingleReleaseCallback::Create(base::Bind(ReleaseSharedMemoryCallback,
- base::Passed(&shared_memory),
- release_called,
- release_sync_point,
- lost_resource));
+ scoped_ptr<SingleReleaseCallbackImpl> callback =
+ SingleReleaseCallbackImpl::Create(
+ base::Bind(ReleaseSharedMemoryCallback,
+ base::Passed(&shared_memory),
+ release_called,
+ release_sync_point,
+ lost_resource));
return child_resource_provider_->CreateResourceFromTextureMailbox(
TextureMailbox(shared_memory_ptr, size), callback.Pass());
}
FakeOutputSurfaceClient child_output_surface_client_;
scoped_ptr<OutputSurface> output_surface_;
scoped_ptr<OutputSurface> child_output_surface_;
+ scoped_ptr<BlockingTaskRunner> main_thread_task_runner_;
scoped_ptr<ResourceProvider> resource_provider_;
scoped_ptr<ResourceProvider> child_resource_provider_;
scoped_ptr<TestSharedBitmapManager> shared_bitmap_manager_;
ASSERT_EQ(4U, pixel_size);
ResourceProvider::ResourceId id = resource_provider->CreateResource(
- size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
+ size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
EXPECT_EQ(1, static_cast<int>(resource_provider->num_resources()));
if (expected_default_type == ResourceProvider::GLTexture)
EXPECT_EQ(0u, context->NumTextures());
ASSERT_EQ(16U, pixel_size);
ResourceProvider::ResourceId id = resource_provider_->CreateResource(
- size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
+ size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
uint8_t image[16] = { 0 };
gfx::Rect image_rect(size);
ASSERT_EQ(4U, pixel_size);
ResourceProvider::ResourceId id1 = child_resource_provider_->CreateResource(
- size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
+ size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
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, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
+ size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
uint8_t data2[4] = { 5, 5, 5, 5 };
child_resource_provider_->SetPixels(id2, data2, rect, rect, gfx::Vector2d());
ResourceProvider::ResourceId id3 = child_resource_provider_->CreateResource(
- size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
- child_resource_provider_->MapImageRasterBuffer(id3);
- child_resource_provider_->UnmapImageRasterBuffer(id3);
+ size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
+ child_resource_provider_->AcquireImage(id3);
+ int stride;
+ child_resource_provider_->MapImage(id3, &stride);
+ child_resource_provider_->UnmapImage(id3);
GLuint external_texture_id = child_context_->createExternalTexture();
child_context_->bindTexture(GL_TEXTURE_EXTERNAL_OES, external_texture_id);
child_resource_provider_->CreateResourceFromTextureMailbox(
TextureMailbox(
external_mailbox, GL_TEXTURE_EXTERNAL_OES, external_sync_point),
- SingleReleaseCallback::Create(base::Bind(&EmptyReleaseCallback)));
+ SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback)));
ReturnedResourceArray returned_to_child;
int child_id =
EXPECT_NE(list[0].mailbox_holder.sync_point,
context3d_->last_waited_sync_point());
{
+ resource_provider_->WaitSyncPointIfNeeded(list[0].id);
ResourceProvider::ScopedReadLockGL lock(resource_provider_.get(),
list[0].id);
}
EXPECT_FALSE(child_resource_provider_->InUseByConsumer(id4));
{
+ child_resource_provider_->WaitSyncPointIfNeeded(id1);
ResourceProvider::ScopedReadLockGL lock(child_resource_provider_.get(),
id1);
ASSERT_NE(0U, lock.texture_id());
EXPECT_EQ(0, memcmp(data1, result, pixel_size));
}
{
+ child_resource_provider_->WaitSyncPointIfNeeded(id2);
ResourceProvider::ScopedReadLockGL lock(child_resource_provider_.get(),
id2);
ASSERT_NE(0U, lock.texture_id());
EXPECT_EQ(0, memcmp(data2, result, pixel_size));
}
{
+ child_resource_provider_->WaitSyncPointIfNeeded(id3);
ResourceProvider::ScopedReadLockGL lock(child_resource_provider_.get(),
id3);
ASSERT_NE(0U, lock.texture_id());
ResourceFormat format = RGBA_8888;
ResourceProvider::ResourceId id1 = child_resource_provider_->CreateResource(
- size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
+ size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
uint8_t data1[4] = {1, 2, 3, 4};
gfx::Rect rect(size);
child_resource_provider_->SetPixels(id1, data1, rect, rect, gfx::Vector2d());
resource_provider_->ReceiveFromChild(child_id, list);
+ resource_provider_->WaitSyncPointIfNeeded(list[0].id);
ResourceProvider::ScopedReadLockGL lock(resource_provider_.get(),
list[0].id);
child_resource_provider_->ReceiveReturnsFromParent(returned_to_child);
{
+ child_resource_provider_->WaitSyncPointIfNeeded(id1);
ResourceProvider::ScopedReadLockGL lock(child_resource_provider_.get(),
id1);
child_resource_provider_->DeleteResource(id1);
uint32 sync_point = 0;
TextureMailbox mailbox(gpu::Mailbox::Generate(), GL_TEXTURE_2D, sync_point);
mailbox.set_allow_overlay(true);
- scoped_ptr<SingleReleaseCallback> release_callback =
- SingleReleaseCallback::Create(base::Bind(&EmptyReleaseCallback));
+ scoped_ptr<SingleReleaseCallbackImpl> release_callback =
+ SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback));
ResourceProvider::ResourceId id1 =
child_resource_provider_->CreateResourceFromTextureMailbox(
mailbox, release_callback.Pass());
TextureMailbox mailbox2(gpu::Mailbox::Generate(), GL_TEXTURE_2D, sync_point);
mailbox2.set_allow_overlay(false);
- scoped_ptr<SingleReleaseCallback> release_callback2 =
- SingleReleaseCallback::Create(base::Bind(&EmptyReleaseCallback));
+ scoped_ptr<SingleReleaseCallbackImpl> release_callback2 =
+ SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback));
ResourceProvider::ResourceId id2 =
child_resource_provider_->CreateResourceFromTextureMailbox(
mailbox2, release_callback2.Pass());
ASSERT_EQ(4U, pixel_size);
ResourceProvider::ResourceId id1 = child_resource_provider_->CreateResource(
- size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
+ size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
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, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
+ size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
uint8_t data2[4] = { 5, 5, 5, 5 };
child_resource_provider_->SetPixels(id2, data2, rect, rect, gfx::Vector2d());
- ResourceProvider::ResourceId id3 = child_resource_provider_->CreateResource(
- size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
- uint8_t data3[4] = { 6, 7, 8, 9 };
- SkImageInfo info = SkImageInfo::MakeN32Premul(size.width(), size.height());
- SkCanvas* raster_canvas = child_resource_provider_->MapImageRasterBuffer(id3);
- raster_canvas->writePixels(info, data3, info.minRowBytes(), 0, 0);
- child_resource_provider_->UnmapImageRasterBuffer(id3);
-
scoped_ptr<base::SharedMemory> shared_memory(new base::SharedMemory());
shared_memory->CreateAndMapAnonymous(1);
base::SharedMemory* shared_memory_ptr = shared_memory.get();
- ResourceProvider::ResourceId id4 =
+ ResourceProvider::ResourceId id3 =
child_resource_provider_->CreateResourceFromTextureMailbox(
TextureMailbox(shared_memory_ptr, gfx::Size(1, 1)),
- SingleReleaseCallback::Create(base::Bind(
+ SingleReleaseCallbackImpl::Create(base::Bind(
&SharedMemoryReleaseCallback, base::Passed(&shared_memory))));
ReturnedResourceArray returned_to_child;
resource_ids_to_transfer.push_back(id1);
resource_ids_to_transfer.push_back(id2);
resource_ids_to_transfer.push_back(id3);
- resource_ids_to_transfer.push_back(id4);
TransferableResourceArray list;
child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
&list);
- ASSERT_EQ(4u, list.size());
+ ASSERT_EQ(3u, list.size());
EXPECT_EQ(0u, list[0].mailbox_holder.sync_point);
EXPECT_EQ(0u, list[1].mailbox_holder.sync_point);
EXPECT_EQ(0u, list[2].mailbox_holder.sync_point);
- EXPECT_EQ(0u, list[3].mailbox_holder.sync_point);
EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id1));
EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id2));
EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id3));
- EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id4));
resource_provider_->ReceiveFromChild(child_id, list);
resource_provider_->DeclareUsedResourcesFromChild(child_id,
resource_ids_to_transfer);
}
- EXPECT_EQ(4u, resource_provider_->num_resources());
+ EXPECT_EQ(3u, 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];
ResourceProvider::ResourceId mapped_id3 = resource_map[id3];
- ResourceProvider::ResourceId mapped_id4 = resource_map[id4];
EXPECT_NE(0u, mapped_id1);
EXPECT_NE(0u, mapped_id2);
EXPECT_NE(0u, mapped_id3);
- EXPECT_NE(0u, mapped_id4);
EXPECT_FALSE(resource_provider_->InUseByConsumer(id1));
EXPECT_FALSE(resource_provider_->InUseByConsumer(id2));
EXPECT_FALSE(resource_provider_->InUseByConsumer(id3));
- EXPECT_FALSE(resource_provider_->InUseByConsumer(id4));
uint8_t result[4] = { 0 };
GetResourcePixels(
resource_provider_.get(), context(), mapped_id2, size, format, result);
EXPECT_EQ(0, memcmp(data2, result, pixel_size));
- GetResourcePixels(
- resource_provider_.get(), context(), mapped_id3, size, format, result);
- EXPECT_EQ(0, memcmp(data3, result, pixel_size));
-
{
// Check that transfering again the same resource from the child to the
// parent works.
ResourceProvider::ResourceIdArray resource_ids_to_transfer;
resource_ids_to_transfer.push_back(id1);
resource_ids_to_transfer.push_back(id2);
- resource_ids_to_transfer.push_back(id3);
TransferableResourceArray list;
child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
&list);
- EXPECT_EQ(3u, list.size());
+ EXPECT_EQ(2u, list.size());
EXPECT_EQ(id1, list[0].id);
EXPECT_EQ(id2, list[1].id);
- EXPECT_EQ(id3, list[2].id);
ReturnedResourceArray returned;
TransferableResource::ReturnResources(list, &returned);
child_resource_provider_->ReceiveReturnsFromParent(returned);
// be in-use.
EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id1));
EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id2));
- EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id3));
}
{
EXPECT_EQ(0u, returned_to_child.size());
ResourceProvider::ResourceIdArray no_resources;
resource_provider_->DeclareUsedResourcesFromChild(child_id, no_resources);
- ASSERT_EQ(4u, returned_to_child.size());
+ ASSERT_EQ(3u, returned_to_child.size());
EXPECT_EQ(0u, returned_to_child[0].sync_point);
EXPECT_EQ(0u, returned_to_child[1].sync_point);
EXPECT_EQ(0u, returned_to_child[2].sync_point);
- EXPECT_EQ(0u, returned_to_child[3].sync_point);
std::set<ResourceProvider::ResourceId> expected_ids;
expected_ids.insert(id1);
expected_ids.insert(id2);
expected_ids.insert(id3);
- expected_ids.insert(id4);
std::set<ResourceProvider::ResourceId> returned_ids;
- for (unsigned i = 0; i < 4; i++)
+ for (unsigned i = 0; i < 3; i++)
returned_ids.insert(returned_to_child[i].id);
EXPECT_EQ(expected_ids, returned_ids);
EXPECT_FALSE(returned_to_child[0].lost);
EXPECT_FALSE(returned_to_child[1].lost);
EXPECT_FALSE(returned_to_child[2].lost);
- EXPECT_FALSE(returned_to_child[3].lost);
child_resource_provider_->ReceiveReturnsFromParent(returned_to_child);
returned_to_child.clear();
}
EXPECT_FALSE(child_resource_provider_->InUseByConsumer(id1));
EXPECT_FALSE(child_resource_provider_->InUseByConsumer(id2));
EXPECT_FALSE(child_resource_provider_->InUseByConsumer(id3));
- EXPECT_FALSE(child_resource_provider_->InUseByConsumer(id4));
{
ResourceProvider::ScopedReadLockSoftware lock(
EXPECT_EQ(0, memcmp(data2, sk_bitmap->getPixels(), pixel_size));
}
{
- ResourceProvider::ScopedReadLockSoftware lock(
- child_resource_provider_.get(), id3);
- const SkBitmap* sk_bitmap = lock.sk_bitmap();
- EXPECT_EQ(sk_bitmap->width(), size.width());
- EXPECT_EQ(sk_bitmap->height(), size.height());
- EXPECT_EQ(0, memcmp(data3, sk_bitmap->getPixels(), 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);
resource_ids_to_transfer.push_back(id3);
- resource_ids_to_transfer.push_back(id4);
TransferableResourceArray list;
child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
&list);
- ASSERT_EQ(4u, list.size());
+ ASSERT_EQ(3u, list.size());
EXPECT_EQ(id1, list[0].id);
EXPECT_EQ(id2, list[1].id);
EXPECT_EQ(id3, list[2].id);
- EXPECT_EQ(id4, list[3].id);
EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id1));
EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id2));
EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id3));
- EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id4));
resource_provider_->ReceiveFromChild(child_id, list);
resource_provider_->DeclareUsedResourcesFromChild(child_id,
resource_ids_to_transfer);
EXPECT_EQ(0u, returned_to_child.size());
- EXPECT_EQ(4u, resource_provider_->num_resources());
+ EXPECT_EQ(3u, resource_provider_->num_resources());
resource_provider_->DestroyChild(child_id);
EXPECT_EQ(0u, resource_provider_->num_resources());
- ASSERT_EQ(4u, returned_to_child.size());
+ ASSERT_EQ(3u, returned_to_child.size());
EXPECT_EQ(0u, returned_to_child[0].sync_point);
EXPECT_EQ(0u, returned_to_child[1].sync_point);
EXPECT_EQ(0u, returned_to_child[2].sync_point);
- EXPECT_EQ(0u, returned_to_child[3].sync_point);
std::set<ResourceProvider::ResourceId> expected_ids;
expected_ids.insert(id1);
expected_ids.insert(id2);
expected_ids.insert(id3);
- expected_ids.insert(id4);
std::set<ResourceProvider::ResourceId> returned_ids;
- for (unsigned i = 0; i < 4; i++)
+ for (unsigned i = 0; i < 3; i++)
returned_ids.insert(returned_to_child[i].id);
EXPECT_EQ(expected_ids, returned_ids);
EXPECT_FALSE(returned_to_child[0].lost);
EXPECT_FALSE(returned_to_child[1].lost);
EXPECT_FALSE(returned_to_child[2].lost);
- EXPECT_FALSE(returned_to_child[3].lost);
}
TEST_P(ResourceProviderTest, TransferGLToSoftware) {
child_context_owned.PassAs<TestWebGraphicsContext3D>()));
CHECK(child_output_surface->BindToClient(&child_output_surface_client));
- scoped_ptr<ResourceProvider> child_resource_provider(ResourceProvider::Create(
- child_output_surface.get(), shared_bitmap_manager_.get(), 0, false, 1,
- false));
+ scoped_ptr<ResourceProvider> child_resource_provider(
+ ResourceProvider::Create(child_output_surface.get(),
+ shared_bitmap_manager_.get(),
+ NULL,
+ 0,
+ false,
+ 1,
+ false));
gfx::Size size(1, 1);
ResourceFormat format = RGBA_8888;
ASSERT_EQ(4U, pixel_size);
ResourceProvider::ResourceId id1 = child_resource_provider->CreateResource(
- size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
+ size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
uint8_t data1[4] = { 1, 2, 3, 4 };
gfx::Rect rect(size);
child_resource_provider->SetPixels(id1, data1, rect, rect, gfx::Vector2d());
ASSERT_EQ(4U, pixel_size);
ResourceProvider::ResourceId id1 = child_resource_provider_->CreateResource(
- size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
+ size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
uint8_t data1[4] = { 1, 2, 3, 4 };
gfx::Rect rect(size);
child_resource_provider_->SetPixels(id1, data1, rect, rect, gfx::Vector2d());
ASSERT_EQ(4U, pixel_size);
ResourceProvider::ResourceId id1 = child_resource_provider_->CreateResource(
- size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
+ size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
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, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
+ size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
uint8_t data2[4] = {5, 5, 5, 5};
child_resource_provider_->SetPixels(id2, data2, rect, rect, gfx::Vector2d());
ASSERT_EQ(4U, pixel_size);
ResourceProvider::ResourceId id1 = child_resource_provider_->CreateResource(
- size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
+ size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
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, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
+ size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
uint8_t data2[4] = {5, 5, 5, 5};
child_resource_provider_->SetPixels(id2, data2, rect, rect, gfx::Vector2d());
ASSERT_EQ(4U, pixel_size);
ResourceProvider::ResourceId id = child_resource_provider_->CreateResource(
- size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
+ size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
uint8_t data[4] = { 1, 2, 3, 4 };
gfx::Rect rect(size);
child_resource_provider_->SetPixels(id, data, rect, rect, gfx::Vector2d());
ASSERT_EQ(4U, pixel_size);
ResourceProvider::ResourceId id = child_resource_provider_->CreateResource(
- size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
+ size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
uint8_t data[4] = {1, 2, 3, 4};
gfx::Rect rect(size);
child_resource_provider_->SetPixels(id, data, rect, rect, gfx::Vector2d());
scoped_ptr<ResourceProvider> child_resource_provider(
ResourceProvider::Create(child_output_surface.get(),
shared_bitmap_manager.get(),
+ NULL,
0,
false,
1,
scoped_ptr<ResourceProvider> parent_resource_provider(
ResourceProvider::Create(parent_output_surface.get(),
shared_bitmap_manager.get(),
+ NULL,
0,
false,
1,
ASSERT_EQ(4U, pixel_size);
ResourceProvider::ResourceId id = child_resource_provider->CreateResource(
- size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
+ size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
// The new texture is created with GL_LINEAR.
EXPECT_CALL(*child_context, bindTexture(GL_TEXTURE_2D, child_texture_id))
EXPECT_CALL(*parent_context, consumeTextureCHROMIUM(GL_TEXTURE_2D, _));
parent_resource_provider->ReceiveFromChild(child_id, list);
{
+ parent_resource_provider->WaitSyncPointIfNeeded(list[0].id);
ResourceProvider::ScopedReadLockGL lock(parent_resource_provider.get(),
list[0].id);
}
uint32 release_sync_point = 0;
bool lost_resource = false;
- ReleaseCallback callback =
- base::Bind(ReleaseTextureMailbox, &release_sync_point, &lost_resource);
+ BlockingTaskRunner* main_thread_task_runner = NULL;
+ ReleaseCallbackImpl callback = base::Bind(ReleaseCallback,
+ &release_sync_point,
+ &lost_resource,
+ &main_thread_task_runner);
ResourceProvider::ResourceId resource =
resource_provider_->CreateResourceFromTextureMailbox(
TextureMailbox(mailbox, GL_TEXTURE_2D, sync_point),
- SingleReleaseCallback::Create(callback));
+ SingleReleaseCallbackImpl::Create(callback));
EXPECT_EQ(1u, context()->NumTextures());
EXPECT_EQ(0u, release_sync_point);
{
resource_provider_->DeleteResource(resource);
EXPECT_LE(list[0].mailbox_holder.sync_point, release_sync_point);
EXPECT_FALSE(lost_resource);
+ EXPECT_EQ(main_thread_task_runner_.get(), main_thread_task_runner);
}
// We're going to do the same thing as above, but testing the case where we
release_sync_point = 0;
resource = resource_provider_->CreateResourceFromTextureMailbox(
TextureMailbox(mailbox, GL_TEXTURE_2D, sync_point),
- SingleReleaseCallback::Create(callback));
+ SingleReleaseCallbackImpl::Create(callback));
EXPECT_EQ(1u, context()->NumTextures());
EXPECT_EQ(0u, release_sync_point);
{
resource_provider_->ReceiveReturnsFromParent(returned);
EXPECT_LE(list[0].mailbox_holder.sync_point, release_sync_point);
EXPECT_FALSE(lost_resource);
+ EXPECT_EQ(main_thread_task_runner_.get(), main_thread_task_runner);
}
context()->waitSyncPoint(release_sync_point);
ResourceFormat format = RGBA_8888;
ResourceProvider::ResourceId resource =
child_resource_provider_->CreateResource(
- size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
+ size,
+ GL_CLAMP_TO_EDGE,
+ ResourceProvider::TextureHintImmutable,
+ format);
child_resource_provider_->AllocateForTesting(resource);
// Expect a GL resource to be lost.
bool should_lose_resource = GetParam() == ResourceProvider::GLTexture;
ResourceFormat format = RGBA_8888;
ResourceProvider::ResourceId resource =
child_resource_provider_->CreateResource(
- size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
+ size,
+ GL_CLAMP_TO_EDGE,
+ ResourceProvider::TextureHintImmutable,
+ format);
child_resource_provider_->AllocateForTesting(resource);
ReturnedResourceArray returned_to_child;
uint32 release_sync_point = 0;
bool lost_resource = false;
- scoped_ptr<SingleReleaseCallback> callback = SingleReleaseCallback::Create(
- base::Bind(ReleaseTextureMailbox, &release_sync_point, &lost_resource));
+ BlockingTaskRunner* main_thread_task_runner = NULL;
+ scoped_ptr<SingleReleaseCallbackImpl> callback =
+ SingleReleaseCallbackImpl::Create(base::Bind(ReleaseCallback,
+ &release_sync_point,
+ &lost_resource,
+ &main_thread_task_runner));
resource_provider_->CreateResourceFromTextureMailbox(
TextureMailbox(mailbox, GL_TEXTURE_2D, sync_point), callback.Pass());
EXPECT_EQ(0u, release_sync_point);
EXPECT_FALSE(lost_resource);
+ EXPECT_EQ(NULL, main_thread_task_runner);
resource_provider_->DidLoseOutputSurface();
resource_provider_.reset();
EXPECT_LE(sync_point, release_sync_point);
EXPECT_TRUE(lost_resource);
+ EXPECT_EQ(main_thread_task_runner_.get(), main_thread_task_runner);
}
TEST_P(ResourceProviderTest, ScopedSampler) {
context_owned.PassAs<TestWebGraphicsContext3D>()));
CHECK(output_surface->BindToClient(&output_surface_client));
- scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
- output_surface.get(), shared_bitmap_manager_.get(), 0, false, 1, false));
+ scoped_ptr<ResourceProvider> resource_provider(
+ ResourceProvider::Create(output_surface.get(),
+ shared_bitmap_manager_.get(),
+ NULL,
+ 0,
+ false,
+ 1,
+ false));
gfx::Size size(1, 1);
ResourceFormat format = RGBA_8888;
int texture_id = 1;
ResourceProvider::ResourceId id = resource_provider->CreateResource(
- size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
+ size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
// Check that the texture gets created with the right sampler settings.
EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id))
context_owned.PassAs<TestWebGraphicsContext3D>()));
CHECK(output_surface->BindToClient(&output_surface_client));
- scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
- output_surface.get(), shared_bitmap_manager_.get(), 0, false, 1, false));
+ scoped_ptr<ResourceProvider> resource_provider(
+ ResourceProvider::Create(output_surface.get(),
+ shared_bitmap_manager_.get(),
+ NULL,
+ 0,
+ false,
+ 1,
+ false));
gfx::Size size(1, 1);
ResourceFormat format = RGBA_8888;
size,
GL_TEXTURE_2D,
GL_CLAMP_TO_EDGE,
- ResourceProvider::TextureUsageAny,
+ ResourceProvider::TextureHintImmutable,
format);
EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id));
EXPECT_CALL(*context,
context_owned.PassAs<TestWebGraphicsContext3D>()));
CHECK(output_surface->BindToClient(&output_surface_client));
- scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
- output_surface.get(), shared_bitmap_manager_.get(), 0, false, 1, false));
+ scoped_ptr<ResourceProvider> resource_provider(
+ ResourceProvider::Create(output_surface.get(),
+ shared_bitmap_manager_.get(),
+ NULL,
+ 0,
+ false,
+ 1,
+ false));
gfx::Size size(1, 1);
ResourceFormat format = RGBA_8888;
for (int texture_id = 1; texture_id <= 2; ++texture_id) {
GLint wrap_mode = texture_id == 1 ? GL_CLAMP_TO_EDGE : GL_REPEAT;
// Check that the texture gets created with the right sampler settings.
+ ResourceProvider::ResourceId id = resource_provider->CreateGLTexture(
+ size,
+ GL_TEXTURE_2D,
+ texture_pool,
+ wrap_mode,
+ ResourceProvider::TextureHintImmutable,
+ format);
+ 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, wrap_mode));
+ EXPECT_CALL(*context,
+ texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrap_mode));
+ EXPECT_CALL(*context,
+ texParameteri(GL_TEXTURE_2D,
+ GL_TEXTURE_POOL_CHROMIUM,
+ GL_TEXTURE_POOL_UNMANAGED_CHROMIUM));
+ resource_provider->CreateForTesting(id);
+ EXPECT_NE(0u, id);
+
+ Mock::VerifyAndClearExpectations(context);
+ }
+}
+
+TEST_P(ResourceProviderTest, TextureHint) {
+ // Sampling is only supported for GL textures.
+ if (GetParam() != ResourceProvider::GLTexture)
+ return;
+
+ scoped_ptr<TextureStateTrackingContext> context_owned(
+ new TextureStateTrackingContext);
+ TextureStateTrackingContext* context = context_owned.get();
+ context->set_support_texture_storage(true);
+ context->set_support_texture_usage(true);
+
+ FakeOutputSurfaceClient output_surface_client;
+ scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
+ context_owned.PassAs<TestWebGraphicsContext3D>()));
+ CHECK(output_surface->BindToClient(&output_surface_client));
+
+ scoped_ptr<ResourceProvider> resource_provider(
+ ResourceProvider::Create(output_surface.get(),
+ shared_bitmap_manager_.get(),
+ NULL,
+ 0,
+ false,
+ 1,
+ false));
+
+ gfx::Size size(1, 1);
+ ResourceFormat format = RGBA_8888;
+ GLenum texture_pool = GL_TEXTURE_POOL_UNMANAGED_CHROMIUM;
+
+ const ResourceProvider::TextureHint hints[4] = {
+ ResourceProvider::TextureHintDefault,
+ ResourceProvider::TextureHintImmutable,
+ ResourceProvider::TextureHintFramebuffer,
+ ResourceProvider::TextureHintImmutableFramebuffer,
+ };
+ for (GLuint texture_id = 1; texture_id <= arraysize(hints); ++texture_id) {
+ // Check that the texture gets created with the right sampler settings.
ResourceProvider::ResourceId id =
resource_provider->CreateGLTexture(size,
GL_TEXTURE_2D,
texture_pool,
- wrap_mode,
- ResourceProvider::TextureUsageAny,
+ GL_CLAMP_TO_EDGE,
+ hints[texture_id - 1],
format);
EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id));
EXPECT_CALL(*context,
texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
EXPECT_CALL(
*context,
- texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrap_mode));
+ texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
EXPECT_CALL(
*context,
- texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrap_mode));
+ 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));
+ // Check only TextureHintFramebuffer set GL_TEXTURE_USAGE_ANGLE.
+ bool is_framebuffer_hint =
+ hints[texture_id - 1] & ResourceProvider::TextureHintFramebuffer;
+ EXPECT_CALL(*context,
+ texParameteri(GL_TEXTURE_2D,
+ GL_TEXTURE_USAGE_ANGLE,
+ GL_FRAMEBUFFER_ATTACHMENT_ANGLE))
+ .Times(is_framebuffer_hint ? 1 : 0);
resource_provider->CreateForTesting(id);
EXPECT_NE(0u, id);
new SoftwareOutputDevice)));
CHECK(output_surface->BindToClient(&output_surface_client));
- scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
- output_surface.get(), shared_bitmap_manager_.get(), 0, false, 1, false));
+ scoped_ptr<ResourceProvider> resource_provider(
+ ResourceProvider::Create(output_surface.get(),
+ shared_bitmap_manager_.get(),
+ main_thread_task_runner_.get(),
+ 0,
+ false,
+ 1,
+ false));
- scoped_ptr<SingleReleaseCallback> callback = SingleReleaseCallback::Create(
- base::Bind(&EmptyReleaseCallback));
+ uint32 release_sync_point = 0;
+ bool lost_resource = false;
+ BlockingTaskRunner* main_thread_task_runner = NULL;
+ scoped_ptr<SingleReleaseCallbackImpl> callback =
+ SingleReleaseCallbackImpl::Create(base::Bind(&ReleaseCallback,
+ &release_sync_point,
+ &lost_resource,
+ &main_thread_task_runner));
TextureMailbox mailbox(shared_memory.get(), size);
ResourceProvider::ResourceId id =
EXPECT_EQ(sk_bitmap->height(), size.height());
EXPECT_EQ(*sk_bitmap->getAddr32(16, 16), kBadBeef);
}
+
+ resource_provider->DeleteResource(id);
+ EXPECT_EQ(0u, release_sync_point);
+ EXPECT_FALSE(lost_resource);
+ EXPECT_EQ(main_thread_task_runner_.get(), main_thread_task_runner);
}
TEST_P(ResourceProviderTest, TextureMailbox_GLTexture2D) {
context_owned.PassAs<TestWebGraphicsContext3D>()));
CHECK(output_surface->BindToClient(&output_surface_client));
- scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
- output_surface.get(), shared_bitmap_manager_.get(), 0, false, 1, false));
+ scoped_ptr<ResourceProvider> resource_provider(
+ ResourceProvider::Create(output_surface.get(),
+ shared_bitmap_manager_.get(),
+ main_thread_task_runner_.get(),
+ 0,
+ false,
+ 1,
+ false));
unsigned texture_id = 1;
uint32 sync_point = 30;
gpu::Mailbox gpu_mailbox;
memcpy(gpu_mailbox.name, "Hello world", strlen("Hello world") + 1);
- scoped_ptr<SingleReleaseCallback> callback = SingleReleaseCallback::Create(
- base::Bind(&EmptyReleaseCallback));
+ uint32 release_sync_point = 0;
+ bool lost_resource = false;
+ BlockingTaskRunner* main_thread_task_runner = NULL;
+ scoped_ptr<SingleReleaseCallbackImpl> callback =
+ SingleReleaseCallbackImpl::Create(base::Bind(&ReleaseCallback,
+ &release_sync_point,
+ &lost_resource,
+ &main_thread_task_runner));
TextureMailbox mailbox(gpu_mailbox, target, sync_point);
Mock::VerifyAndClearExpectations(context);
{
+ // Mailbox sync point WaitSyncPoint before using the texture.
+ EXPECT_CALL(*context, waitSyncPoint(sync_point));
+ resource_provider->WaitSyncPointIfNeeded(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, waitSyncPoint(_)).Times(0);
EXPECT_CALL(*context, consumeTextureCHROMIUM(_, _)).Times(0);
}
+
+ resource_provider->DeleteResource(id);
+ EXPECT_EQ(0u, release_sync_point);
+ EXPECT_FALSE(lost_resource);
+ EXPECT_EQ(main_thread_task_runner_.get(), main_thread_task_runner);
}
TEST_P(ResourceProviderTest, TextureMailbox_GLTextureExternalOES) {
context_owned.PassAs<TestWebGraphicsContext3D>()));
CHECK(output_surface->BindToClient(&output_surface_client));
- scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
- output_surface.get(), shared_bitmap_manager_.get(), 0, false, 1, false));
+ scoped_ptr<ResourceProvider> resource_provider(
+ ResourceProvider::Create(output_surface.get(),
+ shared_bitmap_manager_.get(),
+ NULL,
+ 0,
+ false,
+ 1,
+ false));
unsigned texture_id = 1;
uint32 sync_point = 30;
gpu::Mailbox gpu_mailbox;
memcpy(gpu_mailbox.name, "Hello world", strlen("Hello world") + 1);
- scoped_ptr<SingleReleaseCallback> callback = SingleReleaseCallback::Create(
- base::Bind(&EmptyReleaseCallback));
+ scoped_ptr<SingleReleaseCallbackImpl> callback =
+ SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback));
TextureMailbox mailbox(gpu_mailbox, target, sync_point);
Mock::VerifyAndClearExpectations(context);
{
+ // Mailbox sync point WaitSyncPoint before using the texture.
+ EXPECT_CALL(*context, waitSyncPoint(sync_point));
+ resource_provider->WaitSyncPointIfNeeded(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);
}
}
+TEST_P(ResourceProviderTest,
+ TextureMailbox_WaitSyncPointIfNeeded_WithSyncPoint) {
+ // Mailboxing is only supported for GL textures.
+ if (GetParam() != ResourceProvider::GLTexture)
+ return;
+
+ scoped_ptr<TextureStateTrackingContext> context_owned(
+ new TextureStateTrackingContext);
+ TextureStateTrackingContext* context = context_owned.get();
+
+ FakeOutputSurfaceClient output_surface_client;
+ scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
+ context_owned.PassAs<TestWebGraphicsContext3D>()));
+ CHECK(output_surface->BindToClient(&output_surface_client));
+
+ scoped_ptr<ResourceProvider> resource_provider(
+ ResourceProvider::Create(output_surface.get(),
+ shared_bitmap_manager_.get(),
+ NULL,
+ 0,
+ false,
+ 1,
+ false));
+
+ uint32 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);
+ scoped_ptr<SingleReleaseCallbackImpl> callback =
+ SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback));
+
+ TextureMailbox mailbox(gpu_mailbox, target, sync_point);
+
+ ResourceProvider::ResourceId id =
+ resource_provider->CreateResourceFromTextureMailbox(mailbox,
+ callback.Pass());
+ EXPECT_NE(0u, id);
+
+ Mock::VerifyAndClearExpectations(context);
+
+ {
+ // First call to WaitSyncPointIfNeeded should call waitSyncPoint.
+ EXPECT_CALL(*context, waitSyncPoint(sync_point));
+ resource_provider->WaitSyncPointIfNeeded(id);
+ Mock::VerifyAndClearExpectations(context);
+
+ // Subsequent calls to WaitSyncPointIfNeeded shouldn't call waitSyncPoint.
+ EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
+ resource_provider->WaitSyncPointIfNeeded(id);
+ Mock::VerifyAndClearExpectations(context);
+ }
+}
+
+TEST_P(ResourceProviderTest, TextureMailbox_WaitSyncPointIfNeeded_NoSyncPoint) {
+ // Mailboxing is only supported for GL textures.
+ if (GetParam() != ResourceProvider::GLTexture)
+ return;
+
+ scoped_ptr<TextureStateTrackingContext> context_owned(
+ new TextureStateTrackingContext);
+ TextureStateTrackingContext* context = context_owned.get();
+
+ FakeOutputSurfaceClient output_surface_client;
+ scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
+ context_owned.PassAs<TestWebGraphicsContext3D>()));
+ CHECK(output_surface->BindToClient(&output_surface_client));
+
+ scoped_ptr<ResourceProvider> resource_provider(
+ ResourceProvider::Create(output_surface.get(),
+ shared_bitmap_manager_.get(),
+ NULL,
+ 0,
+ false,
+ 1,
+ false));
+
+ uint32 sync_point = 0;
+ 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);
+ scoped_ptr<SingleReleaseCallbackImpl> callback =
+ SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback));
+
+ TextureMailbox mailbox(gpu_mailbox, target, sync_point);
+
+ ResourceProvider::ResourceId id =
+ resource_provider->CreateResourceFromTextureMailbox(mailbox,
+ callback.Pass());
+ EXPECT_NE(0u, id);
+
+ Mock::VerifyAndClearExpectations(context);
+
+ {
+ // WaitSyncPointIfNeeded with sync_point == 0 shouldn't call waitSyncPoint.
+ EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
+ resource_provider->WaitSyncPointIfNeeded(id);
+ Mock::VerifyAndClearExpectations(context);
+ }
+}
+
class AllocationTrackingContext3D : public TestWebGraphicsContext3D {
public:
MOCK_METHOD0(NextTextureId, GLuint());
context_owned.PassAs<TestWebGraphicsContext3D>()));
CHECK(output_surface->BindToClient(&output_surface_client));
- scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
- output_surface.get(), shared_bitmap_manager_.get(), 0, false, 1, false));
+ scoped_ptr<ResourceProvider> resource_provider(
+ ResourceProvider::Create(output_surface.get(),
+ shared_bitmap_manager_.get(),
+ NULL,
+ 0,
+ false,
+ 1,
+ false));
gfx::Size size(2, 2);
gfx::Vector2d offset(0, 0);
// Lazy allocation. Don't allocate when creating the resource.
id = resource_provider->CreateResource(
- size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
+ size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(1);
// Do allocate when we set the pixels.
id = resource_provider->CreateResource(
- size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
+ size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(3);
// Same for async version.
id = resource_provider->CreateResource(
- size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
- resource_provider->AcquirePixelRasterBuffer(id);
+ size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
+ resource_provider->AcquirePixelBuffer(id);
EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(2);
resource_provider->BeginSetPixels(id);
ASSERT_TRUE(resource_provider->DidSetPixelsComplete(id));
- resource_provider->ReleasePixelRasterBuffer(id);
+ resource_provider->ReleasePixelBuffer(id);
EXPECT_CALL(*context, RetireTextureId(texture_id)).Times(1);
resource_provider->DeleteResource(id);
Mock::VerifyAndClearExpectations(context);
}
-TEST_P(ResourceProviderTest, TextureAllocationStorageUsageAny) {
+TEST_P(ResourceProviderTest, TextureAllocationHint) {
// Only for GL textures.
if (GetParam() != ResourceProvider::GLTexture)
return;
new StrictMock<AllocationTrackingContext3D>);
AllocationTrackingContext3D* context = context_owned.get();
context->set_support_texture_storage(true);
+ context->set_support_texture_usage(true);
FakeOutputSurfaceClient output_surface_client;
scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
context_owned.PassAs<TestWebGraphicsContext3D>()));
CHECK(output_surface->BindToClient(&output_surface_client));
- scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
- output_surface.get(), shared_bitmap_manager_.get(), 0, false, 1, false));
+ scoped_ptr<ResourceProvider> resource_provider(
+ ResourceProvider::Create(output_surface.get(),
+ shared_bitmap_manager_.get(),
+ NULL,
+ 0,
+ false,
+ 1,
+ false));
gfx::Size size(2, 2);
- ResourceFormat format = RGBA_8888;
- ResourceProvider::ResourceId id = 0;
- int texture_id = 123;
-
- // Lazy allocation. Don't allocate when creating the resource.
- id = resource_provider->CreateResource(
- size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
- EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
- EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(2);
- EXPECT_CALL(*context, texStorage2DEXT(_, _, _, 2, 2)).Times(1);
- resource_provider->AllocateForTesting(id);
-
- EXPECT_CALL(*context, RetireTextureId(texture_id)).Times(1);
- resource_provider->DeleteResource(id);
-
- Mock::VerifyAndClearExpectations(context);
+ const ResourceFormat formats[2] = {RGBA_8888, BGRA_8888};
+ const ResourceProvider::TextureHint hints[4] = {
+ ResourceProvider::TextureHintDefault,
+ ResourceProvider::TextureHintImmutable,
+ ResourceProvider::TextureHintFramebuffer,
+ ResourceProvider::TextureHintImmutableFramebuffer,
+ };
+ for (size_t i = 0; i < arraysize(formats); ++i) {
+ for (GLuint texture_id = 1; texture_id <= arraysize(hints); ++texture_id) {
+ // Lazy allocation. Don't allocate when creating the resource.
+ ResourceProvider::ResourceId id = resource_provider->CreateResource(
+ size, GL_CLAMP_TO_EDGE, hints[texture_id - 1], formats[i]);
+
+ EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
+ EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(2);
+ bool is_immutable_hint =
+ hints[texture_id - 1] & ResourceProvider::TextureHintImmutable;
+ bool support_immutable_texture =
+ is_immutable_hint && formats[i] == RGBA_8888;
+ EXPECT_CALL(*context, texStorage2DEXT(_, _, _, 2, 2))
+ .Times(support_immutable_texture ? 1 : 0);
+ EXPECT_CALL(*context, texImage2D(_, _, _, 2, 2, _, _, _, _))
+ .Times(support_immutable_texture ? 0 : 1);
+ resource_provider->AllocateForTesting(id);
+
+ EXPECT_CALL(*context, RetireTextureId(texture_id)).Times(1);
+ resource_provider->DeleteResource(id);
+
+ Mock::VerifyAndClearExpectations(context);
+ }
+ }
}
-TEST_P(ResourceProviderTest, TextureAllocationStorageUsageFramebuffer) {
+TEST_P(ResourceProviderTest, TextureAllocationHint_BGRA) {
// Only for GL textures.
if (GetParam() != ResourceProvider::GLTexture)
return;
scoped_ptr<AllocationTrackingContext3D> context_owned(
new StrictMock<AllocationTrackingContext3D>);
AllocationTrackingContext3D* context = context_owned.get();
+ context->set_support_texture_format_bgra8888(true);
context->set_support_texture_storage(true);
+ context->set_support_texture_usage(true);
FakeOutputSurfaceClient output_surface_client;
scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
context_owned.PassAs<TestWebGraphicsContext3D>()));
CHECK(output_surface->BindToClient(&output_surface_client));
- scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
- output_surface.get(), shared_bitmap_manager_.get(), 0, false, 1, false));
+ scoped_ptr<ResourceProvider> resource_provider(
+ ResourceProvider::Create(output_surface.get(),
+ shared_bitmap_manager_.get(),
+ NULL,
+ 0,
+ false,
+ 1,
+ false));
gfx::Size size(2, 2);
- ResourceFormat format = RGBA_8888;
- ResourceProvider::ResourceId id = 0;
- int texture_id = 123;
-
- // Lazy allocation. Don't allocate when creating the resource.
- id = resource_provider->CreateResource(
- size,
- GL_CLAMP_TO_EDGE,
- ResourceProvider::TextureUsageFramebuffer,
- format);
-
- EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
- EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(2);
- EXPECT_CALL(*context, texImage2D(_, _, _, 2, 2, _, _, _, _)).Times(1);
- resource_provider->AllocateForTesting(id);
-
- EXPECT_CALL(*context, RetireTextureId(texture_id)).Times(1);
- resource_provider->DeleteResource(id);
+ const ResourceFormat formats[2] = {RGBA_8888, BGRA_8888};
- Mock::VerifyAndClearExpectations(context);
+ const ResourceProvider::TextureHint hints[4] = {
+ ResourceProvider::TextureHintDefault,
+ ResourceProvider::TextureHintImmutable,
+ ResourceProvider::TextureHintFramebuffer,
+ ResourceProvider::TextureHintImmutableFramebuffer,
+ };
+ for (size_t i = 0; i < arraysize(formats); ++i) {
+ for (GLuint texture_id = 1; texture_id <= arraysize(hints); ++texture_id) {
+ // Lazy allocation. Don't allocate when creating the resource.
+ ResourceProvider::ResourceId id = resource_provider->CreateResource(
+ size, GL_CLAMP_TO_EDGE, hints[texture_id - 1], formats[i]);
+
+ EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
+ EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(2);
+ bool is_immutable_hint =
+ hints[texture_id - 1] & ResourceProvider::TextureHintImmutable;
+ EXPECT_CALL(*context, texStorage2DEXT(_, _, _, 2, 2))
+ .Times(is_immutable_hint ? 1 : 0);
+ EXPECT_CALL(*context, texImage2D(_, _, _, 2, 2, _, _, _, _))
+ .Times(is_immutable_hint ? 0 : 1);
+ resource_provider->AllocateForTesting(id);
+
+ EXPECT_CALL(*context, RetireTextureId(texture_id)).Times(1);
+ resource_provider->DeleteResource(id);
+
+ Mock::VerifyAndClearExpectations(context);
+ }
+ }
}
TEST_P(ResourceProviderTest, PixelBuffer_GLTexture) {
ResourceProvider::ResourceId id = 0;
int texture_id = 123;
- scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
- output_surface.get(), shared_bitmap_manager_.get(), 0, false, 1, false));
+ scoped_ptr<ResourceProvider> resource_provider(
+ ResourceProvider::Create(output_surface.get(),
+ shared_bitmap_manager_.get(),
+ NULL,
+ 0,
+ false,
+ 1,
+ false));
id = resource_provider->CreateResource(
- size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
- resource_provider->AcquirePixelRasterBuffer(id);
+ size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
+ resource_provider->AcquirePixelBuffer(id);
EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(2);
EXPECT_TRUE(resource_provider->DidSetPixelsComplete(id));
- resource_provider->ReleasePixelRasterBuffer(id);
+ resource_provider->ReleasePixelBuffer(id);
EXPECT_CALL(*context, RetireTextureId(texture_id)).Times(1);
resource_provider->DeleteResource(id);
ResourceProvider::ResourceId id = 0;
int texture_id = 123;
- scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
- output_surface.get(), shared_bitmap_manager_.get(), 0, false, 1, false));
+ scoped_ptr<ResourceProvider> resource_provider(
+ ResourceProvider::Create(output_surface.get(),
+ shared_bitmap_manager_.get(),
+ NULL,
+ 0,
+ false,
+ 1,
+ false));
id = resource_provider->CreateResource(
- size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
- resource_provider->AcquirePixelRasterBuffer(id);
+ size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
+ resource_provider->AcquirePixelBuffer(id);
EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(2);
EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, 0)).Times(1);
resource_provider->ForceSetPixelsToComplete(id);
- resource_provider->ReleasePixelRasterBuffer(id);
+ resource_provider->ReleasePixelBuffer(id);
EXPECT_CALL(*context, RetireTextureId(texture_id)).Times(1);
resource_provider->DeleteResource(id);
ResourceProvider::ResourceId id = 0;
int texture_id = 123;
- scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
- output_surface.get(), shared_bitmap_manager_.get(), 0, false, 1, false));
+ scoped_ptr<ResourceProvider> resource_provider(
+ ResourceProvider::Create(output_surface.get(),
+ shared_bitmap_manager_.get(),
+ NULL,
+ 0,
+ false,
+ 1,
+ false));
EXPECT_CALL(*context, NextTextureId()).WillRepeatedly(Return(texture_id));
id = resource_provider->CreateResource(
- size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
+ size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
context->loseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB,
GL_INNOCENT_CONTEXT_RESET_ARB);
- resource_provider->AcquirePixelRasterBuffer(id);
- SkCanvas* raster_canvas = resource_provider->MapPixelRasterBuffer(id);
- EXPECT_TRUE(raster_canvas == NULL);
- resource_provider->UnmapPixelRasterBuffer(id);
- resource_provider->ReleasePixelRasterBuffer(id);
+ resource_provider->AcquirePixelBuffer(id);
+ int stride;
+ void* buffer = resource_provider->MapPixelBuffer(id, &stride);
+ EXPECT_FALSE(buffer);
+ resource_provider->UnmapPixelBuffer(id);
Mock::VerifyAndClearExpectations(context);
}
const unsigned kTextureId = 123u;
const unsigned kImageId = 234u;
- scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
- output_surface.get(), shared_bitmap_manager_.get(), 0, false, 1, false));
+ scoped_ptr<ResourceProvider> resource_provider(
+ ResourceProvider::Create(output_surface.get(),
+ shared_bitmap_manager_.get(),
+ NULL,
+ 0,
+ false,
+ 1,
+ false));
id = resource_provider->CreateResource(
- size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
+ size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
const int kStride = 4;
void* dummy_mapped_buffer_address = NULL;
createImageCHROMIUM(kWidth, kHeight, GL_RGBA8_OES, GL_IMAGE_MAP_CHROMIUM))
.WillOnce(Return(kImageId))
.RetiresOnSaturation();
+ resource_provider->AcquireImage(id);
+
EXPECT_CALL(*context, getImageParameterivCHROMIUM(kImageId,
GL_IMAGE_ROWBYTES_CHROMIUM,
_))
EXPECT_CALL(*context, mapImageCHROMIUM(kImageId))
.WillOnce(Return(dummy_mapped_buffer_address))
.RetiresOnSaturation();
- resource_provider->MapImageRasterBuffer(id);
+ int stride;
+ resource_provider->MapImage(id, &stride);
EXPECT_CALL(*context, unmapImageCHROMIUM(kImageId))
.Times(1)
.RetiresOnSaturation();
- resource_provider->UnmapImageRasterBuffer(id);
+ resource_provider->UnmapImage(id);
EXPECT_CALL(*context, NextTextureId())
.WillOnce(Return(kTextureId))
EXPECT_CALL(*context, mapImageCHROMIUM(kImageId))
.WillOnce(Return(dummy_mapped_buffer_address))
.RetiresOnSaturation();
- resource_provider->MapImageRasterBuffer(id);
+ resource_provider->MapImage(id, &stride);
EXPECT_CALL(*context, unmapImageCHROMIUM(kImageId))
.Times(1)
.RetiresOnSaturation();
- resource_provider->UnmapImageRasterBuffer(id);
+ resource_provider->UnmapImage(id);
EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, kTextureId)).Times(1)
.RetiresOnSaturation();
.RetiresOnSaturation();
}
-TEST_P(ResourceProviderTest, Image_Bitmap) {
- if (GetParam() != ResourceProvider::Bitmap)
- return;
- FakeOutputSurfaceClient output_surface_client;
- scoped_ptr<OutputSurface> output_surface(
- FakeOutputSurface::CreateSoftware(make_scoped_ptr(
- new SoftwareOutputDevice)));
- CHECK(output_surface->BindToClient(&output_surface_client));
-
- gfx::Size size(1, 1);
- ResourceFormat format = RGBA_8888;
- ResourceProvider::ResourceId id = 0;
- const uint32_t kBadBeef = 0xbadbeef;
-
- scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
- output_surface.get(), shared_bitmap_manager_.get(), 0, false, 1, false));
-
- id = resource_provider->CreateResource(
- size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
-
- SkBitmap bitmap;
- bitmap.allocN32Pixels(size.width(), size.height());
- *(bitmap.getAddr32(0, 0)) = kBadBeef;
- SkCanvas* canvas = resource_provider->MapImageRasterBuffer(id);
- ASSERT_TRUE(!!canvas);
- canvas->writePixels(bitmap, 0, 0);
- resource_provider->UnmapImageRasterBuffer(id);
-
- {
- ResourceProvider::ScopedReadLockSoftware lock(resource_provider.get(), id);
- const SkBitmap* sk_bitmap = lock.sk_bitmap();
- EXPECT_EQ(sk_bitmap->width(), size.width());
- EXPECT_EQ(sk_bitmap->height(), size.height());
- EXPECT_EQ(*sk_bitmap->getAddr32(0, 0), kBadBeef);
- }
-
- resource_provider->DeleteResource(id);
-}
-
TEST_P(ResourceProviderTest, CopyResource_GLTexture) {
if (GetParam() != ResourceProvider::GLTexture)
return;
const unsigned kDestTextureId = 321u;
const unsigned kImageId = 234u;
- scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
- output_surface.get(), shared_bitmap_manager_.get(), 0, false, 1, false));
+ scoped_ptr<ResourceProvider> resource_provider(
+ ResourceProvider::Create(output_surface.get(),
+ shared_bitmap_manager_.get(),
+ NULL,
+ 0,
+ false,
+ 1,
+ false));
source_id = resource_provider->CreateResource(
- size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
+ size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
const int kStride = 4;
void* dummy_mapped_buffer_address = NULL;
EXPECT_CALL(*context, mapImageCHROMIUM(kImageId))
.WillOnce(Return(dummy_mapped_buffer_address))
.RetiresOnSaturation();
- resource_provider->MapImageRasterBuffer(source_id);
- Mock::VerifyAndClearExpectations(context);
-
+ resource_provider->AcquireImage(source_id);
+ int stride;
+ resource_provider->MapImage(source_id, &stride);
EXPECT_CALL(*context, unmapImageCHROMIUM(kImageId))
.Times(1)
.RetiresOnSaturation();
- resource_provider->UnmapImageRasterBuffer(source_id);
+ resource_provider->UnmapImage(source_id);
Mock::VerifyAndClearExpectations(context);
dest_id = resource_provider->CreateResource(
- size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
+ size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
EXPECT_CALL(*context, NextTextureId())
.WillOnce(Return(kDestTextureId))
resource_provider->DeleteResource(dest_id);
}
-TEST_P(ResourceProviderTest, CopyResource_Bitmap) {
- if (GetParam() != ResourceProvider::Bitmap)
- return;
- FakeOutputSurfaceClient output_surface_client;
- scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::CreateSoftware(
- make_scoped_ptr(new SoftwareOutputDevice)));
- CHECK(output_surface->BindToClient(&output_surface_client));
-
- gfx::Size size(1, 1);
- ResourceFormat format = RGBA_8888;
- ResourceProvider::ResourceId source_id = 0;
- ResourceProvider::ResourceId dest_id = 0;
- const uint32_t kBadBeef = 0xbadbeef;
-
- scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
- output_surface.get(), shared_bitmap_manager_.get(), 0, false, 1, false));
-
- source_id = resource_provider->CreateResource(
- size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
-
- SkBitmap bitmap;
- bitmap.allocN32Pixels(size.width(), size.height());
- *(bitmap.getAddr32(0, 0)) = kBadBeef;
- SkCanvas* canvas = resource_provider->MapImageRasterBuffer(source_id);
- ASSERT_TRUE(!!canvas);
- canvas->writePixels(bitmap, 0, 0);
- resource_provider->UnmapImageRasterBuffer(source_id);
-
- dest_id = resource_provider->CreateResource(
- size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
-
- resource_provider->CopyResource(source_id, dest_id);
-
- {
- ResourceProvider::ScopedReadLockSoftware lock(resource_provider.get(),
- dest_id);
- const SkBitmap* sk_bitmap = lock.sk_bitmap();
- EXPECT_EQ(sk_bitmap->width(), size.width());
- EXPECT_EQ(sk_bitmap->height(), size.height());
- EXPECT_EQ(*sk_bitmap->getAddr32(0, 0), kBadBeef);
- }
-
- resource_provider->DeleteResource(source_id);
- resource_provider->DeleteResource(dest_id);
-}
-
void InitializeGLAndCheck(ContextSharedData* shared_data,
ResourceProvider* resource_provider,
FakeOutputSurface* output_surface) {
EXPECT_TRUE(output_surface->BindToClient(&client));
scoped_ptr<SharedBitmapManager> shared_bitmap_manager(
new TestSharedBitmapManager());
- scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
- output_surface.get(), shared_bitmap_manager.get(), 0, false, 1, false));
+ scoped_ptr<ResourceProvider> resource_provider(
+ ResourceProvider::Create(output_surface.get(),
+ shared_bitmap_manager.get(),
+ NULL,
+ 0,
+ false,
+ 1,
+ false));
CheckCreateResource(ResourceProvider::Bitmap, resource_provider.get(), NULL);
scoped_ptr<ResourceProvider> resource_provider(
ResourceProvider::Create(output_surface.get(),
shared_bitmap_manager_.get(),
+ NULL,
0,
false,
1,
int texture_id = 123;
ResourceProvider::ResourceId id = resource_provider->CreateResource(
- size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, ETC1);
+ size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, ETC1);
EXPECT_NE(0u, id);
EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(2);
scoped_ptr<ResourceProvider> resource_provider(
ResourceProvider::Create(output_surface.get(),
shared_bitmap_manager_.get(),
+ NULL,
0,
false,
1,
uint8_t pixels[8];
ResourceProvider::ResourceId id = resource_provider->CreateResource(
- size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, ETC1);
+ size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, ETC1);
EXPECT_NE(0u, id);
EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(3);
scoped_ptr<ResourceProvider> resource_provider(
ResourceProvider::Create(output_surface.get(),
shared_bitmap_manager.get(),
+ NULL,
0,
false,
kTextureAllocationChunkSize,
false));
ResourceProvider::ResourceId id = resource_provider->CreateResource(
- size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
+ size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
resource_provider->AllocateForTesting(id);
Mock::VerifyAndClearExpectations(context);
scoped_ptr<ResourceProvider> resource_provider(
ResourceProvider::Create(output_surface.get(),
shared_bitmap_manager.get(),
+ NULL,
0,
false,
kTextureAllocationChunkSize,
false));
ResourceProvider::ResourceId id = resource_provider->CreateResource(
- size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
+ size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
resource_provider->AllocateForTesting(id);
Mock::VerifyAndClearExpectations(context);
projects / platform / framework / web / crosswalk.git / blobdiff