Apply rotation for texture backed VideoFrames

content/renderer/media/webmediaplayer_ms_unittest.cc

 // Copyright 2015 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 <stddef.h>
 
 #include "base/run_loop.h"
 #include "content/public/renderer/media_stream_renderer_factory.h"
 #include "content/renderer/media/webmediaplayer_ms.h"
 #include "content/renderer/media/webmediaplayer_ms_compositor.h"
@@ skipping 119 matching lines @@
   // Implementation of MediaStreamVideoRenderer
   void Start() override;
   void Stop() override;
   void Resume() override;
   void Pause() override;
 
   // Methods for test use
   void QueueFrames(const std::vector<int>& timestamps_or_frame_type,
                    bool opaque_frame = true,
                    bool odd_size_frame = false,
-                   int double_size_index = -1);
+                   int double_size_index = -1,
+                   media::VideoRotation rotation = media::VIDEO_ROTATION_0);
   bool Started() { return started_; }
   bool Paused() { return paused_; }
 
  private:
   ~MockMediaStreamVideoRenderer() override {}
 
   // Main function that pushes a frame into WebMediaPlayerMS
   void InjectFrame();
 
   // Methods for test use
@@ skipping 39 matching lines @@
 void MockMediaStreamVideoRenderer::AddFrame(
     FrameType category,
     const scoped_refptr<media::VideoFrame>& frame) {
   frames_.push_back(std::make_pair(category, frame));
 }
 
 void MockMediaStreamVideoRenderer::QueueFrames(
     const std::vector<int>& timestamp_or_frame_type,
     bool opaque_frame,
     bool odd_size_frame,
-    int double_size_index) {
+    int double_size_index,
+    media::VideoRotation rotation) {
   gfx::Size standard_size = gfx::Size(kStandardWidth, kStandardHeight);
   for (size_t i = 0; i < timestamp_or_frame_type.size(); i++) {
     const int token = timestamp_or_frame_type[i];
     if (static_cast<int>(i) == double_size_index) {
       standard_size = gfx::Size(kStandardWidth * 2, kStandardHeight * 2);
     }
     if (token < static_cast<int>(FrameType::MIN_TYPE)) {
       CHECK(false) << "Unrecognized frame type: " << token;
       return;
     }
 
     if (token < 0) {
       AddFrame(static_cast<FrameType>(token), nullptr);
       continue;
     }
 
     if (token >= 0) {
       gfx::Size frame_size;
       if (odd_size_frame) {
         frame_size.SetSize(standard_size.width() - kOddSizeOffset,
                            standard_size.height() - kOddSizeOffset);
       } else {
         frame_size.SetSize(standard_size.width(), standard_size.height());
       }
+
       auto frame = media::VideoFrame::CreateZeroInitializedFrame(
           opaque_frame ? media::PIXEL_FORMAT_YV12 : media::PIXEL_FORMAT_YV12A,
           frame_size, gfx::Rect(frame_size), frame_size,
           base::TimeDelta::FromMilliseconds(token));
 
+      frame->metadata()->SetRotation(media::VideoFrameMetadata::ROTATION,
+                                     rotation);
       frame->metadata()->SetTimeTicks(
           media::VideoFrameMetadata::Key::REFERENCE_TIME,
           base::TimeTicks::Now() + base::TimeDelta::FromMilliseconds(token));
 
       AddFrame(FrameType::NORMAL_FRAME, frame);
       continue;
     }
   }
 }
 
@@ skipping 328 matching lines @@
   EXPECT_CALL(*this, DoSetWebLayer(true));
   EXPECT_CALL(*this, DoStartRendering());
   EXPECT_CALL(*this, DoReadyStateChanged(
                          blink::WebMediaPlayer::ReadyStateHaveMetadata));
   EXPECT_CALL(*this, DoReadyStateChanged(
                          blink::WebMediaPlayer::ReadyStateHaveEnoughData));
   EXPECT_CALL(*this,
               CheckSizeChanged(gfx::Size(kStandardWidth, kStandardHeight)));
   message_loop_controller_.RunAndWaitForStatus(
       media::PipelineStatus::PIPELINE_OK);
