Move const ResourceProvider members into Settings struct

cc/resources/resource_provider.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 380 matching lines @@
   SetSynchronized();
 }
 
 ResourceProvider::Child::Child()
     : marked_for_deletion(false), needs_sync_tokens(true) {}
 
 ResourceProvider::Child::Child(const Child& other) = default;
 
 ResourceProvider::Child::~Child() {}
 
+ResourceProvider::Settings::Settings(
+    ContextProvider* compositor_context_provider,
+    bool delegated_sync_points_required,
+    bool use_gpu_memory_buffer_resources,
+    bool enable_color_correct_rendering)
+    : default_resource_type(use_gpu_memory_buffer_resources
+                                ? RESOURCE_TYPE_GPU_MEMORY_BUFFER
+                                : RESOURCE_TYPE_GL_TEXTURE),
+      enable_color_correct_rendering(enable_color_correct_rendering),
+      delegated_sync_points_required(delegated_sync_points_required) {
+  if (!compositor_context_provider) {
+    default_resource_type = RESOURCE_TYPE_BITMAP;
+    // Pick an arbitrary limit here similar to what hardware might.
+    max_texture_size = 16 * 1024;
+    best_texture_format = RGBA_8888;
+    return;
+  }
+
+  DCHECK(IsGpuResourceType(default_resource_type));
+
+  const auto& caps = compositor_context_provider->ContextCapabilities();
+  use_texture_storage_ext = caps.texture_storage;
+  use_texture_format_bgra = caps.texture_format_bgra8888;
+  use_texture_usage_hint = caps.texture_usage;
+  use_sync_query = caps.sync_query;
+
+  if (caps.disable_one_component_textures) {
+    yuv_resource_format = yuv_highbit_resource_format = RGBA_8888;
+  } else {
+    yuv_resource_format = caps.texture_rg ? RED_8 : LUMINANCE_8;
+    yuv_highbit_resource_format =
+        caps.texture_half_float_linear ? LUMINANCE_F16 : yuv_resource_format;
+  }
+
+  GLES2Interface* gl = compositor_context_provider->ContextGL();
+  gl->GetIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_size);
+
+  best_texture_format =
+      PlatformColor::BestSupportedTextureFormat(use_texture_format_bgra);
+  best_render_buffer_format = PlatformColor::BestSupportedTextureFormat(
+      caps.render_buffer_format_bgra8888);
+}
+
 ResourceProvider::ResourceProvider(
     ContextProvider* compositor_context_provider,
     SharedBitmapManager* shared_bitmap_manager,
     gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
     BlockingTaskRunner* blocking_main_thread_task_runner,
-    int highp_threshold_min,
     size_t id_allocation_chunk_size,
     bool delegated_sync_points_required,
     bool use_gpu_memory_buffer_resources,
     bool enable_color_correct_rendering,
     const BufferToTextureTargetMap& buffer_to_texture_target_map)
-    : compositor_context_provider_(compositor_context_provider),
+    : settings_(compositor_context_provider,
+                delegated_sync_points_required,
+                use_gpu_memory_buffer_resources,
+                enable_color_correct_rendering),
+      compositor_context_provider_(compositor_context_provider),
       shared_bitmap_manager_(shared_bitmap_manager),
       gpu_memory_buffer_manager_(gpu_memory_buffer_manager),
       blocking_main_thread_task_runner_(blocking_main_thread_task_runner),
       lost_context_provider_(false),
-      highp_threshold_min_(highp_threshold_min),
       next_id_(1),
       next_child_(1),
-      delegated_sync_points_required_(delegated_sync_points_required),
-      default_resource_type_(use_gpu_memory_buffer_resources
-                                 ? RESOURCE_TYPE_GPU_MEMORY_BUFFER
-                                 : RESOURCE_TYPE_GL_TEXTURE),
-      use_texture_storage_ext_(false),
-      use_texture_format_bgra_(false),
-      use_texture_usage_hint_(false),
-      use_compressed_texture_etc1_(false),
-      yuv_resource_format_(LUMINANCE_8),
-      max_texture_size_(0),
-      best_texture_format_(RGBA_8888),
-      best_render_buffer_format_(RGBA_8888),
-      enable_color_correct_rendering_(enable_color_correct_rendering),
-      id_allocation_chunk_size_(id_allocation_chunk_size),
-      use_sync_query_(false),
       buffer_to_texture_target_map_(buffer_to_texture_target_map),
       tracing_id_(g_next_resource_provider_tracing_id.GetNext()) {
-  DCHECK(id_allocation_chunk_size_);
+  DCHECK(id_allocation_chunk_size);
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // In certain cases, ThreadTaskRunnerHandle isn't set (Android Webview).
   // Don't register a dump provider in these cases.
   // TODO(ericrk): Get this working in Android Webview. crbug.com/517156
   if (base::ThreadTaskRunnerHandle::IsSet()) {
     base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
         this, "cc::ResourceProvider", base::ThreadTaskRunnerHandle::Get());
   }
 
