Convert Pass()→std::move() in //media (Android Cast edition)

media/base/android/media_codec_player_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 "media/base/android/media_codec_player.h"
+
 #include <stdint.h>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/timer/timer.h"
 #include "media/base/android/demuxer_android.h"
-#include "media/base/android/media_codec_player.h"
 #include "media/base/android/media_codec_util.h"
 #include "media/base/android/media_player_manager.h"
 #include "media/base/android/media_task_runner.h"
 #include "media/base/android/sdk_media_codec_bridge.h"
 #include "media/base/android/test_data_factory.h"
 #include "media/base/android/test_statistics.h"
 #include "media/base/timestamp_constants.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gl/android/surface_texture.h"
 
@@ skipping 315 matching lines @@
   // Helper methods that enable using a weak pointer when posting to the player.
   void OnDemuxerDataAvailable(const DemuxerData& chunk);
   void OnDemuxerSeekDone(base::TimeDelta reported_seek_time);
 
   // Sets the callback that is fired when demuxer is deleted (deletion
   // happens on the Media thread).
   void SetDemuxerDeletedCallback(base::Closure cb) { demuxer_deleted_cb_ = cb; }
 
   // Sets the audio data factory.
   void SetAudioFactory(scoped_ptr<AudioFactory> factory) {
-    audio_factory_ = factory.Pass();
+    audio_factory_ = std::move(factory);
   }
 
   // Sets the video data factory.
   void SetVideoFactory(scoped_ptr<VideoFactory> factory) {
-    video_factory_ = factory.Pass();
+    video_factory_ = std::move(factory);
   }
 
   // Accessors for data factories.
   AudioFactory* audio_factory() const { return audio_factory_.get(); }
   VideoFactory* video_factory() const { return video_factory_.get(); }
 
   // Set the preroll interval after seek for audio stream.
   void SetAudioPrerollInterval(base::TimeDelta value) {
     audio_preroll_interval_ = value;
   }
