Remaining code for basic tile compression functionality.

cc/resources/resource_provider.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/resources/resource_provider.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/containers/hash_tables.h"
@@ skipping 103 matching lines @@
 }
 
 gfx::GpuMemoryBuffer::Format ToGpuMemoryBufferFormat(ResourceFormat format) {
   switch (format) {
     case RGBA_8888:
       return gfx::GpuMemoryBuffer::RGBA_8888;
     case BGRA_8888:
       return gfx::GpuMemoryBuffer::BGRA_8888;
     case RGBA_4444:
       return gfx::GpuMemoryBuffer::RGBA_4444;
+    case ETC1:
+      return gfx::GpuMemoryBuffer::ETC1;
     case ALPHA_8:
     case LUMINANCE_8:
     case RGB_565:
-    case ETC1:
     case RED_8:
       break;
   }
   NOTREACHED();
   return gfx::GpuMemoryBuffer::RGBA_8888;
 }
 
 class ScopedSetActiveTexture {
  public:
   ScopedSetActiveTexture(GLES2Interface* gl, GLenum unit)
@@ skipping 247 matching lines @@
 
 ResourceProvider::Child::~Child() {}
 
 scoped_ptr<ResourceProvider> ResourceProvider::Create(
     OutputSurface* output_surface,
     SharedBitmapManager* shared_bitmap_manager,
     gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
     BlockingTaskRunner* blocking_main_thread_task_runner,
     int highp_threshold_min,
     bool use_rgba_4444_texture_format,
+    bool use_tile_compression,
     size_t id_allocation_chunk_size,
     bool use_persistent_map_for_gpu_memory_buffers) {
   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_rgba_4444_texture_format, use_tile_compression,
+      id_allocation_chunk_size, use_persistent_map_for_gpu_memory_buffers));
   resource_provider->Initialize();
   return resource_provider;
 }
 
 ResourceProvider::~ResourceProvider() {
   while (!children_.empty())
     DestroyChildInternal(children_.begin(), FOR_SHUTDOWN);
   while (!resources_.empty())
     DeleteResourceInternal(resources_.begin(), FOR_SHUTDOWN);
 
@@ skipping 11 matching lines @@
        itr != resources_.end(); ++itr) {
     DCHECK_NE(RESOURCE_TYPE_GL_TEXTURE, itr->second.type);
   }
 #endif  // DCHECK_IS_ON()
 
   texture_id_allocator_ = nullptr;
   buffer_id_allocator_ = nullptr;
   gl->Finish();
 }
 
+ResourceFormat ResourceProvider::memory_efficient_texture_format(
+    bool must_be_noncompressed,
+    bool must_support_alpha) const {
+  if (use_tile_compression_ && !must_be_noncompressed && !must_support_alpha)
+    return ETC1;
+
+  return use_rgba_4444_texture_format_ ? RGBA_4444 : best_texture_format_;
+}
+
 bool ResourceProvider::InUseByConsumer(ResourceId id) {
   Resource* resource = GetResource(id);
   return resource->lock_for_read_count > 0 || resource->exported_count > 0 ||
          resource->lost;
 }
 
 bool ResourceProvider::IsLost(ResourceId id) {
   Resource* resource = GetResource(id);
   return resource->lost;
 }
@@ skipping 630 matching lines @@
   gl_->Finish();
 }
 
 ResourceProvider::ResourceProvider(
     OutputSurface* output_surface,
     SharedBitmapManager* shared_bitmap_manager,
     gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
     BlockingTaskRunner* blocking_main_thread_task_runner,
     int highp_threshold_min,
     bool use_rgba_4444_texture_format,
+    bool use_tile_compression,
     size_t id_allocation_chunk_size,
     bool use_persistent_map_for_gpu_memory_buffers)
     : output_surface_(output_surface),
       shared_bitmap_manager_(shared_bitmap_manager),
       gpu_memory_buffer_manager_(gpu_memory_buffer_manager),
       blocking_main_thread_task_runner_(blocking_main_thread_task_runner),
       lost_output_surface_(false),
       highp_threshold_min_(highp_threshold_min),
       next_id_(1),
       next_child_(1),
       default_resource_type_(RESOURCE_TYPE_BITMAP),
       use_texture_storage_ext_(false),
       use_texture_format_bgra_(false),
       use_texture_usage_hint_(false),
       use_compressed_texture_etc1_(false),
       yuv_resource_format_(LUMINANCE_8),
       max_texture_size_(0),
       best_texture_format_(RGBA_8888),
       best_render_buffer_format_(RGBA_8888),
       use_rgba_4444_texture_format_(use_rgba_4444_texture_format),
+      use_tile_compression_(use_tile_compression),
       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) {
   DCHECK(output_surface_->HasClient());
   DCHECK(id_allocation_chunk_size_);
 }
 
 void ResourceProvider::Initialize() {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 757 matching lines @@
     // implementations. crbug.com/436314
     gl->BeginQueryEXT(GL_COMMANDS_ISSUED_CHROMIUM,
                       source_resource->gl_read_lock_query_id);
 #else
     gl->BeginQueryEXT(GL_COMMANDS_COMPLETED_CHROMIUM,
                       source_resource->gl_read_lock_query_id);
 #endif
   }
   DCHECK(!dest_resource->image_id);
   dest_resource->allocated = true;
-  gl->CopySubTextureCHROMIUM(dest_resource->target, source_resource->gl_id,
-                             dest_resource->gl_id, rect.x(), rect.y(), rect.x(),
-                             rect.y(), rect.width(), rect.height());
+  if (IsResourceFormatCompressed(source_resource->format)) {
+    // TODO(christiank): Should use CompressedCopySubTextureCHROMIUM.

[reveman, 2015/07/21 04:26:33]

Let's fix this TODO before landing this patch.

+    gl->CompressedCopyTextureCHROMIUM(
+        dest_resource->target, source_resource->gl_id, dest_resource->gl_id);
+  } else {
+    gl->CopySubTextureCHROMIUM(dest_resource->target, source_resource->gl_id,
+                               dest_resource->gl_id, rect.x(), rect.y(),
+                               rect.x(), rect.y(), rect.width(), rect.height());
+  }
   if (source_resource->gl_read_lock_query_id) {
     // End query and create a read lock fence that will prevent access to
 // source resource until CopySubTextureCHROMIUM command has completed.
 #if defined(OS_CHROMEOS)
     gl->EndQueryEXT(GL_COMMANDS_ISSUED_CHROMIUM);
 #else
     gl->EndQueryEXT(GL_COMMANDS_COMPLETED_CHROMIUM);
 #endif
     source_resource->read_lock_fence = make_scoped_refptr(
         new CopyTextureFence(gl, source_resource->gl_read_lock_query_id));
@@ skipping 51 matching lines @@
 }
 
 class GrContext* ResourceProvider::GrContext(bool worker_context) const {
   ContextProvider* context_provider =
       worker_context ? output_surface_->worker_context_provider()
                      : output_surface_->context_provider();
   return context_provider ? context_provider->GrContext() : NULL;
 }
 
 }  // namespace cc