Change switches::kContentImageTextureTarget to a list of image texture targets

Not knowing the GpuMemoryBuffer format that the compostor will use, the host is
hard to determine the image texture target properly. This CL changes
switches::kContentImageTextureTarget to a list of targets for each format, so
that the compositor can decide what format it wants to use without having to
worry about the target being wrong.

BUG=490362,512665

CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Review URL: https://codereview.chromium.org/1251693003

Cr-Commit-Position: refs/heads/master@{#342339}

21 files changed, 202 insertions, 97 deletions

diff --git a/cc/resources/resource_pool.cc b/cc/resources/resource_pool.cc
index f3e2090..23a6233 100644
--- a/cc/resources/resource_pool.cc
+++ b/cc/resources/resource_pool.cc
@@ -38,6 +38,18 @@ void ResourcePool::PoolResource::OnMemoryDump(
                   base::trace_event::MemoryAllocatorDump::kUnitsBytes,
                   is_free ? total_bytes : 0);
 }
+ResourcePool::ResourcePool(ResourceProvider* resource_provider)
+    : resource_provider_(resource_provider),
+      target_(0),
+      max_memory_usage_bytes_(0),
+      max_unused_memory_usage_bytes_(0),
+      max_resource_count_(0),
+      memory_usage_bytes_(0),
+      unused_memory_usage_bytes_(0),
+      resource_count_(0) {
+  base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
+      this, base::ThreadTaskRunnerHandle::Get());
+}
 
 ResourcePool::ResourcePool(ResourceProvider* resource_provider, GLenum target)
     : resource_provider_(resource_provider),
@@ -48,6 +60,7 @@ ResourcePool::ResourcePool(ResourceProvider* resource_provider, GLenum target)
       memory_usage_bytes_(0),
       unused_memory_usage_bytes_(0),
       resource_count_(0) {
+  DCHECK_NE(0u, target);
   base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
       this, base::ThreadTaskRunnerHandle::Get());
 }
@@ -89,7 +102,9 @@ scoped_ptr<ScopedResource> ResourcePool::AcquireResource(
 
   scoped_ptr<ScopedResource> resource =
       ScopedResource::Create(resource_provider_);
-  resource->AllocateManaged(size, target_, format);
+  GLenum target =
+      target_ ? target_ : resource_provider_->GetImageTextureTarget(format);
+  resource->AllocateManaged(size, target, format);
 
   DCHECK(ResourceUtil::VerifySizeInBytes<size_t>(resource->size(),
                                                  resource->format()));
diff --git a/cc/resources/resource_pool.h b/cc/resources/resource_pool.h
index efd1e01..f336e3b 100644
--- a/cc/resources/resource_pool.h
+++ b/cc/resources/resource_pool.h
@@ -19,6 +19,10 @@ class ScopedResource;
 
 class CC_EXPORT ResourcePool : public base::trace_event::MemoryDumpProvider {
  public:
+  static scoped_ptr<ResourcePool> Create(ResourceProvider* resource_provider) {
+    return make_scoped_ptr(new ResourcePool(resource_provider));
+  }
+
   static scoped_ptr<ResourcePool> Create(ResourceProvider* resource_provider,
                                          GLenum target) {
     return make_scoped_ptr(new ResourcePool(resource_provider, target));
@@ -57,6 +61,7 @@ class CC_EXPORT ResourcePool : public base::trace_event::MemoryDumpProvider {
                     base::trace_event::ProcessMemoryDump* pmd) override;
 
  protected:
+  explicit ResourcePool(ResourceProvider* resource_provider);
   ResourcePool(ResourceProvider* resource_provider, GLenum target);
 
   bool ResourceUsageTooHigh();
diff --git a/cc/resources/resource_provider.cc b/cc/resources/resource_provider.cc
index 204422c..888f728 100644
--- a/cc/resources/resource_provider.cc
+++ b/cc/resources/resource_provider.cc
@@ -397,12 +397,13 @@ scoped_ptr<ResourceProvider> ResourceProvider::Create(
     int highp_threshold_min,
     bool use_rgba_4444_texture_format,
     size_t id_allocation_chunk_size,
-    bool use_persistent_map_for_gpu_memory_buffers) {
+    bool use_persistent_map_for_gpu_memory_buffers,
+    const std::vector<unsigned>& use_image_texture_targets) {
   scoped_ptr<ResourceProvider> resource_provider(new ResourceProvider(
       output_surface, shared_bitmap_manager, gpu_memory_buffer_manager,
       blocking_main_thread_task_runner, highp_threshold_min,
       use_rgba_4444_texture_format, id_allocation_chunk_size,
-      use_persistent_map_for_gpu_memory_buffers));
+      use_persistent_map_for_gpu_memory_buffers, use_image_texture_targets));
   resource_provider->Initialize();
   return resource_provider;
 }
@@ -1091,7 +1092,8 @@ ResourceProvider::ResourceProvider(
     int highp_threshold_min,
     bool use_rgba_4444_texture_format,
     size_t id_allocation_chunk_size,
-    bool use_persistent_map_for_gpu_memory_buffers)
+    bool use_persistent_map_for_gpu_memory_buffers,
+    const std::vector<unsigned>& use_image_texture_targets)
     : output_surface_(output_surface),
       shared_bitmap_manager_(shared_bitmap_manager),
       gpu_memory_buffer_manager_(gpu_memory_buffer_manager),
