cc: Add gfx::BufferFormat to cc::ResourceProvider::Resource.

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 238 matching lines @@
       size(size),
       origin(origin),
       target(target),
       original_filter(filter),
       filter(filter),
       image_id(0),
       bound_image_id(0),
       hint(hint),
       type(type),
       usage(gfx::BufferUsage::GPU_READ_CPU_READ_WRITE),
+      buffer_format(gfx::BufferFormat::RGBA_8888),
       format(format),
       shared_bitmap(nullptr) {
 }
 
 ResourceProvider::Resource::Resource(uint8_t* pixels,
                                      SharedBitmap* bitmap,
                                      const gfx::Size& size,
                                      Origin origin,
                                      GLenum filter)
     : child_id(0),
@@ skipping 20 matching lines @@
       read_lock_fence(nullptr),
       size(size),
       origin(origin),
       target(0),
       original_filter(filter),
       filter(filter),
       image_id(0),
       bound_image_id(0),
       hint(TEXTURE_HINT_IMMUTABLE),
       type(RESOURCE_TYPE_BITMAP),
+      buffer_format(gfx::BufferFormat::RGBA_8888),
       format(RGBA_8888),
       shared_bitmap(bitmap) {
   DCHECK(origin == DELEGATED || pixels);
   if (bitmap)
     shared_bitmap_id = bitmap->id();
 }
 
 ResourceProvider::Resource::Resource(const SharedBitmapId& bitmap_id,
                                      const gfx::Size& size,
                                      Origin origin,
@@ skipping 22 matching lines @@
       read_lock_fence(nullptr),
       size(size),
       origin(origin),
       target(0),
       original_filter(filter),
       filter(filter),
       image_id(0),
       bound_image_id(0),
       hint(TEXTURE_HINT_IMMUTABLE),
       type(RESOURCE_TYPE_BITMAP),
+      buffer_format(gfx::BufferFormat::RGBA_8888),
       format(RGBA_8888),
       shared_bitmap_id(bitmap_id),
       shared_bitmap(nullptr) {
 }
 
 ResourceProvider::Resource::Resource(Resource&& other) = default;
 
 void ResourceProvider::Resource::set_mailbox(const TextureMailbox& mailbox) {
   mailbox_ = mailbox;
   if (IsGpuResourceType(type)) {
@@ skipping 745 matching lines @@
   return !resource->locked_for_write && !resource->lock_for_read_count &&
          !resource->exported_count && resource->origin == Resource::INTERNAL &&
          !resource->lost && ReadLockFenceHasPassed(resource);
 }
 
 bool ResourceProvider::IsOverlayCandidate(ResourceId id) {
   Resource* resource = GetResource(id);
   return resource->is_overlay_candidate;
 }
 
+gfx::BufferFormat ResourceProvider::GetBufferFormat(ResourceId id) {
+  Resource* resource = GetResource(id);
+  return resource->buffer_format;
+}
+
 #if defined(OS_ANDROID)
 bool ResourceProvider::IsBackedBySurfaceTexture(ResourceId id) {
   Resource* resource = GetResource(id);
   return resource->is_backed_by_surface_texture;
 }
 
 bool ResourceProvider::WantsPromotionHint(ResourceId id) {
   return wants_promotion_hints_set_.count(id) > 0;
 }
 
@@ skipping 477 matching lines @@
     if (it->is_software) {
       resource = InsertResource(local_id,
                                 Resource(it->mailbox_holder.mailbox, it->size,
                                          Resource::DELEGATED, GL_LINEAR));
     } else {
       resource = InsertResource(
           local_id, Resource(0, it->size, Resource::DELEGATED,
                              it->mailbox_holder.texture_target, it->filter,
                              TEXTURE_HINT_IMMUTABLE, RESOURCE_TYPE_GL_TEXTURE,
                              it->format));
+      resource->buffer_format = it->buffer_format;
       resource->set_mailbox(TextureMailbox(it->mailbox_holder.mailbox,
                                            it->mailbox_holder.sync_token,
                                            it->mailbox_holder.texture_target));
       resource->read_lock_fences_enabled = it->read_lock_fences_enabled;
       resource->is_overlay_candidate = it->is_overlay_candidate;
 #if defined(OS_ANDROID)
       resource->is_backed_by_surface_texture = it->is_backed_by_surface_texture;
       resource->wants_promotion_hint = it->wants_promotion_hint;
       if (resource->wants_promotion_hint)
         wants_promotion_hints_set_.insert(local_id);
@@ skipping 145 matching lines @@
 
 void ResourceProvider::TransferResource(Resource* source,
                                         ResourceId id,
                                         TransferableResource* resource) {
   DCHECK(!source->locked_for_write);
   DCHECK(!source->lock_for_read_count);
   DCHECK(source->origin != Resource::EXTERNAL || source->mailbox().IsValid());
   DCHECK(source->allocated);
   resource->id = id;
   resource->format = source->format;
+  resource->buffer_format = source->buffer_format;
   resource->mailbox_holder.texture_target = source->target;
   resource->filter = source->filter;
   resource->size = source->size;
   resource->read_lock_fences_enabled = source->read_lock_fences_enabled;
   resource->is_overlay_candidate = source->is_overlay_candidate;
 #if defined(OS_ANDROID)
   resource->is_backed_by_surface_texture = source->is_backed_by_surface_texture;
   resource->wants_promotion_hint = source->wants_promotion_hint;
 #endif
   resource->color_space = source->color_space;
@@ skipping 399 matching lines @@
 
     const int kImportance = 2;
     pmd->CreateSharedGlobalAllocatorDump(guid);
     pmd->AddOwnershipEdge(dump->guid(), guid, kImportance);
   }
 
   return true;
 }
 
 }  // namespace cc