MediaCodecPlayer implementation (stage 3 - browser seek and surface change)

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 "base/bind.h"
 #include "base/logging.h"
 #include "base/timer/timer.h"
 #include "media/base/android/demuxer_android.h"
 #include "media/base/android/media_codec_bridge.h"
 #include "media/base/android/media_codec_player.h"
@@ skipping 40 matching lines @@
 // The method used to compare two TimeDelta values in expectations.
 bool AlmostEqual(base::TimeDelta a, base::TimeDelta b, double tolerance_ms) {
   return (a - b).magnitude().InMilliseconds() <= tolerance_ms;
 }
 
 // Mock of MediaPlayerManager for testing purpose.
 
 class MockMediaPlayerManager : public MediaPlayerManager {
  public:
   MockMediaPlayerManager()
-      : playback_completed_(false), weak_ptr_factory_(this) {}
+      : playback_completed_(false),
+        num_seeks_completed_(0),
+        weak_ptr_factory_(this) {}
   ~MockMediaPlayerManager() override {}
 
   MediaResourceGetter* GetMediaResourceGetter() override { return nullptr; }
   MediaUrlInterceptor* GetMediaUrlInterceptor() override { return nullptr; }
 
   void OnTimeUpdate(int player_id,
                     base::TimeDelta current_timestamp,
                     base::TimeTicks current_time_ticks) override {
     pts_stat_.AddValue(current_timestamp);
   }
 
   void OnMediaMetadataChanged(int player_id,
                               base::TimeDelta duration,
                               int width,
                               int height,
                               bool success) override {
     media_metadata_.duration = duration;
     media_metadata_.width = width;
     media_metadata_.height = height;
     media_metadata_.modified = true;
   }
 
   void OnPlaybackComplete(int player_id) override {
     playback_completed_ = true;
   }
 
   void OnMediaInterrupted(int player_id) override {}
   void OnBufferingUpdate(int player_id, int percentage) override {}
   void OnSeekComplete(int player_id,
-                      const base::TimeDelta& current_time) override {}
+                      const base::TimeDelta& current_time) override {
+    ++num_seeks_completed_;
+  }
   void OnError(int player_id, int error) override {}
   void OnVideoSizeChanged(int player_id, int width, int height) override {}
   void OnAudibleStateChanged(int player_id, bool is_audible_now) override {}
   void OnWaitingForDecryptionKey(int player_id) override {}
   MediaPlayerAndroid* GetFullscreenPlayer() override { return nullptr; }
   MediaPlayerAndroid* GetPlayer(int player_id) override { return nullptr; }
   bool RequestPlay(int player_id) override { return true; }
 
   void OnMediaResourcesRequested(int player_id) {}
 
   base::WeakPtr<MockMediaPlayerManager> GetWeakPtr() {
     return weak_ptr_factory_.GetWeakPtr();
   }
 
   // Conditions to wait for.
   bool IsMetadataChanged() const { return media_metadata_.modified; }
   bool IsPlaybackCompleted() const { return playback_completed_; }
   bool IsPlaybackStarted() const { return pts_stat_.num_values() > 0; }
   bool IsPlaybackBeyondPosition(const base::TimeDelta& pts) const {
     return pts_stat_.max() > pts;
   }
+  bool IsSeekCompleted() const { return num_seeks_completed_ > 0; }
 
   struct MediaMetadata {
     base::TimeDelta duration;
     int width;
     int height;
     bool modified;
     MediaMetadata() : width(0), height(0), modified(false) {}
   };
   MediaMetadata media_metadata_;
 
   Minimax<base::TimeDelta> pts_stat_;
 
  private:
   bool playback_completed_;
