Allow task pools to reason about transparency.

cc/raster/one_copy_tile_task_worker_pool.cc

 // Copyright 2014 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/raster/one_copy_tile_task_worker_pool.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/strings/stringprintf.h"
@@ skipping 82 matching lines @@
     base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(
         kCheckForQueryResultAvailableTickRateMs));
   }
 
   unsigned result = 0;
   gl->GetQueryObjectuivEXT(query_id, GL_QUERY_RESULT_EXT, &result);
 }
 
 }  // 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);
   DCHECK_EQ(image_id, 0u);
   DCHECK_EQ(query_id, 0u);
 }
 
 void OneCopyTileTaskWorkerPool::StagingBuffer::DestroyGLResources(
     gpu::gles2::GLES2Interface* gl) {
   if (query_id) {
@@ skipping 47 matching lines @@
 }
 
 // static
 scoped_ptr<TileTaskWorkerPool> OneCopyTileTaskWorkerPool::Create(
     base::SequencedTaskRunner* task_runner,
     TaskGraphRunner* task_graph_runner,
     ContextProvider* context_provider,
     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(
     base::SequencedTaskRunner* task_runner,
     TaskGraphRunner* task_graph_runner,
     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()),
       resource_provider_(resource_provider),
       max_bytes_per_copy_operation_(
           max_copy_texture_chromium_size
               ? std::min(kMaxBytesPerCopyOperation,
                          max_copy_texture_chromium_size)
               : kMaxBytesPerCopyOperation),
       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_(
           base::TimeDelta::FromMilliseconds(kStagingBufferExpirationDelayMs)),
       reduce_memory_usage_pending_(false),
       weak_ptr_factory_(this),
       task_set_finished_weak_ptr_factory_(this) {
   base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
       this, base::ThreadTaskRunnerHandle::Get());
   reduce_memory_usage_callback_ =
@@ skipping 111 matching lines @@
        it != completed_tasks_.end(); ++it) {
     TileTask* task = static_cast<TileTask*>(it->get());
 
     task->WillComplete();
     task->CompleteOnOriginThread(this);
     task->DidComplete();
   }
   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(
     const Resource* resource,
     uint64_t resource_content_id,
     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(
     scoped_ptr<RasterBuffer> buffer) {
   // Nothing to do here. RasterBufferImpl destructor cleans up after itself.
 }
 
 void OneCopyTileTaskWorkerPool::PlaybackAndCopyOnWorkerThread(
     const Resource* resource,
     const ResourceProvider::ScopedWriteLockGL* resource_lock,
@@ skipping 10 matching lines @@
       AcquireStagingBuffer(resource, previous_content_id);
   DCHECK(staging_buffer);
 
   {
     base::AutoUnlock unlock(lock_);
 
     // Allocate GpuMemoryBuffer if necessary.
     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);
     }
 
     gfx::Rect playback_rect = raster_full_rect;
     if (use_persistent_gpu_memory_buffers_ && previous_content_id) {
       // Reduce playback rect to dirty region if the content id of the staging
       // buffer matches the prevous content id.
       if (previous_content_id == staging_buffer->content_id)
         playback_rect.Intersect(raster_dirty_rect);
     }
 
     if (staging_buffer->gpu_memory_buffer) {
       void* data = nullptr;
       bool rv = staging_buffer->gpu_memory_buffer->Map(&data);
       DCHECK(rv);
       int stride;
       staging_buffer->gpu_memory_buffer->GetStride(&stride);
       // TileTaskWorkerPool::PlaybackToMemory only supports unsigned strides.
       DCHECK_GE(stride, 0);
 
       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;
     }
   }
 
   ContextProvider* context_provider =
       resource_provider_->output_surface()->worker_context_provider();
   DCHECK(context_provider);
 
   {
     ContextProvider::ScopedContextLock scoped_context(context_provider);
 
     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) {
       gl->GenTextures(1, &staging_buffer->texture_id);
       gl->BindTexture(image_target, staging_buffer->texture_id);
       gl->TexParameteri(image_target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
       gl->TexParameteri(image_target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
       gl->TexParameteri(image_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
       gl->TexParameteri(image_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     } else {
       gl->BindTexture(image_target, staging_buffer->texture_id);
     }
 
     // Create and bind image.
     if (!staging_buffer->image_id) {
       if (staging_buffer->gpu_memory_buffer) {
         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 {
       gl->ReleaseTexImage2DCHROMIUM(image_target, staging_buffer->image_id);
       gl->BindTexImage2DCHROMIUM(image_target, staging_buffer->image_id);
     }
 
     // Unbind staging texture.
     gl->BindTexture(image_target, 0);
 
     if (resource_provider_->use_sync_query()) {
       if (!staging_buffer->query_id)
         gl->GenQueriesEXT(1, &staging_buffer->query_id);
 
 #if defined(OS_CHROMEOS)
       // TODO(reveman): This avoids a performance problem on some ChromeOS
       // devices. This needs to be removed to support native GpuMemoryBuffer
       // implementations. crbug.com/436314
       gl->BeginQueryEXT(GL_COMMANDS_ISSUED_CHROMIUM, staging_buffer->query_id);
 #else
       gl->BeginQueryEXT(GL_COMMANDS_COMPLETED_CHROMIUM,
                         staging_buffer->query_id);
 #endif
     }
 
     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.
     chunk_size_in_rows = MathUtil::UncheckedRoundUp(chunk_size_in_rows, 4);
     int y = 0;
     int height = resource->size().height();
     while (y < height) {
       // Copy at most |chunk_size_in_rows|.
       int rows_to_copy = std::min(chunk_size_in_rows, height - y);
       DCHECK_GT(rows_to_copy, 0);
@@ skipping 31 matching lines @@
 
   ScheduleReduceMemoryUsage();
 }
 
 bool OneCopyTileTaskWorkerPool::OnMemoryDump(
     const base::trace_event::MemoryDumpArgs& args,
     base::trace_event::ProcessMemoryDump* pmd) {
   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());
   }
 
   return true;
 }
 
 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;
 }
 
 void OneCopyTileTaskWorkerPool::RemoveStagingBuffer(
     const StagingBuffer* staging_buffer) {
   lock_.AssertAcquired();
 
   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;
 }
 
 void OneCopyTileTaskWorkerPool::MarkStagingBufferAsFree(
     const StagingBuffer* staging_buffer) {
   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;
 }
 
 void OneCopyTileTaskWorkerPool::MarkStagingBufferAsBusy(
     const StagingBuffer* staging_buffer) {
   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;
 }
 
 scoped_ptr<OneCopyTileTaskWorkerPool::StagingBuffer>
 OneCopyTileTaskWorkerPool::AcquireStagingBuffer(const Resource* resource,
                                                 uint64_t previous_content_id) {
   lock_.AssertAcquired();
 
   scoped_ptr<StagingBuffer> staging_buffer;
@@ skipping 47 matching lines @@
         std::find_if(free_buffers_.begin(), free_buffers_.end(),
                      [previous_content_id](const StagingBuffer* buffer) {
                        return buffer->content_id == previous_content_id;
                      });
     if (it != free_buffers_.end()) {
       staging_buffer = free_buffers_.take(it);
       MarkStagingBufferAsBusy(staging_buffer.get());
     }
   }
 
-  // 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);
       MarkStagingBufferAsBusy(staging_buffer.get());
     }
   }
 
   // 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.
   while (staging_buffer_usage_in_bytes_ > max_staging_buffer_usage_in_bytes_) {
     if (free_buffers_.empty())
       break;
 
     free_buffers_.front()->DestroyGLResources(gl);
     MarkStagingBufferAsBusy(free_buffers_.front());
     RemoveStagingBuffer(free_buffers_.front());
@@ skipping 130 matching lines @@
 
   staging_state->SetInteger("staging_buffer_count",
                             static_cast<int>(buffers_.size()));
   staging_state->SetInteger("busy_count",
                             static_cast<int>(busy_buffers_.size()));
   staging_state->SetInteger("free_count",
                             static_cast<int>(free_buffers_.size()));
 }
 
 }  // namespace cc