Move const ResourceProvider members into Settings struct

cc/resources/resource_provider_unittest.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/resources/resource_provider.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 433 matching lines @@
         break;
     }
 
     shared_bitmap_manager_.reset(new TestSharedBitmapManager);
     gpu_memory_buffer_manager_.reset(new TestGpuMemoryBufferManager);
     child_gpu_memory_buffer_manager_ =
         gpu_memory_buffer_manager_->CreateClientGpuMemoryBufferManager();
 
     resource_provider_ = base::MakeUnique<ResourceProvider>(
         context_provider_.get(), shared_bitmap_manager_.get(),
-        gpu_memory_buffer_manager_.get(), main_thread_task_runner_.get(), 0, 1,
+        gpu_memory_buffer_manager_.get(), main_thread_task_runner_.get(), 1,
         kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
         kEnableColorCorrectRendering,
         DefaultBufferToTextureTargetMapForTesting());
     child_resource_provider_ = base::MakeUnique<ResourceProvider>(
         child_context_provider_.get(), shared_bitmap_manager_.get(),
         child_gpu_memory_buffer_manager_.get(), main_thread_task_runner_.get(),
-        0, 1, child_needs_sync_token, kUseGpuMemoryBufferResources,
+        1, child_needs_sync_token, kUseGpuMemoryBufferResources,
         kEnableColorCorrectRendering,
         DefaultBufferToTextureTargetMapForTesting());
   }
 
   ResourceProviderTest() : ResourceProviderTest(true) {}
 
   static void CollectResources(ReturnedResourceArray* array,
                                const ReturnedResourceArray& returned,
                                BlockingTaskRunner* main_thread_task_runner) {
     array->insert(array->end(), returned.begin(), returned.end());
@@ skipping 1086 matching lines @@
     return;
 
   scoped_refptr<TestContextProvider> child_context_provider =
       TestContextProvider::Create(
           ResourceProviderContext::Create(shared_data_.get()));
   child_context_provider->BindToCurrentThread();
 
   std::unique_ptr<ResourceProvider> child_resource_provider(
       base::MakeUnique<ResourceProvider>(
           child_context_provider.get(), shared_bitmap_manager_.get(),
-          gpu_memory_buffer_manager_.get(), nullptr, 0, 1,
+          gpu_memory_buffer_manager_.get(), nullptr, 1,
           kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
           kEnableColorCorrectRendering,
           DefaultBufferToTextureTargetMapForTesting()));
 
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
   size_t pixel_size = TextureSizeBytes(size, format);
   ASSERT_EQ(4U, pixel_size);
 
   ResourceId id1 = child_resource_provider->CreateResource(
@@ skipping 502 matching lines @@
     TextureStateTrackingContext* child_context = child_context_owned.get();
 
     auto child_context_provider =
         TestContextProvider::Create(std::move(child_context_owned));
     child_context_provider->BindToCurrentThread();
     auto shared_bitmap_manager = base::MakeUnique<TestSharedBitmapManager>();
 
     std::unique_ptr<ResourceProvider> child_resource_provider(
         base::MakeUnique<ResourceProvider>(
             child_context_provider.get(), shared_bitmap_manager.get(), nullptr,
-            nullptr, 0, 1, kDelegatedSyncPointsRequired,
+            nullptr, 1, kDelegatedSyncPointsRequired,
             kUseGpuMemoryBufferResources, kEnableColorCorrectRendering,
             DefaultBufferToTextureTargetMapForTesting()));
 
     std::unique_ptr<TextureStateTrackingContext> parent_context_owned(
         new TextureStateTrackingContext);
     TextureStateTrackingContext* parent_context = parent_context_owned.get();
 
     auto parent_context_provider =
         TestContextProvider::Create(std::move(parent_context_owned));
     parent_context_provider->BindToCurrentThread();
 
     std::unique_ptr<ResourceProvider> parent_resource_provider(
         base::MakeUnique<ResourceProvider>(
             parent_context_provider.get(), shared_bitmap_manager.get(), nullptr,
-            nullptr, 0, 1, kDelegatedSyncPointsRequired,
+            nullptr, 1, kDelegatedSyncPointsRequired,
             kUseGpuMemoryBufferResources, kEnableColorCorrectRendering,
             DefaultBufferToTextureTargetMapForTesting()));
 
     gfx::Size size(1, 1);
     ResourceFormat format = RGBA_8888;
     int child_texture_id = 1;
     int parent_texture_id = 2;
 
     size_t pixel_size = TextureSizeBytes(size, format);
     ASSERT_EQ(4U, pixel_size);
@@ skipping 616 matching lines @@
 
   std::unique_ptr<TextureStateTrackingContext> context_owned(
       new TextureStateTrackingContext);
   TextureStateTrackingContext* context = context_owned.get();
   auto context_provider = TestContextProvider::Create(std::move(context_owned));
   context_provider->BindToCurrentThread();
 
   std::unique_ptr<ResourceProvider> resource_provider(
       base::MakeUnique<ResourceProvider>(
           context_provider.get(), shared_bitmap_manager_.get(),
-          gpu_memory_buffer_manager_.get(), nullptr, 0, 1,
+          gpu_memory_buffer_manager_.get(), nullptr, 1,
           kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
           kEnableColorCorrectRendering,
           DefaultBufferToTextureTargetMapForTesting()));
 
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
   int texture_id = 1;
 
   ResourceId id = resource_provider->CreateResource(
       size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format,
@@ skipping 59 matching lines @@
 
   std::unique_ptr<TextureStateTrackingContext> context_owned(
       new TextureStateTrackingContext);
   TextureStateTrackingContext* context = context_owned.get();
   auto context_provider = TestContextProvider::Create(std::move(context_owned));
   context_provider->BindToCurrentThread();
 
   std::unique_ptr<ResourceProvider> resource_provider(
       base::MakeUnique<ResourceProvider>(
           context_provider.get(), shared_bitmap_manager_.get(),
-          gpu_memory_buffer_manager_.get(), nullptr, 0, 1,
+          gpu_memory_buffer_manager_.get(), nullptr, 1,
           kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
           kEnableColorCorrectRendering,
           DefaultBufferToTextureTargetMapForTesting()));
 
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
   int texture_id = 1;
 
   // Check that the texture gets created with the right sampler settings.
   ResourceId id = resource_provider->CreateResource(
@@ skipping 23 matching lines @@
 
   std::unique_ptr<TextureStateTrackingContext> context_owned(
       new TextureStateTrackingContext);
   TextureStateTrackingContext* context = context_owned.get();
   auto context_provider = TestContextProvider::Create(std::move(context_owned));
   context_provider->BindToCurrentThread();
 
   std::unique_ptr<ResourceProvider> resource_provider(
       base::MakeUnique<ResourceProvider>(
           context_provider.get(), shared_bitmap_manager_.get(),
-          gpu_memory_buffer_manager_.get(), nullptr, 0, 1,
+          gpu_memory_buffer_manager_.get(), nullptr, 1,
           kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
           kEnableColorCorrectRendering,
           DefaultBufferToTextureTargetMapForTesting()));
 
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
 
   for (int texture_id = 1; texture_id <= 2; ++texture_id) {
     // Check that the texture gets created with the right sampler settings.
     ResourceId id = resource_provider->CreateResource(
@@ skipping 24 matching lines @@
       new TextureStateTrackingContext);
   TextureStateTrackingContext* context = context_owned.get();
   context->set_support_texture_storage(true);
   context->set_support_texture_usage(true);
   auto context_provider = TestContextProvider::Create(std::move(context_owned));
   context_provider->BindToCurrentThread();
 
   std::unique_ptr<ResourceProvider> resource_provider(
       base::MakeUnique<ResourceProvider>(
           context_provider.get(), shared_bitmap_manager_.get(),
-          gpu_memory_buffer_manager_.get(), nullptr, 0, 1,
+          gpu_memory_buffer_manager_.get(), nullptr, 1,
           kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
           kEnableColorCorrectRendering,
           DefaultBufferToTextureTargetMapForTesting()));
 
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
 
   const ResourceProvider::TextureHint hints[4] = {
       ResourceProvider::TEXTURE_HINT_DEFAULT,
       ResourceProvider::TEXTURE_HINT_IMMUTABLE,
@@ skipping 35 matching lines @@
     return;
 
   gfx::Size size(64, 64);
   const uint32_t kBadBeef = 0xbadbeef;
   std::unique_ptr<SharedBitmap> shared_bitmap(
       CreateAndFillSharedBitmap(shared_bitmap_manager_.get(), size, kBadBeef));
 
   std::unique_ptr<ResourceProvider> resource_provider(
       base::MakeUnique<ResourceProvider>(
           nullptr, shared_bitmap_manager_.get(),
-          gpu_memory_buffer_manager_.get(), main_thread_task_runner_.get(), 0,
-          1, kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
+          gpu_memory_buffer_manager_.get(), main_thread_task_runner_.get(), 1,
+          kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
           kEnableColorCorrectRendering,
           DefaultBufferToTextureTargetMapForTesting()));
 
   gpu::SyncToken release_sync_token;
   bool lost_resource = false;
   BlockingTaskRunner* main_thread_task_runner = nullptr;
   std::unique_ptr<SingleReleaseCallbackImpl> callback =
       SingleReleaseCallbackImpl::Create(
           base::Bind(&ReleaseCallback, &release_sync_token, &lost_resource,
                      &main_thread_task_runner));
@@ skipping 28 matching lines @@
     std::unique_ptr<TextureStateTrackingContext> context_owned(
         new TextureStateTrackingContext);
     TextureStateTrackingContext* context = context_owned.get();
     auto context_provider =
         TestContextProvider::Create(std::move(context_owned));
     context_provider->BindToCurrentThread();
 
     std::unique_ptr<ResourceProvider> resource_provider(
         base::MakeUnique<ResourceProvider>(
             context_provider.get(), shared_bitmap_manager,
-            gpu_memory_buffer_manager, main_thread_task_runner, 0, 1,
+            gpu_memory_buffer_manager, main_thread_task_runner, 1,
             kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
             kEnableColorCorrectRendering,
             DefaultBufferToTextureTargetMapForTesting()));
 
     unsigned texture_id = 1;
     gpu::SyncToken sync_token(gpu::CommandBufferNamespace::GPU_IO, 0,
                               gpu::CommandBufferId::FromUnsafeValue(0x12),
                               0x34);
     unsigned target = GL_TEXTURE_2D;
     const GLuint64 current_fence_sync = context->GetNextFenceSync();
@@ skipping 124 matching lines @@
 
   std::unique_ptr<TextureStateTrackingContext> context_owned(
       new TextureStateTrackingContext);
   TextureStateTrackingContext* context = context_owned.get();
   auto context_provider = TestContextProvider::Create(std::move(context_owned));
   context_provider->BindToCurrentThread();
 
   std::unique_ptr<ResourceProvider> resource_provider(
       base::MakeUnique<ResourceProvider>(
           context_provider.get(), shared_bitmap_manager_.get(),
-          gpu_memory_buffer_manager_.get(), nullptr, 0, 1,
+          gpu_memory_buffer_manager_.get(), nullptr, 1,
           kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
           kEnableColorCorrectRendering,
           DefaultBufferToTextureTargetMapForTesting()));
 
   gpu::SyncToken sync_token(gpu::CommandBufferNamespace::GPU_IO, 0,
                             gpu::CommandBufferId::FromUnsafeValue(0x12), 0x34);
   const GLuint64 current_fence_sync = context->GetNextFenceSync();
   unsigned target = GL_TEXTURE_EXTERNAL_OES;
 
   EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
@@ skipping 49 matching lines @@
 
   std::unique_ptr<TextureStateTrackingContext> context_owned(
       new TextureStateTrackingContext);
   TextureStateTrackingContext* context = context_owned.get();
   auto context_provider = TestContextProvider::Create(std::move(context_owned));
   context_provider->BindToCurrentThread();
 
   std::unique_ptr<ResourceProvider> resource_provider(
       base::MakeUnique<ResourceProvider>(
           context_provider.get(), shared_bitmap_manager_.get(),
-          gpu_memory_buffer_manager_.get(), nullptr, 0, 1,
+          gpu_memory_buffer_manager_.get(), nullptr, 1,
           kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
           kEnableColorCorrectRendering,
           DefaultBufferToTextureTargetMapForTesting()));
 
   gpu::SyncToken sync_token(gpu::CommandBufferNamespace::GPU_IO, 0,
                             gpu::CommandBufferId::FromUnsafeValue(0x12), 0x34);
   const GLuint64 current_fence_sync = context->GetNextFenceSync();
   unsigned target = GL_TEXTURE_2D;
 
   EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
@@ skipping 35 matching lines @@
 
   std::unique_ptr<TextureStateTrackingContext> context_owned(
       new TextureStateTrackingContext);
   TextureStateTrackingContext* context = context_owned.get();
   auto context_provider = TestContextProvider::Create(std::move(context_owned));
   context_provider->BindToCurrentThread();
 
   std::unique_ptr<ResourceProvider> resource_provider(
       base::MakeUnique<ResourceProvider>(
           context_provider.get(), shared_bitmap_manager_.get(),
-          gpu_memory_buffer_manager_.get(), nullptr, 0, 1,
+          gpu_memory_buffer_manager_.get(), nullptr, 1,
           kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
           kEnableColorCorrectRendering,
           DefaultBufferToTextureTargetMapForTesting()));
 
   gpu::SyncToken sync_token;
   const GLuint64 current_fence_sync = context->GetNextFenceSync();
   unsigned target = GL_TEXTURE_2D;
 
   EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
   EXPECT_CALL(*context, waitSyncToken(_)).Times(0);
@@ skipping 101 matching lines @@
     return;
   std::unique_ptr<AllocationTrackingContext3D> context_owned(
       new StrictMock<AllocationTrackingContext3D>);
   AllocationTrackingContext3D* context = context_owned.get();
   auto context_provider = TestContextProvider::Create(std::move(context_owned));
   context_provider->BindToCurrentThread();
 
   std::unique_ptr<ResourceProvider> resource_provider(
       base::MakeUnique<ResourceProvider>(
           context_provider.get(), shared_bitmap_manager_.get(),
-          gpu_memory_buffer_manager_.get(), nullptr, 0, 1,
+          gpu_memory_buffer_manager_.get(), nullptr, 1,
           kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
           kEnableColorCorrectRendering,
           DefaultBufferToTextureTargetMapForTesting()));
 
   gfx::Size size(2, 2);
   gfx::Vector2d offset(0, 0);
   ResourceFormat format = RGBA_8888;
   ResourceId id = 0;
   uint8_t pixels[16] = { 0 };
   int texture_id = 123;
@@ skipping 37 matching lines @@
       new StrictMock<AllocationTrackingContext3D>);
   AllocationTrackingContext3D* context = context_owned.get();
   context->set_support_texture_storage(true);
   context->set_support_texture_usage(true);
   auto context_provider = TestContextProvider::Create(std::move(context_owned));
   context_provider->BindToCurrentThread();
 
   std::unique_ptr<ResourceProvider> resource_provider(
       base::MakeUnique<ResourceProvider>(
           context_provider.get(), shared_bitmap_manager_.get(),
-          gpu_memory_buffer_manager_.get(), nullptr, 0, 1,
+          gpu_memory_buffer_manager_.get(), nullptr, 1,
           kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
           kEnableColorCorrectRendering,
           DefaultBufferToTextureTargetMapForTesting()));
 
   gfx::Size size(2, 2);
 
   const ResourceFormat formats[2] = {RGBA_8888, BGRA_8888};
   const ResourceProvider::TextureHint hints[4] = {
       ResourceProvider::TEXTURE_HINT_DEFAULT,
       ResourceProvider::TEXTURE_HINT_IMMUTABLE,
@@ skipping 35 matching lines @@
   AllocationTrackingContext3D* context = context_owned.get();
   context->set_support_texture_format_bgra8888(true);
   context->set_support_texture_storage(true);
   context->set_support_texture_usage(true);
   auto context_provider = TestContextProvider::Create(std::move(context_owned));
   context_provider->BindToCurrentThread();
 
   std::unique_ptr<ResourceProvider> resource_provider(
       base::MakeUnique<ResourceProvider>(
           context_provider.get(), shared_bitmap_manager_.get(),
-          gpu_memory_buffer_manager_.get(), nullptr, 0, 1,
+          gpu_memory_buffer_manager_.get(), nullptr, 1,
           kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
           kEnableColorCorrectRendering,
           DefaultBufferToTextureTargetMapForTesting()));
 
   gfx::Size size(2, 2);
   const ResourceFormat formats[2] = {RGBA_8888, BGRA_8888};
 
   const ResourceProvider::TextureHint hints[4] = {
       ResourceProvider::TEXTURE_HINT_DEFAULT,
       ResourceProvider::TEXTURE_HINT_IMMUTABLE,
@@ skipping 38 matching lines @@
   const int kHeight = 2;
   gfx::Size size(kWidth, kHeight);
   ResourceFormat format = RGBA_8888;
   ResourceId id = 0;
   const unsigned kTextureId = 123u;
   const unsigned kImageId = 234u;
 
   std::unique_ptr<ResourceProvider> resource_provider(
       base::MakeUnique<ResourceProvider>(
           context_provider.get(), shared_bitmap_manager_.get(),
-          gpu_memory_buffer_manager_.get(), nullptr, 0, 1,
+          gpu_memory_buffer_manager_.get(), nullptr, 1,
           kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
           kEnableColorCorrectRendering,
           DefaultBufferToTextureTargetMapForTesting()));
 
   id = resource_provider->CreateResource(
       size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format,
       gfx::ColorSpace());
 
   EXPECT_CALL(*context, NextTextureId())
       .WillOnce(Return(kTextureId))
@@ skipping 58 matching lines @@
       new AllocationTrackingContext3D);
   AllocationTrackingContext3D* context = context_owned.get();
   context_owned->set_support_compressed_texture_etc1(true);
   auto context_provider = TestContextProvider::Create(std::move(context_owned));
   context_provider->BindToCurrentThread();
 
   gfx::Size size(4, 4);
   std::unique_ptr<ResourceProvider> resource_provider(
       base::MakeUnique<ResourceProvider>(
           context_provider.get(), shared_bitmap_manager_.get(),
-          gpu_memory_buffer_manager_.get(), nullptr, 0, 1,
+          gpu_memory_buffer_manager_.get(), nullptr, 1,
           kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
           kEnableColorCorrectRendering,
           DefaultBufferToTextureTargetMapForTesting()));
   int texture_id = 123;
 
   ResourceId id = resource_provider->CreateResource(
       size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, ETC1, gfx::ColorSpace());
   EXPECT_NE(0u, id);
   EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(2);
@@ skipping 11 matching lines @@
       new AllocationTrackingContext3D);
   AllocationTrackingContext3D* context = context_owned.get();
   context_owned->set_support_compressed_texture_etc1(true);
   auto context_provider = TestContextProvider::Create(std::move(context_owned));
   context_provider->BindToCurrentThread();
 
   gfx::Size size(4, 4);
   std::unique_ptr<ResourceProvider> resource_provider(
       base::MakeUnique<ResourceProvider>(
           context_provider.get(), shared_bitmap_manager_.get(),
-          gpu_memory_buffer_manager_.get(), nullptr, 0, 1,
+          gpu_memory_buffer_manager_.get(), nullptr, 1,
           kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
           kEnableColorCorrectRendering,
           DefaultBufferToTextureTargetMapForTesting()));
   int texture_id = 123;
   uint8_t pixels[8];
 
   ResourceId id = resource_provider->CreateResource(
       size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, ETC1, gfx::ColorSpace());
   EXPECT_NE(0u, id);
   EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
@@ skipping 35 matching lines @@
   auto shared_bitmap_manager = base::MakeUnique<TestSharedBitmapManager>();
 
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
 
   {
     size_t kTextureAllocationChunkSize = 1;
     std::unique_ptr<ResourceProvider> resource_provider(
         base::MakeUnique<ResourceProvider>(
             context_provider.get(), shared_bitmap_manager.get(), nullptr,
-            nullptr, 0, kTextureAllocationChunkSize,
-            kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
-            kEnableColorCorrectRendering,
+            nullptr, kTextureAllocationChunkSize, kDelegatedSyncPointsRequired,
+            kUseGpuMemoryBufferResources, kEnableColorCorrectRendering,
             DefaultBufferToTextureTargetMapForTesting()));
 
     ResourceId id = resource_provider->CreateResource(
         size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format,
         gfx::ColorSpace());
     resource_provider->AllocateForTesting(id);
     Mock::VerifyAndClearExpectations(context);
 
     DCHECK_EQ(2u, context->PeekTextureId());
     resource_provider->DeleteResource(id);
   }
 
   {
     size_t kTextureAllocationChunkSize = 8;
     std::unique_ptr<ResourceProvider> resource_provider(
         base::MakeUnique<ResourceProvider>(
             context_provider.get(), shared_bitmap_manager.get(), nullptr,
-            nullptr, 0, kTextureAllocationChunkSize,
-            kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
-            kEnableColorCorrectRendering,
+            nullptr, kTextureAllocationChunkSize, kDelegatedSyncPointsRequired,
+            kUseGpuMemoryBufferResources, kEnableColorCorrectRendering,
             DefaultBufferToTextureTargetMapForTesting()));
 
     ResourceId id = resource_provider->CreateResource(
         size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format,
         gfx::ColorSpace());
     resource_provider->AllocateForTesting(id);
     Mock::VerifyAndClearExpectations(context);
 
     DCHECK_EQ(10u, context->PeekTextureId());
     resource_provider->DeleteResource(id);
@@ skipping 25 matching lines @@
     lock.set_sync_token(token);
   }
 
   gpu::SyncToken last_token =
       resource_provider_->GetSyncTokenForResources(array);
   EXPECT_EQ(last_token.release_count(), 10u);
 }
 
 }  // namespace
 }  // namespace cc