Allow one-copy task tile worker pool to use compressed textures.

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 158 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,
-    bool use_rgba_4444_texture_format) {
+    bool use_rgba_4444_texture_format,
+    bool use_compressed_texture_formats) {
   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, use_rgba_4444_texture_format));
+      max_staging_buffer_usage_in_bytes, use_rgba_4444_texture_format,
+      use_compressed_texture_formats));
 }
 
 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,
-    bool use_rgba_4444_texture_format)
+    bool use_rgba_4444_texture_format,
+    bool use_compressed_texture_formats)
     : 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),
+      use_compressed_texture_formats_(use_compressed_texture_formats),
       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 113 matching lines @@
 
     task->WillComplete();
     task->CompleteOnOriginThread(this);
     task->DidComplete();
   }
   completed_tasks_.clear();
 }
 
 ResourceFormat OneCopyTileTaskWorkerPool::GetResourceFormat(
     bool must_support_alpha) const {
+  if (use_compressed_texture_formats_ && !must_support_alpha)
+    return ETC1;

[reveman, 2015/09/30 09:55:15]

Can we include zero-copy support in this patch too?

[christiank, 2015/11/26 15:35:35]

Sure!

+
   return use_rgba_4444_texture_format_
              ? RGBA_4444
              : resource_provider_->best_texture_format();
 }
 
 bool OneCopyTileTaskWorkerPool::GetResourceRequiresSwizzle(
     bool must_support_alpha) const {
   return !PlatformColor::SameComponentOrder(
       GetResourceFormat(must_support_alpha));
 }
@@ skipping 138 matching lines @@
         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);
 
-      gl->CopySubTextureCHROMIUM(GL_TEXTURE_2D, staging_buffer->texture_id,
-                                 resource_lock->texture_id(), 0, y, 0, y,
-                                 resource->size().width(), rows_to_copy, false,
-                                 false, false);
+      if (IsResourceFormatCompressed(resource->format())) {
+        // TODO(christiank): Should use CompressedCopySubTextureCHROMIUM.

[christiank, 2015/09/30 07:49:42]

reveman (cited from 1197423003):
"Let's fix this TODO before landing this patch."

As we discussed in another issue it's not possible to preallocate compressed
textures using glCompressedTexImage2D without specifying a valid data pointer
(see ResourceProvider::LazyAllocate). As a walk around you suggested that we
could call CompressedCopyTextureCHROMIUM for the first copy as it doesn't
require the texture to be defined. I am unsure on how to check if a texture is
defined, do you have any ideas? Or is there another better approach to make sure
CompressedCopyTextureCHROMIUM is used only for the first copy?

[reveman, 2015/09/30 09:55:15]

ResourceProvider::LazyAllocate seem wrong. If it can't allocate storage then it
shouldn't set Resource::allocated to true. If we fix that, then we can detect if
storage for the resource has been allocated here (independent of format) and
force a full size copy when that's not the case. I think it would be best to do
this by making the whole "while (y < height)" loop conditional on if storage for
the texture has been allocated or not.

[christiank, 2015/11/26 15:35:35]

Actually these are two different Resource classes. There is the
cc::ResourceProvider::Resource which has the allocated member, but the Resource
object here is cc::Resource.

However, cc::ResourceProvider::Resource can be accessed through
ScopedWriteLockGL. I have added accessors to that class, but it doesn't feel
quite right to me though. What do you think?

[reveman, 2015/11/27 16:46:49]

Ok, I think it's fine to make the use of SubCopy conditional on if the format is
compressed or not but it shouldn't be inside this loop that is performing
SubCopy calls. Can you just move the compressed format check outside this loop?

[christiank, 2015/11/30 15:41:08]

Ahh good, that'll be better. Fixed now.

+        gl->CompressedCopyTextureCHROMIUM(GL_TEXTURE_2D,
+                                          staging_buffer->texture_id,
+                                          resource_lock->texture_id());
+      } else {
+        gl->CopySubTextureCHROMIUM(GL_TEXTURE_2D, staging_buffer->texture_id,
+                                   resource_lock->texture_id(), 0, y, 0, y,
+                                   resource->size().width(), rows_to_copy,
+                                   false, false, false);
+      }
       y += rows_to_copy;
 
       // Increment |bytes_scheduled_since_last_flush_| by the amount of memory
       // used for this copy operation.
       bytes_scheduled_since_last_flush_ += rows_to_copy * bytes_per_row;
 
       if (bytes_scheduled_since_last_flush_ >= max_bytes_per_copy_operation_) {
         gl->ShallowFlushCHROMIUM();
         bytes_scheduled_since_last_flush_ = 0;
       }
@@ skipping 299 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