cc/resources/resource_provider_unittest.cc - Issue 2337913003: Fork cc::OutputSurface into cc::CompositorFrameSink.

Unified Diff: cc/resources/resource_provider_unittest.cc

Issue 2337913003: Fork cc::OutputSurface into cc::CompositorFrameSink. (Closed)

Patch Set: cfsfork: rebase Created 4 years, 3 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Index: cc/resources/resource_provider_unittest.cc

diff --git a/cc/resources/resource_provider_unittest.cc b/cc/resources/resource_provider_unittest.cc

index 26dea2cc17edab0befdd7005cf39ceac6a2b6374..cdc6710e78ada4e4e4c2b6d49e0a5bac46e1355a 100644

--- a/cc/resources/resource_provider_unittest.cc

+++ b/cc/resources/resource_provider_unittest.cc

@@ -19,12 +19,10 @@

#include "base/memory/ptr_util.h"

#include "base/memory/ref_counted.h"

#include "cc/output/buffer_to_texture_target_map.h"

-#include "cc/output/output_surface.h"

#include "cc/resources/returned_resource.h"

#include "cc/resources/shared_bitmap_manager.h"

#include "cc/resources/single_release_callback.h"

-#include "cc/test/fake_output_surface.h"

-#include "cc/test/fake_output_surface_client.h"

+#include "cc/test/test_context_provider.h"

#include "cc/test/test_gpu_memory_buffer_manager.h"

#include "cc/test/test_shared_bitmap_manager.h"

#include "cc/test/test_texture.h"

@@ -431,33 +429,18 @@ class ResourceProviderTest

std::unique_ptr<ResourceProviderContext> context3d(

ResourceProviderContext::Create(shared_data_.get()));

context3d_ = context3d.get();

- scoped_refptr<TestContextProvider> context_provider =

- TestContextProvider::Create(std::move(context3d));

- output_surface_ = FakeOutputSurface::Create3d(context_provider);

+ context_provider_ = TestContextProvider::Create(std::move(context3d));

std::unique_ptr<ResourceProviderContext> child_context_owned =

ResourceProviderContext::Create(shared_data_.get());

child_context_ = child_context_owned.get();

- if (child_needs_sync_token) {

- child_output_surface_ =

- FakeOutputSurface::Create3d(std::move(child_context_owned));

- } else {

- child_output_surface_ = FakeOutputSurface::CreateNoRequireSyncPoint(

- std::move(child_context_owned));

- }

+ child_context_provider_ =

+ TestContextProvider::Create(std::move(child_context_owned));

break;

}

case ResourceProvider::RESOURCE_TYPE_BITMAP:

- output_surface_ = FakeOutputSurface::CreateSoftware(

- base::WrapUnique(new SoftwareOutputDevice));

- child_output_surface_ = FakeOutputSurface::CreateSoftware(

- base::WrapUnique(new SoftwareOutputDevice));

break;

}

- CHECK(output_surface_->BindToClient(&output_surface_client_));

- CHECK(child_output_surface_->BindToClient(&child_output_surface_client_));

shared_bitmap_manager_.reset(new TestSharedBitmapManager);

gpu_memory_buffer_manager_.reset(new TestGpuMemoryBufferManager);

@@ -465,17 +448,16 @@ class ResourceProviderTest

gpu_memory_buffer_manager_->CreateClientGpuMemoryBufferManager();

resource_provider_ = base::MakeUnique<ResourceProvider>(

- output_surface_->context_provider(), shared_bitmap_manager_.get(),

+ context_provider_.get(), shared_bitmap_manager_.get(),

gpu_memory_buffer_manager_.get(), main_thread_task_runner_.get(), 0, 1,

kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,

kEnableColorCorrectRendering,

DefaultBufferToTextureTargetMapForTesting());