-  if (!compositor_context_provider_) {
-    default_resource_type_ = RESOURCE_TYPE_BITMAP;
-    // Pick an arbitrary limit here similar to what hardware might.
-    max_texture_size_ = 16 * 1024;
-    best_texture_format_ = RGBA_8888;
+  if (!compositor_context_provider)
     return;
-  }
 
   DCHECK(!texture_id_allocator_);
   DCHECK(!buffer_id_allocator_);
-
-  const auto& caps = compositor_context_provider_->ContextCapabilities();
-
-  DCHECK(IsGpuResourceType(default_resource_type_));
-  use_texture_storage_ext_ = caps.texture_storage;
-  use_texture_format_bgra_ = caps.texture_format_bgra8888;
-  use_texture_usage_hint_ = caps.texture_usage;
-  use_compressed_texture_etc1_ = caps.texture_format_etc1;
-
-  if (caps.disable_one_component_textures) {
-    yuv_resource_format_ = yuv_highbit_resource_format_ = RGBA_8888;
-  } else {
-    yuv_resource_format_ = caps.texture_rg ? RED_8 : LUMINANCE_8;
-    yuv_highbit_resource_format_ =
-        caps.texture_half_float_linear ? LUMINANCE_F16 : yuv_resource_format_;
-  }
-
-  use_sync_query_ = caps.sync_query;
-
   GLES2Interface* gl = ContextGL();
-
-  max_texture_size_ = 0;  // Context expects cleared value.
-  gl->GetIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_size_);
-  best_texture_format_ =
-      PlatformColor::BestSupportedTextureFormat(use_texture_format_bgra_);
-
-  best_render_buffer_format_ = PlatformColor::BestSupportedTextureFormat(
-      caps.render_buffer_format_bgra8888);
-
   texture_id_allocator_.reset(
-      new TextureIdAllocator(gl, id_allocation_chunk_size_));
+      new TextureIdAllocator(gl, id_allocation_chunk_size));
   buffer_id_allocator_.reset(
-      new BufferIdAllocator(gl, id_allocation_chunk_size_));
+      new BufferIdAllocator(gl, id_allocation_chunk_size));
 }
 
 ResourceProvider::~ResourceProvider() {
   base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
       this);
 
   while (!children_.empty())
     DestroyChildInternal(children_.begin(), FOR_SHUTDOWN);
   while (!resources_.empty())
     DeleteResourceInternal(resources_.begin(), FOR_SHUTDOWN);
 
   GLES2Interface* gl = ContextGL();
