OLD | NEW |
1 // Copyright 2012 The Chromium Authors. All rights reserved. | 1 // Copyright 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "cc/resources/resource_provider.h" | 5 #include "cc/resources/resource_provider.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 #include <stdint.h> | 8 #include <stdint.h> |
9 | 9 |
10 #include <algorithm> | 10 #include <algorithm> |
11 #include <deque> | 11 #include <deque> |
12 #include <map> | 12 #include <map> |
13 #include <set> | 13 #include <set> |
14 #include <unordered_map> | 14 #include <unordered_map> |
15 #include <vector> | 15 #include <vector> |
16 | 16 |
17 #include "base/bind.h" | 17 #include "base/bind.h" |
18 #include "base/logging.h" | 18 #include "base/logging.h" |
19 #include "base/memory/ptr_util.h" | 19 #include "base/memory/ptr_util.h" |
20 #include "base/memory/ref_counted.h" | 20 #include "base/memory/ref_counted.h" |
21 #include "cc/output/output_surface.h" | 21 #include "cc/output/output_surface.h" |
22 #include "cc/resources/returned_resource.h" | 22 #include "cc/resources/returned_resource.h" |
23 #include "cc/resources/shared_bitmap_manager.h" | 23 #include "cc/resources/shared_bitmap_manager.h" |
24 #include "cc/resources/single_release_callback.h" | 24 #include "cc/resources/single_release_callback.h" |
25 #include "cc/test/fake_output_surface.h" | 25 #include "cc/test/fake_output_surface.h" |
26 #include "cc/test/fake_output_surface_client.h" | 26 #include "cc/test/fake_output_surface_client.h" |
27 #include "cc/test/test_gpu_memory_buffer_manager.h" | 27 #include "cc/test/test_gpu_memory_buffer_manager.h" |
| 28 #include "cc/test/test_image_texture_targets_map.h" |
28 #include "cc/test/test_shared_bitmap_manager.h" | 29 #include "cc/test/test_shared_bitmap_manager.h" |
29 #include "cc/test/test_texture.h" | 30 #include "cc/test/test_texture.h" |
30 #include "cc/test/test_web_graphics_context_3d.h" | 31 #include "cc/test/test_web_graphics_context_3d.h" |
31 #include "cc/trees/blocking_task_runner.h" | 32 #include "cc/trees/blocking_task_runner.h" |
32 #include "gpu/GLES2/gl2extchromium.h" | 33 #include "gpu/GLES2/gl2extchromium.h" |
33 #include "testing/gmock/include/gmock/gmock.h" | 34 #include "testing/gmock/include/gmock/gmock.h" |
34 #include "testing/gtest/include/gtest/gtest.h" | 35 #include "testing/gtest/include/gtest/gtest.h" |
35 #include "third_party/khronos/GLES2/gl2.h" | 36 #include "third_party/khronos/GLES2/gl2.h" |
36 #include "third_party/khronos/GLES2/gl2ext.h" | 37 #include "third_party/khronos/GLES2/gl2ext.h" |
37 #include "ui/gfx/geometry/rect.h" | 38 #include "ui/gfx/geometry/rect.h" |
38 #include "ui/gfx/gpu_memory_buffer.h" | 39 #include "ui/gfx/gpu_memory_buffer.h" |
39 | 40 |
40 using testing::Mock; | 41 using testing::Mock; |
41 using testing::NiceMock; | 42 using testing::NiceMock; |
42 using testing::Return; | 43 using testing::Return; |
43 using testing::StrictMock; | 44 using testing::StrictMock; |
44 using testing::_; | 45 using testing::_; |
45 | 46 |
46 namespace cc { | 47 namespace cc { |
47 namespace { | 48 namespace { |
48 | 49 |
49 static const bool kUseGpuMemoryBufferResources = false; | 50 static const bool kUseGpuMemoryBufferResources = false; |
50 static const bool kDelegatedSyncPointsRequired = true; | 51 static const bool kDelegatedSyncPointsRequired = true; |
51 static const std::vector<unsigned> kUseImageTextureTargets( | |
52 static_cast<size_t>(gfx::BufferFormat::LAST) + 1, | |
53 GL_TEXTURE_2D); | |
54 | 52 |
55 MATCHER_P(MatchesSyncToken, sync_token, "") { | 53 MATCHER_P(MatchesSyncToken, sync_token, "") { |
56 gpu::SyncToken other; | 54 gpu::SyncToken other; |
57 memcpy(&other, arg, sizeof(other)); | 55 memcpy(&other, arg, sizeof(other)); |
58 return other == sync_token; | 56 return other == sync_token; |
59 } | 57 } |
60 | 58 |
61 static void EmptyReleaseCallback(const gpu::SyncToken& sync_token, | 59 static void EmptyReleaseCallback(const gpu::SyncToken& sync_token, |
62 bool lost_resource, | 60 bool lost_resource, |
63 BlockingTaskRunner* main_thread_task_runner) {} | 61 BlockingTaskRunner* main_thread_task_runner) {} |
(...skipping 398 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
462 | 460 |
463 shared_bitmap_manager_.reset(new TestSharedBitmapManager); | 461 shared_bitmap_manager_.reset(new TestSharedBitmapManager); |
464 gpu_memory_buffer_manager_.reset(new TestGpuMemoryBufferManager); | 462 gpu_memory_buffer_manager_.reset(new TestGpuMemoryBufferManager); |
465 child_gpu_memory_buffer_manager_ = | 463 child_gpu_memory_buffer_manager_ = |
466 gpu_memory_buffer_manager_->CreateClientGpuMemoryBufferManager(); | 464 gpu_memory_buffer_manager_->CreateClientGpuMemoryBufferManager(); |
467 | 465 |
468 resource_provider_ = base::MakeUnique<ResourceProvider>( | 466 resource_provider_ = base::MakeUnique<ResourceProvider>( |
469 output_surface_->context_provider(), shared_bitmap_manager_.get(), | 467 output_surface_->context_provider(), shared_bitmap_manager_.get(), |
470 gpu_memory_buffer_manager_.get(), main_thread_task_runner_.get(), 0, 1, | 468 gpu_memory_buffer_manager_.get(), main_thread_task_runner_.get(), 0, 1, |
471 kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources, | 469 kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources, |
472 kUseImageTextureTargets); | 470 TestImageTextureTargetsMap()); |
473 child_resource_provider_ = base::MakeUnique<ResourceProvider>( | 471 child_resource_provider_ = base::MakeUnique<ResourceProvider>( |
474 child_output_surface_->context_provider(), shared_bitmap_manager_.get(), | 472 child_output_surface_->context_provider(), shared_bitmap_manager_.get(), |
475 child_gpu_memory_buffer_manager_.get(), main_thread_task_runner_.get(), | 473 child_gpu_memory_buffer_manager_.get(), main_thread_task_runner_.get(), |
476 0, 1, | 474 0, 1, |
477 child_output_surface_->capabilities().delegated_sync_points_required, | 475 child_output_surface_->capabilities().delegated_sync_points_required, |
478 kUseGpuMemoryBufferResources, kUseImageTextureTargets); | 476 kUseGpuMemoryBufferResources, TestImageTextureTargetsMap()); |
479 } | 477 } |
480 | 478 |
481 ResourceProviderTest() : ResourceProviderTest(true) {} | 479 ResourceProviderTest() : ResourceProviderTest(true) {} |
482 | 480 |
483 static void CollectResources(ReturnedResourceArray* array, | 481 static void CollectResources(ReturnedResourceArray* array, |
484 const ReturnedResourceArray& returned, | 482 const ReturnedResourceArray& returned, |
485 BlockingTaskRunner* main_thread_task_runner) { | 483 BlockingTaskRunner* main_thread_task_runner) { |
486 array->insert(array->end(), returned.begin(), returned.end()); | 484 array->insert(array->end(), returned.begin(), returned.end()); |
487 } | 485 } |
488 | 486 |
(...skipping 960 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1449 FakeOutputSurfaceClient child_output_surface_client; | 1447 FakeOutputSurfaceClient child_output_surface_client; |
1450 std::unique_ptr<OutputSurface> child_output_surface( | 1448 std::unique_ptr<OutputSurface> child_output_surface( |
1451 FakeOutputSurface::Create3d(std::move(child_context_owned))); | 1449 FakeOutputSurface::Create3d(std::move(child_context_owned))); |
1452 CHECK(child_output_surface->BindToClient(&child_output_surface_client)); | 1450 CHECK(child_output_surface->BindToClient(&child_output_surface_client)); |
1453 | 1451 |
1454 std::unique_ptr<ResourceProvider> child_resource_provider( | 1452 std::unique_ptr<ResourceProvider> child_resource_provider( |
1455 base::MakeUnique<ResourceProvider>( | 1453 base::MakeUnique<ResourceProvider>( |
1456 child_output_surface->context_provider(), | 1454 child_output_surface->context_provider(), |
1457 shared_bitmap_manager_.get(), gpu_memory_buffer_manager_.get(), | 1455 shared_bitmap_manager_.get(), gpu_memory_buffer_manager_.get(), |
1458 nullptr, 0, 1, kDelegatedSyncPointsRequired, | 1456 nullptr, 0, 1, kDelegatedSyncPointsRequired, |
1459 kUseGpuMemoryBufferResources, kUseImageTextureTargets)); | 1457 kUseGpuMemoryBufferResources, TestImageTextureTargetsMap())); |
1460 | 1458 |
1461 gfx::Size size(1, 1); | 1459 gfx::Size size(1, 1); |
1462 ResourceFormat format = RGBA_8888; | 1460 ResourceFormat format = RGBA_8888; |
1463 size_t pixel_size = TextureSizeBytes(size, format); | 1461 size_t pixel_size = TextureSizeBytes(size, format); |
1464 ASSERT_EQ(4U, pixel_size); | 1462 ASSERT_EQ(4U, pixel_size); |
1465 | 1463 |
1466 ResourceId id1 = child_resource_provider->CreateResource( | 1464 ResourceId id1 = child_resource_provider->CreateResource( |
1467 size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format); | 1465 size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format); |
1468 uint8_t data1[4] = { 1, 2, 3, 4 }; | 1466 uint8_t data1[4] = { 1, 2, 3, 4 }; |
1469 child_resource_provider->CopyToResource(id1, data1, size); | 1467 child_resource_provider->CopyToResource(id1, data1, size); |
(...skipping 495 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1965 FakeOutputSurface::Create3d(std::move(child_context_owned))); | 1963 FakeOutputSurface::Create3d(std::move(child_context_owned))); |
1966 CHECK(child_output_surface->BindToClient(&child_output_surface_client)); | 1964 CHECK(child_output_surface->BindToClient(&child_output_surface_client)); |
1967 std::unique_ptr<SharedBitmapManager> shared_bitmap_manager( | 1965 std::unique_ptr<SharedBitmapManager> shared_bitmap_manager( |
1968 new TestSharedBitmapManager()); | 1966 new TestSharedBitmapManager()); |
1969 | 1967 |
1970 std::unique_ptr<ResourceProvider> child_resource_provider( | 1968 std::unique_ptr<ResourceProvider> child_resource_provider( |
1971 base::MakeUnique<ResourceProvider>( | 1969 base::MakeUnique<ResourceProvider>( |
1972 child_output_surface->context_provider(), | 1970 child_output_surface->context_provider(), |
1973 shared_bitmap_manager.get(), nullptr, nullptr, 0, 1, | 1971 shared_bitmap_manager.get(), nullptr, nullptr, 0, 1, |
1974 kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources, | 1972 kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources, |
1975 kUseImageTextureTargets)); | 1973 TestImageTextureTargetsMap())); |
1976 | 1974 |
1977 std::unique_ptr<TextureStateTrackingContext> parent_context_owned( | 1975 std::unique_ptr<TextureStateTrackingContext> parent_context_owned( |
1978 new TextureStateTrackingContext); | 1976 new TextureStateTrackingContext); |
1979 TextureStateTrackingContext* parent_context = parent_context_owned.get(); | 1977 TextureStateTrackingContext* parent_context = parent_context_owned.get(); |
1980 | 1978 |
1981 FakeOutputSurfaceClient parent_output_surface_client; | 1979 FakeOutputSurfaceClient parent_output_surface_client; |
1982 std::unique_ptr<OutputSurface> parent_output_surface( | 1980 std::unique_ptr<OutputSurface> parent_output_surface( |
1983 FakeOutputSurface::Create3d(std::move(parent_context_owned))); | 1981 FakeOutputSurface::Create3d(std::move(parent_context_owned))); |
1984 CHECK(parent_output_surface->BindToClient(&parent_output_surface_client)); | 1982 CHECK(parent_output_surface->BindToClient(&parent_output_surface_client)); |
1985 | 1983 |
1986 std::unique_ptr<ResourceProvider> parent_resource_provider( | 1984 std::unique_ptr<ResourceProvider> parent_resource_provider( |
1987 base::MakeUnique<ResourceProvider>( | 1985 base::MakeUnique<ResourceProvider>( |
1988 parent_output_surface->context_provider(), | 1986 parent_output_surface->context_provider(), |
1989 shared_bitmap_manager.get(), nullptr, nullptr, 0, 1, | 1987 shared_bitmap_manager.get(), nullptr, nullptr, 0, 1, |
1990 kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources, | 1988 kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources, |
1991 kUseImageTextureTargets)); | 1989 TestImageTextureTargetsMap())); |
1992 | 1990 |
1993 gfx::Size size(1, 1); | 1991 gfx::Size size(1, 1); |
1994 ResourceFormat format = RGBA_8888; | 1992 ResourceFormat format = RGBA_8888; |
1995 int child_texture_id = 1; | 1993 int child_texture_id = 1; |
1996 int parent_texture_id = 2; | 1994 int parent_texture_id = 2; |
1997 | 1995 |
1998 size_t pixel_size = TextureSizeBytes(size, format); | 1996 size_t pixel_size = TextureSizeBytes(size, format); |
1999 ASSERT_EQ(4U, pixel_size); | 1997 ASSERT_EQ(4U, pixel_size); |
2000 | 1998 |
2001 ResourceId id = child_resource_provider->CreateResource( | 1999 ResourceId id = child_resource_provider->CreateResource( |
(...skipping 616 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2618 FakeOutputSurfaceClient output_surface_client; | 2616 FakeOutputSurfaceClient output_surface_client; |
2619 std::unique_ptr<OutputSurface> output_surface( | 2617 std::unique_ptr<OutputSurface> output_surface( |
2620 FakeOutputSurface::Create3d(std::move(context_owned))); | 2618 FakeOutputSurface::Create3d(std::move(context_owned))); |
2621 CHECK(output_surface->BindToClient(&output_surface_client)); | 2619 CHECK(output_surface->BindToClient(&output_surface_client)); |
2622 | 2620 |
2623 std::unique_ptr<ResourceProvider> resource_provider( | 2621 std::unique_ptr<ResourceProvider> resource_provider( |
2624 base::MakeUnique<ResourceProvider>( | 2622 base::MakeUnique<ResourceProvider>( |
2625 output_surface->context_provider(), shared_bitmap_manager_.get(), | 2623 output_surface->context_provider(), shared_bitmap_manager_.get(), |
2626 gpu_memory_buffer_manager_.get(), nullptr, 0, 1, | 2624 gpu_memory_buffer_manager_.get(), nullptr, 0, 1, |
2627 kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources, | 2625 kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources, |
2628 kUseImageTextureTargets)); | 2626 TestImageTextureTargetsMap())); |
2629 | 2627 |
2630 gfx::Size size(1, 1); | 2628 gfx::Size size(1, 1); |
2631 ResourceFormat format = RGBA_8888; | 2629 ResourceFormat format = RGBA_8888; |
2632 int texture_id = 1; | 2630 int texture_id = 1; |
2633 | 2631 |
2634 ResourceId id = resource_provider->CreateResource( | 2632 ResourceId id = resource_provider->CreateResource( |
2635 size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format); | 2633 size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format); |
2636 | 2634 |
2637 // Check that the texture gets created with the right sampler settings. | 2635 // Check that the texture gets created with the right sampler settings. |
2638 EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)) | 2636 EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)) |
(...skipping 60 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2699 FakeOutputSurfaceClient output_surface_client; | 2697 FakeOutputSurfaceClient output_surface_client; |
2700 std::unique_ptr<OutputSurface> output_surface( | 2698 std::unique_ptr<OutputSurface> output_surface( |
2701 FakeOutputSurface::Create3d(std::move(context_owned))); | 2699 FakeOutputSurface::Create3d(std::move(context_owned))); |
2702 CHECK(output_surface->BindToClient(&output_surface_client)); | 2700 CHECK(output_surface->BindToClient(&output_surface_client)); |
2703 | 2701 |
2704 std::unique_ptr<ResourceProvider> resource_provider( | 2702 std::unique_ptr<ResourceProvider> resource_provider( |
2705 base::MakeUnique<ResourceProvider>( | 2703 base::MakeUnique<ResourceProvider>( |
2706 output_surface->context_provider(), shared_bitmap_manager_.get(), | 2704 output_surface->context_provider(), shared_bitmap_manager_.get(), |
2707 gpu_memory_buffer_manager_.get(), nullptr, 0, 1, | 2705 gpu_memory_buffer_manager_.get(), nullptr, 0, 1, |
2708 kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources, | 2706 kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources, |
2709 kUseImageTextureTargets)); | 2707 TestImageTextureTargetsMap())); |
2710 | 2708 |
2711 gfx::Size size(1, 1); | 2709 gfx::Size size(1, 1); |
2712 ResourceFormat format = RGBA_8888; | 2710 ResourceFormat format = RGBA_8888; |
2713 int texture_id = 1; | 2711 int texture_id = 1; |
2714 | 2712 |
2715 // Check that the texture gets created with the right sampler settings. | 2713 // Check that the texture gets created with the right sampler settings. |
2716 ResourceId id = resource_provider->CreateResource( | 2714 ResourceId id = resource_provider->CreateResource( |
2717 size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format); | 2715 size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format); |
2718 EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)); | 2716 EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)); |
2719 EXPECT_CALL(*context, | 2717 EXPECT_CALL(*context, |
(...skipping 24 matching lines...) Expand all Loading... |
2744 FakeOutputSurfaceClient output_surface_client; | 2742 FakeOutputSurfaceClient output_surface_client; |
2745 std::unique_ptr<OutputSurface> output_surface( | 2743 std::unique_ptr<OutputSurface> output_surface( |
2746 FakeOutputSurface::Create3d(std::move(context_owned))); | 2744 FakeOutputSurface::Create3d(std::move(context_owned))); |
2747 CHECK(output_surface->BindToClient(&output_surface_client)); | 2745 CHECK(output_surface->BindToClient(&output_surface_client)); |
2748 | 2746 |
2749 std::unique_ptr<ResourceProvider> resource_provider( | 2747 std::unique_ptr<ResourceProvider> resource_provider( |
2750 base::MakeUnique<ResourceProvider>( | 2748 base::MakeUnique<ResourceProvider>( |
2751 output_surface->context_provider(), shared_bitmap_manager_.get(), | 2749 output_surface->context_provider(), shared_bitmap_manager_.get(), |
2752 gpu_memory_buffer_manager_.get(), nullptr, 0, 1, | 2750 gpu_memory_buffer_manager_.get(), nullptr, 0, 1, |
2753 kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources, | 2751 kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources, |
2754 kUseImageTextureTargets)); | 2752 TestImageTextureTargetsMap())); |
2755 | 2753 |
2756 gfx::Size size(1, 1); | 2754 gfx::Size size(1, 1); |
2757 ResourceFormat format = RGBA_8888; | 2755 ResourceFormat format = RGBA_8888; |
2758 | 2756 |
2759 for (int texture_id = 1; texture_id <= 2; ++texture_id) { | 2757 for (int texture_id = 1; texture_id <= 2; ++texture_id) { |
2760 // Check that the texture gets created with the right sampler settings. | 2758 // Check that the texture gets created with the right sampler settings. |
2761 ResourceId id = resource_provider->CreateResource( | 2759 ResourceId id = resource_provider->CreateResource( |
2762 size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format); | 2760 size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format); |
2763 EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)); | 2761 EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)); |
2764 EXPECT_CALL(*context, | 2762 EXPECT_CALL(*context, |
(...skipping 25 matching lines...) Expand all Loading... |
2790 FakeOutputSurfaceClient output_surface_client; | 2788 FakeOutputSurfaceClient output_surface_client; |
2791 std::unique_ptr<OutputSurface> output_surface( | 2789 std::unique_ptr<OutputSurface> output_surface( |
2792 FakeOutputSurface::Create3d(std::move(context_owned))); | 2790 FakeOutputSurface::Create3d(std::move(context_owned))); |
2793 CHECK(output_surface->BindToClient(&output_surface_client)); | 2791 CHECK(output_surface->BindToClient(&output_surface_client)); |
2794 | 2792 |
2795 std::unique_ptr<ResourceProvider> resource_provider( | 2793 std::unique_ptr<ResourceProvider> resource_provider( |
2796 base::MakeUnique<ResourceProvider>( | 2794 base::MakeUnique<ResourceProvider>( |
2797 output_surface->context_provider(), shared_bitmap_manager_.get(), | 2795 output_surface->context_provider(), shared_bitmap_manager_.get(), |
2798 gpu_memory_buffer_manager_.get(), nullptr, 0, 1, | 2796 gpu_memory_buffer_manager_.get(), nullptr, 0, 1, |
2799 kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources, | 2797 kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources, |
2800 kUseImageTextureTargets)); | 2798 TestImageTextureTargetsMap())); |
2801 | 2799 |
2802 gfx::Size size(1, 1); | 2800 gfx::Size size(1, 1); |
2803 ResourceFormat format = RGBA_8888; | 2801 ResourceFormat format = RGBA_8888; |
2804 | 2802 |
2805 const ResourceProvider::TextureHint hints[4] = { | 2803 const ResourceProvider::TextureHint hints[4] = { |
2806 ResourceProvider::TEXTURE_HINT_DEFAULT, | 2804 ResourceProvider::TEXTURE_HINT_DEFAULT, |
2807 ResourceProvider::TEXTURE_HINT_IMMUTABLE, | 2805 ResourceProvider::TEXTURE_HINT_IMMUTABLE, |
2808 ResourceProvider::TEXTURE_HINT_FRAMEBUFFER, | 2806 ResourceProvider::TEXTURE_HINT_FRAMEBUFFER, |
2809 ResourceProvider::TEXTURE_HINT_IMMUTABLE_FRAMEBUFFER, | 2807 ResourceProvider::TEXTURE_HINT_IMMUTABLE_FRAMEBUFFER, |
2810 }; | 2808 }; |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2851 std::unique_ptr<OutputSurface> output_surface( | 2849 std::unique_ptr<OutputSurface> output_surface( |
2852 FakeOutputSurface::CreateSoftware( | 2850 FakeOutputSurface::CreateSoftware( |
2853 base::WrapUnique(new SoftwareOutputDevice))); | 2851 base::WrapUnique(new SoftwareOutputDevice))); |
2854 CHECK(output_surface->BindToClient(&output_surface_client)); | 2852 CHECK(output_surface->BindToClient(&output_surface_client)); |
2855 | 2853 |
2856 std::unique_ptr<ResourceProvider> resource_provider( | 2854 std::unique_ptr<ResourceProvider> resource_provider( |
2857 base::MakeUnique<ResourceProvider>( | 2855 base::MakeUnique<ResourceProvider>( |
2858 output_surface->context_provider(), shared_bitmap_manager_.get(), | 2856 output_surface->context_provider(), shared_bitmap_manager_.get(), |
2859 gpu_memory_buffer_manager_.get(), main_thread_task_runner_.get(), 0, | 2857 gpu_memory_buffer_manager_.get(), main_thread_task_runner_.get(), 0, |
2860 1, kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources, | 2858 1, kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources, |
2861 kUseImageTextureTargets)); | 2859 TestImageTextureTargetsMap())); |
2862 | 2860 |
2863 gpu::SyncToken release_sync_token; | 2861 gpu::SyncToken release_sync_token; |
2864 bool lost_resource = false; | 2862 bool lost_resource = false; |
2865 BlockingTaskRunner* main_thread_task_runner = nullptr; | 2863 BlockingTaskRunner* main_thread_task_runner = nullptr; |
2866 std::unique_ptr<SingleReleaseCallbackImpl> callback = | 2864 std::unique_ptr<SingleReleaseCallbackImpl> callback = |
2867 SingleReleaseCallbackImpl::Create( | 2865 SingleReleaseCallbackImpl::Create( |
2868 base::Bind(&ReleaseCallback, &release_sync_token, &lost_resource, | 2866 base::Bind(&ReleaseCallback, &release_sync_token, &lost_resource, |
2869 &main_thread_task_runner)); | 2867 &main_thread_task_runner)); |
2870 TextureMailbox mailbox(shared_bitmap.get(), size); | 2868 TextureMailbox mailbox(shared_bitmap.get(), size); |
2871 | 2869 |
(...skipping 30 matching lines...) Expand all Loading... |
2902 FakeOutputSurfaceClient output_surface_client; | 2900 FakeOutputSurfaceClient output_surface_client; |
2903 std::unique_ptr<OutputSurface> output_surface( | 2901 std::unique_ptr<OutputSurface> output_surface( |
2904 FakeOutputSurface::Create3d(std::move(context_owned))); | 2902 FakeOutputSurface::Create3d(std::move(context_owned))); |
2905 CHECK(output_surface->BindToClient(&output_surface_client)); | 2903 CHECK(output_surface->BindToClient(&output_surface_client)); |
2906 | 2904 |
2907 std::unique_ptr<ResourceProvider> resource_provider( | 2905 std::unique_ptr<ResourceProvider> resource_provider( |
2908 base::MakeUnique<ResourceProvider>( | 2906 base::MakeUnique<ResourceProvider>( |
2909 output_surface->context_provider(), shared_bitmap_manager, | 2907 output_surface->context_provider(), shared_bitmap_manager, |
2910 gpu_memory_buffer_manager, main_thread_task_runner, 0, 1, | 2908 gpu_memory_buffer_manager, main_thread_task_runner, 0, 1, |
2911 kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources, | 2909 kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources, |
2912 kUseImageTextureTargets)); | 2910 TestImageTextureTargetsMap())); |
2913 | 2911 |
2914 unsigned texture_id = 1; | 2912 unsigned texture_id = 1; |
2915 gpu::SyncToken sync_token(gpu::CommandBufferNamespace::GPU_IO, 0, | 2913 gpu::SyncToken sync_token(gpu::CommandBufferNamespace::GPU_IO, 0, |
2916 gpu::CommandBufferId::FromUnsafeValue(0x12), | 2914 gpu::CommandBufferId::FromUnsafeValue(0x12), |
2917 0x34); | 2915 0x34); |
2918 unsigned target = GL_TEXTURE_2D; | 2916 unsigned target = GL_TEXTURE_2D; |
2919 const GLuint64 current_fence_sync = context->GetNextFenceSync(); | 2917 const GLuint64 current_fence_sync = context->GetNextFenceSync(); |
2920 | 2918 |
2921 EXPECT_CALL(*context, bindTexture(_, _)).Times(0); | 2919 EXPECT_CALL(*context, bindTexture(_, _)).Times(0); |
2922 EXPECT_CALL(*context, waitSyncToken(_)).Times(0); | 2920 EXPECT_CALL(*context, waitSyncToken(_)).Times(0); |
(...skipping 126 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3049 FakeOutputSurfaceClient output_surface_client; | 3047 FakeOutputSurfaceClient output_surface_client; |
3050 std::unique_ptr<OutputSurface> output_surface( | 3048 std::unique_ptr<OutputSurface> output_surface( |
3051 FakeOutputSurface::Create3d(std::move(context_owned))); | 3049 FakeOutputSurface::Create3d(std::move(context_owned))); |
3052 CHECK(output_surface->BindToClient(&output_surface_client)); | 3050 CHECK(output_surface->BindToClient(&output_surface_client)); |
3053 | 3051 |
3054 std::unique_ptr<ResourceProvider> resource_provider( | 3052 std::unique_ptr<ResourceProvider> resource_provider( |
3055 base::MakeUnique<ResourceProvider>( | 3053 base::MakeUnique<ResourceProvider>( |
3056 output_surface->context_provider(), shared_bitmap_manager_.get(), | 3054 output_surface->context_provider(), shared_bitmap_manager_.get(), |
3057 gpu_memory_buffer_manager_.get(), nullptr, 0, 1, | 3055 gpu_memory_buffer_manager_.get(), nullptr, 0, 1, |
3058 kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources, | 3056 kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources, |
3059 kUseImageTextureTargets)); | 3057 TestImageTextureTargetsMap())); |
3060 | 3058 |
3061 gpu::SyncToken sync_token(gpu::CommandBufferNamespace::GPU_IO, 0, | 3059 gpu::SyncToken sync_token(gpu::CommandBufferNamespace::GPU_IO, 0, |
3062 gpu::CommandBufferId::FromUnsafeValue(0x12), 0x34); | 3060 gpu::CommandBufferId::FromUnsafeValue(0x12), 0x34); |
3063 const GLuint64 current_fence_sync = context->GetNextFenceSync(); | 3061 const GLuint64 current_fence_sync = context->GetNextFenceSync(); |
3064 unsigned target = GL_TEXTURE_EXTERNAL_OES; | 3062 unsigned target = GL_TEXTURE_EXTERNAL_OES; |
3065 | 3063 |
3066 EXPECT_CALL(*context, bindTexture(_, _)).Times(0); | 3064 EXPECT_CALL(*context, bindTexture(_, _)).Times(0); |
3067 EXPECT_CALL(*context, waitSyncToken(_)).Times(0); | 3065 EXPECT_CALL(*context, waitSyncToken(_)).Times(0); |
3068 EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0); | 3066 EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0); |
3069 EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(_, _)).Times(0); | 3067 EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(_, _)).Times(0); |
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3121 FakeOutputSurfaceClient output_surface_client; | 3119 FakeOutputSurfaceClient output_surface_client; |
3122 std::unique_ptr<OutputSurface> output_surface( | 3120 std::unique_ptr<OutputSurface> output_surface( |
3123 FakeOutputSurface::Create3d(std::move(context_owned))); | 3121 FakeOutputSurface::Create3d(std::move(context_owned))); |
3124 CHECK(output_surface->BindToClient(&output_surface_client)); | 3122 CHECK(output_surface->BindToClient(&output_surface_client)); |
3125 | 3123 |
3126 std::unique_ptr<ResourceProvider> resource_provider( | 3124 std::unique_ptr<ResourceProvider> resource_provider( |
3127 base::MakeUnique<ResourceProvider>( | 3125 base::MakeUnique<ResourceProvider>( |
3128 output_surface->context_provider(), shared_bitmap_manager_.get(), | 3126 output_surface->context_provider(), shared_bitmap_manager_.get(), |
3129 gpu_memory_buffer_manager_.get(), nullptr, 0, 1, | 3127 gpu_memory_buffer_manager_.get(), nullptr, 0, 1, |
3130 kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources, | 3128 kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources, |
3131 kUseImageTextureTargets)); | 3129 TestImageTextureTargetsMap())); |
3132 | 3130 |
3133 gpu::SyncToken sync_token(gpu::CommandBufferNamespace::GPU_IO, 0, | 3131 gpu::SyncToken sync_token(gpu::CommandBufferNamespace::GPU_IO, 0, |
3134 gpu::CommandBufferId::FromUnsafeValue(0x12), 0x34); | 3132 gpu::CommandBufferId::FromUnsafeValue(0x12), 0x34); |
3135 const GLuint64 current_fence_sync = context->GetNextFenceSync(); | 3133 const GLuint64 current_fence_sync = context->GetNextFenceSync(); |
3136 unsigned target = GL_TEXTURE_2D; | 3134 unsigned target = GL_TEXTURE_2D; |
3137 | 3135 |
3138 EXPECT_CALL(*context, bindTexture(_, _)).Times(0); | 3136 EXPECT_CALL(*context, bindTexture(_, _)).Times(0); |
3139 EXPECT_CALL(*context, waitSyncToken(_)).Times(0); | 3137 EXPECT_CALL(*context, waitSyncToken(_)).Times(0); |
3140 EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0); | 3138 EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0); |
3141 EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(_, _)).Times(0); | 3139 EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(_, _)).Times(0); |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3179 FakeOutputSurfaceClient output_surface_client; | 3177 FakeOutputSurfaceClient output_surface_client; |
3180 std::unique_ptr<OutputSurface> output_surface( | 3178 std::unique_ptr<OutputSurface> output_surface( |
3181 FakeOutputSurface::Create3d(std::move(context_owned))); | 3179 FakeOutputSurface::Create3d(std::move(context_owned))); |
3182 CHECK(output_surface->BindToClient(&output_surface_client)); | 3180 CHECK(output_surface->BindToClient(&output_surface_client)); |
3183 | 3181 |
3184 std::unique_ptr<ResourceProvider> resource_provider( | 3182 std::unique_ptr<ResourceProvider> resource_provider( |
3185 base::MakeUnique<ResourceProvider>( | 3183 base::MakeUnique<ResourceProvider>( |
3186 output_surface->context_provider(), shared_bitmap_manager_.get(), | 3184 output_surface->context_provider(), shared_bitmap_manager_.get(), |
3187 gpu_memory_buffer_manager_.get(), nullptr, 0, 1, | 3185 gpu_memory_buffer_manager_.get(), nullptr, 0, 1, |
3188 kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources, | 3186 kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources, |
3189 kUseImageTextureTargets)); | 3187 TestImageTextureTargetsMap())); |
3190 | 3188 |
3191 gpu::SyncToken sync_token; | 3189 gpu::SyncToken sync_token; |
3192 const GLuint64 current_fence_sync = context->GetNextFenceSync(); | 3190 const GLuint64 current_fence_sync = context->GetNextFenceSync(); |
3193 unsigned target = GL_TEXTURE_2D; | 3191 unsigned target = GL_TEXTURE_2D; |
3194 | 3192 |
3195 EXPECT_CALL(*context, bindTexture(_, _)).Times(0); | 3193 EXPECT_CALL(*context, bindTexture(_, _)).Times(0); |
3196 EXPECT_CALL(*context, waitSyncToken(_)).Times(0); | 3194 EXPECT_CALL(*context, waitSyncToken(_)).Times(0); |
3197 EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0); | 3195 EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0); |
3198 EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(_, _)).Times(0); | 3196 EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(_, _)).Times(0); |
3199 | 3197 |
(...skipping 103 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3303 FakeOutputSurfaceClient output_surface_client; | 3301 FakeOutputSurfaceClient output_surface_client; |
3304 std::unique_ptr<OutputSurface> output_surface( | 3302 std::unique_ptr<OutputSurface> output_surface( |
3305 FakeOutputSurface::Create3d(std::move(context_owned))); | 3303 FakeOutputSurface::Create3d(std::move(context_owned))); |
3306 CHECK(output_surface->BindToClient(&output_surface_client)); | 3304 CHECK(output_surface->BindToClient(&output_surface_client)); |
3307 | 3305 |
3308 std::unique_ptr<ResourceProvider> resource_provider( | 3306 std::unique_ptr<ResourceProvider> resource_provider( |
3309 base::MakeUnique<ResourceProvider>( | 3307 base::MakeUnique<ResourceProvider>( |
3310 output_surface->context_provider(), shared_bitmap_manager_.get(), | 3308 output_surface->context_provider(), shared_bitmap_manager_.get(), |
3311 gpu_memory_buffer_manager_.get(), nullptr, 0, 1, | 3309 gpu_memory_buffer_manager_.get(), nullptr, 0, 1, |
3312 kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources, | 3310 kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources, |
3313 kUseImageTextureTargets)); | 3311 TestImageTextureTargetsMap())); |
3314 | 3312 |
3315 gfx::Size size(2, 2); | 3313 gfx::Size size(2, 2); |
3316 gfx::Vector2d offset(0, 0); | 3314 gfx::Vector2d offset(0, 0); |
3317 ResourceFormat format = RGBA_8888; | 3315 ResourceFormat format = RGBA_8888; |
3318 ResourceId id = 0; | 3316 ResourceId id = 0; |
3319 uint8_t pixels[16] = { 0 }; | 3317 uint8_t pixels[16] = { 0 }; |
3320 int texture_id = 123; | 3318 int texture_id = 123; |
3321 | 3319 |
3322 // Lazy allocation. Don't allocate when creating the resource. | 3320 // Lazy allocation. Don't allocate when creating the resource. |
3323 id = resource_provider->CreateResource( | 3321 id = resource_provider->CreateResource( |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3361 FakeOutputSurfaceClient output_surface_client; | 3359 FakeOutputSurfaceClient output_surface_client; |
3362 std::unique_ptr<OutputSurface> output_surface( | 3360 std::unique_ptr<OutputSurface> output_surface( |
3363 FakeOutputSurface::Create3d(std::move(context_owned))); | 3361 FakeOutputSurface::Create3d(std::move(context_owned))); |
3364 CHECK(output_surface->BindToClient(&output_surface_client)); | 3362 CHECK(output_surface->BindToClient(&output_surface_client)); |
3365 | 3363 |
3366 std::unique_ptr<ResourceProvider> resource_provider( | 3364 std::unique_ptr<ResourceProvider> resource_provider( |
3367 base::MakeUnique<ResourceProvider>( | 3365 base::MakeUnique<ResourceProvider>( |
3368 output_surface->context_provider(), shared_bitmap_manager_.get(), | 3366 output_surface->context_provider(), shared_bitmap_manager_.get(), |
3369 gpu_memory_buffer_manager_.get(), nullptr, 0, 1, | 3367 gpu_memory_buffer_manager_.get(), nullptr, 0, 1, |
3370 kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources, | 3368 kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources, |
3371 kUseImageTextureTargets)); | 3369 TestImageTextureTargetsMap())); |
3372 | 3370 |
3373 gfx::Size size(2, 2); | 3371 gfx::Size size(2, 2); |
3374 | 3372 |
3375 const ResourceFormat formats[2] = {RGBA_8888, BGRA_8888}; | 3373 const ResourceFormat formats[2] = {RGBA_8888, BGRA_8888}; |
3376 const ResourceProvider::TextureHint hints[4] = { | 3374 const ResourceProvider::TextureHint hints[4] = { |
3377 ResourceProvider::TEXTURE_HINT_DEFAULT, | 3375 ResourceProvider::TEXTURE_HINT_DEFAULT, |
3378 ResourceProvider::TEXTURE_HINT_IMMUTABLE, | 3376 ResourceProvider::TEXTURE_HINT_IMMUTABLE, |
3379 ResourceProvider::TEXTURE_HINT_FRAMEBUFFER, | 3377 ResourceProvider::TEXTURE_HINT_FRAMEBUFFER, |
3380 ResourceProvider::TEXTURE_HINT_IMMUTABLE_FRAMEBUFFER, | 3378 ResourceProvider::TEXTURE_HINT_IMMUTABLE_FRAMEBUFFER, |
3381 }; | 3379 }; |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3419 FakeOutputSurfaceClient output_surface_client; | 3417 FakeOutputSurfaceClient output_surface_client; |
3420 std::unique_ptr<OutputSurface> output_surface( | 3418 std::unique_ptr<OutputSurface> output_surface( |
3421 FakeOutputSurface::Create3d(std::move(context_owned))); | 3419 FakeOutputSurface::Create3d(std::move(context_owned))); |
3422 CHECK(output_surface->BindToClient(&output_surface_client)); | 3420 CHECK(output_surface->BindToClient(&output_surface_client)); |
3423 | 3421 |
3424 std::unique_ptr<ResourceProvider> resource_provider( | 3422 std::unique_ptr<ResourceProvider> resource_provider( |
3425 base::MakeUnique<ResourceProvider>( | 3423 base::MakeUnique<ResourceProvider>( |
3426 output_surface->context_provider(), shared_bitmap_manager_.get(), | 3424 output_surface->context_provider(), shared_bitmap_manager_.get(), |
3427 gpu_memory_buffer_manager_.get(), nullptr, 0, 1, | 3425 gpu_memory_buffer_manager_.get(), nullptr, 0, 1, |
3428 kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources, | 3426 kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources, |
3429 kUseImageTextureTargets)); | 3427 TestImageTextureTargetsMap())); |
3430 | 3428 |
3431 gfx::Size size(2, 2); | 3429 gfx::Size size(2, 2); |
3432 const ResourceFormat formats[2] = {RGBA_8888, BGRA_8888}; | 3430 const ResourceFormat formats[2] = {RGBA_8888, BGRA_8888}; |
3433 | 3431 |
3434 const ResourceProvider::TextureHint hints[4] = { | 3432 const ResourceProvider::TextureHint hints[4] = { |
3435 ResourceProvider::TEXTURE_HINT_DEFAULT, | 3433 ResourceProvider::TEXTURE_HINT_DEFAULT, |
3436 ResourceProvider::TEXTURE_HINT_IMMUTABLE, | 3434 ResourceProvider::TEXTURE_HINT_IMMUTABLE, |
3437 ResourceProvider::TEXTURE_HINT_FRAMEBUFFER, | 3435 ResourceProvider::TEXTURE_HINT_FRAMEBUFFER, |
3438 ResourceProvider::TEXTURE_HINT_IMMUTABLE_FRAMEBUFFER, | 3436 ResourceProvider::TEXTURE_HINT_IMMUTABLE_FRAMEBUFFER, |
3439 }; | 3437 }; |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3480 ResourceFormat format = RGBA_8888; | 3478 ResourceFormat format = RGBA_8888; |
3481 ResourceId id = 0; | 3479 ResourceId id = 0; |
3482 const unsigned kTextureId = 123u; | 3480 const unsigned kTextureId = 123u; |
3483 const unsigned kImageId = 234u; | 3481 const unsigned kImageId = 234u; |
3484 | 3482 |
3485 std::unique_ptr<ResourceProvider> resource_provider( | 3483 std::unique_ptr<ResourceProvider> resource_provider( |
3486 base::MakeUnique<ResourceProvider>( | 3484 base::MakeUnique<ResourceProvider>( |
3487 output_surface->context_provider(), shared_bitmap_manager_.get(), | 3485 output_surface->context_provider(), shared_bitmap_manager_.get(), |
3488 gpu_memory_buffer_manager_.get(), nullptr, 0, 1, | 3486 gpu_memory_buffer_manager_.get(), nullptr, 0, 1, |
3489 kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources, | 3487 kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources, |
3490 kUseImageTextureTargets)); | 3488 TestImageTextureTargetsMap())); |
3491 | 3489 |
3492 id = resource_provider->CreateResource( | 3490 id = resource_provider->CreateResource( |
3493 size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format); | 3491 size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format); |
3494 | 3492 |
3495 EXPECT_CALL(*context, NextTextureId()) | 3493 EXPECT_CALL(*context, NextTextureId()) |
3496 .WillOnce(Return(kTextureId)) | 3494 .WillOnce(Return(kTextureId)) |
3497 .RetiresOnSaturation(); | 3495 .RetiresOnSaturation(); |
3498 EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, kTextureId)) | 3496 EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, kTextureId)) |
3499 .Times(3) | 3497 .Times(3) |
3500 .RetiresOnSaturation(); | 3498 .RetiresOnSaturation(); |
(...skipping 59 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3560 std::unique_ptr<OutputSurface> output_surface( | 3558 std::unique_ptr<OutputSurface> output_surface( |
3561 FakeOutputSurface::Create3d(std::move(context_owned))); | 3559 FakeOutputSurface::Create3d(std::move(context_owned))); |
3562 CHECK(output_surface->BindToClient(&output_surface_client)); | 3560 CHECK(output_surface->BindToClient(&output_surface_client)); |
3563 | 3561 |
3564 gfx::Size size(4, 4); | 3562 gfx::Size size(4, 4); |
3565 std::unique_ptr<ResourceProvider> resource_provider( | 3563 std::unique_ptr<ResourceProvider> resource_provider( |
3566 base::MakeUnique<ResourceProvider>( | 3564 base::MakeUnique<ResourceProvider>( |
3567 output_surface->context_provider(), shared_bitmap_manager_.get(), | 3565 output_surface->context_provider(), shared_bitmap_manager_.get(), |
3568 gpu_memory_buffer_manager_.get(), nullptr, 0, 1, | 3566 gpu_memory_buffer_manager_.get(), nullptr, 0, 1, |
3569 kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources, | 3567 kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources, |
3570 kUseImageTextureTargets)); | 3568 TestImageTextureTargetsMap())); |
3571 int texture_id = 123; | 3569 int texture_id = 123; |
3572 | 3570 |
3573 ResourceId id = resource_provider->CreateResource( | 3571 ResourceId id = resource_provider->CreateResource( |
3574 size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, ETC1); | 3572 size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, ETC1); |
3575 EXPECT_NE(0u, id); | 3573 EXPECT_NE(0u, id); |
3576 EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id)); | 3574 EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id)); |
3577 EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(2); | 3575 EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(2); |
3578 resource_provider->AllocateForTesting(id); | 3576 resource_provider->AllocateForTesting(id); |
3579 | 3577 |
3580 EXPECT_CALL(*context, RetireTextureId(texture_id)).Times(1); | 3578 EXPECT_CALL(*context, RetireTextureId(texture_id)).Times(1); |
(...skipping 13 matching lines...) Expand all Loading... |
3594 std::unique_ptr<OutputSurface> output_surface( | 3592 std::unique_ptr<OutputSurface> output_surface( |
3595 FakeOutputSurface::Create3d(std::move(context_owned))); | 3593 FakeOutputSurface::Create3d(std::move(context_owned))); |
3596 CHECK(output_surface->BindToClient(&output_surface_client)); | 3594 CHECK(output_surface->BindToClient(&output_surface_client)); |
3597 | 3595 |
3598 gfx::Size size(4, 4); | 3596 gfx::Size size(4, 4); |
3599 std::unique_ptr<ResourceProvider> resource_provider( | 3597 std::unique_ptr<ResourceProvider> resource_provider( |
3600 base::MakeUnique<ResourceProvider>( | 3598 base::MakeUnique<ResourceProvider>( |
3601 output_surface->context_provider(), shared_bitmap_manager_.get(), | 3599 output_surface->context_provider(), shared_bitmap_manager_.get(), |
3602 gpu_memory_buffer_manager_.get(), nullptr, 0, 1, | 3600 gpu_memory_buffer_manager_.get(), nullptr, 0, 1, |
3603 kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources, | 3601 kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources, |
3604 kUseImageTextureTargets)); | 3602 TestImageTextureTargetsMap())); |
3605 int texture_id = 123; | 3603 int texture_id = 123; |
3606 uint8_t pixels[8]; | 3604 uint8_t pixels[8]; |
3607 | 3605 |
3608 ResourceId id = resource_provider->CreateResource( | 3606 ResourceId id = resource_provider->CreateResource( |
3609 size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, ETC1); | 3607 size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, ETC1); |
3610 EXPECT_NE(0u, id); | 3608 EXPECT_NE(0u, id); |
3611 EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id)); | 3609 EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id)); |
3612 EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(3); | 3610 EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(3); |
3613 EXPECT_CALL(*context, | 3611 EXPECT_CALL(*context, |
3614 compressedTexImage2D( | 3612 compressedTexImage2D( |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3653 gfx::Size size(1, 1); | 3651 gfx::Size size(1, 1); |
3654 ResourceFormat format = RGBA_8888; | 3652 ResourceFormat format = RGBA_8888; |
3655 | 3653 |
3656 { | 3654 { |
3657 size_t kTextureAllocationChunkSize = 1; | 3655 size_t kTextureAllocationChunkSize = 1; |
3658 std::unique_ptr<ResourceProvider> resource_provider( | 3656 std::unique_ptr<ResourceProvider> resource_provider( |
3659 base::MakeUnique<ResourceProvider>( | 3657 base::MakeUnique<ResourceProvider>( |
3660 output_surface->context_provider(), shared_bitmap_manager.get(), | 3658 output_surface->context_provider(), shared_bitmap_manager.get(), |
3661 nullptr, nullptr, 0, kTextureAllocationChunkSize, | 3659 nullptr, nullptr, 0, kTextureAllocationChunkSize, |
3662 kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources, | 3660 kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources, |
3663 kUseImageTextureTargets)); | 3661 TestImageTextureTargetsMap())); |
3664 | 3662 |
3665 ResourceId id = resource_provider->CreateResource( | 3663 ResourceId id = resource_provider->CreateResource( |
3666 size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format); | 3664 size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format); |
3667 resource_provider->AllocateForTesting(id); | 3665 resource_provider->AllocateForTesting(id); |
3668 Mock::VerifyAndClearExpectations(context); | 3666 Mock::VerifyAndClearExpectations(context); |
3669 | 3667 |
3670 DCHECK_EQ(2u, context->PeekTextureId()); | 3668 DCHECK_EQ(2u, context->PeekTextureId()); |
3671 resource_provider->DeleteResource(id); | 3669 resource_provider->DeleteResource(id); |
3672 } | 3670 } |
3673 | 3671 |
3674 { | 3672 { |
3675 size_t kTextureAllocationChunkSize = 8; | 3673 size_t kTextureAllocationChunkSize = 8; |
3676 std::unique_ptr<ResourceProvider> resource_provider( | 3674 std::unique_ptr<ResourceProvider> resource_provider( |
3677 base::MakeUnique<ResourceProvider>( | 3675 base::MakeUnique<ResourceProvider>( |
3678 output_surface->context_provider(), shared_bitmap_manager.get(), | 3676 output_surface->context_provider(), shared_bitmap_manager.get(), |
3679 nullptr, nullptr, 0, kTextureAllocationChunkSize, | 3677 nullptr, nullptr, 0, kTextureAllocationChunkSize, |
3680 kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources, | 3678 kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources, |
3681 kUseImageTextureTargets)); | 3679 TestImageTextureTargetsMap())); |
3682 | 3680 |
3683 ResourceId id = resource_provider->CreateResource( | 3681 ResourceId id = resource_provider->CreateResource( |
3684 size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format); | 3682 size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format); |
3685 resource_provider->AllocateForTesting(id); | 3683 resource_provider->AllocateForTesting(id); |
3686 Mock::VerifyAndClearExpectations(context); | 3684 Mock::VerifyAndClearExpectations(context); |
3687 | 3685 |
3688 DCHECK_EQ(10u, context->PeekTextureId()); | 3686 DCHECK_EQ(10u, context->PeekTextureId()); |
3689 resource_provider->DeleteResource(id); | 3687 resource_provider->DeleteResource(id); |
3690 } | 3688 } |
3691 } | 3689 } |
3692 | 3690 |
3693 } // namespace | 3691 } // namespace |
3694 } // namespace cc | 3692 } // namespace cc |
OLD | NEW |