child_resource_provider_ = base::MakeUnique<ResourceProvider>(

- child_output_surface_->context_provider(), shared_bitmap_manager_.get(),

+ child_context_provider_.get(), shared_bitmap_manager_.get(),

child_gpu_memory_buffer_manager_.get(), main_thread_task_runner_.get(),

- 0, 1,

- child_output_surface_->capabilities().delegated_sync_points_required,

- kUseGpuMemoryBufferResources, kEnableColorCorrectRendering,

+ 0, 1, child_needs_sync_token, kUseGpuMemoryBufferResources,

+ kEnableColorCorrectRendering,

DefaultBufferToTextureTargetMapForTesting());

}

@@ -541,10 +523,8 @@ class ResourceProviderTest

std::unique_ptr<ContextSharedData> shared_data_;

ResourceProviderContext* context3d_;

ResourceProviderContext* child_context_;

- FakeOutputSurfaceClient output_surface_client_;

- FakeOutputSurfaceClient child_output_surface_client_;

- std::unique_ptr<OutputSurface> output_surface_;

- std::unique_ptr<OutputSurface> child_output_surface_;

+ scoped_refptr<TestContextProvider> context_provider_;

+ scoped_refptr<TestContextProvider> child_context_provider_;

std::unique_ptr<BlockingTaskRunner> main_thread_task_runner_;

std::unique_ptr<TestGpuMemoryBufferManager> gpu_memory_buffer_manager_;

std::unique_ptr<ResourceProvider> resource_provider_;