@@ -1113,7 +1115,8 @@ ResourceProvider::ResourceProvider(
       id_allocation_chunk_size_(id_allocation_chunk_size),
       use_sync_query_(false),
       use_persistent_map_for_gpu_memory_buffers_(
-          use_persistent_map_for_gpu_memory_buffers) {
+          use_persistent_map_for_gpu_memory_buffers),
+      use_image_texture_targets_(use_image_texture_targets) {
   DCHECK(output_surface_->HasClient());
   DCHECK(id_allocation_chunk_size_);
 }
@@ -1950,6 +1953,13 @@ GLint ResourceProvider::GetActiveTextureUnit(GLES2Interface* gl) {
   return active_unit;
 }
 
+GLenum ResourceProvider::GetImageTextureTarget(ResourceFormat format) {
+  gfx::BufferFormat buffer_format = ToGpuMemoryBufferFormat(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)];
+}
+
 void ResourceProvider::ValidateResource(ResourceId id) const {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(id);
diff --git a/cc/resources/resource_provider.h b/cc/resources/resource_provider.h
index bee3ce1..375ed54 100644
--- a/cc/resources/resource_provider.h
+++ b/cc/resources/resource_provider.h
@@ -88,7 +88,8 @@ class CC_EXPORT ResourceProvider
       int highp_threshold_min,
       bool use_rgba_4444_texture_format,
       size_t id_allocation_chunk_size,
-      bool use_persistent_map_for_gpu_memory_buffers);
+      bool use_persistent_map_for_gpu_memory_buffers,
+      const std::vector<unsigned>& use_image_texture_targets);
   ~ResourceProvider() override;
 
   void DidLoseOutputSurface() { lost_output_surface_ = true; }
@@ -441,6 +442,8 @@ class CC_EXPORT ResourceProvider
 
   void ValidateResource(ResourceId id) const;
 
+  GLenum GetImageTextureTarget(ResourceFormat format);
+
   // base::trace_event::MemoryDumpProvider implementation.
   bool OnMemoryDump(const base::trace_event::MemoryDumpArgs& args,
                     base::trace_event::ProcessMemoryDump* pmd) override;
@@ -453,7 +456,8 @@ class CC_EXPORT ResourceProvider
                    int highp_threshold_min,
                    bool use_rgba_4444_texture_format,
                    size_t id_allocation_chunk_size,
-                   bool use_persistent_map_for_gpu_memory_buffers);
+                   bool use_persistent_map_for_gpu_memory_buffers,
+                   const std::vector<unsigned>& use_image_texture_targets);
   void Initialize();
 
  private:
@@ -611,6 +615,7 @@ class CC_EXPORT ResourceProvider
   bool use_persistent_map_for_gpu_memory_buffers_;
   // Fence used for CopyResource if CHROMIUM_sync_query is not supported.
   scoped_refptr<SynchronousFence> synchronous_fence_;
+  std::vector<unsigned> use_image_texture_targets_;
 
   DISALLOW_COPY_AND_ASSIGN(ResourceProvider);
 };
diff --git a/cc/resources/resource_provider_unittest.cc b/cc/resources/resource_provider_unittest.cc
index 1368558..4a02e82 100644
--- a/cc/resources/resource_provider_unittest.cc
+++ b/cc/resources/resource_provider_unittest.cc
@@ -7,6 +7,7 @@
 #include <algorithm>
 #include <map>
 #include <set>
+#include <vector>
 
 #include "base/bind.h"
 #include "base/containers/hash_tables.h"
@@ -421,11 +422,11 @@ class ResourceProviderTest
     resource_provider_ = ResourceProvider::Create(
         output_surface_.get(), shared_bitmap_manager_.get(),
         gpu_memory_buffer_manager_.get(), main_thread_task_runner_.get(), 0,
-        false, 1, false);
+        false, 1, false, use_image_texture_targets_);
     child_resource_provider_ = ResourceProvider::Create(
         child_output_surface_.get(), shared_bitmap_manager_.get(),
         gpu_memory_buffer_manager_.get(), main_thread_task_runner_.get(), 0,
-        false, 1, false);
+        false, 1, false, use_image_texture_targets_);
   }
 
   ResourceProviderTest() : ResourceProviderTest(true) {}
@@ -485,7 +486,13 @@ class ResourceProviderTest
     }
   }
 
+ public:
+  static std::vector<unsigned> use_image_texture_targets() {
+    return use_image_texture_targets_;
+  }
+
  protected:
+  static std::vector<unsigned> use_image_texture_targets_;
   scoped_ptr<ContextSharedData> shared_data_;
   ResourceProviderContext* context3d_;
   ResourceProviderContext* child_context_;
@@ -500,6 +507,10 @@ class ResourceProviderTest
   scoped_ptr<TestGpuMemoryBufferManager> gpu_memory_buffer_manager_;
 };
 
+std::vector<unsigned> ResourceProviderTest::use_image_texture_targets_ =
+    std::vector<unsigned>(static_cast<size_t>(gfx::BufferFormat::LAST) + 1,
+                          GL_TEXTURE_2D);
+
 void CheckCreateResource(ResourceProvider::ResourceType expected_default_type,
                          ResourceProvider* resource_provider,
                          ResourceProviderContext* context) {
@@ -1367,7 +1378,8 @@ TEST_P(ResourceProviderTest, TransferGLToSoftware) {
 
   scoped_ptr<ResourceProvider> child_resource_provider(ResourceProvider::Create(
       child_output_surface.get(), shared_bitmap_manager_.get(),
-      gpu_memory_buffer_manager_.get(), NULL, 0, false, 1, false));
+      gpu_memory_buffer_manager_.get(), NULL, 0, false, 1, false,
+      use_image_texture_targets_));
 
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
@@ -1851,7 +1863,7 @@ class ResourceProviderTestTextureFilters : public ResourceProviderTest {
     scoped_ptr<ResourceProvider> child_resource_provider(
         ResourceProvider::Create(child_output_surface.get(),
                                  shared_bitmap_manager.get(), NULL, NULL, 0,
-                                 false, 1, false));
+                                 false, 1, false, use_image_texture_targets_));
 
     scoped_ptr<TextureStateTrackingContext> parent_context_owned(
         new TextureStateTrackingContext);
