Allow task pools to reason about transparency.

This will allow task pools to select different formats depending on if a tile contains transparency or not.

BUG=434699
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

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

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

11 files changed, 108 insertions, 82 deletions

diff --git a/cc/raster/bitmap_tile_task_worker_pool.cc b/cc/raster/bitmap_tile_task_worker_pool.cc
index 8c6513b..034ad0f 100644
--- a/cc/raster/bitmap_tile_task_worker_pool.cc
+++ b/cc/raster/bitmap_tile_task_worker_pool.cc
@@ -179,12 +179,15 @@ void BitmapTileTaskWorkerPool::CheckForCompletedTasks() {
   completed_tasks_.clear();
 }
 
-ResourceFormat BitmapTileTaskWorkerPool::GetResourceFormat() const {
+ResourceFormat BitmapTileTaskWorkerPool::GetResourceFormat(
+    bool must_support_alpha) const {
   return resource_provider_->best_texture_format();
 }
 
-bool BitmapTileTaskWorkerPool::GetResourceRequiresSwizzle() const {
-  return !PlatformColor::SameComponentOrder(GetResourceFormat());
+bool BitmapTileTaskWorkerPool::GetResourceRequiresSwizzle(
+    bool must_support_alpha) const {
+  return !PlatformColor::SameComponentOrder(
+      GetResourceFormat(must_support_alpha));
 }
 
 scoped_ptr<RasterBuffer> BitmapTileTaskWorkerPool::AcquireBufferForRaster(
diff --git a/cc/raster/bitmap_tile_task_worker_pool.h b/cc/raster/bitmap_tile_task_worker_pool.h
index 3df206a..fe9c4e8 100644
--- a/cc/raster/bitmap_tile_task_worker_pool.h
+++ b/cc/raster/bitmap_tile_task_worker_pool.h
@@ -38,8 +38,8 @@ class CC_EXPORT BitmapTileTaskWorkerPool : public TileTaskWorkerPool,
   void Shutdown() override;
   void ScheduleTasks(TileTaskQueue* queue) override;
   void CheckForCompletedTasks() override;
-  ResourceFormat GetResourceFormat() const override;
-  bool GetResourceRequiresSwizzle() const override;
+  ResourceFormat GetResourceFormat(bool must_support_alpha) const override;
+  bool GetResourceRequiresSwizzle(bool must_support_alpha) const override;
 
   // Overridden from TileTaskClient:
   scoped_ptr<RasterBuffer> AcquireBufferForRaster(
diff --git a/cc/raster/gpu_tile_task_worker_pool.cc b/cc/raster/gpu_tile_task_worker_pool.cc
index 0f3d607..e8dc102 100644
--- a/cc/raster/gpu_tile_task_worker_pool.cc
+++ b/cc/raster/gpu_tile_task_worker_pool.cc
@@ -201,11 +201,13 @@ void GpuTileTaskWorkerPool::CheckForCompletedTasks() {
   completed_tasks_.clear();
 }
 
-ResourceFormat GpuTileTaskWorkerPool::GetResourceFormat() const {
+ResourceFormat GpuTileTaskWorkerPool::GetResourceFormat(
+    bool must_support_alpha) const {
   return rasterizer_->resource_provider()->best_render_buffer_format();
 }
 
-bool GpuTileTaskWorkerPool::GetResourceRequiresSwizzle() const {
+bool GpuTileTaskWorkerPool::GetResourceRequiresSwizzle(
+    bool must_support_alpha) const {
   // This doesn't require a swizzle because we rasterize to the correct format.
   return false;
 }
diff --git a/cc/raster/gpu_tile_task_worker_pool.h b/cc/raster/gpu_tile_task_worker_pool.h
index 32a9d23..f9ab24c 100644
--- a/cc/raster/gpu_tile_task_worker_pool.h
+++ b/cc/raster/gpu_tile_task_worker_pool.h
@@ -36,8 +36,8 @@ class CC_EXPORT GpuTileTaskWorkerPool : public TileTaskWorkerPool,
   void Shutdown() override;
   void ScheduleTasks(TileTaskQueue* queue) override;
   void CheckForCompletedTasks() override;
-  ResourceFormat GetResourceFormat() const override;
-  bool GetResourceRequiresSwizzle() const override;
+  ResourceFormat GetResourceFormat(bool must_support_alpha) const override;
+  bool GetResourceRequiresSwizzle(bool must_support_alpha) const override;
 
   // Overridden from TileTaskClient:
   scoped_ptr<RasterBuffer> AcquireBufferForRaster(
diff --git a/cc/raster/one_copy_tile_task_worker_pool.cc b/cc/raster/one_copy_tile_task_worker_pool.cc
index c5518e3..86a0561 100644
--- a/cc/raster/one_copy_tile_task_worker_pool.cc
+++ b/cc/raster/one_copy_tile_task_worker_pool.cc
@@ -100,8 +100,14 @@ void WaitForQueryResult(gpu::gles2::GLES2Interface* gl, unsigned query_id) {
 
 }  // namespace
 
-OneCopyTileTaskWorkerPool::StagingBuffer::StagingBuffer(const gfx::Size& size)
-    : size(size), texture_id(0), image_id(0), query_id(0), content_id(0) {}
+OneCopyTileTaskWorkerPool::StagingBuffer::StagingBuffer(const gfx::Size& size,
+                                                        ResourceFormat format)
+    : size(size),
+      format(format),
+      texture_id(0),
+      image_id(0),
+      query_id(0),
+      content_id(0) {}
 
 OneCopyTileTaskWorkerPool::StagingBuffer::~StagingBuffer() {
   DCHECK_EQ(texture_id, 0u);
@@ -169,11 +175,12 @@ scoped_ptr<TileTaskWorkerPool> OneCopyTileTaskWorkerPool::Create(
     ResourceProvider* resource_provider,
     int max_copy_texture_chromium_size,
     bool use_persistent_gpu_memory_buffers,
-    int max_staging_buffer_usage_in_bytes) {
+    int max_staging_buffer_usage_in_bytes,
+    bool use_rgba_4444_texture_format) {
   return make_scoped_ptr<TileTaskWorkerPool>(new OneCopyTileTaskWorkerPool(
       task_runner, task_graph_runner, resource_provider,
       max_copy_texture_chromium_size, use_persistent_gpu_memory_buffers,
-      max_staging_buffer_usage_in_bytes));
+      max_staging_buffer_usage_in_bytes, use_rgba_4444_texture_format));
 }
 
 OneCopyTileTaskWorkerPool::OneCopyTileTaskWorkerPool(
@@ -182,7 +189,8 @@ OneCopyTileTaskWorkerPool::OneCopyTileTaskWorkerPool(
     ResourceProvider* resource_provider,
     int max_copy_texture_chromium_size,
     bool use_persistent_gpu_memory_buffers,
-    int max_staging_buffer_usage_in_bytes)
+    int max_staging_buffer_usage_in_bytes,
+    bool use_rgba_4444_texture_format)
     : task_runner_(task_runner),
       task_graph_runner_(task_graph_runner),
       namespace_token_(task_graph_runner->GetNamespaceToken()),
@@ -195,6 +203,7 @@ OneCopyTileTaskWorkerPool::OneCopyTileTaskWorkerPool(
       use_persistent_gpu_memory_buffers_(use_persistent_gpu_memory_buffers),
       bytes_scheduled_since_last_flush_(0),
       max_staging_buffer_usage_in_bytes_(max_staging_buffer_usage_in_bytes),
+      use_rgba_4444_texture_format_(use_rgba_4444_texture_format),
       staging_buffer_usage_in_bytes_(0),
       free_staging_buffer_usage_in_bytes_(0),
       staging_buffer_expiration_delay_(
@@ -326,12 +335,17 @@ void OneCopyTileTaskWorkerPool::CheckForCompletedTasks() {
   completed_tasks_.clear();
 }
 
-ResourceFormat OneCopyTileTaskWorkerPool::GetResourceFormat() const {
-  return resource_provider_->memory_efficient_texture_format();
+ResourceFormat OneCopyTileTaskWorkerPool::GetResourceFormat(
+    bool must_support_alpha) const {
+  return use_rgba_4444_texture_format_
+             ? RGBA_4444
+             : resource_provider_->best_texture_format();
 }
 
-bool OneCopyTileTaskWorkerPool::GetResourceRequiresSwizzle() const {
-  return !PlatformColor::SameComponentOrder(GetResourceFormat());
+bool OneCopyTileTaskWorkerPool::GetResourceRequiresSwizzle(
+    bool must_support_alpha) const {
+  return !PlatformColor::SameComponentOrder(
+      GetResourceFormat(must_support_alpha));
 }
 
 scoped_ptr<RasterBuffer> OneCopyTileTaskWorkerPool::AcquireBufferForRaster(
@@ -340,12 +354,9 @@ scoped_ptr<RasterBuffer> OneCopyTileTaskWorkerPool::AcquireBufferForRaster(
     uint64_t previous_content_id) {
   // TODO(danakj): If resource_content_id != 0, we only need to copy/upload
   // the dirty rect.
-  DCHECK_EQ(resource->format(),
-            resource_provider_->memory_efficient_texture_format());
-  return make_scoped_ptr<RasterBuffer>(new RasterBufferImpl(
-      this, resource_provider_,
-      resource_provider_->memory_efficient_texture_format(), resource,
-      previous_content_id));
+  return make_scoped_ptr<RasterBuffer>(
+      new RasterBufferImpl(this, resource_provider_, resource->format(),
+                           resource, previous_content_id));
 }
 
 void OneCopyTileTaskWorkerPool::ReleaseBufferForRaster(
@@ -376,13 +387,11 @@ void OneCopyTileTaskWorkerPool::PlaybackAndCopyOnWorkerThread(
     if (!staging_buffer->gpu_memory_buffer) {
       staging_buffer->gpu_memory_buffer =
           resource_provider_->gpu_memory_buffer_manager()
-              ->AllocateGpuMemoryBuffer(
-                  staging_buffer->size,
-                  BufferFormat(
-                      resource_provider_->memory_efficient_texture_format()),
-                  use_persistent_gpu_memory_buffers_
-                      ? gfx::BufferUsage::PERSISTENT_MAP
-                      : gfx::BufferUsage::MAP);
+              ->AllocateGpuMemoryBuffer(staging_buffer->size,
+                                        BufferFormat(resource->format()),
+                                        use_persistent_gpu_memory_buffers_
+                                            ? gfx::BufferUsage::PERSISTENT_MAP
+                                            : gfx::BufferUsage::MAP);
       DCHECK_EQ(gfx::NumberOfPlanesForBufferFormat(
                     staging_buffer->gpu_memory_buffer->GetFormat()),
                 1u);
@@ -408,9 +417,9 @@ void OneCopyTileTaskWorkerPool::PlaybackAndCopyOnWorkerThread(
       DCHECK(!playback_rect.IsEmpty())
           << "Why are we rastering a tile that's not dirty?";
       TileTaskWorkerPool::PlaybackToMemory(
-          data, resource_provider_->memory_efficient_texture_format(),
-          staging_buffer->size, static_cast<size_t>(stride), raster_source,
-          raster_full_rect, playback_rect, scale, include_images);
+          data, resource->format(), staging_buffer->size,
+          static_cast<size_t>(stride), raster_source, raster_full_rect,
+          playback_rect, scale, include_images);
       staging_buffer->gpu_memory_buffer->Unmap();
       staging_buffer->content_id = new_content_id;
     }
@@ -426,8 +435,8 @@ void OneCopyTileTaskWorkerPool::PlaybackAndCopyOnWorkerThread(
     gpu::gles2::GLES2Interface* gl = scoped_context.ContextGL();
     DCHECK(gl);
 
-    unsigned image_target = resource_provider_->GetImageTextureTarget(
-        resource_provider_->memory_efficient_texture_format());
+    unsigned image_target =
+        resource_provider_->GetImageTextureTarget(resource->format());
 
     // Create and bind staging texture.
     if (!staging_buffer->texture_id) {
@@ -447,8 +456,7 @@ void OneCopyTileTaskWorkerPool::PlaybackAndCopyOnWorkerThread(
         staging_buffer->image_id = gl->CreateImageCHROMIUM(
             staging_buffer->gpu_memory_buffer->AsClientBuffer(),
             staging_buffer->size.width(), staging_buffer->size.height(),
-            GLInternalFormat(
-                resource_provider_->memory_efficient_texture_format()));
+            GLInternalFormat(resource->format()));
         gl->BindTexImage2DCHROMIUM(image_target, staging_buffer->image_id);
       }
     } else {
@@ -475,9 +483,7 @@ void OneCopyTileTaskWorkerPool::PlaybackAndCopyOnWorkerThread(
     }
 
     int bytes_per_row =
-        (BitsPerPixel(resource_provider_->memory_efficient_texture_format()) *
-         resource->size().width()) /
-        8;
+        (BitsPerPixel(resource->format()) * resource->size().width()) / 8;
     int chunk_size_in_rows =
         std::max(1, max_bytes_per_copy_operation_ / bytes_per_row);
     // Align chunk size to 4. Required to support compressed texture formats.
@@ -529,8 +535,7 @@ bool OneCopyTileTaskWorkerPool::OnMemoryDump(
   base::AutoLock lock(lock_);
 
   for (const auto& buffer : buffers_) {
-    buffer->OnMemoryDump(pmd,
-                         resource_provider_->memory_efficient_texture_format(),
+    buffer->OnMemoryDump(pmd, buffer->format,
                          std::find(free_buffers_.begin(), free_buffers_.end(),
                                    buffer) != free_buffers_.end());
   }
@@ -539,14 +544,14 @@ bool OneCopyTileTaskWorkerPool::OnMemoryDump(
 }
 
 void OneCopyTileTaskWorkerPool::AddStagingBuffer(
-    const StagingBuffer* staging_buffer) {
+    const StagingBuffer* staging_buffer,
+    ResourceFormat format) {
   lock_.AssertAcquired();
 
   DCHECK(buffers_.find(staging_buffer) == buffers_.end());
   buffers_.insert(staging_buffer);
-  int buffer_usage_in_bytes = ResourceUtil::UncheckedSizeInBytes<int>(
-      staging_buffer->size,
-      resource_provider_->memory_efficient_texture_format());
+  int buffer_usage_in_bytes =
+      ResourceUtil::UncheckedSizeInBytes<int>(staging_buffer->size, format);
   staging_buffer_usage_in_bytes_ += buffer_usage_in_bytes;
 }
 
@@ -557,8 +562,7 @@ void OneCopyTileTaskWorkerPool::RemoveStagingBuffer(
   DCHECK(buffers_.find(staging_buffer) != buffers_.end());
   buffers_.erase(staging_buffer);
   int buffer_usage_in_bytes = ResourceUtil::UncheckedSizeInBytes<int>(
-      staging_buffer->size,
-      resource_provider_->memory_efficient_texture_format());
+      staging_buffer->size, staging_buffer->format);
   DCHECK_GE(staging_buffer_usage_in_bytes_, buffer_usage_in_bytes);
   staging_buffer_usage_in_bytes_ -= buffer_usage_in_bytes;
 }
@@ -568,8 +572,7 @@ void OneCopyTileTaskWorkerPool::MarkStagingBufferAsFree(
   lock_.AssertAcquired();
 
   int buffer_usage_in_bytes = ResourceUtil::UncheckedSizeInBytes<int>(
-      staging_buffer->size,
-      resource_provider_->memory_efficient_texture_format());
+      staging_buffer->size, staging_buffer->format);
   free_staging_buffer_usage_in_bytes_ += buffer_usage_in_bytes;
 }
 
@@ -578,8 +581,7 @@ void OneCopyTileTaskWorkerPool::MarkStagingBufferAsBusy(
   lock_.AssertAcquired();
 
   int buffer_usage_in_bytes = ResourceUtil::UncheckedSizeInBytes<int>(
-      staging_buffer->size,
-      resource_provider_->memory_efficient_texture_format());
+      staging_buffer->size, staging_buffer->format);
   DCHECK_GE(free_staging_buffer_usage_in_bytes_, buffer_usage_in_bytes);
   free_staging_buffer_usage_in_bytes_ -= buffer_usage_in_bytes;
 }
@@ -647,12 +649,13 @@ OneCopyTileTaskWorkerPool::AcquireStagingBuffer(const Resource* resource,
     }
   }
 
-  // Find staging buffer of correct size.
+  // Find staging buffer of correct size and format.
   if (!staging_buffer) {
     StagingBufferDeque::iterator it =
         std::find_if(free_buffers_.begin(), free_buffers_.end(),
                      [resource](const StagingBuffer* buffer) {
-                       return buffer->size == resource->size();
+                       return buffer->size == resource->size() &&
+                              buffer->format == resource->format();
                      });
     if (it != free_buffers_.end()) {
       staging_buffer = free_buffers_.take(it);
@@ -662,8 +665,9 @@ OneCopyTileTaskWorkerPool::AcquireStagingBuffer(const Resource* resource,
 
   // Create new staging buffer if necessary.
   if (!staging_buffer) {
-    staging_buffer = make_scoped_ptr(new StagingBuffer(resource->size()));
-    AddStagingBuffer(staging_buffer.get());
+    staging_buffer = make_scoped_ptr(
+        new StagingBuffer(resource->size(), resource->format()));
+    AddStagingBuffer(staging_buffer.get(), resource->format());
   }
 
   // Release enough free buffers to stay within the limit.
diff --git a/cc/raster/one_copy_tile_task_worker_pool.h b/cc/raster/one_copy_tile_task_worker_pool.h
index 783d103..3b02bae 100644
--- a/cc/raster/one_copy_tile_task_worker_pool.h
+++ b/cc/raster/one_copy_tile_task_worker_pool.h
@@ -49,7 +49,8 @@ class CC_EXPORT OneCopyTileTaskWorkerPool
       ResourceProvider* resource_provider,
       int max_copy_texture_chromium_size,
       bool use_persistent_gpu_memory_buffers,
-      int max_staging_buffer_usage_in_bytes);
+      int max_staging_buffer_usage_in_bytes,
+      bool use_rgba_4444_texture_format);
 
   // Overridden from TileTaskWorkerPool:
   TileTaskRunner* AsTileTaskRunner() override;
@@ -59,8 +60,8 @@ class CC_EXPORT OneCopyTileTaskWorkerPool
   void Shutdown() override;
   void ScheduleTasks(TileTaskQueue* queue) override;
   void CheckForCompletedTasks() override;
-  ResourceFormat GetResourceFormat() const override;
-  bool GetResourceRequiresSwizzle() const override;
+  ResourceFormat GetResourceFormat(bool must_support_alpha) const override;
+  bool GetResourceRequiresSwizzle(bool must_support_alpha) const override;
 
   // Overridden from TileTaskClient:
   scoped_ptr<RasterBuffer> AcquireBufferForRaster(
@@ -91,11 +92,12 @@ class CC_EXPORT OneCopyTileTaskWorkerPool
                             ResourceProvider* resource_provider,
                             int max_copy_texture_chromium_size,
                             bool use_persistent_gpu_memory_buffers,
-                            int max_staging_buffer_usage_in_bytes);
+                            int max_staging_buffer_usage_in_bytes,
+                            bool use_rgba_4444_texture_format);
 
  private:
   struct StagingBuffer {
-    explicit StagingBuffer(const gfx::Size& size);
+    StagingBuffer(const gfx::Size& size, ResourceFormat format);
     ~StagingBuffer();
 
     void DestroyGLResources(gpu::gles2::GLES2Interface* gl);
@@ -104,6 +106,7 @@ class CC_EXPORT OneCopyTileTaskWorkerPool
                       bool is_free) const;
 
     const gfx::Size size;
+    const ResourceFormat format;
     scoped_ptr<gfx::GpuMemoryBuffer> gpu_memory_buffer;
     base::TimeTicks last_usage;
     unsigned texture_id;
@@ -112,7 +115,8 @@ class CC_EXPORT OneCopyTileTaskWorkerPool
     uint64_t content_id;
   };
 
-  void AddStagingBuffer(const StagingBuffer* staging_buffer);
+  void AddStagingBuffer(const StagingBuffer* staging_buffer,
+                        ResourceFormat format);
   void RemoveStagingBuffer(const StagingBuffer* staging_buffer);
   void MarkStagingBufferAsFree(const StagingBuffer* staging_buffer);
   void MarkStagingBufferAsBusy(const StagingBuffer* staging_buffer);
@@ -153,6 +157,7 @@ class CC_EXPORT OneCopyTileTaskWorkerPool
   StagingBufferDeque busy_buffers_;
   int bytes_scheduled_since_last_flush_;
   const int max_staging_buffer_usage_in_bytes_;
+  bool use_rgba_4444_texture_format_;
   int staging_buffer_usage_in_bytes_;
   int free_staging_buffer_usage_in_bytes_;
   const base::TimeDelta staging_buffer_expiration_delay_;
diff --git a/cc/raster/tile_task_runner.h b/cc/raster/tile_task_runner.h
index 64c72f0..103da1f 100644
--- a/cc/raster/tile_task_runner.h
+++ b/cc/raster/tile_task_runner.h
@@ -149,10 +149,10 @@ class CC_EXPORT TileTaskRunner {
   virtual void CheckForCompletedTasks() = 0;
 
   // Returns the format to use for the tiles.
-  virtual ResourceFormat GetResourceFormat() const = 0;
+  virtual ResourceFormat GetResourceFormat(bool must_support_alpha) const = 0;
 
   // Determine if the resource requires swizzling.
-  virtual bool GetResourceRequiresSwizzle() const = 0;
+  virtual bool GetResourceRequiresSwizzle(bool must_support_alpha) const = 0;
 
  protected:
   virtual ~TileTaskRunner() {}
diff --git a/cc/raster/tile_task_worker_pool_perftest.cc b/cc/raster/tile_task_worker_pool_perftest.cc
index 12b7464..2605064 100644
--- a/cc/raster/tile_task_worker_pool_perftest.cc
+++ b/cc/raster/tile_task_worker_pool_perftest.cc
@@ -251,7 +251,7 @@ class TileTaskWorkerPoolPerfTest
         Create3dOutputSurfaceAndResourceProvider();
         tile_task_worker_pool_ = ZeroCopyTileTaskWorkerPool::Create(
             task_runner_.get(), task_graph_runner_.get(),
-            resource_provider_.get());
+            resource_provider_.get(), false);
         break;
       case TILE_TASK_WORKER_POOL_TYPE_ONE_COPY:
         Create3dOutputSurfaceAndResourceProvider();
@@ -259,7 +259,7 @@ class TileTaskWorkerPoolPerfTest
             task_runner_.get(), task_graph_runner_.get(),
             context_provider_.get(), resource_provider_.get(),
             std::numeric_limits<int>::max(), false,
-            std::numeric_limits<int>::max());
+            std::numeric_limits<int>::max(), false);
         break;
       case TILE_TASK_WORKER_POOL_TYPE_GPU:
         Create3dOutputSurfaceAndResourceProvider();
diff --git a/cc/raster/tile_task_worker_pool_unittest.cc b/cc/raster/tile_task_worker_pool_unittest.cc
index 6e40e49..515035b 100644
--- a/cc/raster/tile_task_worker_pool_unittest.cc
+++ b/cc/raster/tile_task_worker_pool_unittest.cc
@@ -144,14 +144,14 @@ class TileTaskWorkerPoolTest
         Create3dOutputSurfaceAndResourceProvider();
         tile_task_worker_pool_ = ZeroCopyTileTaskWorkerPool::Create(
             base::ThreadTaskRunnerHandle::Get().get(), &task_graph_runner_,
-            resource_provider_.get());
+            resource_provider_.get(), false);
         break;
       case TILE_TASK_WORKER_POOL_TYPE_ONE_COPY:
         Create3dOutputSurfaceAndResourceProvider();
         tile_task_worker_pool_ = OneCopyTileTaskWorkerPool::Create(
             base::ThreadTaskRunnerHandle::Get().get(), &task_graph_runner_,
             context_provider_.get(), resource_provider_.get(),
-            kMaxBytesPerCopyOperation, false, kMaxStagingBuffers);
+            kMaxBytesPerCopyOperation, false, kMaxStagingBuffers, false);
         break;
       case TILE_TASK_WORKER_POOL_TYPE_GPU:
         Create3dOutputSurfaceAndResourceProvider();
diff --git a/cc/raster/zero_copy_tile_task_worker_pool.cc b/cc/raster/zero_copy_tile_task_worker_pool.cc
index 2e3dca14..0a6e80e 100644
--- a/cc/raster/zero_copy_tile_task_worker_pool.cc
+++ b/cc/raster/zero_copy_tile_task_worker_pool.cc
@@ -65,21 +65,24 @@ class RasterBufferImpl : public RasterBuffer {
 scoped_ptr<TileTaskWorkerPool> ZeroCopyTileTaskWorkerPool::Create(
     base::SequencedTaskRunner* task_runner,
     TaskGraphRunner* task_graph_runner,
-    ResourceProvider* resource_provider) {
+    ResourceProvider* resource_provider,
+    bool use_rgba_4444_texture_format) {
   return make_scoped_ptr<TileTaskWorkerPool>(new ZeroCopyTileTaskWorkerPool(
-      task_runner, task_graph_runner, resource_provider));
+      task_runner, task_graph_runner, resource_provider,
+      use_rgba_4444_texture_format));
 }
 
 ZeroCopyTileTaskWorkerPool::ZeroCopyTileTaskWorkerPool(
     base::SequencedTaskRunner* task_runner,
     TaskGraphRunner* task_graph_runner,
-    ResourceProvider* resource_provider)
+    ResourceProvider* resource_provider,
+    bool use_rgba_4444_texture_format)
     : task_runner_(task_runner),
       task_graph_runner_(task_graph_runner),
       namespace_token_(task_graph_runner->GetNamespaceToken()),
       resource_provider_(resource_provider),
-      task_set_finished_weak_ptr_factory_(this) {
-}
+      use_rgba_4444_texture_format_(use_rgba_4444_texture_format),
+      task_set_finished_weak_ptr_factory_(this) {}
 
 ZeroCopyTileTaskWorkerPool::~ZeroCopyTileTaskWorkerPool() {
 }
@@ -179,12 +182,17 @@ void ZeroCopyTileTaskWorkerPool::CheckForCompletedTasks() {
   completed_tasks_.clear();
 }
 
-ResourceFormat ZeroCopyTileTaskWorkerPool::GetResourceFormat() const {
-  return resource_provider_->memory_efficient_texture_format();
+ResourceFormat ZeroCopyTileTaskWorkerPool::GetResourceFormat(
+    bool must_support_alpha) const {
+  return use_rgba_4444_texture_format_
+             ? RGBA_4444
+             : resource_provider_->best_texture_format();
 }
 
-bool ZeroCopyTileTaskWorkerPool::GetResourceRequiresSwizzle() const {
-  return !PlatformColor::SameComponentOrder(GetResourceFormat());
+bool ZeroCopyTileTaskWorkerPool::GetResourceRequiresSwizzle(
+    bool must_support_alpha) const {
+  return !PlatformColor::SameComponentOrder(
+      GetResourceFormat(must_support_alpha));
 }
 
 scoped_ptr<RasterBuffer> ZeroCopyTileTaskWorkerPool::AcquireBufferForRaster(
diff --git a/cc/raster/zero_copy_tile_task_worker_pool.h b/cc/raster/zero_copy_tile_task_worker_pool.h
index 7dcdff0a..b101559 100644
--- a/cc/raster/zero_copy_tile_task_worker_pool.h
+++ b/cc/raster/zero_copy_tile_task_worker_pool.h
@@ -28,7 +28,8 @@ class CC_EXPORT ZeroCopyTileTaskWorkerPool : public TileTaskWorkerPool,
   static scoped_ptr<TileTaskWorkerPool> Create(
       base::SequencedTaskRunner* task_runner,
       TaskGraphRunner* task_graph_runner,
-      ResourceProvider* resource_provider);
+      ResourceProvider* resource_provider,
+      bool use_rgba_4444_texture_format);
 
   // Overridden from TileTaskWorkerPool:
   TileTaskRunner* AsTileTaskRunner() override;
@@ -38,8 +39,8 @@ class CC_EXPORT ZeroCopyTileTaskWorkerPool : public TileTaskWorkerPool,
   void Shutdown() override;
   void ScheduleTasks(TileTaskQueue* queue) override;
   void CheckForCompletedTasks() override;
-  ResourceFormat GetResourceFormat() const override;
-  bool GetResourceRequiresSwizzle() const override;
+  ResourceFormat GetResourceFormat(bool must_support_alpha) const override;
+  bool GetResourceRequiresSwizzle(bool must_support_alpha) const override;
 
   // Overridden from TileTaskClient:
   scoped_ptr<RasterBuffer> AcquireBufferForRaster(
@@ -51,7 +52,8 @@ class CC_EXPORT ZeroCopyTileTaskWorkerPool : public TileTaskWorkerPool,
  protected:
   ZeroCopyTileTaskWorkerPool(base::SequencedTaskRunner* task_runner,
                              TaskGraphRunner* task_graph_runner,
-                             ResourceProvider* resource_provider);
+                             ResourceProvider* resource_provider,
+                             bool use_rgba_4444_texture_format);
 
  private:
   void OnTaskSetFinished(TaskSet task_set);
@@ -64,6 +66,8 @@ class CC_EXPORT ZeroCopyTileTaskWorkerPool : public TileTaskWorkerPool,
   TileTaskRunnerClient* client_;
   ResourceProvider* resource_provider_;
 
+  bool use_rgba_4444_texture_format_;
+
   TaskSetCollection tasks_pending_;
 
   scoped_refptr<TileTask> task_set_finished_tasks_[kNumberOfTaskSets];