+  const blink::WebSize& natural_size = player_->naturalSize();
+  EXPECT_EQ(kStandardWidth, natural_size.width);
+  EXPECT_EQ(kStandardHeight, natural_size.height);
   testing::Mock::VerifyAndClearExpectations(this);
 
   EXPECT_CALL(*this, DoSetWebLayer(false));
   EXPECT_CALL(*this, DoStopRendering());
 }
 
 TEST_F(WebMediaPlayerMSTest, Playing_ErrorFrame) {
   // This tests sends a broken frame to WebMediaPlayerMS, and verifies
   // OnSourceError function works as expected.
 
@@ skipping 114 matching lines @@
 
   EXPECT_CALL(*this, DoSetWebLayer(false));
   EXPECT_CALL(*this, DoStopRendering());
 }
 
 INSTANTIATE_TEST_CASE_P(,
                         WebMediaPlayerMSTest,
                         ::testing::Combine(::testing::Bool(),
                                            ::testing::Bool()));
 
+TEST_F(WebMediaPlayerMSTest, RotatedVideoFrame) {
+  // During this test, we check that when we send rotated video frames, it
+  // applies to player's natural size.

[mcasas, 2016/07/15 01:57:34]

nit: This is a TEST comment, move it to l.719

[emircan, 2016/07/15 18:43:13]

Done.

+  MockMediaStreamVideoRenderer* provider = LoadAndGetFrameProvider(true);
+
+  int tokens[] = {0, 33, 66};
+  std::vector<int> timestamps(tokens, tokens + sizeof(tokens) / sizeof(int));

[mcasas, 2016/07/15 01:57:34]

If |tokens| is constant, make it 
static int kTokens[] = {...}
std::vector<int> timestamps(tokens, tokens +arraysize(tokens));

arraysize() being calculated in compile time.

[emircan, 2016/07/15 18:43:13]

Done.

+  provider->QueueFrames(timestamps, false, false, 17, media::VIDEO_ROTATION_90);
+
+  EXPECT_CALL(*this, DoSetWebLayer(true));
+  EXPECT_CALL(*this, DoStartRendering());
+  EXPECT_CALL(*this, DoReadyStateChanged(
+                         blink::WebMediaPlayer::ReadyStateHaveMetadata));
+  EXPECT_CALL(*this, DoReadyStateChanged(
+                         blink::WebMediaPlayer::ReadyStateHaveEnoughData));
+  EXPECT_CALL(*this,
+              CheckSizeChanged(gfx::Size(kStandardWidth, kStandardHeight)));
+  message_loop_controller_.RunAndWaitForStatus(
+      media::PipelineStatus::PIPELINE_OK);
+  const blink::WebSize& natural_size = player_->naturalSize();
+  // Check that height and width are flipped.
+  EXPECT_EQ(kStandardHeight, natural_size.width);
+  EXPECT_EQ(kStandardWidth, natural_size.height);
+  testing::Mock::VerifyAndClearExpectations(this);
+
+  EXPECT_CALL(*this, DoSetWebLayer(false));
+  EXPECT_CALL(*this, DoStopRendering());
+}
+
 TEST_F(WebMediaPlayerMSTest, BackgroundRendering) {
   // During this test, we will switch to background rendering mode, in which
   // WebMediaPlayerMS::pause does not get called, but
   // cc::VideoFrameProviderClient simply stops asking frames from
   // WebMediaPlayerMS without an explicit notification. We should expect that
   // WebMediaPlayerMS can digest old frames, rather than piling frames up and
   // explode.
   MockMediaStreamVideoRenderer* provider = LoadAndGetFrameProvider(true);
 
   const int kTestBrake = static_cast<int>(FrameType::TEST_BRAKE);
@@ skipping 110 matching lines @@
   // OnShown() should restart after a forced suspension.
   player_->OnShown();
   EXPECT_FALSE(player_->paused());
   EXPECT_CALL(*this, DoSetWebLayer(false));
 
   message_loop_.RunUntilIdle();
 }
 #endif
 
 }  // namespace content