Bug Fix: Resize Event Trigger

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 "content/public/renderer/media_stream_renderer_factory.h"
 #include "content/renderer/media/webmediaplayer_ms.h"
 #include "content/renderer/media/webmediaplayer_ms_compositor.h"
 #include "content/renderer/render_frame_impl.h"
 #include "media/base/test_helpers.h"
 #include "media/base/video_frame.h"
 #include "third_party/WebKit/public/platform/WebMediaPlayer.h"
 #include "third_party/WebKit/public/platform/WebMediaPlayerClient.h"
 #include "third_party/WebKit/public/platform/WebMediaPlayerSource.h"
 
 namespace content {
 
 enum class FrameType {
   NORMAL_FRAME = 0,
   BROKEN_FRAME = -1,
   TEST_BRAKE = -2,  // Signal to pause message loop.
   MIN_TYPE = TEST_BRAKE
 };
 
 using TestFrame = std::pair<FrameType, scoped_refptr<media::VideoFrame>>;
 
 static const int kOddSizeOffset = 3;
+static const int kStandardWidth = 320;
+static const int kStandardHeight = 240;
 
 class FakeWebMediaPlayerDelegate
     : public media::WebMediaPlayerDelegate,
       public base::SupportsWeakPtr<FakeWebMediaPlayerDelegate> {
  public:
   FakeWebMediaPlayerDelegate() {}
   ~FakeWebMediaPlayerDelegate() override {
     DCHECK(!observer_);
     DCHECK(is_gone_);
   }
@@ skipping 87 matching lines @@
 
   // Implementation of VideoFrameProvider
   void Start() override;
   void Stop() override;
   void Play() 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);
+                   bool odd_size_frame = false,
+                   int double_size_index = -1);
   bool Started() { return started_; }
   bool Paused() { return paused_; }
 
  private:
   ~MockVideoFrameProvider() override {}
 
   // Main function that pushes a frame into WebMediaPlayerMS
   void InjectFrame();
 
   // Methods for test use
@@ skipping 37 matching lines @@
 
 void MockVideoFrameProvider::AddFrame(
     FrameType category,
     const scoped_refptr<media::VideoFrame>& frame) {
   frames_.push_back(std::make_pair(category, frame));
 }
 
 void MockVideoFrameProvider::QueueFrames(
     const std::vector<int>& timestamp_or_frame_type,
     bool opaque_frame,
-    bool odd_size_frame) {
-  for (const int token : timestamp_or_frame_type) {
+    bool odd_size_frame,
+    int double_size_index) {
+  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 natural_size = media::TestVideoConfig::NormalCodedSize();
+      gfx::Size frame_size;
       if (odd_size_frame) {
-        natural_size.SetSize(natural_size.width() - kOddSizeOffset,
-                             natural_size.height() - kOddSizeOffset);
+        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,
-          natural_size, gfx::Rect(natural_size), natural_size,
+          frame_size, gfx::Rect(frame_size), frame_size,
           base::TimeDelta::FromMilliseconds(token));
 
       frame->metadata()->SetTimeTicks(
           media::VideoFrameMetadata::Key::REFERENCE_TIME,
           base::TimeTicks::Now() + base::TimeDelta::FromMilliseconds(token));
 
       AddFrame(FrameType::NORMAL_FRAME, frame);
       continue;
     }
   }
@@ skipping 140 matching lines @@
   ~WebMediaPlayerMSTest() override {}
 
   MockVideoFrameProvider* LoadAndGetFrameProvider(bool algorithm_enabled);
 
   // Implementation of WebMediaPlayerClient
   void networkStateChanged() override;
   void readyStateChanged() override;
   void timeChanged() override {}
   void repaint() override {}
   void durationChanged() override {}
-  void sizeChanged() override {}
+  void sizeChanged() override;
   void playbackStateChanged() override {}
   void setWebLayer(blink::WebLayer* layer) override;
   blink::WebMediaPlayer::TrackId addAudioTrack(const blink::WebString& id,
                                                AudioTrackKind,
                                                const blink::WebString& label,
                                                const blink::WebString& language,
                                                bool enabled) override {
     return 0;
   }
   void removeAudioTrack(blink::WebMediaPlayer::TrackId) override {}
@@ skipping 26 matching lines @@
   }
 
  protected:
   MOCK_METHOD0(DoStartRendering, void());
   MOCK_METHOD0(DoStopRendering, void());
 
   MOCK_METHOD1(DoSetWebLayer, void(bool));
   MOCK_METHOD1(DoNetworkStateChanged,
                void(blink::WebMediaPlayer::NetworkState));
   MOCK_METHOD1(DoReadyStateChanged, void(blink::WebMediaPlayer::ReadyState));
+  MOCK_METHOD1(CheckSizeChanged, void(gfx::Size));
 
   base::MessageLoop message_loop_;
   MockRenderFactory* render_factory_;
   FakeWebMediaPlayerDelegate delegate_;
   WebMediaPlayerMS player_;
   WebMediaPlayerMSCompositor* compositor_;
   ReusableMessageLoopEvent message_loop_controller_;
 
  private:
   // Main function trying to ask WebMediaPlayerMS to submit a frame for
