cc: make resource keep video buffer format for hardware overlay.

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 652 matching lines @@
   Resource* resource = InsertResource(
       id,
       Resource(pixels, bitmap.release(), size, Resource::INTERNAL, GL_LINEAR));
   resource->allocated = true;
   resource->color_space = color_space;
   return id;
 }
 
 ResourceId ResourceProvider::CreateResourceFromTextureMailbox(
     const TextureMailbox& mailbox,
+    gfx::BufferFormat buffer_format,
     std::unique_ptr<SingleReleaseCallbackImpl> release_callback_impl,
     bool read_lock_fences_enabled) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // Just store the information. Mailbox will be consumed in LockForRead().
   ResourceId id = next_id_++;
   DCHECK(mailbox.IsValid());
   Resource* resource = nullptr;
   if (mailbox.IsTexture()) {
     resource = InsertResource(
         id,
         Resource(0, mailbox.size_in_pixels(), Resource::EXTERNAL,
                  mailbox.target(),
                  mailbox.nearest_neighbor() ? GL_NEAREST : GL_LINEAR,
                  TEXTURE_HINT_IMMUTABLE, RESOURCE_TYPE_GL_TEXTURE, RGBA_8888));
   } else {
     DCHECK(mailbox.IsSharedMemory());
     SharedBitmap* shared_bitmap = mailbox.shared_bitmap();
     uint8_t* pixels = shared_bitmap->pixels();
     DCHECK(pixels);
     resource = InsertResource(
         id, Resource(pixels, shared_bitmap, mailbox.size_in_pixels(),
                      Resource::EXTERNAL, GL_LINEAR));
   }
+  resource->buffer_format = buffer_format;
   resource->allocated = true;
   resource->set_mailbox(mailbox);
   resource->color_space = mailbox.color_space();
   resource->release_callback_impl =
       base::Bind(&SingleReleaseCallbackImpl::Run,
                  base::Owned(release_callback_impl.release()));
   resource->read_lock_fences_enabled = read_lock_fences_enabled;
   resource->is_overlay_candidate = mailbox.is_overlay_candidate();
 #if defined(OS_ANDROID)
   resource->is_backed_by_surface_texture =
       mailbox.is_backed_by_surface_texture();
   resource->wants_promotion_hint = mailbox.wants_promotion_hint();
   if (resource->wants_promotion_hint)
     wants_promotion_hints_set_.insert(id);
 #endif
   resource->color_space = mailbox.color_space();
 
   return id;
 }
 
 ResourceId ResourceProvider::CreateResourceFromTextureMailbox(
     const TextureMailbox& mailbox,
     std::unique_ptr<SingleReleaseCallbackImpl> release_callback_impl) {
-  return CreateResourceFromTextureMailbox(
-      mailbox, std::move(release_callback_impl), false);
+  return CreateResourceFromTextureMailbox(mailbox, gfx::BufferFormat::RGBA_8888,
+                                          std::move(release_callback_impl),
+                                          false);
 }
 
 void ResourceProvider::DeleteResource(ResourceId id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ResourceMap::iterator it = resources_.find(id);
   CHECK(it != resources_.end());
   Resource* resource = &it->second;
   DCHECK(!resource->marked_for_deletion);
   DCHECK_EQ(resource->imported_count, 0);
   DCHECK(!resource->locked_for_write);
@@ skipping 1439 matching lines @@
 
     const int kImportance = 2;
     pmd->CreateSharedGlobalAllocatorDump(guid);
     pmd->AddOwnershipEdge(dump->guid(), guid, kImportance);
   }
 
   return true;
 }
 
 }  // namespace cc