-  if (!IsGpuResourceType(default_resource_type_)) {
+  if (!IsGpuResourceType(settings_.default_resource_type)) {
     // We are not in GL mode, but double check before returning.
     DCHECK(!gl);
     return;
   }
 
   DCHECK(gl);
 #if DCHECK_IS_ON()
   // Check that all GL resources has been deleted.
   for (ResourceMap::const_iterator itr = resources_.begin();
        itr != resources_.end(); ++itr) {
@@ skipping 44 matching lines @@
 }
 
 void ResourceProvider::LoseResourceForTesting(ResourceId id) {
   Resource* resource = GetResource(id);
   DCHECK(resource);
   resource->lost = true;
 }
 
 ResourceFormat ResourceProvider::YuvResourceFormat(int bits) const {
   if (bits > 8) {
-    return yuv_highbit_resource_format_;
+    return settings_.yuv_highbit_resource_format;
   } else {
-    return yuv_resource_format_;
+    return settings_.yuv_resource_format;
   }
 }
 
 ResourceId ResourceProvider::CreateResource(
     const gfx::Size& size,
     TextureHint hint,
     ResourceFormat format,
     const gfx::ColorSpace& color_space) {
   DCHECK(!size.IsEmpty());
-  switch (default_resource_type_) {
+  switch (settings_.default_resource_type) {
     case RESOURCE_TYPE_GPU_MEMORY_BUFFER:
       // GPU memory buffers don't support LUMINANCE_F16.
       if (format != LUMINANCE_F16) {
         return CreateGLTexture(
             size, hint, RESOURCE_TYPE_GPU_MEMORY_BUFFER, format,
             gfx::BufferUsage::GPU_READ_CPU_READ_WRITE, color_space);
       }
     // Fall through and use a regular texture.
     case RESOURCE_TYPE_GL_TEXTURE:
       return CreateGLTexture(size, hint, RESOURCE_TYPE_GL_TEXTURE, format,
                              gfx::BufferUsage::GPU_READ_CPU_READ_WRITE,
                              color_space);
 
     case RESOURCE_TYPE_BITMAP:
       DCHECK_EQ(RGBA_8888, format);
       return CreateBitmap(size, color_space);
   }
 
   LOG(FATAL) << "Invalid default resource type.";
   return 0;
 }
 
 ResourceId ResourceProvider::CreateGpuMemoryBufferResource(
     const gfx::Size& size,
     TextureHint hint,
     ResourceFormat format,
     gfx::BufferUsage usage,
     const gfx::ColorSpace& color_space) {
   DCHECK(!size.IsEmpty());
-  switch (default_resource_type_) {
+  switch (settings_.default_resource_type) {
     case RESOURCE_TYPE_GPU_MEMORY_BUFFER:
     case RESOURCE_TYPE_GL_TEXTURE: {
       return CreateGLTexture(size, hint, RESOURCE_TYPE_GPU_MEMORY_BUFFER,
                              format, usage, color_space);
     }
     case RESOURCE_TYPE_BITMAP:
       DCHECK_EQ(RGBA_8888, format);
       return CreateBitmap(size, color_space);
   }
 
   LOG(FATAL) << "Invalid default resource type.";
   return 0;
 }
 
 ResourceId ResourceProvider::CreateGLTexture(
     const gfx::Size& size,
     TextureHint hint,
     ResourceType type,
     ResourceFormat format,
     gfx::BufferUsage usage,
     const gfx::ColorSpace& color_space) {
-  DCHECK_LE(size.width(), max_texture_size_);
-  DCHECK_LE(size.height(), max_texture_size_);
+  DCHECK_LE(size.width(), settings_.max_texture_size);
+  DCHECK_LE(size.height(), settings_.max_texture_size);
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // TODO(crbug.com/590317): We should not assume that all resources created by
   // ResourceProvider are GPU_READ_CPU_READ_WRITE. We should determine this
   // based on the current RasterBufferProvider's needs.
   GLenum target = type == RESOURCE_TYPE_GPU_MEMORY_BUFFER
                       ? GetImageTextureTarget(usage, format)
                       : GL_TEXTURE_2D;
 
   ResourceId id = next_id_++;
@@ skipping 208 matching lines @@
 ResourceProvider::ResourceType ResourceProvider::GetResourceType(
     ResourceId id) {
   return GetResource(id)->type;
 }
 
 GLenum ResourceProvider::GetResourceTextureTarget(ResourceId id) {
   return GetResource(id)->target;
 }
 
 bool ResourceProvider::IsImmutable(ResourceId id) {
-  if (IsGpuResourceType(default_resource_type_)) {
+  if (IsGpuResourceType(settings_.default_resource_type)) {
     return GetTextureHint(id) == TEXTURE_HINT_IMMUTABLE;
   } else {
     // Software resources are immutable; they cannot change format or be
     // resized.
     return true;
   }
 }
 
 ResourceProvider::TextureHint ResourceProvider::GetTextureHint(ResourceId id) {
   return GetResource(id)->hint;
 }
 
 sk_sp<SkColorSpace> ResourceProvider::GetResourceSkColorSpace(
     const Resource* resource) const {
-  if (!enable_color_correct_rendering_)
+  if (!settings_.enable_color_correct_rendering)
     return nullptr;
   return resource->color_space.ToSkColorSpace();
 }
 
 void ResourceProvider::CopyToResource(ResourceId id,
                                       const uint8_t* image,
                                       const gfx::Size& image_size) {
   Resource* resource = GetResource(id);
   DCHECK(!resource->locked_for_write);
   DCHECK(!resource->lock_for_read_count);
@@ skipping 459 matching lines @@
   gpu_memory_buffer_ = std::move(resource->gpu_memory_buffer);
   resource->gpu_memory_buffer = nullptr;
 }
 
 ResourceProvider::ScopedWriteLockGpuMemoryBuffer::
     ~ScopedWriteLockGpuMemoryBuffer() {
   DCHECK(thread_checker_.CalledOnValidThread());
   Resource* resource = resource_provider_->GetResource(resource_id_);
   DCHECK(resource);
   if (gpu_memory_buffer_) {
-    if (resource_provider_->enable_color_correct_rendering_)
+    if (resource_provider_->settings_.enable_color_correct_rendering)
       gpu_memory_buffer_->SetColorSpaceForScanout(resource->color_space);
     DCHECK(!resource->gpu_memory_buffer);
     resource_provider_->LazyCreate(resource);
     resource->gpu_memory_buffer = std::move(gpu_memory_buffer_);
     resource->allocated = true;
     resource_provider_->LazyCreateImage(resource);
     resource->dirty_image = true;
     resource->is_overlay_candidate = true;
     // GpuMemoryBuffer provides direct access to the memory used by the GPU.
     // Read lock fences are required to ensure that we're not trying to map a
@@ skipping 101 matching lines @@
   // This function goes through the array multiple times, store the resources
   // as pointers so we don't have to look up the resource id multiple times.
   std::vector<Resource*> resources;
   resources.reserve(resource_ids.size());
   for (const ResourceId id : resource_ids) {
     Resource* resource = GetResource(id);
     // Check the synchronization and sync token state when delegated sync points
     // are required. The only case where we allow a sync token to not be set is
     // the case where the image is dirty. In that case we will bind the image
     // lazily and generate a sync token at that point.
-    DCHECK(!delegated_sync_points_required_ || resource->dirty_image ||
+    DCHECK(!settings_.delegated_sync_points_required || resource->dirty_image ||
            !resource->needs_sync_token());
 
     // If we are validating the resource to be sent, the resource cannot be
     // in a LOCALLY_USED state. It must have been properly synchronized.
-    DCHECK(!delegated_sync_points_required_ ||
+    DCHECK(!settings_.delegated_sync_points_required ||
            Resource::LOCALLY_USED != resource->synchronization_state());
 
     resources.push_back(resource);
   }
 
   // Lazily create any mailboxes and verify all unverified sync tokens.
   std::vector<GLbyte*> unverified_sync_tokens;
   std::vector<Resource*> need_synchronization_resources;
   for (Resource* resource : resources) {
     if (!IsGpuResourceType(resource->type))
       continue;
 
     CreateMailboxAndBindResource(gl, resource);
 
-    if (delegated_sync_points_required_) {
+    if (settings_.delegated_sync_points_required) {
       if (resource->needs_sync_token()) {
         need_synchronization_resources.push_back(resource);
       } else if (resource->mailbox().HasSyncToken() &&
                  !resource->mailbox().sync_token().verified_flush()) {
         unverified_sync_tokens.push_back(resource->GetSyncTokenData());
       }
     }
   }
 
   // Insert sync point to synchronize the mailbox creation or bound textures.
   gpu::SyncToken new_sync_token;
   if (!need_synchronization_resources.empty()) {
-    DCHECK(delegated_sync_points_required_);
+    DCHECK(settings_.delegated_sync_points_required);
     DCHECK(gl);
     const uint64_t fence_sync = gl->InsertFenceSyncCHROMIUM();
     gl->OrderingBarrierCHROMIUM();
     gl->GenUnverifiedSyncTokenCHROMIUM(fence_sync, new_sync_token.GetData());
     unverified_sync_tokens.push_back(new_sync_token.GetData());
   }
 
   if (!unverified_sync_tokens.empty()) {
-    DCHECK(delegated_sync_points_required_);
+    DCHECK(settings_.delegated_sync_points_required);
     DCHECK(gl);
     gl->VerifySyncTokensCHROMIUM(unverified_sync_tokens.data(),
                                  unverified_sync_tokens.size());
   }
 
   // Set sync token after verification.
   for (Resource* resource : need_synchronization_resources) {
     DCHECK(IsGpuResourceType(resource->type));
     resource->UpdateSyncToken(new_sync_token);
     resource->SetSynchronized();
   }
 
   // Transfer Resources
   DCHECK_EQ(resources.size(), resource_ids.size());
   for (size_t i = 0; i < resources.size(); ++i) {
     Resource* source = resources[i];
     const ResourceId id = resource_ids[i];
 
-    DCHECK(!delegated_sync_points_required_ || !source->needs_sync_token());
-    DCHECK(!delegated_sync_points_required_ ||
+    DCHECK(!settings_.delegated_sync_points_required ||
+           !source->needs_sync_token());
+    DCHECK(!settings_.delegated_sync_points_required ||
            Resource::LOCALLY_USED != source->synchronization_state());
 
     TransferableResource resource;
     TransferResource(source, id, &resource);
 
     source->exported_count++;
     list->push_back(resource);
   }
 }
 
@@ skipping 393 matching lines @@
   DCHECK(gl);
 
   // Create and set texture properties. Allocation is delayed until needed.
   gl->BindTexture(resource->target, resource->gl_id);
   gl->TexParameteri(resource->target, GL_TEXTURE_MIN_FILTER,
                     resource->original_filter);
   gl->TexParameteri(resource->target, GL_TEXTURE_MAG_FILTER,
                     resource->original_filter);
   gl->TexParameteri(resource->target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
   gl->TexParameteri(resource->target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-  if (use_texture_usage_hint_ && (resource->hint & TEXTURE_HINT_FRAMEBUFFER)) {
+  if (settings_.use_texture_usage_hint &&
+      (resource->hint & TEXTURE_HINT_FRAMEBUFFER)) {
     gl->TexParameteri(resource->target, GL_TEXTURE_USAGE_ANGLE,
                       GL_FRAMEBUFFER_ATTACHMENT_ANGLE);
   }
 }
 
 void ResourceProvider::AllocateForTesting(ResourceId id) {
   LazyAllocate(GetResource(id));
 }
 
 void ResourceProvider::LazyAllocate(Resource* resource) {
   DCHECK(resource);
   if (resource->allocated)
     return;
   LazyCreate(resource);
   if (!resource->gl_id)
     return;
   resource->allocated = true;
   GLES2Interface* gl = ContextGL();
   gfx::Size& size = resource->size;
   ResourceFormat format = resource->format;
   gl->BindTexture(resource->target, resource->gl_id);
   if (resource->type == RESOURCE_TYPE_GPU_MEMORY_BUFFER) {
     resource->gpu_memory_buffer =
         gpu_memory_buffer_manager_->CreateGpuMemoryBuffer(
             size, BufferFormat(format), resource->usage,
             gpu::kNullSurfaceHandle);
-    if (resource->gpu_memory_buffer && enable_color_correct_rendering_) {
+    if (resource->gpu_memory_buffer &&
+        settings_.enable_color_correct_rendering) {
       resource->gpu_memory_buffer->SetColorSpaceForScanout(
           resource->color_space);
     }
 
     LazyCreateImage(resource);
     resource->dirty_image = true;
     resource->is_overlay_candidate = true;
     // GpuMemoryBuffer provides direct access to the memory used by the GPU.
     // Read lock fences are required to ensure that we're not trying to map a
     // buffer that is currently in-use by the GPU.
     resource->read_lock_fences_enabled = true;
-  } else if (use_texture_storage_ext_ &&
-             IsFormatSupportedForStorage(format, use_texture_format_bgra_) &&
+  } else if (settings_.use_texture_storage_ext &&
+             IsFormatSupportedForStorage(format,
+                                         settings_.use_texture_format_bgra) &&
              (resource->hint & TEXTURE_HINT_IMMUTABLE)) {
     GLenum storage_format = TextureToStorageFormat(format);
     gl->TexStorage2DEXT(resource->target, 1, storage_format, size.width(),
                         size.height());
   } else {
     // ETC1 does not support preallocation.
     if (format != ETC1) {
       gl->TexImage2D(resource->target, 0, GLInternalFormat(format),
                      size.width(), size.height(), 0, GLDataFormat(format),
                      GLDataType(format), nullptr);
@@ skipping 156 matching lines @@
 
     const int kImportance = 2;
     pmd->CreateSharedGlobalAllocatorDump(guid);
     pmd->AddOwnershipEdge(dump->guid(), guid, kImportance);
   }
 
   return true;
 }
 
 }  // namespace cc