@@ skipping 89 matching lines @@
     compositor_->UpdateCurrentFrame(deadline_min, deadline_max);
     auto frame = compositor_->GetCurrentFrame();
     compositor_->PutCurrentFrame();
   }
   message_loop_.PostDelayedTask(
       FROM_HERE,
       base::Bind(&WebMediaPlayerMSTest::RenderFrame, base::Unretained(this)),
       base::TimeDelta::FromSecondsD(1.0 / 60.0));
 }
 
+void WebMediaPlayerMSTest::sizeChanged() {
+  gfx::Size frame_size = compositor_->GetCurrentSize();
+  CheckSizeChanged(frame_size);
+}
+
 TEST_F(WebMediaPlayerMSTest, Playing_Normal) {
   // This test sends a bunch of normal frames with increasing timestamps
   // and verifies that they are produced by WebMediaPlayerMS in appropriate
   // order.
 
   MockVideoFrameProvider* provider = LoadAndGetFrameProvider(true);
 
   int tokens[] = {0,   33,  66,  100, 133, 166, 200, 233, 266, 300,
                   333, 366, 400, 433, 466, 500, 533, 566, 600};
   std::vector<int> timestamps(tokens, tokens + sizeof(tokens) / sizeof(int));
   provider->QueueFrames(timestamps);
 
   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);
   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.
 
   MockVideoFrameProvider* provider = LoadAndGetFrameProvider(false);
 
   const int kBrokenFrame = static_cast<int>(FrameType::BROKEN_FRAME);
   int tokens[] = {0,   33,  66,  100, 133, 166, 200, 233, 266, 300,
                   333, 366, 400, 433, 466, 500, 533, 566, 600, kBrokenFrame};
   std::vector<int> timestamps(tokens, tokens + sizeof(tokens) / sizeof(int));
   provider->QueueFrames(timestamps);
 
   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, DoNetworkStateChanged(
                          blink::WebMediaPlayer::NetworkStateFormatError));
+  EXPECT_CALL(*this,
+              CheckSizeChanged(gfx::Size(kStandardWidth, kStandardHeight)));
   message_loop_controller_.RunAndWaitForStatus(
       media::PipelineStatus::PIPELINE_ERROR_NETWORK);
   testing::Mock::VerifyAndClearExpectations(this);
 
   EXPECT_CALL(*this, DoSetWebLayer(false));
   EXPECT_CALL(*this, DoStopRendering());
 }
 
 TEST_P(WebMediaPlayerMSTest, PlayThenPause) {
   const bool opaque_frame = testing::get<0>(GetParam());
   const bool odd_size_frame = testing::get<1>(GetParam());
   // In the middle of this test, WebMediaPlayerMS::pause will be called, and we
   // are going to verify that during the pause stage, a frame gets freezed, and
   // cc::VideoFrameProviderClient should also be paused.
   MockVideoFrameProvider* provider = LoadAndGetFrameProvider(false);
 
   const int kTestBrake = static_cast<int>(FrameType::TEST_BRAKE);
   int tokens[] = {0,   33,  66,  100, 133, kTestBrake, 166, 200, 233, 266,
                   300, 333, 366, 400, 433, 466,        500, 533, 566, 600};
   std::vector<int> timestamps(tokens, tokens + sizeof(tokens) / sizeof(int));
   provider->QueueFrames(timestamps, opaque_frame, odd_size_frame);
 
   EXPECT_CALL(*this, DoSetWebLayer(true));
   EXPECT_CALL(*this, DoStartRendering());
   EXPECT_CALL(*this, DoReadyStateChanged(
                          blink::WebMediaPlayer::ReadyStateHaveMetadata));
   EXPECT_CALL(*this, DoReadyStateChanged(
                          blink::WebMediaPlayer::ReadyStateHaveEnoughData));
+  gfx::Size frame_size =
+      gfx::Size(kStandardWidth - (odd_size_frame ? kOddSizeOffset : 0),
+                kStandardHeight - (odd_size_frame ? kOddSizeOffset : 0));
+  EXPECT_CALL(*this, CheckSizeChanged(frame_size));
   message_loop_controller_.RunAndWaitForStatus(
       media::PipelineStatus::PIPELINE_OK);
   testing::Mock::VerifyAndClearExpectations(this);
 
   // Here we call pause, and expect a freezing frame.
   EXPECT_CALL(*this, DoStopRendering());
   player_.pause();
   auto prev_frame = compositor_->GetCurrentFrame();
   message_loop_controller_.RunAndWaitForStatus(
       media::PipelineStatus::PIPELINE_OK);
@@ skipping 17 matching lines @@
                   433, kTestBrake, 466, 500, 533, 566,        600};
   std::vector<int> timestamps(tokens, tokens + sizeof(tokens) / sizeof(int));
   provider->QueueFrames(timestamps, opaque_frame, odd_size_frame);
 
   EXPECT_CALL(*this, DoSetWebLayer(true));
   EXPECT_CALL(*this, DoStartRendering());
   EXPECT_CALL(*this, DoReadyStateChanged(
                          blink::WebMediaPlayer::ReadyStateHaveMetadata));
   EXPECT_CALL(*this, DoReadyStateChanged(
                          blink::WebMediaPlayer::ReadyStateHaveEnoughData));
