Convert media constants to constexpr.

media/base/android/media_source_player_unittest.cc

 // Copyright 2013 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_source_player.h"
 
 #include <stdint.h>
 
 #include <string>
 #include <utility>
@@ skipping 469 matching lines @@
 
     // Wait for the decode job to finish so we can process the seek request.
     WaitForDecodeDone(is_audio, !is_audio);
 
     // Verify that the seek is requested.
     EXPECT_EQ(original_num_seeks + 1, demuxer_->num_seek_requests());
 
     // Send back the seek done notification. This should trigger the player to
     // call OnReadFromDemuxer() again.
     EXPECT_EQ(original_num_data_requests, demuxer_->num_data_requests());
-    player_.OnDemuxerSeekDone(kNoTimestamp());
+    player_.OnDemuxerSeekDone(kNoTimestamp);
     EXPECT_EQ(original_num_data_requests + 1, demuxer_->num_data_requests());
 
     // No other seek should have been requested.
     EXPECT_EQ(original_num_seeks + 1, demuxer_->num_seek_requests());
   }
 
   // Preroll the decoder job to |target_timestamp|. The first access unit
   // to decode will have a timestamp equal to |start_timestamp|.
   // |is_clock_manager| indicates whether the decoder serves as the clock
   // manager for the player.
@@ skipping 260 matching lines @@
     EXPECT_EQ(original_num_data_requests, demuxer_->num_data_requests());
   }
 
   void VerifyCompletedPlaybackResumesOnSeekPlusStart(bool have_audio,
                                                      bool have_video) {
     DCHECK(have_audio || have_video);
 
     EXPECT_TRUE(manager_.playback_completed());
 
     player_.SeekTo(base::TimeDelta());
-    player_.OnDemuxerSeekDone(kNoTimestamp());
+    player_.OnDemuxerSeekDone(kNoTimestamp);
     Resume(have_audio, have_video);
   }
 
   // Starts the appropriate decoder jobs according to |have_audio| and
   // |have_video|. Then starts seek during decode of EOS or non-EOS according to
   // |eos_audio| and |eos_video|. Simulates seek completion and verifies that
   // playback never completed. |eos_{audio,video}| is ignored if the
   // corresponding |have_{audio,video}| is false.
   void VerifySeekDuringEOSDecodePreventsPlaybackCompletion(bool have_audio,
                                                            bool have_video,
@@ skipping 32 matching lines @@
         player_.OnDemuxerDataAvailable(CreateEOSAck(false));
       else
         player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo(false));
     }
 
     player_.SeekTo(base::TimeDelta());
     EXPECT_EQ(0, demuxer_->num_seek_requests());
     WaitForDecodeDone(have_audio, have_video);
     EXPECT_EQ(1, demuxer_->num_seek_requests());
 
-    player_.OnDemuxerSeekDone(kNoTimestamp());
+    player_.OnDemuxerSeekDone(kNoTimestamp);
     EXPECT_FALSE(manager_.playback_completed());
   }
 
   base::TimeTicks StartTimeTicks() {
     return player_.start_time_ticks_;
   }
 
   bool IsRequestingDemuxerData(bool is_audio) {
     return GetMediaDecoderJob(is_audio)->is_requesting_demuxer_data_;
   }
@@ skipping 119 matching lines @@
   // Initiate a seek. Skip requesting element seek of renderer.
   // Instead behave as if the renderer has asked us to seek.
   player_.SeekTo(base::TimeDelta());
   EXPECT_EQ(1, demuxer_->num_seek_requests());
 
   CreateNextTextureAndSetVideoSurface();
   EXPECT_EQ(1, demuxer_->num_seek_requests());
   player_.Start();
 
   // Send the seek done notification. The player should start requesting data.
-  player_.OnDemuxerSeekDone(kNoTimestamp());
+  player_.OnDemuxerSeekDone(kNoTimestamp);
   EXPECT_FALSE(GetMediaCodecBridge(false));
   EXPECT_EQ(1, demuxer_->num_data_requests());
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo(false));
   EXPECT_TRUE(GetMediaCodecBridge(false));
 
   // Reconfirm exactly 1 seek request has been made of demuxer, and that it
   // was not a browser seek request.
   EXPECT_EQ(1, demuxer_->num_seek_requests());
   EXPECT_EQ(0, demuxer_->num_browser_seek_requests());
   WaitForVideoDecodeDone();
@@ skipping 109 matching lines @@
 
   // Initiate a seek. Skip requesting element seek of renderer.
   // Instead behave as if the renderer has asked us to seek.
   player_.SeekTo(base::TimeDelta());
   EXPECT_EQ(1, demuxer_->num_seek_requests());
 
   player_.Start();
   EXPECT_EQ(0, demuxer_->num_data_requests());
 
   // Sending back the seek done notification.
