Send hardware video frames with mailboxes.

cc/layers/video_layer_impl.cc

 // Copyright 2011 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/layers/video_layer_impl.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "cc/layers/quad_sink.h"
 #include "cc/layers/video_frame_provider_client_impl.h"
@@ skipping 19 matching lines @@
     VideoFrameProvider* provider) {
   scoped_ptr<VideoLayerImpl> layer(new VideoLayerImpl(tree_impl, id));
   layer->SetProviderClientImpl(VideoFrameProviderClientImpl::Create(provider));
   DCHECK(tree_impl->proxy()->IsImplThread());
   DCHECK(tree_impl->proxy()->IsMainThreadBlocked());
   return layer.Pass();
 }
 
 VideoLayerImpl::VideoLayerImpl(LayerTreeImpl* tree_impl, int id)
     : LayerImpl(tree_impl, id),
-      frame_(NULL),
-      hardware_resource_(0) {}
+      frame_(NULL) {}
 
 VideoLayerImpl::~VideoLayerImpl() {
   if (!provider_client_impl_->Stopped()) {
     // In impl side painting, we may have a pending and active layer
     // associated with the video provider at the same time. Both have a ref
     // on the VideoFrameProviderClientImpl, but we stop when the first
     // LayerImpl (the one on the pending tree) is destroyed since we know
     // the main thread is blocked for this commit.
     DCHECK(layer_tree_impl()->proxy()->IsImplThread());
     DCHECK(layer_tree_impl()->proxy()->IsMainThreadBlocked());
@@ skipping 37 matching lines @@
 
     provider_client_impl_->ReleaseLock();
     return false;
   }
 
   LayerImpl::WillDraw(draw_mode, resource_provider);
 
   if (!updater_)
     updater_.reset(new VideoResourceUpdater(resource_provider));
 
-  VideoFrameExternalResources external_resources;
-  if (frame_->format() == media::VideoFrame::NATIVE_TEXTURE)
-    external_resources = updater_->CreateForHardwarePlanes(frame_);
-  else
-    external_resources = updater_->CreateForSoftwarePlanes(frame_);
-
+  VideoFrameExternalResources external_resources =
+      updater_->CreateExternalResourcesFromVideoFrame(frame_);
   frame_resource_type_ = external_resources.type;
 
   if (external_resources.type ==
       VideoFrameExternalResources::SOFTWARE_RESOURCE) {
     software_resources_ = external_resources.software_resources;
     software_release_callback_ =
         external_resources.software_release_callback;
     return true;
   }
 
-  if (external_resources.hardware_resource) {
-    hardware_resource_ = external_resources.hardware_resource;
-    hardware_release_callback_ =
-        external_resources.hardware_release_callback;
-    return true;
-  }
-
   for (size_t i = 0; i < external_resources.mailboxes.size(); ++i) {
     frame_resources_.push_back(
         resource_provider->CreateResourceFromTextureMailbox(
             external_resources.mailboxes[i]));
   }
 
   return true;
 }
 
 void VideoLayerImpl::AppendQuads(QuadSink* quad_sink,
@@ skipping 52 matching lines @@
                              tex_scale,
                              frame_resources_[0],
                              frame_resources_[1],
                              frame_resources_[2],
                              frame_resources_.size() > 3 ?
                                  frame_resources_[3] : 0);
       quad_sink->Append(yuv_video_quad.PassAs<DrawQuad>(), append_quads_data);
       break;
     }
     case VideoFrameExternalResources::RGB_RESOURCE: {
-      if (!hardware_resource_) {
-        DCHECK_EQ(frame_resources_.size(), 1u);
-        if (frame_resources_.size() < 1u)
-          break;
-      }
+      DCHECK_EQ(frame_resources_.size(), 1u);
+      if (frame_resources_.size() < 1u)
+        break;
       bool premultiplied_alpha = true;
       gfx::PointF uv_top_left(0.f, 0.f);
       gfx::PointF uv_bottom_right(tex_width_scale, tex_height_scale);
       float opacity[] = {1.0f, 1.0f, 1.0f, 1.0f};
       bool flipped = false;
       scoped_ptr<TextureDrawQuad> texture_quad = TextureDrawQuad::Create();
       texture_quad->SetNew(shared_quad_state,
                            quad_rect,
                            opaque_rect,
-                           hardware_resource_ ? hardware_resource_
-                                              : frame_resources_[0],
+                           frame_resources_[0],
                            premultiplied_alpha,
                            uv_top_left,
                            uv_bottom_right,
                            opacity,
                            flipped);
       quad_sink->Append(texture_quad.PassAs<DrawQuad>(), append_quads_data);
       break;
     }
     case VideoFrameExternalResources::STREAM_TEXTURE_RESOURCE: {
-      if (!hardware_resource_) {
-        DCHECK_EQ(frame_resources_.size(), 1u);
-        if (frame_resources_.size() < 1u)
-          break;
-      }
+      DCHECK_EQ(frame_resources_.size(), 1u);
+      if (frame_resources_.size() < 1u)
+        break;
       gfx::Transform transform(
           provider_client_impl_->stream_texture_matrix());
       transform.Scale(tex_width_scale, tex_height_scale);
       scoped_ptr<StreamVideoDrawQuad> stream_video_quad =
           StreamVideoDrawQuad::Create();
       stream_video_quad->SetNew(shared_quad_state,
                                 quad_rect,
                                 opaque_rect,
-                                hardware_resource_ ? hardware_resource_
-                                                   : frame_resources_[0],
+                                frame_resources_[0],
                                 transform);
       quad_sink->Append(stream_video_quad.PassAs<DrawQuad>(),
                         append_quads_data);
       break;
     }
     case VideoFrameExternalResources::IO_SURFACE: {
-      if (!hardware_resource_) {
-        DCHECK_EQ(frame_resources_.size(), 1u);
-        if (frame_resources_.size() < 1u)
-          break;
-      }
+      DCHECK_EQ(frame_resources_.size(), 1u);
+      if (frame_resources_.size() < 1u)
+        break;
       gfx::Size visible_size(visible_rect.width(), visible_rect.height());
       scoped_ptr<IOSurfaceDrawQuad> io_surface_quad =
           IOSurfaceDrawQuad::Create();
       io_surface_quad->SetNew(shared_quad_state,
                               quad_rect,
                               opaque_rect,
                               visible_size,
-                              hardware_resource_ ? hardware_resource_
-                                                 : frame_resources_[0],
+                              frame_resources_[0],
                               IOSurfaceDrawQuad::UNFLIPPED);
       quad_sink->Append(io_surface_quad.PassAs<DrawQuad>(),
                         append_quads_data);
       break;
     }
 #if defined(GOOGLE_TV)
     // This block and other blocks wrapped around #if defined(GOOGLE_TV) is not
     // maintained by the general compositor team. Please contact the following
     // people instead:
     //
@@ skipping 25 matching lines @@
 
   DCHECK(frame_.get());
 
   if (frame_resource_type_ ==
       VideoFrameExternalResources::SOFTWARE_RESOURCE) {
     for (size_t i = 0; i < software_resources_.size(); ++i)
       software_release_callback_.Run(0, false);
 
     software_resources_.clear();
     software_release_callback_.Reset();
-  } else if (hardware_resource_) {
-    hardware_release_callback_.Run(0, false);
-    hardware_resource_ = 0;
-    hardware_release_callback_.Reset();
   } else {
     for (size_t i = 0; i < frame_resources_.size(); ++i)
       resource_provider->DeleteResource(frame_resources_[i]);
     frame_resources_.clear();
   }
 
   provider_client_impl_->PutCurrentFrame(frame_);
   frame_ = NULL;
 
   provider_client_impl_->ReleaseLock();
@@ skipping 11 matching lines @@
 void VideoLayerImpl::SetProviderClientImpl(
     scoped_refptr<VideoFrameProviderClientImpl> provider_client_impl) {
   provider_client_impl_ = provider_client_impl;
 }
 
 const char* VideoLayerImpl::LayerTypeAsString() const {
   return "cc::VideoLayerImpl";
 }
 
 }  // namespace cc