Convert media constants to constexpr.

chromecast/media/cma/pipeline/av_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/av_pipeline_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 23 matching lines @@
 const int kNoCallbackId = -1;
 
 }  // namespace
 
 AvPipelineImpl::AvPipelineImpl(MediaPipelineBackend::Decoder* decoder,
                                const AvPipelineClient& client)
     : bytes_decoded_since_last_update_(0),
       decoder_(decoder),
       client_(client),
       state_(kUninitialized),
-      buffered_time_(::media::kNoTimestamp()),
-      playable_buffered_time_(::media::kNoTimestamp()),
+      buffered_time_(::media::kNoTimestamp),
+      playable_buffered_time_(::media::kNoTimestamp),
       enable_feeding_(false),
       pending_read_(false),
       cast_cdm_context_(NULL),
       player_tracker_callback_id_(kNoCallbackId),
       weak_factory_(this) {
   DCHECK(decoder_);
   decoder_->SetDelegate(this);
   weak_this_ = weak_factory_.GetWeakPtr();
   thread_checker_.DetachFromThread();
 }
@@ skipping 59 matching lines @@
   }
   DCHECK_EQ(state_, kStopped);
   set_state(kFlushing);
 
   flush_cb_ = flush_cb;
   // Remove any pending buffer.
   pending_buffer_ = nullptr;
   pushed_buffer_ = nullptr;
   // Remove any frames left in the frame provider.
   pending_read_ = false;
-  buffered_time_ = ::media::kNoTimestamp();
-  playable_buffered_time_ = ::media::kNoTimestamp();
+  buffered_time_ = ::media::kNoTimestamp;
+  playable_buffered_time_ = ::media::kNoTimestamp;
   non_playable_frames_.clear();
 
   frame_provider_->Flush(base::Bind(&AvPipelineImpl::OnFlushDone, weak_this_));
 }
 
 void AvPipelineImpl::OnFlushDone() {
   CMALOG(kLogControl) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
   if (state_ == kError) {
     // Flush callback is reset on error.
@@ skipping 112 matching lines @@
   PushPendingBuffer();
 }
 
 void AvPipelineImpl::PushPendingBuffer() {
   DCHECK(pending_buffer_);
   DCHECK(!pushed_buffer_);
 
   if (!pending_buffer_->end_of_stream() && buffering_state_.get()) {
     base::TimeDelta timestamp =
         base::TimeDelta::FromMicroseconds(pending_buffer_->timestamp());
-    if (timestamp != ::media::kNoTimestamp())
+    if (timestamp != ::media::kNoTimestamp)
       buffering_state_->SetMaxRenderingTime(timestamp);
   }
 
   pushed_buffer_ = pending_buffer_;
   pending_buffer_ = nullptr;
   MediaPipelineBackend::BufferStatus status =
       decoder_->PushBuffer(pushed_buffer_.get());
 
   if (status != MediaPipelineBackend::kBufferPending)
     OnPushBufferComplete(status);
@@ skipping 71 matching lines @@
 
 void AvPipelineImpl::OnDataBuffered(
     const scoped_refptr<DecoderBufferBase>& buffer,
     bool is_at_max_capacity) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!buffering_state_.get())
     return;
 
   if (!buffer->end_of_stream() &&
-      (buffered_time_ == ::media::kNoTimestamp() ||
+      (buffered_time_ == ::media::kNoTimestamp ||
        buffered_time_ <
            base::TimeDelta::FromMicroseconds(buffer->timestamp()))) {
     buffered_time_ = base::TimeDelta::FromMicroseconds(buffer->timestamp());
   }
 
   if (is_at_max_capacity)
     buffering_state_->NotifyMaxCapacity(buffered_time_);
 
   // No need to update the list of playable frames,
   // if we are already blocking on a frame.
@@ skipping 15 matching lines @@
           non_playable_frame->decrypt_config();
       if (decrypt_config &&
           !(cast_cdm_context_ &&
             cast_cdm_context_->GetDecryptContext(decrypt_config->key_id())
                 .get())) {
         // The frame is still not playable. All the following are thus not
         // playable.
         break;
       }
 
-      if (playable_buffered_time_ == ::media::kNoTimestamp() ||
+      if (playable_buffered_time_ == ::media::kNoTimestamp ||
           playable_buffered_time_ < base::TimeDelta::FromMicroseconds(
                                         non_playable_frame->timestamp())) {
         playable_buffered_time_ =
             base::TimeDelta::FromMicroseconds(non_playable_frame->timestamp());
         buffering_state_->SetBufferedTime(playable_buffered_time_);
       }
     }
 
     // The frame is playable: remove it from the list of non playable frames.
     non_playable_frames_.pop_front();
   }
 }
 
 }  // namespace media
 }  // namespace chromecast