@@ -1865,7 +1877,7 @@ class ResourceProviderTestTextureFilters : public ResourceProviderTest {
     scoped_ptr<ResourceProvider> parent_resource_provider(
         ResourceProvider::Create(parent_output_surface.get(),
                                  shared_bitmap_manager.get(), NULL, NULL, 0,
-                                 false, 1, false));
+                                 false, 1, false, use_image_texture_targets_));
 
     gfx::Size size(1, 1);
     ResourceFormat format = RGBA_8888;
@@ -2497,7 +2509,8 @@ TEST_P(ResourceProviderTest, ScopedSampler) {
 
   scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
       output_surface.get(), shared_bitmap_manager_.get(),
-      gpu_memory_buffer_manager_.get(), NULL, 0, false, 1, false));
+      gpu_memory_buffer_manager_.get(), NULL, 0, false, 1, false,
+      use_image_texture_targets_));
 
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
@@ -2579,7 +2592,8 @@ TEST_P(ResourceProviderTest, ManagedResource) {
 
   scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
       output_surface.get(), shared_bitmap_manager_.get(),
-      gpu_memory_buffer_manager_.get(), NULL, 0, false, 1, false));
+      gpu_memory_buffer_manager_.get(), NULL, 0, false, 1, false,
+      use_image_texture_targets_));
 
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
@@ -2626,7 +2640,8 @@ TEST_P(ResourceProviderTest, TextureWrapMode) {
 
   scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
       output_surface.get(), shared_bitmap_manager_.get(),
-      gpu_memory_buffer_manager_.get(), NULL, 0, false, 1, false));
+      gpu_memory_buffer_manager_.get(), NULL, 0, false, 1, false,
+      use_image_texture_targets_));
 
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
@@ -2676,7 +2691,8 @@ TEST_P(ResourceProviderTest, TextureHint) {
 
   scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
       output_surface.get(), shared_bitmap_manager_.get(),
-      gpu_memory_buffer_manager_.get(), NULL, 0, false, 1, false));
+      gpu_memory_buffer_manager_.get(), NULL, 0, false, 1, false,
+      use_image_texture_targets_));
 
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
@@ -2741,7 +2757,7 @@ TEST_P(ResourceProviderTest, TextureMailbox_SharedMemory) {
   scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
       output_surface.get(), shared_bitmap_manager_.get(),
       gpu_memory_buffer_manager_.get(), main_thread_task_runner_.get(), 0,
-      false, 1, false));
+      false, 1, false, use_image_texture_targets_));
 
   uint32 release_sync_point = 0;
   bool lost_resource = false;
@@ -2790,7 +2806,8 @@ class ResourceProviderTestTextureMailboxGLFilters
 
     scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
         output_surface.get(), shared_bitmap_manager, gpu_memory_buffer_manager,
-        main_thread_task_runner, 0, false, 1, false));
+        main_thread_task_runner, 0, false, 1, false,
+        use_image_texture_targets_));
 
     unsigned texture_id = 1;
     uint32 sync_point = 30;
@@ -2933,7 +2950,8 @@ TEST_P(ResourceProviderTest, TextureMailbox_GLTextureExternalOES) {
 
   scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
       output_surface.get(), shared_bitmap_manager_.get(),
-      gpu_memory_buffer_manager_.get(), NULL, 0, false, 1, false));
+      gpu_memory_buffer_manager_.get(), NULL, 0, false, 1, false,
+      use_image_texture_targets_));
 
   uint32 sync_point = 30;
   unsigned target = GL_TEXTURE_EXTERNAL_OES;
@@ -3002,7 +3020,8 @@ TEST_P(ResourceProviderTest,
 
   scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
       output_surface.get(), shared_bitmap_manager_.get(),
-      gpu_memory_buffer_manager_.get(), NULL, 0, false, 1, false));
+      gpu_memory_buffer_manager_.get(), NULL, 0, false, 1, false,
+      use_image_texture_targets_));
 
   uint32 sync_point = 30;
   unsigned target = GL_TEXTURE_2D;
@@ -3055,7 +3074,8 @@ TEST_P(ResourceProviderTest, TextureMailbox_WaitSyncPointIfNeeded_NoSyncPoint) {
 
   scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
       output_surface.get(), shared_bitmap_manager_.get(),
-      gpu_memory_buffer_manager_.get(), NULL, 0, false, 1, false));
+      gpu_memory_buffer_manager_.get(), NULL, 0, false, 1, false,
+      use_image_texture_targets_));
 
   uint32 sync_point = 0;
   unsigned target = GL_TEXTURE_2D;
@@ -3175,7 +3195,8 @@ TEST_P(ResourceProviderTest, TextureAllocation) {
 
   scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
       output_surface.get(), shared_bitmap_manager_.get(),
-      gpu_memory_buffer_manager_.get(), NULL, 0, false, 1, false));
+      gpu_memory_buffer_manager_.get(), NULL, 0, false, 1, false,
+      use_image_texture_targets_));
 
   gfx::Size size(2, 2);
   gfx::Vector2d offset(0, 0);
@@ -3249,7 +3270,8 @@ TEST_P(ResourceProviderTest, TextureAllocationHint) {
 
   scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
       output_surface.get(), shared_bitmap_manager_.get(),
-      gpu_memory_buffer_manager_.get(), NULL, 0, false, 1, false));
+      gpu_memory_buffer_manager_.get(), NULL, 0, false, 1, false,
+      use_image_texture_targets_));
 
   gfx::Size size(2, 2);
 
@@ -3304,7 +3326,8 @@ TEST_P(ResourceProviderTest, TextureAllocationHint_BGRA) {
 
   scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
       output_surface.get(), shared_bitmap_manager_.get(),
-      gpu_memory_buffer_manager_.get(), NULL, 0, false, 1, false));
+      gpu_memory_buffer_manager_.get(), NULL, 0, false, 1, false,
+      use_image_texture_targets_));
 
   gfx::Size size(2, 2);
   const ResourceFormat formats[2] = {RGBA_8888, BGRA_8888};
