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

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/atomic_sequence_num.h"
@@ skipping 350 matching lines @@
        itr != resources_.end(); ++itr) {
     DCHECK(!IsGpuResourceType(itr->second.type));
   }
 #endif  // DCHECK_IS_ON()
 
   texture_id_allocator_ = nullptr;
   buffer_id_allocator_ = nullptr;
   gl->Finish();
 }
 
+bool ResourceProvider::IsResourceFormatSupported(ResourceFormat format) const {
+  const ContextProvider::Capabilities& caps =
+      output_surface_->context_provider()->ContextCapabilities();
+
+  switch (format) {
+    case ALPHA_8:
+    case RGBA_4444:
+    case RGBA_8888:
+    case RGB_565:
+    case LUMINANCE_8:
+      return true;
+    case BGRA_8888:
+      return caps.gpu.texture_format_bgra8888;
+    case ETC1:
+      return caps.gpu.texture_format_etc1;
+    case RED_8:
+      return caps.gpu.texture_rg;
+  }
+
+  NOTREACHED();
+  return false;
+}
+
 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 440 matching lines @@
 }
 
 ResourceProvider::ScopedSamplerGL::~ScopedSamplerGL() {
 }
 
 ResourceProvider::ScopedWriteLockGL::ScopedWriteLockGL(
     ResourceProvider* resource_provider,
     ResourceId resource_id)
     : resource_provider_(resource_provider),
       resource_(resource_provider->LockForWrite(resource_id)) {
   resource_provider_->LazyAllocate(resource_);

[piman, 2015/12/03 23:01:50]

What happens now if this is ETC1?

Or are we guaranteed never to go through here? If so can we add a DCHECK?

[christiank, 2015/12/04 10:20:40]

It should be fine. As far as I understand we still need to lock the resource
even for ETC1. The only thing that will be different in the ETC1 case is that no
texture memory will be pre-allocated. That shouldn't be a problem. It's
addressed by performing a full upload or copy (which doesn't require texture
memory to be pre-allocated) when updating the resource.

[piman, 2015/12/04 21:30:48]

So, if I understand correctly, you expect the caller to "allocate" the resource.
However, what sets the allocate flag? There's a bunch of places that expect it
to be set. There's DCHECKs, but there's also some active logic (e.g. memory
tracking).

[christiank, 2015/12/07 08:38:11]

Oh, now I see what you mean. I experimented with updating the allocated flag
from outside LazyAllocate() in patch set 2 but ended up reverting that. It
turned out to me rather messy, it's difficult to expose a nice clean API for
updating that flag from outside ResourceProvider.

I have reverted back to the original behavior.

   texture_id_ = resource_->gl_id;
   DCHECK(texture_id_);
   if (resource_->dirty_image)
     resource_provider_->BindImageForSampling(resource_);
 }
 
 ResourceProvider::ScopedWriteLockGL::~ScopedWriteLockGL() {
   resource_provider_->UnlockForWrite(resource_);
 }
 
@@ skipping 72 matching lines @@
   }
   return gpu_memory_buffer_.get();
 }
 
 ResourceProvider::ScopedWriteLockGr::ScopedWriteLockGr(
     ResourceProvider* resource_provider,
     ResourceId resource_id)
     : resource_provider_(resource_provider),
       resource_(resource_provider->LockForWrite(resource_id)) {
   DCHECK(thread_checker_.CalledOnValidThread());
   resource_provider_->LazyAllocate(resource_);

[piman, 2015/12/03 23:01:50]

Same here

 }
 
 ResourceProvider::ScopedWriteLockGr::~ScopedWriteLockGr() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(resource_->locked_for_write);
   resource_provider_->UnlockForWrite(resource_);
 }
 
 void ResourceProvider::ScopedWriteLockGr::InitSkSurface(
     bool use_distance_field_text,
@@ skipping 125 matching lines @@
   use_texture_storage_ext_ = caps.gpu.texture_storage;
   use_texture_format_bgra_ = caps.gpu.texture_format_bgra8888;
   use_texture_usage_hint_ = caps.gpu.texture_usage;
   use_compressed_texture_etc1_ = caps.gpu.texture_format_etc1;
   yuv_resource_format_ = caps.gpu.texture_rg ? RED_8 : LUMINANCE_8;
   use_sync_query_ = caps.gpu.sync_query;
 
   max_texture_size_ = 0;  // Context expects cleared value.
   gl->GetIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_size_);
   best_texture_format_ =