-  player_.OnDemuxerSeekDone(kNoTimestamp());
+  player_.OnDemuxerSeekDone(kNoTimestamp);
   EXPECT_FALSE(GetMediaCodecBridge(true));
   EXPECT_EQ(1, demuxer_->num_data_requests());
 
   // Reconfirm exactly 1 seek request has been made of demuxer.
   EXPECT_EQ(1, demuxer_->num_seek_requests());
 
   // Decoder is created after data is received.
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(0));
   EXPECT_TRUE(GetMediaCodecBridge(true));
 }
 
 TEST_F(MediaSourcePlayerTest, VideoOnlyStartAfterSeekFinish) {
   // crbug.com/604602 and crbug.com/597836
   SKIP_TEST_IF_VP8_DECODER_IS_NOT_SUPPORTED();
 
   // Test video decoder job will not start until pending seek event is handled.
   CreateNextTextureAndSetVideoSurface();
   DemuxerConfigs configs = CreateVideoDemuxerConfigs(false);
   player_.OnDemuxerConfigsAvailable(configs);
 
   // Initiate a seek. Skip requesting element seek of renderer.
   // Instead behave as if the renderer has asked us to seek.
   player_.SeekTo(base::TimeDelta());
   EXPECT_EQ(1, demuxer_->num_seek_requests());
 
   player_.Start();
   EXPECT_EQ(0, demuxer_->num_data_requests());
 
   // Sending back the seek done notification.
-  player_.OnDemuxerSeekDone(kNoTimestamp());
+  player_.OnDemuxerSeekDone(kNoTimestamp);
   EXPECT_FALSE(GetMediaCodecBridge(false));
   EXPECT_EQ(1, demuxer_->num_data_requests());
 
   // Reconfirm exactly 1 seek request has been made of demuxer.
   EXPECT_EQ(1, demuxer_->num_seek_requests());
 
   // Decoder is created after data is received.
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo(false));
   EXPECT_TRUE(GetMediaCodecBridge(false));
   WaitForVideoDecodeDone();
@@ skipping 361 matching lines @@
   // still has no video codec configured, and has not requested any
   // further data since the surface change event became pending in
   // BrowserSeekPlayer().
   EXPECT_EQ(1, demuxer_->num_seek_requests());
   player_.OnDemuxerSeekDone(base::TimeDelta());
   EXPECT_EQ(2, demuxer_->num_seek_requests());
   EXPECT_EQ(1, demuxer_->num_browser_seek_requests());
 
   // Simulate regular seek is done and confirm player requests more data for
   // new video codec.