+  gfx::Size frame_size =
+      gfx::Size(kStandardWidth - (odd_size_frame ? kOddSizeOffset : 0),
+                kStandardHeight - (odd_size_frame ? kOddSizeOffset : 0));
+  EXPECT_CALL(*this, CheckSizeChanged(frame_size));
   message_loop_controller_.RunAndWaitForStatus(
       media::PipelineStatus::PIPELINE_OK);
   testing::Mock::VerifyAndClearExpectations(this);
 
   // Here we call pause, and expect a freezing frame.
   EXPECT_CALL(*this, DoStopRendering());
   player_.pause();
   auto prev_frame = compositor_->GetCurrentFrame();
   message_loop_controller_.RunAndWaitForStatus(
       media::PipelineStatus::PIPELINE_OK);
@@ skipping 35 matching lines @@
                   433, kTestBrake, 466, 500, 533, 566,        600};
   std::vector<int> timestamps(tokens, tokens + sizeof(tokens) / sizeof(int));
   provider->QueueFrames(timestamps);
 
   EXPECT_CALL(*this, DoSetWebLayer(true));
   EXPECT_CALL(*this, DoStartRendering());
   EXPECT_CALL(*this, DoReadyStateChanged(
                          blink::WebMediaPlayer::ReadyStateHaveMetadata));
   EXPECT_CALL(*this, DoReadyStateChanged(
                          blink::WebMediaPlayer::ReadyStateHaveEnoughData));
-
+  gfx::Size frame_size = gfx::Size(kStandardWidth, kStandardHeight);
+  EXPECT_CALL(*this, CheckSizeChanged(frame_size));
   message_loop_controller_.RunAndWaitForStatus(
       media::PipelineStatus::PIPELINE_OK);
   testing::Mock::VerifyAndClearExpectations(this);
 
   // Switch to background rendering, expect rendering to continue.
   SetBackgroundRendering(true);
   auto prev_frame = compositor_->GetCurrentFrame();
   message_loop_controller_.RunAndWaitForStatus(
       media::PipelineStatus::PIPELINE_OK);
   auto after_frame = compositor_->GetCurrentFrame();
   EXPECT_NE(prev_frame->timestamp(), after_frame->timestamp());
 
   // Switch to foreground rendering.
   SetBackgroundRendering(false);
   prev_frame = compositor_->GetCurrentFrame();
   message_loop_controller_.RunAndWaitForStatus(
       media::PipelineStatus::PIPELINE_OK);
   after_frame = compositor_->GetCurrentFrame();
   EXPECT_NE(prev_frame->timestamp(), after_frame->timestamp());
   testing::Mock::VerifyAndClearExpectations(this);
 
   EXPECT_CALL(*this, DoSetWebLayer(false));
   EXPECT_CALL(*this, DoStopRendering());
 }
 
+TEST_F(WebMediaPlayerMSTest, FrameSizeChange) {
+  // During this test, the frame size of the input changes.
+  // We need to make sure, when sizeChanged() gets called, new size should be
+  // returned by GetCurrentSize().
+  MockVideoFrameProvider* provider = LoadAndGetFrameProvider(true);
+
+  int tokens[] = {0,   33,  66,  100, 133, 166, 200, 233, 266, 300,
+                  333, 366, 400, 433, 466, 500, 533, 566, 600};
+  std::vector<int> timestamps(tokens, tokens + sizeof(tokens) / sizeof(int));
+  provider->QueueFrames(timestamps, false, false, 7);
+
+  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)));
+  EXPECT_CALL(*this, CheckSizeChanged(
+                         gfx::Size(kStandardWidth * 2, kStandardHeight * 2)));
+  message_loop_controller_.RunAndWaitForStatus(
+      media::PipelineStatus::PIPELINE_OK);
+  testing::Mock::VerifyAndClearExpectations(this);
+
+  EXPECT_CALL(*this, DoSetWebLayer(false));
+  EXPECT_CALL(*this, DoStopRendering());
+}
+
 #if defined(OS_ANDROID)
 TEST_F(WebMediaPlayerMSTest, HiddenPlayerTests) {
   LoadAndGetFrameProvider(true);
 
   // Hidden status should not affect playback.
   delegate_.set_hidden(true);
   player_.play();
   EXPECT_FALSE(player_.paused());
 
   // A pause delivered via the delegate should not pause the video since these
@@ skipping 30 matching lines @@
   EXPECT_TRUE(player_.paused());
 
   // OnShown() should restart after a forced suspension.
   player_.OnShown();
   EXPECT_FALSE(player_.paused());
   EXPECT_CALL(*this, DoSetWebLayer(false));
 }
 #endif
 
 }  // namespace content