Convert media constants to constexpr.

media/base/pipeline_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/base/pipeline_impl.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 75 matching lines @@
     // than DidLoadingProgress().
     bool did_loading_progress = false;
 
     // Amount of available buffered data as reported by Demuxer.
     Ranges<base::TimeDelta> buffered_time_ranges;
 
     // Accumulated statistics reported by the renderer.
     PipelineStatistics statistics;
 
     // The media timestamp to return while the pipeline is suspended.
-    // Otherwise set to kNoTimestamp().
-    base::TimeDelta suspend_timestamp = kNoTimestamp();
+    // Otherwise set to kNoTimestamp.
+    base::TimeDelta suspend_timestamp = kNoTimestamp;
   };
 
   // DemuxerHost implementaion.
   void OnBufferedTimeRangesChanged(const Ranges<base::TimeDelta>& ranges) final;
   void SetDuration(base::TimeDelta duration) final;
   void OnDemuxerError(PipelineStatus error) final;
   void AddTextStream(DemuxerStream* text_stream,
                      const TextTrackConfig& config) final;
   void RemoveTextStream(DemuxerStream* text_stream) final;
 
@@ skipping 183 matching lines @@
   DCHECK(!pending_callbacks_.get());
 
   SetState(kSuspending);
 
   // Freeze playback and record the media time before flushing. (Flushing clears
   // the value.)
   shared_state_.renderer->SetPlaybackRate(0.0);
   {
     base::AutoLock auto_lock(shared_state_lock_);
     shared_state_.suspend_timestamp = shared_state_.renderer->GetMediaTime();
-    DCHECK(shared_state_.suspend_timestamp != kNoTimestamp());
+    DCHECK(shared_state_.suspend_timestamp != kNoTimestamp);
   }
 
   // Queue the asynchronous actions required to stop playback. (Matches setup in
   // DoSeek().)
   // TODO(sandersd): Share implementation with DoSeek().
   SerialRunner::Queue fns;
 
   if (text_renderer_) {
     fns.Push(base::Bind(&TextRenderer::Pause,
                         base::Unretained(text_renderer_.get())));
@@ skipping 66 matching lines @@
 
   volume_ = volume;
   if (state_ == kPlaying)
     shared_state_.renderer->SetVolume(volume_);
 }
 
 base::TimeDelta PipelineImpl::RendererWrapper::GetMediaTime() const {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(shared_state_lock_);
-  if (shared_state_.suspend_timestamp != kNoTimestamp())
+  if (shared_state_.suspend_timestamp != kNoTimestamp)
     return shared_state_.suspend_timestamp;
   return shared_state_.renderer ? shared_state_.renderer->GetMediaTime()
                                 : base::TimeDelta();
 }
 
 Ranges<base::TimeDelta> PipelineImpl::RendererWrapper::GetBufferedTimeRanges()
     const {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(shared_state_lock_);
@@ skipping 425 matching lines @@
       ReportMetadata();
       start_timestamp_ = demuxer_->GetStartTime();
 
       return InitializeRenderer(done_cb);
 
     case kPlaying:
       DCHECK(start_timestamp_ >= base::TimeDelta());
       shared_state_.renderer->StartPlayingFrom(start_timestamp_);
       {
         base::AutoLock auto_lock(shared_state_lock_);
-        shared_state_.suspend_timestamp = kNoTimestamp();
+        shared_state_.suspend_timestamp = kNoTimestamp;
       }
 
       if (text_renderer_)
         text_renderer_->StartPlaying();
 
       main_task_runner_->PostTask(
           FROM_HERE, base::Bind(&PipelineImpl::OnSeekDone, weak_pipeline_,
                                 start_timestamp_));
 
       shared_state_.renderer->SetPlaybackRate(playback_rate_);
@@ skipping 450 matching lines @@
 void PipelineImpl::OnSuspendDone(base::TimeDelta suspend_time) {
   DVLOG(3) << __FUNCTION__ << "(" << suspend_time.InMicroseconds() << ")";
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(IsRunning());
 
   DCHECK(!suspend_cb_.is_null());
   base::ResetAndReturn(&suspend_cb_).Run(PIPELINE_OK);
 }
 
 }  // namespace media