@@ -1262,7 +1242,7 @@ TEST_P(ResourceProviderTest, ReadLockFenceContextLost) {

EXPECT_EQ(0u, returned_to_child.size());

EXPECT_EQ(2u, resource_provider_->num_resources());

- resource_provider_->DidLoseOutputSurface();

+ resource_provider_->DidLoseContextProvider();

resource_provider_ = nullptr;

EXPECT_EQ(2u, returned_to_child.size());

@@ -1480,20 +1460,16 @@ TEST_P(ResourceProviderTest, TransferGLToSoftware) {

if (GetParam() != ResourceProvider::RESOURCE_TYPE_BITMAP)

return;

- std::unique_ptr<ResourceProviderContext> child_context_owned(

- ResourceProviderContext::Create(shared_data_.get()));

- FakeOutputSurfaceClient child_output_surface_client;

- std::unique_ptr<OutputSurface> child_output_surface(

- FakeOutputSurface::Create3d(std::move(child_context_owned)));

- CHECK(child_output_surface->BindToClient(&child_output_surface_client));

+ scoped_refptr<TestContextProvider> child_context_provider =

+ TestContextProvider::Create(

+ ResourceProviderContext::Create(shared_data_.get()));

std::unique_ptr<ResourceProvider> child_resource_provider(

base::MakeUnique<ResourceProvider>(

- child_output_surface->context_provider(),

- shared_bitmap_manager_.get(), gpu_memory_buffer_manager_.get(),

- nullptr, 0, 1, kDelegatedSyncPointsRequired,

- kUseGpuMemoryBufferResources, kEnableColorCorrectRendering,

+ child_context_provider.get(), shared_bitmap_manager_.get(),

+ gpu_memory_buffer_manager_.get(), nullptr, 0, 1,

+ kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,

+ kEnableColorCorrectRendering,

DefaultBufferToTextureTargetMapForTesting()));

gfx::Size size(1, 1);

@@ -2006,36 +1982,29 @@ class ResourceProviderTestTextureFilters : public ResourceProviderTest {

new TextureStateTrackingContext);

TextureStateTrackingContext* child_context = child_context_owned.get();

- FakeOutputSurfaceClient child_output_surface_client;

- std::unique_ptr<OutputSurface> child_output_surface(

- FakeOutputSurface::Create3d(std::move(child_context_owned)));

- CHECK(child_output_surface->BindToClient(&child_output_surface_client));

- std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(

- new TestSharedBitmapManager());

+ auto child_context_provider =

+ TestContextProvider::Create(std::move(child_context_owned));

+ auto shared_bitmap_manager = base::MakeUnique<TestSharedBitmapManager>();

std::unique_ptr<ResourceProvider> child_resource_provider(

base::MakeUnique<ResourceProvider>(

- child_output_surface->context_provider(),

- shared_bitmap_manager.get(), nullptr, nullptr, 0, 1,

- kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,

- kEnableColorCorrectRendering,

+ child_context_provider.get(), shared_bitmap_manager.get(), nullptr,

+ nullptr, 0, 1, kDelegatedSyncPointsRequired,

+ kUseGpuMemoryBufferResources, kEnableColorCorrectRendering,

DefaultBufferToTextureTargetMapForTesting()));

std::unique_ptr<TextureStateTrackingContext> parent_context_owned(

new TextureStateTrackingContext);

TextureStateTrackingContext* parent_context = parent_context_owned.get();

- FakeOutputSurfaceClient parent_output_surface_client;

- std::unique_ptr<OutputSurface> parent_output_surface(

- FakeOutputSurface::Create3d(std::move(parent_context_owned)));

- CHECK(parent_output_surface->BindToClient(&parent_output_surface_client));

+ auto parent_context_provider =

+ TestContextProvider::Create(std::move(parent_context_owned));

std::unique_ptr<ResourceProvider> parent_resource_provider(

base::MakeUnique<ResourceProvider>(

- parent_output_surface->context_provider(),

- shared_bitmap_manager.get(), nullptr, nullptr, 0, 1,

- kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,

- kEnableColorCorrectRendering,

+ parent_context_provider.get(), shared_bitmap_manager.get(), nullptr,

+ nullptr, 0, 1, kDelegatedSyncPointsRequired,

+ kUseGpuMemoryBufferResources, kEnableColorCorrectRendering,

DefaultBufferToTextureTargetMapForTesting()));

gfx::Size size(1, 1);

@@ -2351,7 +2320,7 @@ TEST_P(ResourceProviderTest, LostResourceInParent) {

}

// Lose the output surface in the parent.

- resource_provider_->DidLoseOutputSurface();

+ resource_provider_->DidLoseContextProvider();

{

EXPECT_EQ(0u, returned_to_child.size());

@@ -2482,7 +2451,7 @@ TEST_P(ResourceProviderTest, LostMailboxInParent) {

}

// Lose the output surface in the parent.

- resource_provider_->DidLoseOutputSurface();

+ resource_provider_->DidLoseContextProvider();

{

EXPECT_EQ(0u, returned_to_child.size());

@@ -2649,7 +2618,7 @@ TEST_P(ResourceProviderTest, LostContext) {

EXPECT_FALSE(lost_resource);

EXPECT_FALSE(main_thread_task_runner);

- resource_provider_->DidLoseOutputSurface();

+ resource_provider_->DidLoseContextProvider();

resource_provider_ = nullptr;

EXPECT_LE(sync_token.release_count(), release_sync_token.release_count());

@@ -2665,15 +2634,11 @@ TEST_P(ResourceProviderTest, ScopedSampler) {

std::unique_ptr<TextureStateTrackingContext> context_owned(

new TextureStateTrackingContext);

TextureStateTrackingContext* context = context_owned.get();

- FakeOutputSurfaceClient output_surface_client;

- std::unique_ptr<OutputSurface> output_surface(

- FakeOutputSurface::Create3d(std::move(context_owned)));

- CHECK(output_surface->BindToClient(&output_surface_client));

+ auto context_provider = TestContextProvider::Create(std::move(context_owned));

std::unique_ptr<ResourceProvider> resource_provider(

base::MakeUnique<ResourceProvider>(

- output_surface->context_provider(), shared_bitmap_manager_.get(),

+ context_provider.get(), shared_bitmap_manager_.get(),

gpu_memory_buffer_manager_.get(), nullptr, 0, 1,

kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,

kEnableColorCorrectRendering,

@@ -2748,15 +2713,11 @@ TEST_P(ResourceProviderTest, ManagedResource) {

std::unique_ptr<TextureStateTrackingContext> context_owned(

new TextureStateTrackingContext);

TextureStateTrackingContext* context = context_owned.get();

- FakeOutputSurfaceClient output_surface_client;

- std::unique_ptr<OutputSurface> output_surface(

- FakeOutputSurface::Create3d(std::move(context_owned)));

- CHECK(output_surface->BindToClient(&output_surface_client));

+ auto context_provider = TestContextProvider::Create(std::move(context_owned));

std::unique_ptr<ResourceProvider> resource_provider(

base::MakeUnique<ResourceProvider>(

- output_surface->context_provider(), shared_bitmap_manager_.get(),

+ context_provider.get(), shared_bitmap_manager_.get(),

gpu_memory_buffer_manager_.get(), nullptr, 0, 1,

kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,

kEnableColorCorrectRendering,

@@ -2795,15 +2756,11 @@ TEST_P(ResourceProviderTest, TextureWrapMode) {

std::unique_ptr<TextureStateTrackingContext> context_owned(

new TextureStateTrackingContext);

TextureStateTrackingContext* context = context_owned.get();

- FakeOutputSurfaceClient output_surface_client;

- std::unique_ptr<OutputSurface> output_surface(

- FakeOutputSurface::Create3d(std::move(context_owned)));

- CHECK(output_surface->BindToClient(&output_surface_client));

+ auto context_provider = TestContextProvider::Create(std::move(context_owned));

std::unique_ptr<ResourceProvider> resource_provider(

base::MakeUnique<ResourceProvider>(

- output_surface->context_provider(), shared_bitmap_manager_.get(),

+ context_provider.get(), shared_bitmap_manager_.get(),

gpu_memory_buffer_manager_.get(), nullptr, 0, 1,

kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,

kEnableColorCorrectRendering,

@@ -2843,15 +2800,11 @@ TEST_P(ResourceProviderTest, TextureHint) {

TextureStateTrackingContext* context = context_owned.get();

context->set_support_texture_storage(true);

context->set_support_texture_usage(true);

- FakeOutputSurfaceClient output_surface_client;

- std::unique_ptr<OutputSurface> output_surface(

- FakeOutputSurface::Create3d(std::move(context_owned)));

- CHECK(output_surface->BindToClient(&output_surface_client));

+ auto context_provider = TestContextProvider::Create(std::move(context_owned));

std::unique_ptr<ResourceProvider> resource_provider(

base::MakeUnique<ResourceProvider>(

- output_surface->context_provider(), shared_bitmap_manager_.get(),

+ context_provider.get(), shared_bitmap_manager_.get(),

gpu_memory_buffer_manager_.get(), nullptr, 0, 1,

kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,

kEnableColorCorrectRendering,

@@ -2905,15 +2858,9 @@ TEST_P(ResourceProviderTest, TextureMailbox_SharedMemory) {

std::unique_ptr<SharedBitmap> shared_bitmap(

CreateAndFillSharedBitmap(shared_bitmap_manager_.get(), size, kBadBeef));

- FakeOutputSurfaceClient output_surface_client;

- std::unique_ptr<OutputSurface> output_surface(

- FakeOutputSurface::CreateSoftware(

- base::WrapUnique(new SoftwareOutputDevice)));

- CHECK(output_surface->BindToClient(&output_surface_client));

std::unique_ptr<ResourceProvider> resource_provider(

base::MakeUnique<ResourceProvider>(

- output_surface->context_provider(), shared_bitmap_manager_.get(),

+ nullptr, shared_bitmap_manager_.get(),

gpu_memory_buffer_manager_.get(), main_thread_task_runner_.get(), 0,

1, kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,

kEnableColorCorrectRendering,

@@ -2957,15 +2904,12 @@ class ResourceProviderTestTextureMailboxGLFilters

std::unique_ptr<TextureStateTrackingContext> context_owned(

new TextureStateTrackingContext);

TextureStateTrackingContext* context = context_owned.get();

- FakeOutputSurfaceClient output_surface_client;

- std::unique_ptr<OutputSurface> output_surface(

- FakeOutputSurface::Create3d(std::move(context_owned)));

- CHECK(output_surface->BindToClient(&output_surface_client));

+ auto context_provider =

+ TestContextProvider::Create(std::move(context_owned));

std::unique_ptr<ResourceProvider> resource_provider(

base::MakeUnique<ResourceProvider>(

- output_surface->context_provider(), shared_bitmap_manager,

+ context_provider.get(), shared_bitmap_manager,

gpu_memory_buffer_manager, main_thread_task_runner, 0, 1,

kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,

kEnableColorCorrectRendering,

@@ -3105,15 +3049,11 @@ TEST_P(ResourceProviderTest, TextureMailbox_GLTextureExternalOES) {

std::unique_ptr<TextureStateTrackingContext> context_owned(

new TextureStateTrackingContext);

TextureStateTrackingContext* context = context_owned.get();

- FakeOutputSurfaceClient output_surface_client;

- std::unique_ptr<OutputSurface> output_surface(

- FakeOutputSurface::Create3d(std::move(context_owned)));

- CHECK(output_surface->BindToClient(&output_surface_client));

+ auto context_provider = TestContextProvider::Create(std::move(context_owned));

std::unique_ptr<ResourceProvider> resource_provider(

base::MakeUnique<ResourceProvider>(

- output_surface->context_provider(), shared_bitmap_manager_.get(),

+ context_provider.get(), shared_bitmap_manager_.get(),

gpu_memory_buffer_manager_.get(), nullptr, 0, 1,

kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,

kEnableColorCorrectRendering,

@@ -3178,15 +3118,11 @@ TEST_P(ResourceProviderTest,

std::unique_ptr<TextureStateTrackingContext> context_owned(

new TextureStateTrackingContext);

TextureStateTrackingContext* context = context_owned.get();

- FakeOutputSurfaceClient output_surface_client;

- std::unique_ptr<OutputSurface> output_surface(

- FakeOutputSurface::Create3d(std::move(context_owned)));

- CHECK(output_surface->BindToClient(&output_surface_client));

+ auto context_provider = TestContextProvider::Create(std::move(context_owned));

std::unique_ptr<ResourceProvider> resource_provider(

base::MakeUnique<ResourceProvider>(

- output_surface->context_provider(), shared_bitmap_manager_.get(),

+ context_provider.get(), shared_bitmap_manager_.get(),

gpu_memory_buffer_manager_.get(), nullptr, 0, 1,

kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,

kEnableColorCorrectRendering,

@@ -3237,15 +3173,11 @@ TEST_P(ResourceProviderTest, TextureMailbox_WaitSyncTokenIfNeeded_NoSyncToken) {

std::unique_ptr<TextureStateTrackingContext> context_owned(

new TextureStateTrackingContext);

TextureStateTrackingContext* context = context_owned.get();

- FakeOutputSurfaceClient output_surface_client;

- std::unique_ptr<OutputSurface> output_surface(

- FakeOutputSurface::Create3d(std::move(context_owned)));

- CHECK(output_surface->BindToClient(&output_surface_client));

+ auto context_provider = TestContextProvider::Create(std::move(context_owned));

std::unique_ptr<ResourceProvider> resource_provider(

base::MakeUnique<ResourceProvider>(

- output_surface->context_provider(), shared_bitmap_manager_.get(),

+ context_provider.get(), shared_bitmap_manager_.get(),

gpu_memory_buffer_manager_.get(), nullptr, 0, 1,

kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,

kEnableColorCorrectRendering,

@@ -3362,15 +3294,11 @@ TEST_P(ResourceProviderTest, TextureAllocation) {

std::unique_ptr<AllocationTrackingContext3D> context_owned(

new StrictMock<AllocationTrackingContext3D>);

AllocationTrackingContext3D* context = context_owned.get();

- FakeOutputSurfaceClient output_surface_client;

- std::unique_ptr<OutputSurface> output_surface(

- FakeOutputSurface::Create3d(std::move(context_owned)));

- CHECK(output_surface->BindToClient(&output_surface_client));

+ auto context_provider = TestContextProvider::Create(std::move(context_owned));

std::unique_ptr<ResourceProvider> resource_provider(

base::MakeUnique<ResourceProvider>(

- output_surface->context_provider(), shared_bitmap_manager_.get(),

+ context_provider.get(), shared_bitmap_manager_.get(),

gpu_memory_buffer_manager_.get(), nullptr, 0, 1,

kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,

kEnableColorCorrectRendering,

@@ -3423,15 +3351,11 @@ TEST_P(ResourceProviderTest, TextureAllocationHint) {

AllocationTrackingContext3D* context = context_owned.get();

context->set_support_texture_storage(true);

context->set_support_texture_usage(true);

- FakeOutputSurfaceClient output_surface_client;

- std::unique_ptr<OutputSurface> output_surface(

- FakeOutputSurface::Create3d(std::move(context_owned)));

- CHECK(output_surface->BindToClient(&output_surface_client));

+ auto context_provider = TestContextProvider::Create(std::move(context_owned));

std::unique_ptr<ResourceProvider> resource_provider(

base::MakeUnique<ResourceProvider>(

- output_surface->context_provider(), shared_bitmap_manager_.get(),

+ context_provider.get(), shared_bitmap_manager_.get(),

gpu_memory_buffer_manager_.get(), nullptr, 0, 1,

kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,

kEnableColorCorrectRendering,

@@ -3482,15 +3406,11 @@ TEST_P(ResourceProviderTest, TextureAllocationHint_BGRA) {

context->set_support_texture_format_bgra8888(true);

context->set_support_texture_storage(true);

context->set_support_texture_usage(true);

- FakeOutputSurfaceClient output_surface_client;

- std::unique_ptr<OutputSurface> output_surface(

- FakeOutputSurface::Create3d(std::move(context_owned)));

- CHECK(output_surface->BindToClient(&output_surface_client));

+ auto context_provider = TestContextProvider::Create(std::move(context_owned));

std::unique_ptr<ResourceProvider> resource_provider(

base::MakeUnique<ResourceProvider>(

- output_surface->context_provider(), shared_bitmap_manager_.get(),

+ context_provider.get(), shared_bitmap_manager_.get(),

gpu_memory_buffer_manager_.get(), nullptr, 0, 1,

kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,

kEnableColorCorrectRendering,

@@ -3536,11 +3456,7 @@ TEST_P(ResourceProviderTest, Image_GLTexture) {

std::unique_ptr<AllocationTrackingContext3D> context_owned(

new StrictMock<AllocationTrackingContext3D>);

AllocationTrackingContext3D* context = context_owned.get();

- FakeOutputSurfaceClient output_surface_client;

enne (OOO) 2016/09/14 00:35:44 Removing output surface for all these resource pro

- std::unique_ptr<OutputSurface> output_surface(

- FakeOutputSurface::Create3d(std::move(context_owned)));

- CHECK(output_surface->BindToClient(&output_surface_client));

+ auto context_provider = TestContextProvider::Create(std::move(context_owned));

const int kWidth = 2;

const int kHeight = 2;

@@ -3552,7 +3468,7 @@ TEST_P(ResourceProviderTest, Image_GLTexture) {

std::unique_ptr<ResourceProvider> resource_provider(

base::MakeUnique<ResourceProvider>(

- output_surface->context_provider(), shared_bitmap_manager_.get(),

+ context_provider.get(), shared_bitmap_manager_.get(),

gpu_memory_buffer_manager_.get(), nullptr, 0, 1,

kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,

kEnableColorCorrectRendering,

@@ -3625,16 +3541,12 @@ TEST_P(ResourceProviderTest, CompressedTextureETC1Allocate) {

new AllocationTrackingContext3D);

AllocationTrackingContext3D* context = context_owned.get();

context_owned->set_support_compressed_texture_etc1(true);

- FakeOutputSurfaceClient output_surface_client;

- std::unique_ptr<OutputSurface> output_surface(

- FakeOutputSurface::Create3d(std::move(context_owned)));

- CHECK(output_surface->BindToClient(&output_surface_client));

+ auto context_provider = TestContextProvider::Create(std::move(context_owned));

gfx::Size size(4, 4);

std::unique_ptr<ResourceProvider> resource_provider(

base::MakeUnique<ResourceProvider>(

- output_surface->context_provider(), shared_bitmap_manager_.get(),

+ context_provider.get(), shared_bitmap_manager_.get(),

gpu_memory_buffer_manager_.get(), nullptr, 0, 1,

kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,

kEnableColorCorrectRendering,

@@ -3660,16 +3572,12 @@ TEST_P(ResourceProviderTest, CompressedTextureETC1Upload) {

new AllocationTrackingContext3D);

AllocationTrackingContext3D* context = context_owned.get();

context_owned->set_support_compressed_texture_etc1(true);

- FakeOutputSurfaceClient output_surface_client;

- std::unique_ptr<OutputSurface> output_surface(

- FakeOutputSurface::Create3d(std::move(context_owned)));

- CHECK(output_surface->BindToClient(&output_surface_client));

+ auto context_provider = TestContextProvider::Create(std::move(context_owned));

gfx::Size size(4, 4);

std::unique_ptr<ResourceProvider> resource_provider(

base::MakeUnique<ResourceProvider>(

- output_surface->context_provider(), shared_bitmap_manager_.get(),

+ context_provider.get(), shared_bitmap_manager_.get(),

gpu_memory_buffer_manager_.get(), nullptr, 0, 1,

kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,

kEnableColorCorrectRendering,

@@ -3714,13 +3622,8 @@ TEST(ResourceProviderTest, TextureAllocationChunkSize) {

std::unique_ptr<TextureIdAllocationTrackingContext> context_owned(

new TextureIdAllocationTrackingContext);

TextureIdAllocationTrackingContext* context = context_owned.get();

- FakeOutputSurfaceClient output_surface_client;

- std::unique_ptr<OutputSurface> output_surface(

- FakeOutputSurface::Create3d(std::move(context_owned)));

- CHECK(output_surface->BindToClient(&output_surface_client));

- std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(

- new TestSharedBitmapManager());

+ auto context_provider = TestContextProvider::Create(std::move(context_owned));

+ auto shared_bitmap_manager = base::MakeUnique<TestSharedBitmapManager>();

gfx::Size size(1, 1);

ResourceFormat format = RGBA_8888;

@@ -3729,8 +3632,8 @@ TEST(ResourceProviderTest, TextureAllocationChunkSize) {

size_t kTextureAllocationChunkSize = 1;

std::unique_ptr<ResourceProvider> resource_provider(

base::MakeUnique<ResourceProvider>(

- output_surface->context_provider(), shared_bitmap_manager.get(),

- nullptr, nullptr, 0, kTextureAllocationChunkSize,

+ context_provider.get(), shared_bitmap_manager.get(), nullptr,

+ nullptr, 0, kTextureAllocationChunkSize,

kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,

kEnableColorCorrectRendering,

DefaultBufferToTextureTargetMapForTesting()));

@@ -3749,8 +3652,8 @@ TEST(ResourceProviderTest, TextureAllocationChunkSize) {

size_t kTextureAllocationChunkSize = 8;

std::unique_ptr<ResourceProvider> resource_provider(

base::MakeUnique<ResourceProvider>(

- output_surface->context_provider(), shared_bitmap_manager.get(),

- nullptr, nullptr, 0, kTextureAllocationChunkSize,

+ context_provider.get(), shared_bitmap_manager.get(), nullptr,

+ nullptr, 0, kTextureAllocationChunkSize,

kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,

kEnableColorCorrectRendering,

DefaultBufferToTextureTargetMapForTesting()));

« cc/output/compositor_frame_sink.h ('K') | « cc/resources/resource_provider.cc ('k') | cc/resources/scoped_resource_unittest.cc » ('j') | cc/surfaces/direct_compositor_frame_sink.h » ('J')