@@ skipping 279 matching lines @@
       scoped_ptr<MockDemuxerAndroid>(demuxer_), GURL());
 
   DCHECK(player_);
 }
 
 void MediaCodecPlayerTest::SetVideoSurface() {
   surface_texture_a_ = gfx::SurfaceTexture::Create(0);
   gfx::ScopedJavaSurface surface(surface_texture_a_.get());
 
   ASSERT_NE(nullptr, player_);
-  player_->SetVideoSurface(surface.Pass());
+  player_->SetVideoSurface(std::move(surface));
 }
 
 void MediaCodecPlayerTest::SetVideoSurfaceB() {
   surface_texture_b_ = gfx::SurfaceTexture::Create(1);
   gfx::ScopedJavaSurface surface(surface_texture_b_.get());
 
   ASSERT_NE(nullptr, player_);
-  player_->SetVideoSurface(surface.Pass());
+  player_->SetVideoSurface(std::move(surface));
 }
 
 void MediaCodecPlayerTest::RemoveVideoSurface() {
   player_->SetVideoSurface(gfx::ScopedJavaSurface());
   surface_texture_a_ = NULL;
 }
 
 bool MediaCodecPlayerTest::WaitForCondition(const Predicate& condition,
                                             const base::TimeDelta& timeout) {
   // Let the message_loop_ process events.
@@ skipping 70 matching lines @@
   }
 
   return true;
 }
 
 bool MediaCodecPlayerTest::StartAVPlayback(
     scoped_ptr<AudioFactory> audio_factory,
     scoped_ptr<VideoFactory> video_factory,
     uint32_t flags,
     const char* test_name) {
-  demuxer_->SetAudioFactory(audio_factory.Pass());
-  demuxer_->SetVideoFactory(video_factory.Pass());
+  demuxer_->SetAudioFactory(std::move(audio_factory));
+  demuxer_->SetVideoFactory(std::move(video_factory));
 
   CreatePlayer();
   SetVideoSurface();
 
   // Wait till the player is initialized on media thread.
   EXPECT_TRUE(WaitForCondition(base::Bind(&MockDemuxerAndroid::IsInitialized,
                                           base::Unretained(demuxer_))));
 
   if (!demuxer_->IsInitialized()) {
     DVLOG(0) << test_name << ": demuxer is not initialized";
@@ skipping 39 matching lines @@
 }
 
 bool MediaCodecPlayerTest::StartAVSeekAndPreroll(
     scoped_ptr<AudioFactory> audio_factory,
     scoped_ptr<VideoFactory> video_factory,
     base::TimeDelta seek_position,
     uint32_t flags,
     const char* test_name) {
   // Initialize A/V playback
 
-  demuxer_->SetAudioFactory(audio_factory.Pass());
-  demuxer_->SetVideoFactory(video_factory.Pass());
+  demuxer_->SetAudioFactory(std::move(audio_factory));
+  demuxer_->SetVideoFactory(std::move(video_factory));
 
   CreatePlayer();
   SetVideoSurface();
 
   // Wait till the player is initialized on media thread.
   EXPECT_TRUE(WaitForCondition(base::Bind(&MockDemuxerAndroid::IsInitialized,
                                           base::Unretained(demuxer_))));
 
   if (!demuxer_->IsInitialized()) {
     DVLOG(0) << test_name << ": demuxer is not initialized";
@@ skipping 713 matching lines @@
   // per frame it would take 250 ms to preroll.
   base::TimeDelta seek_position = base::TimeDelta::FromMilliseconds(1000);
   base::TimeDelta preroll_intvl = base::TimeDelta::FromMilliseconds(500);
   base::TimeDelta preroll_timeout = base::TimeDelta::FromMilliseconds(1000);
 
   scoped_ptr<AudioFactory> audio_factory(new AudioFactory(duration));
   scoped_ptr<VideoFactory> video_factory(new VideoFactory(duration));
 
   demuxer_->SetVideoPrerollInterval(preroll_intvl);
 
-  ASSERT_TRUE(StartAVSeekAndPreroll(audio_factory.Pass(), video_factory.Pass(),
-                                    seek_position, 0,
+  ASSERT_TRUE(StartAVSeekAndPreroll(std::move(audio_factory),
+                                    std::move(video_factory), seek_position, 0,
                                     "AVPrerollAudioWaitsForVideo"));
 
   // Wait till preroll finishes and the real playback starts.
   EXPECT_TRUE(
       WaitForCondition(base::Bind(&MockMediaPlayerManager::IsPlaybackStarted,
                                   base::Unretained(&manager_)),
                        preroll_timeout));
 
   // Ensure that the first audio and video pts are close to each other and are
   // reported at the close moments in time.
@@ skipping 27 matching lines @@
   base::TimeDelta preroll_intvl = base::TimeDelta::FromMilliseconds(500);
 
   base::TimeDelta start_timeout = base::TimeDelta::FromMilliseconds(800);
   base::TimeDelta preroll_timeout = base::TimeDelta::FromMilliseconds(1000);
 
   scoped_ptr<AudioFactory> audio_factory(new AudioFactory(duration));
   scoped_ptr<VideoFactory> video_factory(new VideoFactory(duration));
 
   demuxer_->SetVideoPrerollInterval(preroll_intvl);
 
-  ASSERT_TRUE(StartAVSeekAndPreroll(audio_factory.Pass(), video_factory.Pass(),
-                                    seek_position, 0,
+  ASSERT_TRUE(StartAVSeekAndPreroll(std::move(audio_factory),
+                                    std::move(video_factory), seek_position, 0,
                                     "AVPrerollReleaseAndRestart"));
 
   // Issue Release().
   player_->Release();
 
   // Make sure we have not been playing.
   WaitForDelay(base::TimeDelta::FromMilliseconds(400));
 
   EXPECT_FALSE(manager_.HasFirstFrame(DemuxerStream::AUDIO));
   EXPECT_FALSE(manager_.HasFirstFrame(DemuxerStream::VIDEO));
@@ skipping 52 matching lines @@
   base::TimeDelta preroll_intvl = base::TimeDelta::FromMilliseconds(500);
 
   base::TimeDelta start_timeout = base::TimeDelta::FromMilliseconds(800);
   base::TimeDelta preroll_timeout = base::TimeDelta::FromMilliseconds(1000);
 
   scoped_ptr<AudioFactory> audio_factory(new AudioFactory(duration));
   scoped_ptr<VideoFactory> video_factory(new VideoFactory(duration));
 
   demuxer_->SetVideoPrerollInterval(preroll_intvl);
 
-  ASSERT_TRUE(StartAVSeekAndPreroll(audio_factory.Pass(), video_factory.Pass(),
-                                    seek_position, 0,
+  ASSERT_TRUE(StartAVSeekAndPreroll(std::move(audio_factory),
+                                    std::move(video_factory), seek_position, 0,
                                     "AVPrerollStopAndRestart"));
 
   // Video stream should be prerolling. Request to stop.
   EXPECT_FALSE(IsPaused());
   player_->Pause(true);
 
   EXPECT_TRUE(WaitForCondition(
       base::Bind(&MediaCodecPlayerTest::IsPaused, base::Unretained(this))));
 
   // Test that we have not been playing.
@@ skipping 221 matching lines @@
   base::TimeDelta config_change_position =
       base::TimeDelta::FromMilliseconds(1000);
 
   base::TimeDelta completion_timeout = base::TimeDelta::FromMilliseconds(3000);
 
   scoped_ptr<AudioFactory> audio_factory(new AudioFactory(duration));
   scoped_ptr<VideoFactory> video_factory(new VideoFactory(duration));
 
   video_factory->RequestConfigChange(config_change_position);
 
-  ASSERT_TRUE(StartAVPlayback(audio_factory.Pass(), video_factory.Pass(),
-                              kAlwaysReconfigVideo,
+  ASSERT_TRUE(StartAVPlayback(std::move(audio_factory),
+                              std::move(video_factory), kAlwaysReconfigVideo,
                               "AVVideoConfigChangeWhilePlaying"));
 
   // Wait till completion
   EXPECT_TRUE(
       WaitForCondition(base::Bind(&MockMediaPlayerManager::IsPlaybackCompleted,
                                   base::Unretained(&manager_)),
                        completion_timeout));
 
   // The audio codec should be kept.
   EXPECT_EQ(1, manager_.num_audio_codecs_created());
@@ skipping 24 matching lines @@
   base::TimeDelta config_change_position =
       base::TimeDelta::FromMilliseconds(1000);
 
   base::TimeDelta completion_timeout = base::TimeDelta::FromMilliseconds(3000);
 
   scoped_ptr<AudioFactory> audio_factory(new AudioFactory(duration));
   scoped_ptr<VideoFactory> video_factory(new VideoFactory(duration));
 
   audio_factory->RequestConfigChange(config_change_position);
 
-  ASSERT_TRUE(StartAVPlayback(audio_factory.Pass(), video_factory.Pass(),
-                              kAlwaysReconfigAudio,
+  ASSERT_TRUE(StartAVPlayback(std::move(audio_factory),
+                              std::move(video_factory), kAlwaysReconfigAudio,
                               "AVAudioConfigChangeWhilePlaying"));
 
   // Wait till completion
   EXPECT_TRUE(
       WaitForCondition(base::Bind(&MockMediaPlayerManager::IsPlaybackCompleted,
                                   base::Unretained(&manager_)),
                        completion_timeout));
 
   // The audio codec should be recreated upon config changes.
   EXPECT_EQ(2, manager_.num_audio_codecs_created());
@@ skipping 24 matching lines @@
   base::TimeDelta config_change_video = base::TimeDelta::FromMilliseconds(1000);
 
   base::TimeDelta completion_timeout = base::TimeDelta::FromMilliseconds(3000);
 
   scoped_ptr<AudioFactory> audio_factory(new AudioFactory(duration));
   scoped_ptr<VideoFactory> video_factory(new VideoFactory(duration));
 
   audio_factory->RequestConfigChange(config_change_audio);
   video_factory->RequestConfigChange(config_change_video);
 
-  ASSERT_TRUE(StartAVPlayback(audio_factory.Pass(), video_factory.Pass(),
+  ASSERT_TRUE(StartAVPlayback(std::move(audio_factory),
+                              std::move(video_factory),
                               kAlwaysReconfigAudio | kAlwaysReconfigVideo,
                               "AVSimultaneousConfigChange_1"));
 
   // Wait till completion
   EXPECT_TRUE(
       WaitForCondition(base::Bind(&MockMediaPlayerManager::IsPlaybackCompleted,
                                   base::Unretained(&manager_)),
                        completion_timeout));
 
   // The audio codec should be recreated upon config changes.
@@ skipping 26 matching lines @@
   base::TimeDelta config_change_video = base::TimeDelta::FromMilliseconds(1000);
 
   base::TimeDelta completion_timeout = base::TimeDelta::FromMilliseconds(3000);
 
   scoped_ptr<AudioFactory> audio_factory(new AudioFactory(duration));
   scoped_ptr<VideoFactory> video_factory(new VideoFactory(duration));
 
   audio_factory->RequestConfigChange(config_change_audio);
   video_factory->RequestConfigChange(config_change_video);
 
-  ASSERT_TRUE(StartAVPlayback(audio_factory.Pass(), video_factory.Pass(),
+  ASSERT_TRUE(StartAVPlayback(std::move(audio_factory),
+                              std::move(video_factory),
                               kAlwaysReconfigAudio | kAlwaysReconfigVideo,
                               "AVSimultaneousConfigChange_2"));
 
   // Wait till completion
   EXPECT_TRUE(
       WaitForCondition(base::Bind(&MockMediaPlayerManager::IsPlaybackCompleted,
                                   base::Unretained(&manager_)),
                        completion_timeout));
 
   // The audio codec should be recreated upon config changes.
@@ skipping 23 matching lines @@
   base::TimeDelta video_duration = base::TimeDelta::FromMilliseconds(1200);
   base::TimeDelta config_change_video = base::TimeDelta::FromMilliseconds(1000);
 
   base::TimeDelta completion_timeout = base::TimeDelta::FromMilliseconds(3000);
 
   scoped_ptr<AudioFactory> audio_factory(new AudioFactory(audio_duration));
   scoped_ptr<VideoFactory> video_factory(new VideoFactory(video_duration));
 
   video_factory->RequestConfigChange(config_change_video);
 
-  ASSERT_TRUE(StartAVPlayback(audio_factory.Pass(), video_factory.Pass(),
-                              kAlwaysReconfigVideo,
+  ASSERT_TRUE(StartAVPlayback(std::move(audio_factory),
+                              std::move(video_factory), kAlwaysReconfigVideo,
                               "AVAudioEndsAcrossVideoConfigChange"));
 
   // Wait till completion
   EXPECT_TRUE(
       WaitForCondition(base::Bind(&MockMediaPlayerManager::IsPlaybackCompleted,
                                   base::Unretained(&manager_)),
                        completion_timeout));
 
   // The audio codec should not be recreated.
   EXPECT_EQ(1, manager_.num_audio_codecs_created());
@@ skipping 27 matching lines @@
   base::TimeDelta video_duration = base::TimeDelta::FromMilliseconds(1000);
   base::TimeDelta config_change_audio = base::TimeDelta::FromMilliseconds(1000);
 
   base::TimeDelta completion_timeout = base::TimeDelta::FromMilliseconds(3000);
 
   scoped_ptr<AudioFactory> audio_factory(new AudioFactory(audio_duration));
   scoped_ptr<VideoFactory> video_factory(new VideoFactory(video_duration));
 
   audio_factory->RequestConfigChange(config_change_audio);
 
-  ASSERT_TRUE(StartAVPlayback(audio_factory.Pass(), video_factory.Pass(),
-                              kAlwaysReconfigAudio,
+  ASSERT_TRUE(StartAVPlayback(std::move(audio_factory),
+                              std::move(video_factory), kAlwaysReconfigAudio,
                               "AVVideoEndsAcrossAudioConfigChange"));
 
   // Wait till completion
   EXPECT_TRUE(
       WaitForCondition(base::Bind(&MockMediaPlayerManager::IsPlaybackCompleted,
                                   base::Unretained(&manager_)),
                        completion_timeout));
 
   // The audio codec should be recreated upon config changes.
   EXPECT_EQ(2, manager_.num_audio_codecs_created());
@@ skipping 21 matching lines @@
   base::TimeDelta video_preroll_intvl = base::TimeDelta::FromMilliseconds(500);
   base::TimeDelta preroll_timeout = base::TimeDelta::FromMilliseconds(3000);
 
   demuxer_->SetVideoPrerollInterval(video_preroll_intvl);
 
   scoped_ptr<AudioFactory> audio_factory(new AudioFactory(duration));
 
   scoped_ptr<VideoFactory> video_factory(new VideoFactory(duration));
   video_factory->RequestConfigChange(config_change_position);
 
-  ASSERT_TRUE(StartAVSeekAndPreroll(audio_factory.Pass(), video_factory.Pass(),
-                                    seek_position, kAlwaysReconfigVideo,
-                                    "AVPrerollAcrossVideoConfigChange"));
+  ASSERT_TRUE(StartAVSeekAndPreroll(
+      std::move(audio_factory), std::move(video_factory), seek_position,
+      kAlwaysReconfigVideo, "AVPrerollAcrossVideoConfigChange"));
 
   // Wait till preroll finishes and the real playback starts.
   EXPECT_TRUE(
       WaitForCondition(base::Bind(&MockMediaPlayerManager::IsPlaybackStarted,
                                   base::Unretained(&manager_)),
                        preroll_timeout));
 
   // The presense of config change should not affect preroll behavior:
 
   // Ensure that the first audio and video pts are close to each other and are
@@ skipping 26 matching lines @@
   base::TimeDelta audio_preroll_intvl = base::TimeDelta::FromMilliseconds(400);
   base::TimeDelta preroll_timeout = base::TimeDelta::FromMilliseconds(3000);
 
   demuxer_->SetAudioPrerollInterval(audio_preroll_intvl);
 
   scoped_ptr<AudioFactory> audio_factory(new AudioFactory(duration));
   audio_factory->RequestConfigChange(config_change_position);
 
   scoped_ptr<VideoFactory> video_factory(new VideoFactory(duration));
 
-  ASSERT_TRUE(StartAVSeekAndPreroll(audio_factory.Pass(), video_factory.Pass(),
-                                    seek_position, kAlwaysReconfigAudio,
-                                    "AVPrerollAcrossAudioConfigChange"));
+  ASSERT_TRUE(StartAVSeekAndPreroll(
+      std::move(audio_factory), std::move(video_factory), seek_position,
+      kAlwaysReconfigAudio, "AVPrerollAcrossAudioConfigChange"));
 
   // Wait till preroll finishes and the real playback starts.
   EXPECT_TRUE(
       WaitForCondition(base::Bind(&MockMediaPlayerManager::IsPlaybackStarted,
                                   base::Unretained(&manager_)),
                        preroll_timeout));
 
   // The presense of config change should not affect preroll behavior:
 
   // Ensure that the first audio and video pts are close to each other and are
@@ skipping 16 matching lines @@
   // TODO(timav): maybe we should not call the testing callback for
   // kRenderAfterPreroll for video (for audio we already do not call).
   // EXPECT_TRUE(AlmostEqual(manager_.FirstFrameTime(DemuxerStream::AUDIO),
   //                        manager_.FirstFrameTime(DemuxerStream::VIDEO), 50));
 
   // The playback should start at |seek_position|
   EXPECT_TRUE(AlmostEqual(seek_position, manager_.pts_stat_.min(), 25));
 }
 
 }  // namespace media