Convert media constants to constexpr.

media/renderers/audio_renderer_impl.cc

 // Copyright (c) 2012 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/renderers/audio_renderer_impl.h"
 
 #include <math.h>
 #include <stddef.h>
 #include <algorithm>
 #include <utility>
@@ skipping 156 matching lines @@
 
 void AudioRendererImpl::SetMediaTime(base::TimeDelta time) {
   DVLOG(1) << __FUNCTION__ << "(" << time << ")";
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(lock_);
   DCHECK(!rendering_);
   DCHECK_EQ(state_, kFlushed);
 
   start_timestamp_ = time;
-  ended_timestamp_ = kInfiniteDuration();
+  ended_timestamp_ = kInfiniteDuration;
   last_render_time_ = stop_rendering_time_ = base::TimeTicks();
-  first_packet_timestamp_ = kNoTimestamp();
+  first_packet_timestamp_ = kNoTimestamp;
   last_media_timestamp_ = base::TimeDelta();
   audio_clock_.reset(new AudioClock(time, audio_parameters_.sample_rate()));
 }
 
 base::TimeDelta AudioRendererImpl::CurrentMediaTime() {
   base::AutoLock auto_lock(lock_);
 
   // Return the current time based on the known extents of the rendered audio
   // data plus an estimate based on the last time those values were calculated.
   base::TimeDelta current_media_time = audio_clock_->front_timestamp();
@@ skipping 102 matching lines @@
   DoFlush_Locked();
 }
 
 void AudioRendererImpl::DoFlush_Locked() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   lock_.AssertAcquired();
 
   DCHECK(!pending_read_);
   DCHECK_EQ(state_, kFlushed);
 
-  ended_timestamp_ = kInfiniteDuration();
+  ended_timestamp_ = kInfiniteDuration;
   audio_buffer_stream_->Reset(base::Bind(&AudioRendererImpl::ResetDecoderDone,
                                          weak_factory_.GetWeakPtr()));
 }
 
 void AudioRendererImpl::ResetDecoderDone() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   {
     base::AutoLock auto_lock(lock_);
 
     DCHECK_EQ(state_, kFlushed);
@@ skipping 345 matching lines @@
       if (!buffer->frame_count())
         return true;
     }
 
     if (state_ != kUninitialized)
       algorithm_->EnqueueBuffer(buffer);
   }
 
   // Store the timestamp of the first packet so we know when to start actual
   // audio playback.
-  if (first_packet_timestamp_ == kNoTimestamp())
+  if (first_packet_timestamp_ == kNoTimestamp)
     first_packet_timestamp_ = buffer->timestamp();
 
   const size_t memory_usage = algorithm_->GetMemoryUsage();
   PipelineStatistics stats;
   stats.audio_memory_usage = memory_usage - last_audio_memory_usage_;
   last_audio_memory_usage_ = memory_usage;
   task_runner_->PostTask(FROM_HERE,
                          base::Bind(&AudioRendererImpl::OnStatisticsUpdate,
                                     weak_factory_.GetWeakPtr(), stats));
 
@@ skipping 124 matching lines @@
     // Mute audio by returning 0 when not playing.
     if (state_ != kPlaying) {
       audio_clock_->WroteAudio(0, frames_requested, frames_delayed,
                                playback_rate_);
       return 0;
     }
 
     // Delay playback by writing silence if we haven't reached the first
     // timestamp yet; this can occur if the video starts before the audio.
     if (algorithm_->frames_buffered() > 0) {
-      CHECK_NE(first_packet_timestamp_, kNoTimestamp());
+      CHECK_NE(first_packet_timestamp_, kNoTimestamp);
       CHECK_GE(first_packet_timestamp_, base::TimeDelta());
       const base::TimeDelta play_delay =
           first_packet_timestamp_ - audio_clock_->back_timestamp();
       if (play_delay > base::TimeDelta()) {
         DCHECK_EQ(frames_written, 0);
 
         // Don't multiply |play_delay| out since it can be a huge value on
         // poorly encoded media and multiplying by the sample rate could cause
         // the value to overflow.
         if (play_delay.InSecondsF() > static_cast<double>(frames_requested) /
@@ skipping 33 matching lines @@
     // we've rendered all known audio data. Doing so simplifies scenarios where
     // we have other sources of media data that need to be scheduled after audio
     // data has ended.
     //
     // That being said, we don't want to advance time when underflowed as we
     // know more decoded frames will eventually arrive. If we did, we would
     // throw things out of sync when said decoded frames arrive.
     int frames_after_end_of_stream = 0;
     if (frames_written == 0) {
       if (received_end_of_stream_) {
-        if (ended_timestamp_ == kInfiniteDuration())
+        if (ended_timestamp_ == kInfiniteDuration)
           ended_timestamp_ = audio_clock_->back_timestamp();
         frames_after_end_of_stream = frames_requested;
       } else if (state_ == kPlaying &&
                  buffering_state_ != BUFFERING_HAVE_NOTHING) {
         algorithm_->IncreaseQueueCapacity();
         SetBufferingState_Locked(BUFFERING_HAVE_NOTHING);
       }
     }
 
     audio_clock_->WroteAudio(frames_written + frames_after_end_of_stream,
@@ skipping 90 matching lines @@
   DCHECK_NE(buffering_state_, buffering_state);
   lock_.AssertAcquired();
   buffering_state_ = buffering_state;
 
   task_runner_->PostTask(
       FROM_HERE, base::Bind(&AudioRendererImpl::OnBufferingStateChange,
                             weak_factory_.GetWeakPtr(), buffering_state_));
 }
 
 }  // namespace media