+  int num_seeks_completed_;
 
   base::WeakPtrFactory<MockMediaPlayerManager> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MockMediaPlayerManager);
 };
 
 // Helper method that creates demuxer configuration.
 
 DemuxerConfigs CreateAudioVideoConfigs(const base::TimeDelta& duration,
                                        const gfx::Size& video_size) {
@@ skipping 31 matching lines @@
   void ModifyAccessUnit(int index_in_chunk, AccessUnit* unit) override {
     unit->is_key_frame = true;
   }
 };
 
 // VideoFactory creates a video stream from demuxer.
 
 class VideoFactory : public TestDataFactory {
  public:
   VideoFactory(base::TimeDelta duration)
-      : TestDataFactory("h264-320x180-frame-%d", duration, kVideoFramePeriod) {}
+      : TestDataFactory("h264-320x180-frame-%d", duration, kVideoFramePeriod),
+        key_frame_requested_(true) {}
 
   DemuxerConfigs GetConfigs() const override {
     return TestDataFactory::CreateVideoConfigs(kCodecH264, duration_,
                                                gfx::Size(320, 180));
   }
 
+  void RequestKeyFrame() { key_frame_requested_ = true; }
+
  protected:
   void ModifyAccessUnit(int index_in_chunk, AccessUnit* unit) override {
     // The frames are taken from High profile and some are B-frames.
     // The first 4 frames appear in the file in the following order:
     //
     // Frames:             I P B P
     // Decoding order:     0 1 2 3
     // Presentation order: 0 2 1 4(3)
     //
     // I keep the last PTS to be 3 for simplicity.
 
     // Swap pts for second and third frames. Make first frame a key frame.
     switch (index_in_chunk) {
       case 0:  // first frame
-        unit->is_key_frame = true;
+        unit->is_key_frame = key_frame_requested_;
+        key_frame_requested_ = false;
         break;
       case 1:  // second frame
         unit->timestamp += frame_period_;
         break;
       case 2:  // third frame
         unit->timestamp -= frame_period_;
         break;
       case 3:  // fourth frame, do not modify
         break;
       default:
         NOTREACHED();
         break;
     }
   }
+
+ private:
+  bool key_frame_requested_;
 };
 
 // Mock of DemuxerAndroid for testing purpose.
 
 class MockDemuxerAndroid : public DemuxerAndroid {
  public:
-  MockDemuxerAndroid() : client_(nullptr) {}
+  MockDemuxerAndroid()
+      : client_(nullptr), num_seeks_(0), num_browser_seeks_(0) {}
   ~MockDemuxerAndroid() override {}
 
   // DemuxerAndroid implementation
   void Initialize(DemuxerAndroidClient* client) override;
   void RequestDemuxerData(DemuxerStream::Type type) override;
   void RequestDemuxerSeek(const base::TimeDelta& time_to_seek,
                           bool is_browser_seek) override;
 
   // Sets the audio data factory.
-  void SetAudioFactory(scoped_ptr<TestDataFactory> factory) {
+  void SetAudioFactory(scoped_ptr<AudioFactory> factory) {
     audio_factory_ = factory.Pass();
   }
 
   // Sets the video data factory.
-  void SetVideoFactory(scoped_ptr<TestDataFactory> factory) {
+  void SetVideoFactory(scoped_ptr<VideoFactory> factory) {
     video_factory_ = factory.Pass();
   }
 
+  // Sets the delay in OnDemuxerSeekDone response.
+  void SetSeekDoneDelay(base::TimeDelta delay) { seek_done_delay_ = delay; }
+
   // Post DemuxerConfigs to the client (i.e. the player) on correct thread.
   void PostConfigs(const DemuxerConfigs& configs);
 
   // Post DemuxerConfigs derived from data factories that has been set.
   void PostInternalConfigs();
 
   // Conditions to wait for.
   bool IsInitialized() const { return client_; }
   bool HasPendingConfigs() const { return pending_configs_; }
+  bool ReceivedSeekRequest() const { return num_seeks_ > 0; }
+  bool ReceivedBrowserSeekRequest() const { return num_browser_seeks_ > 0; }
 
  private:
   DemuxerAndroidClient* client_;
   scoped_ptr<DemuxerConfigs> pending_configs_;
-  scoped_ptr<TestDataFactory> audio_factory_;
-  scoped_ptr<TestDataFactory> video_factory_;
+  scoped_ptr<AudioFactory> audio_factory_;
+  scoped_ptr<VideoFactory> video_factory_;
+  base::TimeDelta seek_done_delay_;
+  int num_seeks_;
+  int num_browser_seeks_;
 
   DISALLOW_COPY_AND_ASSIGN(MockDemuxerAndroid);
 };
 
 void MockDemuxerAndroid::Initialize(DemuxerAndroidClient* client) {
   DVLOG(1) << "MockDemuxerAndroid::" << __FUNCTION__;
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 
   client_ = client;
   if (pending_configs_)
@@ skipping 21 matching lines @@
       FROM_HERE, base::Bind(&DemuxerAndroidClient::OnDemuxerDataAvailable,
                             base::Unretained(client_), chunk),
       delay);
 }
 
 void MockDemuxerAndroid::RequestDemuxerSeek(const base::TimeDelta& time_to_seek,
                                             bool is_browser_seek) {
   // Tell data factories to start next chunk with the new timestamp.
   if (audio_factory_)
     audio_factory_->SeekTo(time_to_seek);
-  if (video_factory_)
+  if (video_factory_) {
     video_factory_->SeekTo(time_to_seek);
+    video_factory_->RequestKeyFrame();
+  }
+
+  ++num_seeks_;
+  if (is_browser_seek)
+    ++num_browser_seeks_;
 
   // Post OnDemuxerSeekDone() to the player.
   DCHECK(client_);
   base::TimeDelta reported_seek_time =
       is_browser_seek ? time_to_seek : kNoTimestamp();
-  GetMediaTaskRunner()->PostTask(
+  GetMediaTaskRunner()->PostDelayedTask(
       FROM_HERE, base::Bind(&DemuxerAndroidClient::OnDemuxerSeekDone,
-                            base::Unretained(client_), reported_seek_time));
+                            base::Unretained(client_), reported_seek_time),
+      seek_done_delay_);
 }
 
 void MockDemuxerAndroid::PostConfigs(const DemuxerConfigs& configs) {
   RUN_ON_MEDIA_THREAD(MockDemuxerAndroid, PostConfigs, configs);
 
   DVLOG(1) << "MockDemuxerAndroid::" << __FUNCTION__;
 
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 
   if (client_)
@@ skipping 25 matching lines @@
   ~MediaCodecPlayerTest() override;
 
   // Conditions to wait for.
   bool IsPaused() const { return !(player_ && player_->IsPlaying()); }
 
  protected:
   typedef base::Callback<bool()> Predicate;
 
   void CreatePlayer();
   void SetVideoSurface();
+  void SetVideoSurfaceB();
+  void RemoveVideoSurface();
 
   // Waits for condition to become true or for timeout to expire.
   // Returns true if the condition becomes true.
   bool WaitForCondition(const Predicate& condition,
                         const base::TimeDelta& timeout = kDefaultTimeout);
 
   // Waits for timeout to expire.
   void WaitForDelay(const base::TimeDelta& timeout);
 
   // Waits till playback position as determined by maximal reported pts
   // reaches the given value or for timeout to expire. Returns true if the
   // playback has passed the given position.
   bool WaitForPlaybackBeyondPosition(
       const base::TimeDelta& pts,
       const base::TimeDelta& timeout = kDefaultTimeout);
 
+  // Helper method that starts video only stream. Waits till it actually
+  // started.
+  void StartVideoPlayback(base::TimeDelta duration);
+
   base::MessageLoop message_loop_;
   MockMediaPlayerManager manager_;
   MockDemuxerAndroid* demuxer_;  // owned by player_
-  scoped_refptr<gfx::SurfaceTexture> surface_texture_;
+  scoped_refptr<gfx::SurfaceTexture> surface_texture_a_;
+  scoped_refptr<gfx::SurfaceTexture> surface_texture_b_;
   MediaCodecPlayer* player_;     // raw pointer due to DeleteOnCorrectThread()
 
  private:
   bool is_timeout_expired() const { return is_timeout_expired_; }
   void SetTimeoutExpired(bool value) { is_timeout_expired_ = value; }
 
   bool is_timeout_expired_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaCodecPlayerTest);
 };
