Always post deletion of WebMediaPlayerMSCompositor.

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"
 #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"
 
@@ skipping 338 matching lines @@
 // 7. When WebMediaPlayerMS::play gets called, evething paused in step 6 should
 //    be resumed.
 class WebMediaPlayerMSTest
     : public testing::TestWithParam<testing::tuple<bool, bool>> ,
       public blink::WebMediaPlayerClient,
       public cc::VideoFrameProvider::Client {
  public:
   WebMediaPlayerMSTest()
       : render_factory_(new MockRenderFactory(message_loop_.task_runner(),
                                               &message_loop_controller_)),
-        player_(nullptr,
-                this,
-                delegate_.AsWeakPtr(),
-                new media::MediaLog(),
-                std::unique_ptr<MediaStreamRendererFactory>(render_factory_),
-                message_loop_.task_runner(),
-                message_loop_.task_runner(),
-                message_loop_.task_runner(),
-                nullptr,
-                blink::WebString(),
-                blink::WebSecurityOrigin()),
+        player_(new WebMediaPlayerMS(
+            nullptr,
+            this,
+            delegate_.AsWeakPtr(),
+            new media::MediaLog(),
+            std::unique_ptr<MediaStreamRendererFactory>(render_factory_),
+            message_loop_.task_runner(),
+            message_loop_.task_runner(),
+            message_loop_.task_runner(),
+            nullptr,
+            blink::WebString(),
+            blink::WebSecurityOrigin())),
         rendering_(false),
         background_rendering_(false) {}
-  ~WebMediaPlayerMSTest() override {}
+  ~WebMediaPlayerMSTest() override {
+    player_.reset();
+    base::RunLoop().RunUntilIdle();
+  }
 
   MockMediaStreamVideoRenderer* 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;
@@ skipping 41 matching lines @@
 
   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_;
+  std::unique_ptr<WebMediaPlayerMS> player_;
   WebMediaPlayerMSCompositor* compositor_;
   ReusableMessageLoopEvent message_loop_controller_;
 
  private:
   // Main function trying to ask WebMediaPlayerMS to submit a frame for
   // rendering.
   void RenderFrame();
 
   bool rendering_;
   bool background_rendering_;
 };
 
 MockMediaStreamVideoRenderer* WebMediaPlayerMSTest::LoadAndGetFrameProvider(
     bool algorithm_enabled) {
   EXPECT_FALSE(!!render_factory_->provider()) << "There should not be a "
                                                  "FrameProvider yet.";
 
   EXPECT_CALL(
       *this, DoNetworkStateChanged(blink::WebMediaPlayer::NetworkStateLoading));
   EXPECT_CALL(
       *this, DoReadyStateChanged(blink::WebMediaPlayer::ReadyStateHaveNothing));
-  player_.load(blink::WebMediaPlayer::LoadTypeURL,
-               blink::WebMediaPlayerSource(),
-               blink::WebMediaPlayer::CORSModeUnspecified);
-  compositor_ = player_.compositor_.get();
+  player_->load(blink::WebMediaPlayer::LoadTypeURL,
+                blink::WebMediaPlayerSource(),
+                blink::WebMediaPlayer::CORSModeUnspecified);
+  compositor_ = player_->compositor_.get();
   EXPECT_TRUE(!!compositor_);
   compositor_->SetAlgorithmEnabledForTesting(algorithm_enabled);
 
   MockMediaStreamVideoRenderer* const provider = render_factory_->provider();
   EXPECT_TRUE(!!provider);
   EXPECT_TRUE(provider->Started());
 
   testing::Mock::VerifyAndClearExpectations(this);
   return provider;
 }
 
 void WebMediaPlayerMSTest::networkStateChanged() {
-  blink::WebMediaPlayer::NetworkState state = player_.getNetworkState();
+  blink::WebMediaPlayer::NetworkState state = player_->getNetworkState();
   DoNetworkStateChanged(state);
   if (state == blink::WebMediaPlayer::NetworkState::NetworkStateFormatError ||
       state == blink::WebMediaPlayer::NetworkState::NetworkStateDecodeError ||
       state == blink::WebMediaPlayer::NetworkState::NetworkStateNetworkError) {
     message_loop_controller_.GetPipelineStatusCB().Run(
         media::PipelineStatus::PIPELINE_ERROR_NETWORK);
   }
 }
 
 void WebMediaPlayerMSTest::readyStateChanged() {
-  blink::WebMediaPlayer::ReadyState state = player_.getReadyState();
+  blink::WebMediaPlayer::ReadyState state = player_->getReadyState();
   DoReadyStateChanged(state);
   if (state == blink::WebMediaPlayer::ReadyState::ReadyStateHaveEnoughData)
-    player_.play();
+    player_->play();
 }
 
 void WebMediaPlayerMSTest::setWebLayer(blink::WebLayer* layer) {
   if (layer)
     compositor_->SetVideoFrameProviderClient(this);
   DoSetWebLayer(!!layer);
 }
 
 void WebMediaPlayerMSTest::StopUsingProvider() {
   if (rendering_)
@@ skipping 125 matching lines @@
   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();
+  player_->pause();
   auto prev_frame = compositor_->GetCurrentFrameWithoutUpdatingStatistics();
   message_loop_controller_.RunAndWaitForStatus(
       media::PipelineStatus::PIPELINE_OK);
   auto after_frame = compositor_->GetCurrentFrameWithoutUpdatingStatistics();
   EXPECT_EQ(prev_frame->timestamp(), after_frame->timestamp());
   testing::Mock::VerifyAndClearExpectations(this);
 
   EXPECT_CALL(*this, DoSetWebLayer(false));
 }
 