@@ -3358,7 +3381,8 @@ TEST_P(ResourceProviderTest, PixelBuffer_GLTexture) {
 
   scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
       output_surface.get(), shared_bitmap_manager_.get(),
-      gpu_memory_buffer_manager_.get(), NULL, 0, false, 1, false));
+      gpu_memory_buffer_manager_.get(), NULL, 0, false, 1, false,
+      use_image_texture_targets_));
 
   id = resource_provider->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
@@ -3400,7 +3424,8 @@ TEST_P(ResourceProviderTest, ForcingAsyncUploadToComplete) {
 
   scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
       output_surface.get(), shared_bitmap_manager_.get(),
-      gpu_memory_buffer_manager_.get(), NULL, 0, false, 1, false));
+      gpu_memory_buffer_manager_.get(), NULL, 0, false, 1, false,
+      use_image_texture_targets_));
 
   id = resource_provider->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
@@ -3442,7 +3467,8 @@ TEST_P(ResourceProviderTest, PixelBufferLostContext) {
 
   scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
       output_surface.get(), shared_bitmap_manager_.get(),
-      gpu_memory_buffer_manager_.get(), NULL, 0, false, 1, false));
+      gpu_memory_buffer_manager_.get(), NULL, 0, false, 1, false,
+      use_image_texture_targets_));
 
   EXPECT_CALL(*context, NextTextureId()).WillRepeatedly(Return(texture_id));
 
@@ -3482,7 +3508,8 @@ TEST_P(ResourceProviderTest, Image_GLTexture) {
 
   scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
       output_surface.get(), shared_bitmap_manager_.get(),
-      gpu_memory_buffer_manager_.get(), NULL, 0, false, 1, false));
+      gpu_memory_buffer_manager_.get(), NULL, 0, false, 1, false,
+      use_image_texture_targets_));
 
   id = resource_provider->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
@@ -3567,7 +3594,9 @@ TEST_P(ResourceProviderTest, CopyResource_GLTexture) {
 
   scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
       output_surface.get(), shared_bitmap_manager_.get(),
-      gpu_memory_buffer_manager_.get(), NULL, 0, false, 1, false));
+      gpu_memory_buffer_manager_.get(), NULL, 0, false, 1, false,
+      std::vector<unsigned>(static_cast<size_t>(gfx::BufferFormat::LAST) + 1,
+                            GL_TEXTURE_2D)));
 
   source_id = resource_provider->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
@@ -3640,7 +3669,8 @@ TEST_P(ResourceProviderTest, CompressedTextureETC1Allocate) {
   gfx::Size size(4, 4);
   scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
       output_surface.get(), shared_bitmap_manager_.get(),
-      gpu_memory_buffer_manager_.get(), NULL, 0, false, 1, false));
+      gpu_memory_buffer_manager_.get(), NULL, 0, false, 1, false,
+      use_image_texture_targets_));
   int texture_id = 123;
 
   ResourceId id = resource_provider->CreateResource(
@@ -3671,7 +3701,8 @@ TEST_P(ResourceProviderTest, CompressedTextureETC1Upload) {
   gfx::Size size(4, 4);
   scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
       output_surface.get(), shared_bitmap_manager_.get(),
-      gpu_memory_buffer_manager_.get(), NULL, 0, false, 1, false));
+      gpu_memory_buffer_manager_.get(), NULL, 0, false, 1, false,
+      use_image_texture_targets_));
   int texture_id = 123;
   uint8_t pixels[8];
 