@@ skipping 13 matching lines @@
       0,  // player_id
       manager_.GetWeakPtr(),
       base::Bind(&MockMediaPlayerManager::OnMediaResourcesRequested,
                  base::Unretained(&manager_)),
       scoped_ptr<MockDemuxerAndroid>(demuxer_), GURL());
 
   DCHECK(player_);
 }
 
 void MediaCodecPlayerTest::SetVideoSurface() {
-  surface_texture_ = gfx::SurfaceTexture::Create(0);
-  gfx::ScopedJavaSurface surface(surface_texture_.get());
+  surface_texture_a_ = gfx::SurfaceTexture::Create(0);
+  gfx::ScopedJavaSurface surface(surface_texture_a_.get());
 
   ASSERT_NE(nullptr, player_);
   player_->SetVideoSurface(surface.Pass());
 }
 
+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());
+}
+
+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.
   // We start the timer and RunUntilIdle() until it signals.
 
   SetTimeoutExpired(false);
 
   base::Timer timer(false, false);
   timer.Start(FROM_HERE, timeout,
               base::Bind(&MediaCodecPlayerTest::SetTimeoutExpired,
@@ skipping 17 matching lines @@
 
 bool MediaCodecPlayerTest::WaitForPlaybackBeyondPosition(
     const base::TimeDelta& pts,
     const base::TimeDelta& timeout) {
   return WaitForCondition(
       base::Bind(&MockMediaPlayerManager::IsPlaybackBeyondPosition,
                  base::Unretained(&manager_), pts),
       timeout);
 }
 
+void MediaCodecPlayerTest::StartVideoPlayback(base::TimeDelta duration) {
+  const base::TimeDelta start_timeout = base::TimeDelta::FromMilliseconds(800);
+
+  demuxer_->SetVideoFactory(
+      scoped_ptr<VideoFactory>(new VideoFactory(duration)));
+
+  CreatePlayer();
+  SetVideoSurface();
+
+  // Wait till the player is initialized on media thread.
+  EXPECT_TRUE(WaitForCondition(base::Bind(&MockDemuxerAndroid::IsInitialized,
+                                          base::Unretained(demuxer_))));
+
+  // Post configuration after the player has been initialized.
+  demuxer_->PostInternalConfigs();
+
+  // Start the player.
+  EXPECT_FALSE(manager_.IsPlaybackStarted());
+  player_->Start();
+
+  // Wait for playback to start.
+  EXPECT_TRUE(
+      WaitForCondition(base::Bind(&MockMediaPlayerManager::IsPlaybackStarted,
+                                  base::Unretained(&manager_)),
+                       start_timeout));
+}
+
 TEST_F(MediaCodecPlayerTest, SetAudioConfigsBeforePlayerCreation) {
   // Post configuration when there is no player yet.
   EXPECT_EQ(nullptr, player_);
 
   base::TimeDelta duration = base::TimeDelta::FromSeconds(10);
 
   demuxer_->PostConfigs(
       TestDataFactory::CreateAudioConfigs(kCodecAAC, duration));
 
   // Wait until the configuration gets to the media thread.
@@ skipping 88 matching lines @@
   base::TimeDelta audio_pts_delay = base::TimeDelta::FromMilliseconds(100);
   EXPECT_LT(duration - audio_pts_delay, manager_.pts_stat_.max());
 }
 
 TEST_F(MediaCodecPlayerTest, VideoPlayTillCompletion) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(500);
   base::TimeDelta timeout = base::TimeDelta::FromMilliseconds(1500);
 
-  demuxer_->SetVideoFactory(
-      scoped_ptr<VideoFactory>(new VideoFactory(duration)));
+  StartVideoPlayback(duration);
 
-  CreatePlayer();
-  SetVideoSurface();
-
-  // Wait till the player is initialized on media thread.
-  EXPECT_TRUE(WaitForCondition(base::Bind(&MockDemuxerAndroid::IsInitialized,
-                                          base::Unretained(demuxer_))));
-
-  // Post configuration after the player has been initialized.
-  demuxer_->PostInternalConfigs();
-
-  EXPECT_FALSE(manager_.IsPlaybackCompleted());
-
-  player_->Start();
-
+  // Wait till completion.
   EXPECT_TRUE(
       WaitForCondition(base::Bind(&MockMediaPlayerManager::IsPlaybackCompleted,
                                   base::Unretained(&manager_)),
                        timeout));
 
   EXPECT_LE(duration, manager_.pts_stat_.max());
 }
 
 TEST_F(MediaCodecPlayerTest, AudioSeekAfterStop) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
@@ skipping 41 matching lines @@
 
   player_->Start();
 
   // Wait for playback to start.
   EXPECT_TRUE(
       WaitForCondition(base::Bind(&MockMediaPlayerManager::IsPlaybackStarted,
                                   base::Unretained(&manager_))));
 
   // Make sure we started from the beginninig
   EXPECT_GT(base::TimeDelta::FromMilliseconds(40), manager_.pts_stat_.min());
+
+  // The player should have reported the seek completion to the manager.
+  EXPECT_TRUE(WaitForCondition(base::Bind(
+      &MockMediaPlayerManager::IsSeekCompleted, base::Unretained(&manager_))));
 }
 
 TEST_F(MediaCodecPlayerTest, AudioSeekThenPlay) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Issue Seek command immediately followed by Start. The playback should
   // start at the seek position.
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(2000);
   base::TimeDelta seek_position = base::TimeDelta::FromMilliseconds(500);
