Fix use_image_texture_target inconsistencies

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 372 matching lines @@
 
 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,
-    const std::vector<unsigned>& use_image_texture_targets)
+    const BufferToTextureTargetMap& buffer_to_texture_target_map)
     : 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_output_surface_(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),
       id_allocation_chunk_size_(id_allocation_chunk_size),
       use_sync_query_(false),
-      use_image_texture_targets_(use_image_texture_targets),
+      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(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());
@@ skipping 165 matching lines @@
 }
 
 ResourceId ResourceProvider::CreateGLTexture(const gfx::Size& size,
                                              TextureHint hint,
                                              ResourceType type,
                                              ResourceFormat format) {
   DCHECK_LE(size.width(), max_texture_size_);
   DCHECK_LE(size.height(), 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(format)
+                      ? GetImageTextureTarget(
+                            gfx::BufferUsage::GPU_READ_CPU_READ_WRITE, format)
                       : GL_TEXTURE_2D;
 
   ResourceId id = next_id_++;
   Resource* resource =
       InsertResource(id, Resource(0, size, Resource::INTERNAL, target,
                                   GL_LINEAR, hint, type, format));
   resource->allocated = false;
   return id;
 }
 
@@ skipping 1279 matching lines @@
     resource->WaitSyncToken(gl);
   }
 }
 
 GLint ResourceProvider::GetActiveTextureUnit(GLES2Interface* gl) {
   GLint active_unit = 0;
   gl->GetIntegerv(GL_ACTIVE_TEXTURE, &active_unit);
   return active_unit;
 }
 
-GLenum ResourceProvider::GetImageTextureTarget(ResourceFormat format) {
+GLenum ResourceProvider::GetImageTextureTarget(gfx::BufferUsage usage,
+                                               ResourceFormat format) {
   gfx::BufferFormat buffer_format = BufferFormat(format);
-  DCHECK_GT(use_image_texture_targets_.size(),
-            static_cast<size_t>(buffer_format));
-  return use_image_texture_targets_[static_cast<size_t>(buffer_format)];
+  auto found = buffer_to_texture_target_map_.find(
+      BufferToTextureTargetKey(usage, buffer_format));
+  DCHECK(found != buffer_to_texture_target_map_.end());
+  return found->second;
 }
 
 void ResourceProvider::ValidateResource(ResourceId id) const {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(id);
   DCHECK(resources_.find(id) != resources_.end());
 }
 
 GLES2Interface* ResourceProvider::ContextGL() const {
   ContextProvider* context_provider = compositor_context_provider_;
@@ skipping 73 matching lines @@
 
     const int kImportance = 2;
     pmd->CreateSharedGlobalAllocatorDump(guid);
     pmd->AddOwnershipEdge(dump->guid(), guid, kImportance);
   }
 
   return true;
 }
 
 }  // namespace cc