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

cc/resources/video_resource_updater.cc

 // Copyright 2013 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/video_resource_updater.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 143 matching lines @@
 void VideoResourceUpdater::PlaneResource::SetUniqueId(int unique_frame_id,
                                                       size_t plane_index) {
   DCHECK_EQ(ref_count_, 1);
   plane_index_ = plane_index;
   unique_frame_id_ = unique_frame_id;
   has_unique_frame_id_and_plane_index_ = true;
 }
 
 VideoFrameExternalResources::VideoFrameExternalResources()
     : type(NONE),
+      pixel_format(media::PIXEL_FORMAT_UNKNOWN),
       read_lock_fences_enabled(false),
       offset(0.0f),
       multiplier(1.0f),
       bits_per_channel(8) {}
 
 VideoFrameExternalResources::VideoFrameExternalResources(
     const VideoFrameExternalResources& other) = default;
 
 VideoFrameExternalResources::~VideoFrameExternalResources() {}
 
@@ skipping 197 matching lines @@
     ResourceList::iterator resource_it = RecycleOrAllocateResource(
         output_plane_resource_size, output_resource_format, output_color_space,
         software_compositor, is_immutable, video_frame->unique_id(), i);
 
     resource_it->add_ref();
     plane_resources.push_back(resource_it);
   }
 
   VideoFrameExternalResources external_resources;
 
+  external_resources.pixel_format = video_frame->format();
   external_resources.bits_per_channel = bits_per_channel;
 
   if (software_compositor || texture_needs_rgb_conversion) {
     DCHECK_EQ(plane_resources.size(), 1u);
     PlaneResource& plane_resource = *plane_resources[0];
     DCHECK_EQ(plane_resource.resource_format(), kRGBResourceFormat);
     DCHECK_EQ(software_compositor, plane_resource.mailbox().IsZero());
 
     if (!plane_resource.Matches(video_frame->unique_id(), 0)) {
       // We need to transfer data from |video_frame| to the plane resource.
@@ skipping 222 matching lines @@
 }
 
 VideoFrameExternalResources VideoResourceUpdater::CreateForHardwarePlanes(
     scoped_refptr<media::VideoFrame> video_frame) {
   TRACE_EVENT0("cc", "VideoResourceUpdater::CreateForHardwarePlanes");
   DCHECK(video_frame->HasTextures());
   if (!context_provider_)
     return VideoFrameExternalResources();
 
   VideoFrameExternalResources external_resources;
+  external_resources.pixel_format = video_frame->format();
   if (video_frame->metadata()->IsTrue(
           media::VideoFrameMetadata::READ_LOCK_FENCES_ENABLED)) {
     external_resources.read_lock_fences_enabled = true;
   }
   gfx::ColorSpace resource_color_space = video_frame->ColorSpace();
 
   external_resources.type = ResourceTypeForVideoFrame(video_frame.get());
   if (external_resources.type == VideoFrameExternalResources::NONE) {
     DLOG(ERROR) << "Unsupported Texture format"
                 << media::VideoPixelFormatToString(video_frame->format());
@@ skipping 62 matching lines @@
   if (lost_resource) {
     resource_it->clear_refs();
     updater->DeleteResource(resource_it);
     return;
   }
 
   resource_it->remove_ref();
 }
 
 }  // namespace cc