Convert media constants to constexpr.

media/cdm/ppapi/external_clear_key/ffmpeg_cdm_audio_decoder.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/cdm/ppapi/external_clear_key/ffmpeg_cdm_audio_decoder.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 121 matching lines @@
   }
 }
 
 FFmpegCdmAudioDecoder::FFmpegCdmAudioDecoder(ClearKeyCdmHost* host)
     : is_initialized_(false),
       host_(host),
       samples_per_second_(0),
       channels_(0),
       av_sample_format_(0),
       bytes_per_frame_(0),
-      last_input_timestamp_(kNoTimestamp()),
-      output_bytes_to_drop_(0) {
-}
+      last_input_timestamp_(kNoTimestamp),
+      output_bytes_to_drop_(0) {}
 
 FFmpegCdmAudioDecoder::~FFmpegCdmAudioDecoder() {
   ReleaseFFmpegResources();
 }
 
 bool FFmpegCdmAudioDecoder::Initialize(const cdm::AudioDecoderConfig& config) {
   DVLOG(1) << "Initialize()";
   if (!IsValidConfig(config)) {
     LOG(ERROR) << "Initialize(): invalid audio decoder configuration.";
     return false;
@@ skipping 71 matching lines @@
     int32_t compressed_buffer_size,
     int64_t input_timestamp,
     cdm::AudioFrames* decoded_frames) {
   DVLOG(1) << "DecodeBuffer()";
   const bool is_end_of_stream = !compressed_buffer;
   base::TimeDelta timestamp =
       base::TimeDelta::FromMicroseconds(input_timestamp);
 
   bool is_vorbis = codec_context_->codec_id == AV_CODEC_ID_VORBIS;
   if (!is_end_of_stream) {
-    if (last_input_timestamp_ == kNoTimestamp()) {
+    if (last_input_timestamp_ == kNoTimestamp) {
       if (is_vorbis && timestamp < base::TimeDelta()) {
         // Dropping frames for negative timestamps as outlined in section A.2
         // in the Vorbis spec. http://xiph.org/vorbis/doc/Vorbis_I_spec.html
         int frames_to_drop = floor(
             0.5 + -timestamp.InSecondsF() * samples_per_second_);
         output_bytes_to_drop_ = bytes_per_frame_ * frames_to_drop;
       } else {
         last_input_timestamp_ = timestamp;
       }
-    } else if (timestamp != kNoTimestamp()) {
+    } else if (timestamp != kNoTimestamp) {
       if (timestamp < last_input_timestamp_) {
         base::TimeDelta diff = timestamp - last_input_timestamp_;
         DVLOG(1) << "Input timestamps are not monotonically increasing! "
                  << " ts " << timestamp.InMicroseconds() << " us"
                  << " diff " << diff.InMicroseconds() << " us";
         return cdm::kDecodeError;
       }
 
       last_input_timestamp_ = timestamp;
     }
@@ skipping 35 matching lines @@
           << compressed_buffer_size << " bytes";
 
       return cdm::kDecodeError;
     }
 
     // Update packet size and data pointer in case we need to call the decoder
     // with the remaining bytes from this packet.
     packet.size -= result;
     packet.data += result;
 
-    if (output_timestamp_helper_->base_timestamp() == kNoTimestamp() &&
+    if (output_timestamp_helper_->base_timestamp() == kNoTimestamp &&
         !is_end_of_stream) {
-      DCHECK(timestamp != kNoTimestamp());
+      DCHECK(timestamp != kNoTimestamp);
       if (output_bytes_to_drop_ > 0) {
         // Currently Vorbis is the only codec that causes us to drop samples.
         // If we have to drop samples it always means the timeline starts at 0.
         DCHECK_EQ(codec_context_->codec_id, AV_CODEC_ID_VORBIS);
         output_timestamp_helper_->SetBaseTimestamp(base::TimeDelta());
       } else {
         output_timestamp_helper_->SetBaseTimestamp(timestamp);
       }
     }
 
@@ skipping 88 matching lines @@
     decoded_frames->FrameBuffer()->SetSize(serialized_audio_frames_.size());
     serialized_audio_frames_.clear();
 
     return cdm::kSuccess;
   }
 
   return cdm::kNeedMoreData;
 }
 
 void FFmpegCdmAudioDecoder::ResetTimestampState() {
-  output_timestamp_helper_->SetBaseTimestamp(kNoTimestamp());
-  last_input_timestamp_ = kNoTimestamp();
+  output_timestamp_helper_->SetBaseTimestamp(kNoTimestamp);
+  last_input_timestamp_ = kNoTimestamp;
   output_bytes_to_drop_ = 0;
 }
 
 void FFmpegCdmAudioDecoder::ReleaseFFmpegResources() {
   DVLOG(1) << "ReleaseFFmpegResources()";
 
   codec_context_.reset();
   av_frame_.reset();
 }
 
 void FFmpegCdmAudioDecoder::SerializeInt64(int64_t value) {
   const size_t previous_size = serialized_audio_frames_.size();
   serialized_audio_frames_.resize(previous_size + sizeof(value));
   memcpy(&serialized_audio_frames_[0] + previous_size, &value, sizeof(value));
 }
 
 }  // namespace media