@@ skipping 10 matching lines @@
   player_->SeekTo(seek_position);
   player_->Start();
 
   // Wait for playback to start.
   EXPECT_TRUE(
       WaitForCondition(base::Bind(&MockMediaPlayerManager::IsPlaybackStarted,
                                   base::Unretained(&manager_))));
 
   // The playback should start at |seek_position|
   EXPECT_TRUE(AlmostEqual(seek_position, manager_.pts_stat_.min(), 1));
+
+  // The player should have reported the seek completion to the manager.
+  EXPECT_TRUE(WaitForCondition(base::Bind(
+      &MockMediaPlayerManager::IsSeekCompleted, base::Unretained(&manager_))));
 }
 
 TEST_F(MediaCodecPlayerTest, AudioSeekThenPlayThenConfig) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Issue Seek command immediately followed by Start but without prior demuxer
   // configuration. Start should wait for configuration. After it has been
   // posted the playback should start at the seek position.
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(2000);
@@ skipping 15 matching lines @@
   // Post configuration.
   demuxer_->PostInternalConfigs();
 
   // Wait for playback to start.
   EXPECT_TRUE(
       WaitForCondition(base::Bind(&MockMediaPlayerManager::IsPlaybackStarted,
                                   base::Unretained(&manager_))));
 
   // The playback should start at |seek_position|
   EXPECT_TRUE(AlmostEqual(seek_position, manager_.pts_stat_.min(), 1));