@@ skipping 20 matching lines @@
   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();
+  player_->pause();
   auto prev_frame = compositor_->GetCurrentFrameWithoutUpdatingStatistics();
   message_loop_controller_.RunAndWaitForStatus(
       media::PipelineStatus::PIPELINE_OK);
   auto after_frame = compositor_->GetCurrentFrameWithoutUpdatingStatistics();
   EXPECT_EQ(prev_frame->timestamp(), after_frame->timestamp());
   testing::Mock::VerifyAndClearExpectations(this);
 
   // We resume the player, and expect rendering can continue.
   EXPECT_CALL(*this, DoStartRendering());
-  player_.play();
+  player_->play();
   prev_frame = compositor_->GetCurrentFrameWithoutUpdatingStatistics();
   message_loop_controller_.RunAndWaitForStatus(
       media::PipelineStatus::PIPELINE_OK);
   after_frame = compositor_->GetCurrentFrameWithoutUpdatingStatistics();
   EXPECT_NE(prev_frame->timestamp(), after_frame->timestamp());
   testing::Mock::VerifyAndClearExpectations(this);
 
   EXPECT_CALL(*this, DoSetWebLayer(false));
   EXPECT_CALL(*this, DoStopRendering());
 }
@@ skipping 80 matching lines @@
   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());
+  player_->play();
+  EXPECT_FALSE(player_->paused());
 
   // A pause delivered via the delegate should not pause the video since these
   // calls are currently ignored.
-  player_.OnPause();
-  EXPECT_FALSE(player_.paused());
+  player_->OnPause();
+  EXPECT_FALSE(player_->paused());
 
   // A hidden player should start still be playing upon shown.
   delegate_.set_hidden(false);
-  player_.OnShown();
-  EXPECT_FALSE(player_.paused());
+  player_->OnShown();
+  EXPECT_FALSE(player_->paused());
 
   // A hidden event should not pause the player.
   delegate_.set_hidden(true);
-  player_.OnHidden();
-  EXPECT_FALSE(player_.paused());
+  player_->OnHidden();
+  EXPECT_FALSE(player_->paused());
 
   // A user generated pause() should clear the automatic resumption.
-  player_.pause();
+  player_->pause();
   delegate_.set_hidden(false);
-  player_.OnShown();
-  EXPECT_TRUE(player_.paused());
+  player_->OnShown();
+  EXPECT_TRUE(player_->paused());
 
   // A user generated play() should start playback.
-  player_.play();
-  EXPECT_FALSE(player_.paused());
+  player_->play();
+  EXPECT_FALSE(player_->paused());
 
   // An OnSuspendRequested() without forced suspension should do nothing.
-  player_.OnSuspendRequested(false);
-  EXPECT_FALSE(player_.paused());
+  player_->OnSuspendRequested(false);
+  EXPECT_FALSE(player_->paused());
 
   // An OnSuspendRequested() with forced suspension should pause playback.
-  player_.OnSuspendRequested(true);
-  EXPECT_TRUE(player_.paused());
+  player_->OnSuspendRequested(true);
+  EXPECT_TRUE(player_->paused());
 
   // OnShown() should restart after a forced suspension.
-  player_.OnShown();
-  EXPECT_FALSE(player_.paused());
+  player_->OnShown();
+  EXPECT_FALSE(player_->paused());
   EXPECT_CALL(*this, DoSetWebLayer(false));
 }
 #endif
 
 }  // namespace content