-      PlatformColor::BestTextureFormat(use_texture_format_bgra_);
+      PlatformColor::BestSupportedTextureFormat(use_texture_format_bgra_);
 
-  best_render_buffer_format_ =
-      PlatformColor::BestTextureFormat(caps.gpu.render_buffer_format_bgra8888);
+  best_render_buffer_format_ = PlatformColor::BestSupportedTextureFormat(
+      caps.gpu.render_buffer_format_bgra8888);
 
   texture_id_allocator_.reset(
       new TextureIdAllocator(gl, id_allocation_chunk_size_));
   buffer_id_allocator_.reset(
       new BufferIdAllocator(gl, id_allocation_chunk_size_));
 }
 
 int ResourceProvider::CreateChild(const ReturnCallback& return_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
@@ skipping 412 matching lines @@
   LazyAllocate(GetResource(id));
 }
 
 void ResourceProvider::LazyAllocate(Resource* resource) {
   DCHECK(resource);
   if (resource->allocated)
     return;
   LazyCreate(resource);
   if (!resource->gl_id)
     return;
-  resource->allocated = true;
   GLES2Interface* gl = ContextGL();
   gfx::Size& size = resource->size;
   ResourceFormat format = resource->format;
   gl->BindTexture(resource->target, resource->gl_id);
   if (resource->type == RESOURCE_TYPE_GPU_MEMORY_BUFFER) {
     resource->gpu_memory_buffer =
         gpu_memory_buffer_manager_->AllocateGpuMemoryBuffer(
                                       size, BufferFormat(format),
                                       gfx::BufferUsage::GPU_READ_CPU_READ_WRITE)
             .release();

[piman, 2015/12/03 23:01:50]

Doesn't resource->allocated need to be true here too? LazyCreateImage DCHECKs
it.

[christiank, 2015/12/04 10:20:40]

You're absolutely right, my bad.

     LazyCreateImage(resource);
     resource->dirty_image = true;
     resource->is_overlay_candidate = true;
   } else if (use_texture_storage_ext_ &&
              IsFormatSupportedForStorage(format, use_texture_format_bgra_) &&
              (resource->hint & TEXTURE_HINT_IMMUTABLE)) {
     GLenum storage_format = TextureToStorageFormat(format);
     gl->TexStorage2DEXT(resource->target, 1, storage_format, size.width(),
                         size.height());
+    resource->allocated = true;
   } else {
     // ETC1 does not support preallocation.
     if (format != ETC1) {
       gl->TexImage2D(resource->target, 0, GLInternalFormat(format),
                      size.width(), size.height(), 0, GLDataFormat(format),
                      GLDataType(format), NULL);
+      resource->allocated = true;
     }
   }
 }
 
 void ResourceProvider::LazyCreateImage(Resource* resource) {
   DCHECK(resource->gpu_memory_buffer);
   DCHECK(resource->gl_id);
   DCHECK(resource->allocated);
   if (!resource->image_id) {
     GLES2Interface* gl = ContextGL();
@@ skipping 119 matching lines @@
       const int kImportance = 2;
       pmd->CreateSharedGlobalAllocatorDump(guid);
       pmd->AddOwnershipEdge(dump->guid(), guid, kImportance);
     }
   }
 
   return true;
 }
 
 }  // namespace cc