@@ -3727,7 +3758,8 @@ TEST(ResourceProviderTest, TextureAllocationChunkSize) {
     size_t kTextureAllocationChunkSize = 1;
     scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
         output_surface.get(), shared_bitmap_manager.get(), NULL, NULL, 0, false,
-        kTextureAllocationChunkSize, false));
+        kTextureAllocationChunkSize, false,
+        ResourceProviderTest::use_image_texture_targets()));
 
     ResourceId id = resource_provider->CreateResource(
         size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE,
@@ -3743,7 +3775,8 @@ TEST(ResourceProviderTest, TextureAllocationChunkSize) {
     size_t kTextureAllocationChunkSize = 8;
     scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
         output_surface.get(), shared_bitmap_manager.get(), NULL, NULL, 0, false,
-        kTextureAllocationChunkSize, false));
+        kTextureAllocationChunkSize, false,
+        ResourceProviderTest::use_image_texture_targets()));
 
     ResourceId id = resource_provider->CreateResource(
         size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE,
diff --git a/cc/surfaces/display.cc b/cc/surfaces/display.cc
index 7e80854..af24a97 100644
--- a/cc/surfaces/display.cc
+++ b/cc/surfaces/display.cc
@@ -20,6 +20,7 @@
 #include "cc/surfaces/surface_aggregator.h"
 #include "cc/surfaces/surface_manager.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
+#include "ui/gfx/buffer_types.h"
 
 namespace cc {
 
@@ -107,7 +108,9 @@ void Display::InitializeRenderer() {
       output_surface_.get(), bitmap_manager_, gpu_memory_buffer_manager_,
       nullptr, settings_.highp_threshold_min, settings_.use_rgba_4444_textures,
       settings_.texture_id_allocation_chunk_size,
-      use_persistent_map_for_gpu_memory_buffers);
+      use_persistent_map_for_gpu_memory_buffers,
+      std::vector<unsigned>(static_cast<size_t>(gfx::BufferFormat::LAST) + 1,
+                            GL_TEXTURE_2D));
   if (!resource_provider)
     return;
 
diff --git a/cc/test/fake_resource_provider.h b/cc/test/fake_resource_provider.h
index c96beba..2295a4f 100644
--- a/cc/test/fake_resource_provider.h
+++ b/cc/test/fake_resource_provider.h
@@ -6,6 +6,7 @@
 #define CC_TEST_FAKE_RESOURCE_PROVIDER_H_
 
 #include "cc/resources/resource_provider.h"
+#include "ui/gfx/buffer_types.h"
 
 namespace cc {
 
@@ -14,9 +15,11 @@ class FakeResourceProvider : public ResourceProvider {
   static scoped_ptr<FakeResourceProvider> Create(
       OutputSurface* output_surface,
       SharedBitmapManager* shared_bitmap_manager) {
-    scoped_ptr<FakeResourceProvider> provider(
-        new FakeResourceProvider(output_surface, shared_bitmap_manager, nullptr,
-                                 nullptr, 0, false, 1, false));
+    scoped_ptr<FakeResourceProvider> provider(new FakeResourceProvider(
+        output_surface, shared_bitmap_manager, nullptr, nullptr, 0, false, 1,
+        false,
+        std::vector<unsigned>(static_cast<size_t>(gfx::BufferFormat::LAST) + 1,
+                              GL_TEXTURE_2D)));
     provider->Initialize();
     return provider;
   }
@@ -27,7 +30,9 @@ class FakeResourceProvider : public ResourceProvider {
       gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager) {
     scoped_ptr<FakeResourceProvider> provider(new FakeResourceProvider(
         output_surface, shared_bitmap_manager, gpu_memory_buffer_manager,
-        nullptr, 0, false, 1, false));
+        nullptr, 0, false, 1, false,
+        std::vector<unsigned>(static_cast<size_t>(gfx::BufferFormat::LAST) + 1,
+                              GL_TEXTURE_2D)));
     provider->Initialize();
     return provider;
   }
@@ -40,7 +45,8 @@ class FakeResourceProvider : public ResourceProvider {
                        int highp_threshold_min,
                        bool use_rgba_4444_texture_format,
                        size_t id_allocation_chunk_size,
-                       bool use_persistent_map_for_gpu_memory_buffers)
+                       bool use_persistent_map_for_gpu_memory_buffers,
+                       const std::vector<unsigned>& use_image_texture_targets)
       : ResourceProvider(output_surface,
                          shared_bitmap_manager,
                          gpu_memory_buffer_manager,
@@ -48,7 +54,8 @@ class FakeResourceProvider : public ResourceProvider {
                          highp_threshold_min,
                          use_rgba_4444_texture_format,
                          id_allocation_chunk_size,
-                         use_persistent_map_for_gpu_memory_buffers) {}
+                         use_persistent_map_for_gpu_memory_buffers,
+                         use_image_texture_targets) {}
 };
 
 }  // namespace cc
diff --git a/cc/test/pixel_test.cc b/cc/test/pixel_test.cc
index ae3cef1..32f32d3 100644
--- a/cc/test/pixel_test.cc
+++ b/cc/test/pixel_test.cc
@@ -136,7 +136,7 @@ void PixelTest::SetUpGLRenderer(bool use_skia_gpu_backend,
   resource_provider_ = ResourceProvider::Create(
       output_surface_.get(), shared_bitmap_manager_.get(),
       gpu_memory_buffer_manager_.get(), main_thread_task_runner_.get(), 0,
-      false, 1, false);
+      false, 1, false, settings_.use_image_texture_targets);
 
   texture_mailbox_deleter_ = make_scoped_ptr(
       new TextureMailboxDeleter(base::ThreadTaskRunnerHandle::Get()));
@@ -177,7 +177,7 @@ void PixelTest::SetUpSoftwareRenderer() {
   resource_provider_ = ResourceProvider::Create(
       output_surface_.get(), shared_bitmap_manager_.get(),
       gpu_memory_buffer_manager_.get(), main_thread_task_runner_.get(), 0,
-      false, 1, false);
+      false, 1, false, settings_.use_image_texture_targets);
   renderer_ =
       SoftwareRenderer::Create(this, &settings_.renderer_settings,
                                output_surface_.get(), resource_provider_.get());
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index ae0c943..628fc59 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -2114,16 +2114,9 @@ void LayerTreeHostImpl::CreateResourceAndTileTaskWorkerPool(
   }
 
   DCHECK(GetRendererCapabilities().using_image);
