Convert media constants to constexpr.

media/base/seekable_buffer.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/seekable_buffer.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "media/base/data_buffer.h"
 #include "media/base/timestamp_constants.h"
 
 namespace media {
 
 SeekableBuffer::SeekableBuffer(int backward_capacity, int forward_capacity)
     : current_buffer_offset_(0),
       backward_capacity_(backward_capacity),
       backward_bytes_(0),
       forward_capacity_(forward_capacity),
       forward_bytes_(0),
-      current_time_(kNoTimestamp()) {
+      current_time_(kNoTimestamp) {
   current_buffer_ = buffers_.begin();
 }
 
 SeekableBuffer::~SeekableBuffer() {
 }
 
 void SeekableBuffer::Clear() {
   buffers_.clear();
   current_buffer_ = buffers_.begin();
   current_buffer_offset_ = 0;
   backward_bytes_ = 0;
   forward_bytes_ = 0;
-  current_time_ = kNoTimestamp();
+  current_time_ = kNoTimestamp;
 }
 
 int SeekableBuffer::Read(uint8_t* data, int size) {
   DCHECK(data);
   return InternalRead(data, size, true, 0);
 }
 
 int SeekableBuffer::Peek(uint8_t* data, int size, int forward_offset) {
   DCHECK(data);
   return InternalRead(data, size, false, forward_offset);
 }
 
 bool SeekableBuffer::GetCurrentChunk(const uint8_t** data, int* size) const {
   BufferQueue::iterator current_buffer = current_buffer_;
   int current_buffer_offset = current_buffer_offset_;
   // Advance position if we are in the end of the current buffer.
   while (current_buffer != buffers_.end() &&
          current_buffer_offset >= (*current_buffer)->data_size()) {
     ++current_buffer;
     current_buffer_offset = 0;
   }
   if (current_buffer == buffers_.end())
     return false;
   *data = (*current_buffer)->data() + current_buffer_offset;
   *size = (*current_buffer)->data_size() - current_buffer_offset;
   return true;
 }
 
 bool SeekableBuffer::Append(const scoped_refptr<DataBuffer>& buffer_in) {
-  if (buffers_.empty() && buffer_in->timestamp() != kNoTimestamp()) {
+  if (buffers_.empty() && buffer_in->timestamp() != kNoTimestamp) {
     current_time_ = buffer_in->timestamp();
   }
 
   // Since the forward capacity is only used to check the criteria for buffer
   // full, we always append data to the buffer.
   buffers_.push_back(buffer_in);
 
   // After we have written the first buffer, update |current_buffer_| to point
   // to it.
   if (current_buffer_ == buffers_.end()) {
@@ skipping 184 matching lines @@
     UpdateCurrentTime(current_buffer_, current_buffer_offset_);
     EvictBackwardBuffers();
   }
 
   return taken;
 }
 
 void SeekableBuffer::UpdateCurrentTime(BufferQueue::iterator buffer,
                                        int offset) {
   // Garbage values are unavoidable, so this check will remain.
-  if (buffer != buffers_.end() &&
-      (*buffer)->timestamp() != kNoTimestamp()) {
+  if (buffer != buffers_.end() && (*buffer)->timestamp() != kNoTimestamp) {
     int64_t time_offset = ((*buffer)->duration().InMicroseconds() * offset) /
                           (*buffer)->data_size();
 
     current_time_ = (*buffer)->timestamp() +
                     base::TimeDelta::FromMicroseconds(time_offset);
   }
 }
 
 }  // namespace media