+
+  // The player should have reported the seek completion to the manager.
+  EXPECT_TRUE(WaitForCondition(base::Bind(
+      &MockMediaPlayerManager::IsSeekCompleted, base::Unretained(&manager_))));
 }
 
 TEST_F(MediaCodecPlayerTest, AudioSeekWhilePlaying) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Play for 300 ms, then issue several Seek commands in the row.
   // The playback should continue at the last seek position.
 
   // To test this condition without analyzing the reported time details
   // and without introducing dependency on implementation I make a long (10s)
@@ skipping 25 matching lines @@
 
   // Seek forward several times.
   player_->SeekTo(base::TimeDelta::FromSeconds(3));
   player_->SeekTo(base::TimeDelta::FromSeconds(4));
   player_->SeekTo(base::TimeDelta::FromSeconds(5));
 
   // Make sure that we reached the last timestamp within default timeout,
   // i.e. 200 ms.
   EXPECT_TRUE(WaitForPlaybackBeyondPosition(base::TimeDelta::FromSeconds(5)));
   EXPECT_TRUE(player_->IsPlaying());
+
+  // The player should have reported the seek completion to the manager.
+  EXPECT_TRUE(WaitForCondition(base::Bind(
+      &MockMediaPlayerManager::IsSeekCompleted, base::Unretained(&manager_))));
+}
+
+TEST_F(MediaCodecPlayerTest, VideoReplaceSurface) {
+  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+
+  base::TimeDelta duration = base::TimeDelta::FromMilliseconds(1000);
+  base::TimeDelta timeout = base::TimeDelta::FromMilliseconds(1500);
+
+  StartVideoPlayback(duration);
+
+  // Wait for some time and check statistics.
+  WaitForDelay(base::TimeDelta::FromMilliseconds(200));
+
+  // Make sure we played at least 100 ms.
+  EXPECT_LT(base::TimeDelta::FromMilliseconds(100), manager_.pts_stat_.max());
+
+  // Set new video surface without removing the old one.
+  SetVideoSurfaceB();
+
+  // We should receive a browser seek request.
+  EXPECT_TRUE(WaitForCondition(
+      base::Bind(&MockDemuxerAndroid::ReceivedBrowserSeekRequest,
+                 base::Unretained(demuxer_))));
+
+  // Playback should continue with a new surface. Wait till completion.
+  EXPECT_TRUE(
+      WaitForCondition(base::Bind(&MockMediaPlayerManager::IsPlaybackCompleted,
+                                  base::Unretained(&manager_)),
+                       timeout));
+  EXPECT_LE(duration, manager_.pts_stat_.max());
+}
+
+TEST_F(MediaCodecPlayerTest, VideoRemoveAndSetSurface) {
+  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+
+  base::TimeDelta duration = base::TimeDelta::FromMilliseconds(1000);
+
+  StartVideoPlayback(duration);
+
+  // Wait for some time and check statistics.
+  WaitForDelay(base::TimeDelta::FromMilliseconds(200));
+
+  // Make sure we played at least 100 ms.
+  EXPECT_LT(base::TimeDelta::FromMilliseconds(100), manager_.pts_stat_.max());
+
+  // Remove video surface.
+  RemoveVideoSurface();
+
+  // We should be stuck waiting for the new surface.
+  WaitForDelay(base::TimeDelta::FromMilliseconds(200));
+  EXPECT_FALSE(player_->IsPlaying());
+
+  // Save last PTS and clear statistics.
+  base::TimeDelta max_pts_before_removal = manager_.pts_stat_.max();
+  manager_.pts_stat_.Clear();
+
+  // After clearing statistics we are ready to wait for IsPlaybackStarted again.
+  EXPECT_FALSE(manager_.IsPlaybackStarted());
+
+  // Extra RemoveVideoSurface() should not change anything.
+  RemoveVideoSurface();
+
+  // Set another video surface.
+  SetVideoSurfaceB();
+
+  // We should receive a browser seek request.
+  EXPECT_TRUE(WaitForCondition(
+      base::Bind(&MockDemuxerAndroid::ReceivedBrowserSeekRequest,
+                 base::Unretained(demuxer_))));
+
+  // Playback should continue with a new surface. Wait till it starts again.
+  base::TimeDelta reconfigure_timeout = base::TimeDelta::FromMilliseconds(800);
+  EXPECT_TRUE(
+      WaitForCondition(base::Bind(&MockMediaPlayerManager::IsPlaybackStarted,
+                                  base::Unretained(&manager_)),
+                       reconfigure_timeout));
+
+  // Timestamps should not go back.
+  EXPECT_LE(max_pts_before_removal, manager_.pts_stat_.max());
+}
+
+TEST_F(MediaCodecPlayerTest, VideoReleaseAndStart) {
+  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+
+  base::TimeDelta duration = base::TimeDelta::FromMilliseconds(1000);
+
+  StartVideoPlayback(duration);
+
+  // Wait for some time and check statistics.
+  WaitForDelay(base::TimeDelta::FromMilliseconds(200));
+
+  // Make sure we played at least 100 ms.
+  EXPECT_LT(base::TimeDelta::FromMilliseconds(100), manager_.pts_stat_.max());
+
+  // When the user presses Tasks button Chrome calls Pause() and Release().
+  player_->Pause(true);
+  player_->Release();
+
+  // Make sure we are not playing any more.
+  WaitForDelay(base::TimeDelta::FromMilliseconds(200));
+  EXPECT_FALSE(player_->IsPlaying());
+
+  // Save last PTS and clear statistics.
+  base::TimeDelta max_pts_before_backgrounding = manager_.pts_stat_.max();
+  manager_.pts_stat_.Clear();
+
+  // After clearing statistics we are ready to wait for IsPlaybackStarted again.
+  EXPECT_FALSE(manager_.IsPlaybackStarted());
+
+  // Restart.
+  SetVideoSurface();
+  player_->Start();
+
+  // We should receive a browser seek request.
+  EXPECT_TRUE(WaitForCondition(
+      base::Bind(&MockDemuxerAndroid::ReceivedBrowserSeekRequest,
+                 base::Unretained(demuxer_))));
+
+  // Wait for playback to start again.
+  base::TimeDelta reconfigure_timeout = base::TimeDelta::FromMilliseconds(800);
+  EXPECT_TRUE(
+      WaitForCondition(base::Bind(&MockMediaPlayerManager::IsPlaybackStarted,
+                                  base::Unretained(&manager_)),
+                       reconfigure_timeout));
+
+  // Timestamps should not go back.
+  EXPECT_LE(max_pts_before_backgrounding, manager_.pts_stat_.max());
+}
+
+TEST_F(MediaCodecPlayerTest, VideoSeekAndRelease) {
+  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+
+  base::TimeDelta duration = base::TimeDelta::FromMilliseconds(2000);
+  base::TimeDelta seek_position = base::TimeDelta::FromMilliseconds(1000);
+
+  StartVideoPlayback(duration);
+
+  // Wait for some time and check statistics.
+  WaitForDelay(base::TimeDelta::FromMilliseconds(200));
+
+  // Make sure we played at least 100 ms.
+  EXPECT_LT(base::TimeDelta::FromMilliseconds(100), manager_.pts_stat_.max());
+
+  // Issue SeekTo() immediately followed by Release().
+  player_->SeekTo(seek_position);
+  player_->Release();
+
+  // Make sure we are not playing any more.
+  WaitForDelay(base::TimeDelta::FromMilliseconds(400));
+  EXPECT_FALSE(player_->IsPlaying());
+
+  // The Release() should not cancel the SeekTo() and we should have received
+  // the seek request by this time.
+  EXPECT_TRUE(demuxer_->ReceivedSeekRequest());
+
+  // The player should have reported the seek completion to the manager.
+  EXPECT_TRUE(WaitForCondition(base::Bind(
+      &MockMediaPlayerManager::IsSeekCompleted, base::Unretained(&manager_))));
+
+  // Clear statistics.
+  manager_.pts_stat_.Clear();
+
+  // After clearing statistics we are ready to wait for IsPlaybackStarted again.
+  EXPECT_FALSE(manager_.IsPlaybackStarted());
+
+  // Restart.
+  SetVideoSurface();
+  player_->Start();
+
+  // Wait for playback to start again.
+  base::TimeDelta reconfigure_timeout = base::TimeDelta::FromMilliseconds(800);
+  EXPECT_TRUE(
+      WaitForCondition(base::Bind(&MockMediaPlayerManager::IsPlaybackStarted,
+                                  base::Unretained(&manager_)),
+                       reconfigure_timeout));
+
+  // Timestamps should start at the new seek position
+  EXPECT_LE(seek_position, manager_.pts_stat_.min());
+}
+
+TEST_F(MediaCodecPlayerTest, VideoReleaseWhileWaitingForSeek) {
+  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+
+  base::TimeDelta duration = base::TimeDelta::FromMilliseconds(2000);
+  base::TimeDelta seek_position = base::TimeDelta::FromMilliseconds(1000);
+
+  StartVideoPlayback(duration);
+
+  // Wait for some time and check statistics.
+  WaitForDelay(base::TimeDelta::FromMilliseconds(200));
+
+  // Make sure we played at least 100 ms.
+  EXPECT_LT(base::TimeDelta::FromMilliseconds(100), manager_.pts_stat_.max());
+
+  // Set artificial delay in the OnDemuxerSeekDone response so we can
+  // issue commands while the player is in the STATE_WAITING_FOR_SEEK.
+  demuxer_->SetSeekDoneDelay(base::TimeDelta::FromMilliseconds(100));
+
+  // Issue SeekTo().
+  player_->SeekTo(seek_position);
+
+  // Wait for the seek request to demuxer.
+  EXPECT_TRUE(WaitForCondition(base::Bind(
+      &MockDemuxerAndroid::ReceivedSeekRequest, base::Unretained(demuxer_))));
+
+  // The player is supposed to be in STATE_WAITING_FOR_SEEK. Issue Release().
+  player_->Release();
+
+  // Make sure we are not playing any more.
+  WaitForDelay(base::TimeDelta::FromMilliseconds(400));
+  EXPECT_FALSE(player_->IsPlaying());
+
+  // Clear statistics.
+  manager_.pts_stat_.Clear();
+
+  // After clearing statistics we are ready to wait for IsPlaybackStarted again.
+  EXPECT_FALSE(manager_.IsPlaybackStarted());
+
+  // Restart.
+  SetVideoSurface();
+  player_->Start();
+
+  // Wait for playback to start again.
+  base::TimeDelta reconfigure_timeout = base::TimeDelta::FromMilliseconds(1000);
+  EXPECT_TRUE(
+      WaitForCondition(base::Bind(&MockMediaPlayerManager::IsPlaybackStarted,
+                                  base::Unretained(&manager_)),
+                       reconfigure_timeout));
+
+  // Timestamps should start at the new seek position
+  EXPECT_LE(seek_position, manager_.pts_stat_.min());
+
+  // The player should have reported the seek completion to the manager.
+  EXPECT_TRUE(WaitForCondition(base::Bind(
+      &MockMediaPlayerManager::IsSeekCompleted, base::Unretained(&manager_))));
 }
 
 }  // namespace media