-  unsigned image_target = settings_.use_image_texture_target;
-  DCHECK_IMPLIES(image_target == GL_TEXTURE_RECTANGLE_ARB,
-                 context_provider->ContextCapabilities().gpu.texture_rectangle);
-  DCHECK_IMPLIES(
-      image_target == GL_TEXTURE_EXTERNAL_OES,
-      context_provider->ContextCapabilities().gpu.egl_image_external);
 
   if (settings_.use_zero_copy) {
-    *resource_pool =
-        ResourcePool::Create(resource_provider_.get(), image_target);
+    *resource_pool = ResourcePool::Create(resource_provider_.get());
 
     *tile_task_worker_pool = ZeroCopyTileTaskWorkerPool::Create(
         GetTaskRunner(), task_graph_runner, resource_provider_.get());
@@ -2137,8 +2130,7 @@ void LayerTreeHostImpl::CreateResourceAndTileTaskWorkerPool(
     DCHECK(!is_synchronous_single_threaded_);
 
     // We need to create a staging resource pool when using copy rasterizer.
-    *staging_resource_pool =
-        ResourcePool::Create(resource_provider_.get(), image_target);
+    *staging_resource_pool = ResourcePool::Create(resource_provider_.get());
     *resource_pool =
         ResourcePool::Create(resource_provider_.get(), GL_TEXTURE_2D);
 
@@ -2227,7 +2219,8 @@ bool LayerTreeHostImpl::InitializeRenderer(
       settings_.renderer_settings.highp_threshold_min,
       settings_.renderer_settings.use_rgba_4444_textures,
       settings_.renderer_settings.texture_id_allocation_chunk_size,
-      settings_.use_persistent_map_for_gpu_memory_buffers);
+      settings_.use_persistent_map_for_gpu_memory_buffers,
+      settings_.use_image_texture_targets);
 
   CreateAndSetRenderer();
 
diff --git a/cc/trees/layer_tree_settings.cc b/cc/trees/layer_tree_settings.cc
index 0869e92..801dc6d 100644
--- a/cc/trees/layer_tree_settings.cc
+++ b/cc/trees/layer_tree_settings.cc
@@ -10,6 +10,7 @@
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
+#include "ui/gfx/buffer_types.h"
 
 namespace cc {
 
@@ -61,7 +62,9 @@ LayerTreeSettings::LayerTreeSettings()
       use_zero_copy(false),
       use_persistent_map_for_gpu_memory_buffers(false),
       enable_elastic_overscroll(false),
-      use_image_texture_target(GL_TEXTURE_2D),
+      use_image_texture_targets(
+          static_cast<size_t>(gfx::BufferFormat::LAST) + 1,
+          GL_TEXTURE_2D),
       ignore_root_layer_flings(false),
       scheduled_raster_task_limit(32),
       use_occlusion_for_tile_prioritization(false),
diff --git a/cc/trees/layer_tree_settings.h b/cc/trees/layer_tree_settings.h
index 27e80af..dbc9004 100644
--- a/cc/trees/layer_tree_settings.h
+++ b/cc/trees/layer_tree_settings.h
@@ -5,6 +5,8 @@
 #ifndef CC_TREES_LAYER_TREE_SETTINGS_H_
 #define CC_TREES_LAYER_TREE_SETTINGS_H_
 
+#include <vector>
+
 #include "base/basictypes.h"
 #include "cc/base/cc_export.h"
 #include "cc/debug/layer_tree_debug_state.h"
@@ -75,7 +77,8 @@ class CC_EXPORT LayerTreeSettings {
   bool use_zero_copy;
   bool use_persistent_map_for_gpu_memory_buffers;
   bool enable_elastic_overscroll;
-  unsigned use_image_texture_target;
+  // An array of image texture targets for each GpuMemoryBuffer format.
+  std::vector<unsigned> use_image_texture_targets;
   bool ignore_root_layer_flings;
   size_t scheduled_raster_task_limit;
   bool use_occlusion_for_tile_prioritization;
diff --git a/components/html_viewer/web_layer_tree_view_impl.cc b/components/html_viewer/web_layer_tree_view_impl.cc
index cbc4664..9d54f7e 100644
--- a/components/html_viewer/web_layer_tree_view_impl.cc
+++ b/components/html_viewer/web_layer_tree_view_impl.cc
@@ -15,6 +15,7 @@
 #include "mojo/cc/output_surface_mojo.h"
 #include "mojo/converters/surfaces/surfaces_type_converters.h"
 #include "third_party/WebKit/public/web/WebWidget.h"
+#include "ui/gfx/buffer_types.h"
 
 namespace html_viewer {
 
@@ -36,7 +37,8 @@ WebLayerTreeViewImpl::WebLayerTreeViewImpl(
   // blink::RuntimeEnabledFeature::slimmingPaintEnabled()
   settings.use_display_lists = true;
 
-  settings.use_image_texture_target = GL_TEXTURE_2D;
+  settings.use_image_texture_targets = std::vector<unsigned>(
+      static_cast<size_t>(gfx::BufferFormat::LAST) + 1, GL_TEXTURE_2D);
   settings.use_one_copy = true;
   // TODO(jam): use multiple compositor raster threads and set gather_pixel_refs
   // accordingly (see content).
diff --git a/content/browser/renderer_host/render_process_host_impl.cc b/content/browser/renderer_host/render_process_host_impl.cc
index d290778..538def2 100644
--- a/content/browser/renderer_host/render_process_host_impl.cc
+++ b/content/browser/renderer_host/render_process_host_impl.cc
@@ -404,6 +404,16 @@ class SessionStorageHolder : public base::SupportsUserData::Data {
   DISALLOW_COPY_AND_ASSIGN(SessionStorageHolder);
 };
 
+std::string UintVectorToString(const std::vector<unsigned>& vector) {
+  std::string str;
+  for (auto it : vector) {
+    if (!str.empty())
+      str += ",";
+    str += base::UintToString(it);
+  }
+  return str;
+}
+
 }  // namespace
 
 RendererMainThreadFactoryFunction g_renderer_main_thread_factory = NULL;
@@ -1142,21 +1152,19 @@ static void AppendCompositorCommandLineFlags(base::CommandLine* command_line) {
   if (IsForceGpuRasterizationEnabled())
     command_line->AppendSwitch(switches::kForceGpuRasterization);
 
-  command_line->AppendSwitchASCII(
-      switches::kContentImageTextureTarget,
-      base::UintToString(
-          // TODO(reveman): We currently assume that the compositor will use
-          // BGRA_8888 if it's able to, and RGBA_8888 otherwise. Since we don't
-          // know what it will use we hardcode BGRA_8888 here for now. We should
-          // instead move decisions about GpuMemoryBuffer format to the browser
-          // embedder so we know it here, and pass that decision to the
-          // compositor for each usage.
-          // crbug.com/490362
-          BrowserGpuMemoryBufferManager::GetImageTextureTarget(
-              gfx::BufferFormat::BGRA_8888,
-              // TODO(danakj): When one-copy supports partial update, change
-              // this usage to PERSISTENT_MAP for one-copy.
-              gfx::BufferUsage::MAP)));
+  std::vector<unsigned> image_targets(
+      static_cast<size_t>(gfx::BufferFormat::LAST) + 1, GL_TEXTURE_2D);
+  for (size_t format = 0;
+       format < static_cast<size_t>(gfx::BufferFormat::LAST) + 1; format++) {
+    image_targets[format] =
+        BrowserGpuMemoryBufferManager::GetImageTextureTarget(
+            static_cast<gfx::BufferFormat>(format),
+            // TODO(danakj): When one-copy supports partial update, change
+            // this usage to PERSISTENT_MAP for one-copy.
+            gfx::BufferUsage::MAP);
+  }
+  command_line->AppendSwitchASCII(switches::kContentImageTextureTarget,
+                                  UintVectorToString(image_targets));
 
   command_line->AppendSwitchASCII(
       switches::kVideoImageTextureTarget,
diff --git a/content/renderer/gpu/compositor_dependencies.h b/content/renderer/gpu/compositor_dependencies.h
index 7caab24..81aad86f 100644
--- a/content/renderer/gpu/compositor_dependencies.h
+++ b/content/renderer/gpu/compositor_dependencies.h
@@ -5,6 +5,8 @@
 #ifndef CONTENT_RENDERER_GPU_COMPOSITOR_DEPENDENCIES_H_
 #define CONTENT_RENDERER_GPU_COMPOSITOR_DEPENDENCIES_H_
 
+#include <vector>
+
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 
@@ -39,7 +41,7 @@ class CompositorDependencies {
   virtual bool IsZeroCopyEnabled() = 0;
   virtual bool IsOneCopyEnabled() = 0;
   virtual bool IsElasticOverscrollEnabled() = 0;
-  virtual uint32 GetImageTextureTarget() = 0;
+  virtual std::vector<unsigned> GetImageTextureTargets() = 0;
   virtual scoped_refptr<base::SingleThreadTaskRunner>
   GetCompositorMainThreadTaskRunner() = 0;
   // Returns null if the compositor is in single-threaded mode (ie. there is no
diff --git a/content/renderer/gpu/render_widget_compositor.cc b/content/renderer/gpu/render_widget_compositor.cc
index 942470b..a1291cd 100644
--- a/content/renderer/gpu/render_widget_compositor.cc
+++ b/content/renderer/gpu/render_widget_compositor.cc
@@ -305,7 +305,8 @@ void RenderWidgetCompositor::Initialize() {
   settings.use_one_copy = compositor_deps_->IsOneCopyEnabled();
   settings.enable_elastic_overscroll =
       compositor_deps_->IsElasticOverscrollEnabled();
-  settings.use_image_texture_target = compositor_deps_->GetImageTextureTarget();
+  settings.use_image_texture_targets =
+      compositor_deps_->GetImageTextureTargets();
   settings.gather_pixel_refs = compositor_deps_->IsGatherPixelRefsEnabled();
 
   if (cmd->HasSwitch(cc::switches::kTopControlsShowThreshold)) {
diff --git a/content/renderer/render_thread_impl.cc b/content/renderer/render_thread_impl.cc
index f619f84..7c1cee2 100644
--- a/content/renderer/render_thread_impl.cc
+++ b/content/renderer/render_thread_impl.cc
@@ -422,6 +422,19 @@ void CreateEmbeddedWorkerSetup(
   new EmbeddedWorkerSetupImpl(request.Pass());
 }
 
+void StringToUintVector(const std::string& str, std::vector<unsigned>* vector) {
+  DCHECK(vector->empty());
+  std::vector<std::string> pieces;
+  base::SplitString(str, ',', &pieces);
+  DCHECK_EQ(pieces.size(), static_cast<size_t>(gfx::BufferFormat::LAST) + 1);
+  for (size_t i = 0; i < pieces.size(); ++i) {
+    unsigned number = 0;
+    bool succeed = base::StringToUint(pieces[i], &number);
+    DCHECK(succeed);
+    vector->push_back(number);
+  }
+}
+
 }  // namespace
 
 // For measuring memory usage after each task. Behind a command line flag.
@@ -654,9 +667,7 @@ void RenderThreadImpl::Init() {
 
   std::string image_texture_target_string =
       command_line.GetSwitchValueASCII(switches::kContentImageTextureTarget);
-  bool parsed_image_texture_target = base::StringToUint(
-      image_texture_target_string, &use_image_texture_target_);
-  DCHECK(parsed_image_texture_target);
+  StringToUintVector(image_texture_target_string, &use_image_texture_targets_);
 
   if (command_line.HasSwitch(switches::kDisableLCDText)) {
     is_lcd_text_enabled_ = false;
@@ -1337,7 +1348,7 @@ RenderThreadImpl::GetGpuFactories() {
     bool enable_video_accelerator =
         !cmd_line->HasSwitch(switches::kDisableAcceleratedVideoDecode);
     std::string image_texture_target_string =
-        cmd_line->GetSwitchValueASCII(switches::kContentImageTextureTarget);
+        cmd_line->GetSwitchValueASCII(switches::kVideoImageTextureTarget);
     unsigned image_texture_target = 0;
     bool parsed_image_texture_target =
         base::StringToUint(image_texture_target_string, &image_texture_target);
@@ -1466,8 +1477,8 @@ bool RenderThreadImpl::IsElasticOverscrollEnabled() {
   return is_elastic_overscroll_enabled_;
 }
 
-uint32 RenderThreadImpl::GetImageTextureTarget() {
-  return use_image_texture_target_;
+std::vector<unsigned> RenderThreadImpl::GetImageTextureTargets() {
+  return use_image_texture_targets_;
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
diff --git a/content/renderer/render_thread_impl.h b/content/renderer/render_thread_impl.h
index eb6516e..c7aeb9f 100644
--- a/content/renderer/render_thread_impl.h
+++ b/content/renderer/render_thread_impl.h
@@ -195,7 +195,7 @@ class CONTENT_EXPORT RenderThreadImpl
   bool IsZeroCopyEnabled() override;
   bool IsOneCopyEnabled() override;
   bool IsElasticOverscrollEnabled() override;
-  uint32 GetImageTextureTarget() override;
+  std::vector<unsigned> GetImageTextureTargets() override;
   scoped_refptr<base::SingleThreadTaskRunner>
   GetCompositorMainThreadTaskRunner() override;
   scoped_refptr<base::SingleThreadTaskRunner>
@@ -615,7 +615,7 @@ class CONTENT_EXPORT RenderThreadImpl
   bool is_zero_copy_enabled_;
   bool is_one_copy_enabled_;
   bool is_elastic_overscroll_enabled_;
-  unsigned use_image_texture_target_;
+  std::vector<unsigned> use_image_texture_targets_;
   bool is_gather_pixel_refs_enabled_;
 
   class PendingRenderFrameConnect
diff --git a/content/renderer/render_thread_impl_browsertest.cc b/content/renderer/render_thread_impl_browsertest.cc
index b722b29..145a7fa 100644
--- a/content/renderer/render_thread_impl_browsertest.cc
+++ b/content/renderer/render_thread_impl_browsertest.cc
@@ -163,8 +163,14 @@ class RenderThreadImplBrowserTest : public testing::Test {
     base::CommandLine::StringVector old_argv = cmd->argv();
 
     cmd->AppendSwitchASCII(switches::kNumRasterThreads, "1");
-    cmd->AppendSwitchASCII(switches::kContentImageTextureTarget,
-                           base::UintToString(GL_TEXTURE_2D));
+    std::string image_targets;
+    for (size_t format = 0;
+         format < static_cast<size_t>(gfx::BufferFormat::LAST) + 1; format++) {
+      if (!image_targets.empty())
+        image_targets += ",";
+      image_targets += base::UintToString(GL_TEXTURE_2D);
+    }
+    cmd->AppendSwitchASCII(switches::kContentImageTextureTarget, image_targets);
 
     scoped_ptr<scheduler::RendererScheduler> renderer_scheduler =
         scheduler::RendererScheduler::Create();
diff --git a/content/test/fake_compositor_dependencies.cc b/content/test/fake_compositor_dependencies.cc
index e33554d..700af54 100644
--- a/content/test/fake_compositor_dependencies.cc
+++ b/content/test/fake_compositor_dependencies.cc
@@ -8,6 +8,7 @@
 #include "base/thread_task_runner_handle.h"
 #include "cc/test/fake_external_begin_frame_source.h"
 #include "third_party/khronos/GLES2/gl2.h"
+#include "ui/gfx/buffer_types.h"
 
 namespace content {
 
@@ -48,9 +49,9 @@ bool FakeCompositorDependencies::IsOneCopyEnabled() {
 bool FakeCompositorDependencies::IsElasticOverscrollEnabled() {
   return false;
 }
-
-uint32 FakeCompositorDependencies::GetImageTextureTarget() {
-  return GL_TEXTURE_2D;
+std::vector<unsigned> FakeCompositorDependencies::GetImageTextureTargets() {
+  return std::vector<unsigned>(static_cast<size_t>(gfx::BufferFormat::LAST) + 1,
+                               GL_TEXTURE_2D);
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
diff --git a/content/test/fake_compositor_dependencies.h b/content/test/fake_compositor_dependencies.h
index 9828a0b..770a487b 100644
--- a/content/test/fake_compositor_dependencies.h
+++ b/content/test/fake_compositor_dependencies.h
@@ -27,7 +27,7 @@ class FakeCompositorDependencies : public CompositorDependencies {
   bool IsZeroCopyEnabled() override;
   bool IsOneCopyEnabled() override;
   bool IsElasticOverscrollEnabled() override;
-  uint32 GetImageTextureTarget() override;
+  std::vector<unsigned> GetImageTextureTargets() override;
   scoped_refptr<base::SingleThreadTaskRunner>
   GetCompositorMainThreadTaskRunner() override;
   scoped_refptr<base::SingleThreadTaskRunner>
diff --git a/ui/compositor/compositor.cc b/ui/compositor/compositor.cc
index 015a6ea..b5474a7 100644
--- a/ui/compositor/compositor.cc
+++ b/ui/compositor/compositor.cc
@@ -137,21 +137,18 @@ Compositor::Compositor(gfx::AcceleratedWidget widget,
   settings.use_zero_copy = IsUIZeroCopyEnabled();
   settings.use_one_copy = IsUIOneCopyEnabled();
 
-  // TODO(reveman): We currently assume that the compositor will use BGRA_8888
-  // if it's able to, and RGBA_8888 otherwise. Since we don't know what it will
-  // use we hardcode BGRA_8888 here for now. We should instead
-  // move decisions about GpuMemoryBuffer format to the browser embedder so we
-  // know it here, and pass that decision to the compositor for each usage.
-  // crbug.com/490362
-  gfx::BufferFormat format = gfx::BufferFormat::BGRA_8888;
-
   // Use PERSISTENT_MAP memory buffers to support partial tile raster for
   // software raster into GpuMemoryBuffers.
   gfx::BufferUsage usage = gfx::BufferUsage::PERSISTENT_MAP;
   settings.use_persistent_map_for_gpu_memory_buffers = true;
 
-  settings.use_image_texture_target =
-      context_factory_->GetImageTextureTarget(format, usage);
+  for (size_t format = 0;
+      format < static_cast<size_t>(gfx::BufferFormat::LAST) + 1; format++) {
+    DCHECK_GT(settings.use_image_texture_targets.size(), format);
+    settings.use_image_texture_targets[format] =
+        context_factory_->GetImageTextureTarget(
+            static_cast<gfx::BufferFormat>(format), usage);
+  }
 
   // Note: gathering of pixel refs is only needed when using multiple
   // raster threads.