-  player_.OnDemuxerSeekDone(kNoTimestamp());
+  player_.OnDemuxerSeekDone(kNoTimestamp);
   EXPECT_FALSE(GetMediaCodecBridge(false));
   EXPECT_EQ(3, demuxer_->num_data_requests());
   EXPECT_EQ(2, demuxer_->num_seek_requests());
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo(false));
   EXPECT_TRUE(GetMediaCodecBridge(false));
   WaitForVideoDecodeDone();
 }
 
 TEST_F(MediaSourcePlayerTest, BrowserSeek_InitialReleaseAndStart) {
   // crbug.com/604602 and crbug.com/597836
@@ skipping 232 matching lines @@
 
   // Initiate a seek.
   base::TimeDelta seek_position = base::TimeDelta::FromMilliseconds(100);
   player_.SeekTo(seek_position);
   player_.OnDemuxerDataAvailable(CreateAbortedAck(true));
   player_.OnDemuxerDataAvailable(CreateAbortedAck(false));
   WaitForDecodeDone(true, true);
 
   // Verify that the seek is requested.
   EXPECT_EQ(1, demuxer_->num_seek_requests());
-  player_.OnDemuxerSeekDone(kNoTimestamp());
+  player_.OnDemuxerSeekDone(kNoTimestamp);
   EXPECT_EQ(4, demuxer_->num_data_requests());
   EXPECT_EQ(player_.GetCurrentTime().InMillisecondsF(), 100.0);
   EXPECT_EQ(GetPrerollTimestamp().InMillisecondsF(), 100.0);
 
   // Send both audio and video data to finish prefetching.
   base::TimeDelta seek_ack_position = base::TimeDelta::FromMilliseconds(70);
   DemuxerData audio_data = CreateReadFromDemuxerAckForAudio(0);
   audio_data.access_units[0].timestamp = seek_ack_position;
   DemuxerData video_data = CreateReadFromDemuxerAckForVideo(false);
   video_data.access_units[0].timestamp = seek_ack_position;
@@ skipping 205 matching lines @@
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test if a decoder is being drained while receiving a seek request, draining
   // is canceled.
   SendConfigChangeToDecoder(true, false, 0, false);
   EXPECT_TRUE(IsDrainingDecoder(true));
 
   player_.SeekTo(base::TimeDelta::FromMilliseconds(100));
   WaitForAudioDecodeDone();
   EXPECT_FALSE(IsDrainingDecoder(true));
-  player_.OnDemuxerSeekDone(kNoTimestamp());
+  player_.OnDemuxerSeekDone(kNoTimestamp);
 
   EXPECT_EQ(1, demuxer_->num_seek_requests());
   EXPECT_EQ(4, demuxer_->num_data_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, DecoderDrainInterruptedByRelease) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test if a decoder is being drained while receiving a release request,
   // draining is canceled.
@@ skipping 115 matching lines @@
   // has not yet been sent, then the seek request is sent after Release(). Also,
   // test if OnDemuxerSeekDone() occurs prior to next Start(), then the player
   // will resume correct post-seek preroll upon Start().
   StartAudioDecoderJobAndSeekToWhileDecoding(
       base::TimeDelta::FromMilliseconds(100));
   ReleasePlayer();
   EXPECT_EQ(0, demuxer_->num_seek_requests());
   WaitForAudioDecodeDone();
   EXPECT_EQ(1, demuxer_->num_seek_requests());
 
-  player_.OnDemuxerSeekDone(kNoTimestamp());
+  player_.OnDemuxerSeekDone(kNoTimestamp);
   EXPECT_EQ(100.0, GetPrerollTimestamp().InMillisecondsF());
   EXPECT_FALSE(GetMediaCodecBridge(true));
   EXPECT_FALSE(player_.IsPlaying());
 
   // Player should begin prefetch and resume preroll upon Start().
   EXPECT_EQ(2, demuxer_->num_data_requests());
   Resume(true, false);
   EXPECT_TRUE(IsPrerolling(true));
   EXPECT_EQ(100.0, GetPrerollTimestamp().InMillisecondsF());
 
@@ skipping 14 matching lines @@
   ReleasePlayer();
   EXPECT_EQ(0, demuxer_->num_seek_requests());
 
   // Player should not prefetch upon Start() nor create the media codec bridge,
   // due to awaiting DemuxerSeekDone.
   EXPECT_EQ(2, demuxer_->num_data_requests());
   Resume(false, false);
 
   WaitForAudioDecodeDone();
   EXPECT_EQ(1, demuxer_->num_seek_requests());
-  player_.OnDemuxerSeekDone(kNoTimestamp());
+  player_.OnDemuxerSeekDone(kNoTimestamp);
   EXPECT_TRUE(GetMediaDecoderJob(true));
   EXPECT_TRUE(IsPrerolling(true));
   EXPECT_EQ(100.0, GetPrerollTimestamp().InMillisecondsF());
   EXPECT_EQ(3, demuxer_->num_data_requests());
 
   // No further seek should have been requested since Release(), above.
   EXPECT_EQ(1, demuxer_->num_seek_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, SeekToThenDemuxerSeekThenReleaseThenSeekDone) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test if Release() occurs after a SeekTo()'s subsequent DemuxerSeek IPC
   // request and OnDemuxerSeekDone() arrives prior to the next Start(), then the
   // player will resume correct post-seek preroll upon Start().
   StartAudioDecoderJobAndSeekToWhileDecoding(
       base::TimeDelta::FromMilliseconds(100));
   WaitForAudioDecodeDone();
   EXPECT_EQ(1, demuxer_->num_seek_requests());
 
   ReleasePlayer();
-  player_.OnDemuxerSeekDone(kNoTimestamp());
+  player_.OnDemuxerSeekDone(kNoTimestamp);
   EXPECT_FALSE(player_.IsPlaying());
   EXPECT_FALSE(GetMediaCodecBridge(true));
   EXPECT_EQ(100.0, GetPrerollTimestamp().InMillisecondsF());
 
   // Player should begin prefetch and resume preroll upon Start().
   EXPECT_EQ(2, demuxer_->num_data_requests());
   Resume(true, false);
   EXPECT_TRUE(IsPrerolling(true));
   EXPECT_EQ(100.0, GetPrerollTimestamp().InMillisecondsF());
 
@@ skipping 10 matching lines @@
   // correct post-seek preroll after) OnDemuxerSeekDone().
   StartAudioDecoderJobAndSeekToWhileDecoding(
       base::TimeDelta::FromMilliseconds(100));
   WaitForAudioDecodeDone();
   EXPECT_EQ(1, demuxer_->num_seek_requests());
 
   ReleasePlayer();
   EXPECT_EQ(2, demuxer_->num_data_requests());
   Resume(false, false);
 
-  player_.OnDemuxerSeekDone(kNoTimestamp());
+  player_.OnDemuxerSeekDone(kNoTimestamp);
   EXPECT_FALSE(GetMediaCodecBridge(true));
   EXPECT_TRUE(IsPrerolling(true));
   EXPECT_EQ(100.0, GetPrerollTimestamp().InMillisecondsF());
   EXPECT_EQ(3, demuxer_->num_data_requests());
 
   // No further seek should have been requested since before Release(), above.
   EXPECT_EQ(1, demuxer_->num_seek_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, ConfigChangedThenReleaseThenStart) {
@@ skipping 198 matching lines @@
 
   EXPECT_EQ(demuxer_->num_data_requests(), 0);
   player_.OnDemuxerConfigsAvailable(CreateDemuxerConfigs(true, true));
 
   manager_.set_allow_play(true);
   player_.Start();
   EXPECT_TRUE(player_.IsPlaying());
 }
 
 }  // namespace media