Rotation into Video Layer + Content Transform

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/video_frame_provider_client_impl.h"
 #include "cc/quads/io_surface_draw_quad.h"
@@ skipping 10 matching lines @@
 #if defined(VIDEO_HOLE)
 #include "cc/quads/solid_color_draw_quad.h"
 #endif  // defined(VIDEO_HOLE)
 
 namespace cc {
 
 // static
 scoped_ptr<VideoLayerImpl> VideoLayerImpl::Create(
     LayerTreeImpl* tree_impl,
     int id,
-    VideoFrameProvider* provider) {
-  scoped_ptr<VideoLayerImpl> layer(new VideoLayerImpl(tree_impl, id));
+    VideoFrameProvider* provider,
+    media::VideoRotation video_rotation) {
+  scoped_ptr<VideoLayerImpl> layer(
+      new VideoLayerImpl(tree_impl, id, video_rotation));
   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) {}
+VideoLayerImpl::VideoLayerImpl(LayerTreeImpl* tree_impl,
+                               int id,
+                               media::VideoRotation video_rotation)
+    : LayerImpl(tree_impl, id), frame_(NULL), video_rotation_(video_rotation) {
+}
 
 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());
     provider_client_impl_->Stop();
   }
 }
 
 scoped_ptr<LayerImpl> VideoLayerImpl::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
-  return scoped_ptr<LayerImpl>(new VideoLayerImpl(tree_impl, id()));
+  VideoLayerImpl* impl = new VideoLayerImpl(tree_impl, id(), video_rotation_);
+  return scoped_ptr<LayerImpl>(impl);
 }
 
 void VideoLayerImpl::PushPropertiesTo(LayerImpl* layer) {
   LayerImpl::PushPropertiesTo(layer);
 
   VideoLayerImpl* other = static_cast<VideoLayerImpl*>(layer);
   other->SetProviderClientImpl(provider_client_impl_);
 }
 
 void VideoLayerImpl::DidBecomeActive() {
@@ skipping 56 matching lines @@
 }
 
 void VideoLayerImpl::AppendQuads(
     RenderPass* render_pass,
     const OcclusionTracker<LayerImpl>& occlusion_tracker,
     AppendQuadsData* append_quads_data) {
   DCHECK(frame_.get());
 
   SharedQuadState* shared_quad_state =
       render_pass->CreateAndAppendSharedQuadState();
   PopulateSharedQuadState(shared_quad_state);

[danakj, 2014/08/05 20:18:21]

drop this, since you do SetALl below. Can you move teh
CreateAndAppendSharedQuadState() just above the SetAll()?

 
+  gfx::Transform transform = draw_transform();
+  gfx::Size rotated_size = content_bounds();
+
+  switch (video_rotation_) {
+    case media::VIDEO_ROTATION_90:
+      rotated_size = gfx::Size(rotated_size.height(), rotated_size.width());
+      transform.Rotate(90.0);
+      transform.Translate(0.0, -rotated_size.height());
+      break;
+    case media::VIDEO_ROTATION_180:
+      transform.Rotate(180.0);
+      transform.Translate(-rotated_size.width(), -rotated_size.height());
+      break;
+    case media::VIDEO_ROTATION_270:
+      rotated_size = gfx::Size(rotated_size.height(), rotated_size.width());
+      transform.Rotate(270.0);
+      transform.Translate(-rotated_size.width(), 0);
+    case media::VIDEO_ROTATION_0:
+      break;
+  }
+
+  shared_quad_state->SetAll(transform,
+                            rotated_size,
+                            visible_content_rect(),
+                            clip_rect(),
+                            is_clipped(),
+                            draw_opacity(),
+                            blend_mode(),
+                            sorting_context_id());
+
   AppendDebugBorderQuad(
-      render_pass, content_bounds(), shared_quad_state, append_quads_data);
+      render_pass, rotated_size, shared_quad_state, append_quads_data);
 
-  gfx::Rect quad_rect(content_bounds());
+  gfx::Rect quad_rect(rotated_size);
   gfx::Rect opaque_rect(contents_opaque() ? quad_rect : gfx::Rect());
   gfx::Rect visible_rect = frame_->visible_rect();
   gfx::Size coded_size = frame_->coded_size();
 
-  gfx::Rect visible_quad_rect = occlusion_tracker.UnoccludedContentRect(
-      quad_rect, draw_properties().target_space_transform);
+  gfx::Rect visible_quad_rect =
+      occlusion_tracker.UnoccludedContentRect(quad_rect, transform);
   if (visible_quad_rect.IsEmpty())
     return;
 
   // Pixels for macroblocked formats.
   const float tex_width_scale =
       static_cast<float>(visible_rect.width()) / coded_size.width();
   const float tex_height_scale =
       static_cast<float>(visible_rect.height()) / coded_size.height();
   const float tex_x_offset =
       static_cast<float>(visible_rect.x()) / coded_size.width();
@@ skipping 175 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