Convert media constants to constexpr.

media/base/android/media_decoder_job.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/base/android/media_decoder_job.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 70 matching lines @@
 
   base::Closure done_cb = base::ResetAndReturn(&data_received_cb_);
 
   // If this data request is for the inactive chunk, or |data_received_cb_|
   // was set to null by Flush() or Release(), do nothing.
   if (done_cb.is_null())
     return;
 
   if (stop_decode_pending_) {
     DCHECK(is_decoding());
-    OnDecodeCompleted(MEDIA_CODEC_ABORT, false, kNoTimestamp(), kNoTimestamp());
+    OnDecodeCompleted(MEDIA_CODEC_ABORT, false, kNoTimestamp, kNoTimestamp);
     return;
   }
 
   done_cb.Run();
 }
 
 void MediaDecoderJob::Prefetch(const base::Closure& prefetch_cb) {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
   DCHECK(data_received_cb_.is_null());
   DCHECK(decode_cb_.is_null());
@@ skipping 243 matching lines @@
     bool reconfigure_needed = IsCodecReconfigureNeeded(configs);
     SetDemuxerConfigs(configs);
     if (!drain_decoder_) {
       // If we haven't decoded any data yet, just skip the current access unit
       // and request the MediaCodec to be recreated on next Decode().
       if (skip_eos_enqueue_ || !reconfigure_needed) {
         need_to_reconfig_decoder_job_ =
             need_to_reconfig_decoder_job_ || reconfigure_needed;
         // Report MEDIA_CODEC_OK status so decoder will continue decoding and
         // MEDIA_CODEC_OUTPUT_FORMAT_CHANGED status will come later.
-        ui_task_runner_->PostTask(FROM_HERE, base::Bind(
-            &MediaDecoderJob::OnDecodeCompleted, base::Unretained(this),
-            MEDIA_CODEC_OK, false, kNoTimestamp(), kNoTimestamp()));
+        ui_task_runner_->PostTask(
+            FROM_HERE, base::Bind(&MediaDecoderJob::OnDecodeCompleted,
+                                  base::Unretained(this), MEDIA_CODEC_OK, false,
+                                  kNoTimestamp, kNoTimestamp));
         return;
       }
       // Start draining the decoder so that all the remaining frames are
       // rendered.
       drain_decoder_ = true;
     }
   }
 
   DCHECK(!(needs_flush_ && drain_decoder_));
   decoder_task_runner_->PostTask(FROM_HERE, base::Bind(
@@ skipping 15 matching lines @@
   DCHECK(decoder_task_runner_->BelongsToCurrentThread());
   TRACE_EVENT0("media", __FUNCTION__);
 
   if (needs_flush) {
     DVLOG(1) << "DecodeInternal needs flush.";
     input_eos_encountered_ = false;
     output_eos_encountered_ = false;
     input_buf_index_ = -1;
     MediaCodecStatus flush_status = media_codec_bridge_->Flush();
     if (flush_status != MEDIA_CODEC_OK) {
-      callback.Run(flush_status, false, kNoTimestamp(), kNoTimestamp());
+      callback.Run(flush_status, false, kNoTimestamp, kNoTimestamp);
       return;
     }
   }
 
   // Once output EOS has occurred, we should not be asked to decode again.
   // MediaCodec has undefined behavior if similarly asked to decode after output
   // EOS.
   DCHECK(!output_eos_encountered_);
 
   // For aborted access unit, just skip it and inform the player.
   if (unit.status == DemuxerStream::kAborted) {
-    callback.Run(MEDIA_CODEC_ABORT, false, kNoTimestamp(), kNoTimestamp());
+    callback.Run(MEDIA_CODEC_ABORT, false, kNoTimestamp, kNoTimestamp);
     return;
   }
 
   if (skip_eos_enqueue_) {
     if (unit.is_end_of_stream || unit.data.empty()) {
       input_eos_encountered_ = true;
       output_eos_encountered_ = true;
-      callback.Run(MEDIA_CODEC_OUTPUT_END_OF_STREAM, false, kNoTimestamp(),
-                   kNoTimestamp());
+      callback.Run(MEDIA_CODEC_OUTPUT_END_OF_STREAM, false, kNoTimestamp,
+                   kNoTimestamp);
       return;
     }
 
     skip_eos_enqueue_ = false;
   }
 
   MediaCodecStatus input_status = MEDIA_CODEC_INPUT_END_OF_STREAM;
   if (!input_eos_encountered_) {
     input_status = QueueInputBuffer(unit);
     if (input_status == MEDIA_CODEC_INPUT_END_OF_STREAM) {
       input_eos_encountered_ = true;
     } else if (input_status == MEDIA_CODEC_DEQUEUE_INPUT_AGAIN_LATER) {
       // In some cases, all buffers must be released to codec before format
       // change can be resolved. Context: b/21786703
       DVLOG(1) << "dequeueInputBuffer gave AGAIN_LATER, dequeue output buffers";
     } else if (input_status != MEDIA_CODEC_OK) {
-      callback.Run(input_status, false, kNoTimestamp(), kNoTimestamp());
+      callback.Run(input_status, false, kNoTimestamp, kNoTimestamp);
       return;
     }
   }
 
   int buffer_index = 0;
   size_t offset = 0;
   size_t size = 0;
   base::TimeDelta presentation_timestamp;
 
   base::TimeDelta timeout = base::TimeDelta::FromMilliseconds(
@@ skipping 17 matching lines @@
       // dequeued, post a task on the UI thread to signal the format change.
       if (OnOutputFormatChanged())
         has_format_change = true;
       else
         status = MEDIA_CODEC_ERROR;
     }
   } while (status != MEDIA_CODEC_OK && status != MEDIA_CODEC_ERROR &&
            status != MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER);
 
   if (status != MEDIA_CODEC_OK) {
-    callback.Run(status, false, kNoTimestamp(), kNoTimestamp());
+    callback.Run(status, false, kNoTimestamp, kNoTimestamp);
     return;
   }
 
   // TODO(xhwang/qinmin): This logic is correct but strange. Clean it up.
   if (output_eos_encountered_)
     status = MEDIA_CODEC_OUTPUT_END_OF_STREAM;
   else if (has_format_change)
     status = MEDIA_CODEC_OUTPUT_FORMAT_CHANGED;
 
   bool render_output  = presentation_timestamp >= preroll_timestamp_ &&
@@ skipping 20 matching lines @@
   // |start_presentation_timestamp_| and |start_time_ticks_| in
   // media_source_player.cc.
   DVLOG(1) << "codec is lagging behind :" << time_to_render.InMicroseconds();
   if (render_output) {
     // The player won't expect a timestamp smaller than the
     // |start_presentation_timestamp|. However, this could happen due to decoder
     // errors.
     presentation_timestamp = std::max(
         presentation_timestamp, start_presentation_timestamp);
   } else {
-    presentation_timestamp = kNoTimestamp();
+    presentation_timestamp = kNoTimestamp;
   }
 
   const bool is_late_frame = (time_to_render < base::TimeDelta());
   ReleaseOutputBuffer(buffer_index, offset, size, render_output, is_late_frame,
                       presentation_timestamp, status, callback);
 }
 
 void MediaDecoderJob::OnDecodeCompleted(
     MediaCodecStatus status,
     bool is_late_frame,
     base::TimeDelta current_presentation_timestamp,
     base::TimeDelta max_presentation_timestamp) {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 
   if (destroy_pending_) {
     DVLOG(1) << __FUNCTION__ << " : completing pending deletion";
     delete this;
     return;
   }
 
   if (status == MEDIA_CODEC_OUTPUT_END_OF_STREAM)
     output_eos_encountered_ = true;
 
   DCHECK(!decode_cb_.is_null());
 
   // If output was queued for rendering, then we have completed prerolling.
-  if (current_presentation_timestamp != kNoTimestamp() ||
+  if (current_presentation_timestamp != kNoTimestamp ||
       status == MEDIA_CODEC_OUTPUT_END_OF_STREAM) {
     prerolling_ = false;
   }
 
   switch (status) {
     case MEDIA_CODEC_OK:
     case MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER:
     case MEDIA_CODEC_OUTPUT_FORMAT_CHANGED:
     case MEDIA_CODEC_OUTPUT_END_OF_STREAM:
       if (!input_eos_encountered_)
@@ skipping 135 matching lines @@
 
 void MediaDecoderJob::ReleaseMediaCodecBridge() {
   if (!media_codec_bridge_)
     return;
 
   media_codec_bridge_.reset();
   input_buf_index_ = -1;
 }
 
 }  // namespace media