Convert media constants to constexpr.

chromecast/media/cma/pipeline/media_pipeline_impl.cc

 // Copyright 2014 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 "chromecast/media/cma/pipeline/media_pipeline_impl.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 69 matching lines @@
   base::Closure done_cb;
 };
 
 MediaPipelineImpl::MediaPipelineImpl()
     : cdm_context_(nullptr),
       backend_state_(BACKEND_STATE_UNINITIALIZED),
       playback_rate_(1.0f),
       audio_decoder_(nullptr),
       video_decoder_(nullptr),
       pending_time_update_task_(false),
-      last_media_time_(::media::kNoTimestamp()),
+      last_media_time_(::media::kNoTimestamp),
       statistics_rolling_counter_(0),
       audio_bytes_for_bitrate_estimation_(0),
       video_bytes_for_bitrate_estimation_(0),
       playback_stalled_(false),
       playback_stalled_notification_sent_(false),
       weak_factory_(this) {
   CMALOG(kLogControl) << __FUNCTION__;
   weak_this_ = weak_factory_.GetWeakPtr();
   thread_checker_.DetachFromThread();
 }
@@ skipping 324 matching lines @@
   } else if (!is_buffering && (backend_state_ == BACKEND_STATE_PAUSED)) {
     // Once we finish buffering, we need to honour the desired playback rate
     // (rather than just resuming). This way, if playback was paused while
     // buffering, it will remain paused rather than incorrectly resuming.
     SetPlaybackRate(playback_rate_);
   }
 }
 
 void MediaPipelineImpl::CheckForPlaybackStall(base::TimeDelta media_time,
                                               base::TimeTicks current_stc) {
-  DCHECK(media_time != ::media::kNoTimestamp());
+  DCHECK(media_time != ::media::kNoTimestamp);
 
   // A playback stall is defined as a scenario where the underlying media
   // pipeline has unexpectedly stopped making forward progress. The pipeline is
   // NOT stalled if:
   //
   // 1. Media time is progressing
   // 2. The backend is paused
   // 3. We are currently buffering (this is captured in a separate event)
   if (media_time != last_media_time_ ||
       backend_state_ != BACKEND_STATE_PLAYING ||
@@ skipping 67 matching lines @@
       }
       last_sample_time_ = current_time;
     }
   }
 
   statistics_rolling_counter_ =
       (statistics_rolling_counter_ + 1) % kStatisticsUpdatePeriod;
 
   base::TimeDelta media_time = base::TimeDelta::FromMicroseconds(
       media_pipeline_backend_->GetCurrentPts());
-  if (media_time == ::media::kNoTimestamp()) {
+  if (media_time == ::media::kNoTimestamp) {
     pending_time_update_task_ = true;
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE, base::Bind(&MediaPipelineImpl::UpdateMediaTime, weak_this_),
         kTimeUpdateInterval);
     return;
   }
   base::TimeTicks stc = base::TimeTicks::Now();
 
   CheckForPlaybackStall(media_time, stc);
 
   base::TimeDelta max_rendering_time = media_time;
   if (buffering_controller_) {
     buffering_controller_->SetMediaTime(media_time);
 
     // Receiving the same time twice in a row means playback isn't moving,
     // so don't interpolate ahead.
     if (media_time != last_media_time_) {
       max_rendering_time = buffering_controller_->GetMaxRenderingTime();
-      if (max_rendering_time == ::media::kNoTimestamp())
+      if (max_rendering_time == ::media::kNoTimestamp)
         max_rendering_time = media_time;
 
       // Cap interpolation time to avoid interpolating too far ahead.
       max_rendering_time =
           std::min(max_rendering_time, media_time + 2 * kTimeUpdateInterval);
     }
   }
 
   last_media_time_ = media_time;
   if (!client_.time_update_cb.is_null())
@@ skipping 18 matching lines @@
 
 void MediaPipelineImpl::ResetBitrateState() {
   elapsed_time_delta_ = base::TimeDelta::FromSeconds(0);
   audio_bytes_for_bitrate_estimation_ = 0;
   video_bytes_for_bitrate_estimation_ = 0;
   last_sample_time_ = base::TimeTicks::Now();
 }
 
 }  // namespace media
 }  // namespace chromecast