Declare kAppendWholeFile as constexpr

media/test/mock_media_source.cc

 // Copyright 2017 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/test/mock_media_source.h"
 
 #include "base/threading/thread_task_runner_handle.h"
 #include "media/base/test_data_util.h"
 #include "media/base/timestamp_constants.h"
 
 namespace media {
 
 constexpr char kSourceId[] = "SourceId";
-const size_t kAppendWholeFile = std::numeric_limits<size_t>::max();
 
 MockMediaSource::MockMediaSource(const std::string& filename,
                                  const std::string& mimetype,
                                  size_t initial_append_size)
     : current_position_(0),
       initial_append_size_(initial_append_size),
       mimetype_(mimetype),
       chunk_demuxer_(new ChunkDemuxer(
           base::Bind(&MockMediaSource::DemuxerOpened, base::Unretained(this)),
           base::Bind(&MockMediaSource::OnEncryptedMediaInitData,
                      base::Unretained(this)),
           &media_log_)),
       owned_chunk_demuxer_(chunk_demuxer_) {
   file_data_ = ReadTestDataFile(filename);
 
   if (initial_append_size_ == kAppendWholeFile)
     initial_append_size_ = file_data_->data_size();
 
-  DCHECK_GT(initial_append_size_, 0u);
-  DCHECK_LE(initial_append_size_, file_data_->data_size());
+  CHECK_GT(initial_append_size_, 0u);
+  CHECK_LE(initial_append_size_, file_data_->data_size());
 }
 
 MockMediaSource::~MockMediaSource() {}
 
 std::unique_ptr<Demuxer> MockMediaSource::GetDemuxer() {
   return std::move(owned_chunk_demuxer_);
 }
 
 void MockMediaSource::Seek(base::TimeDelta seek_time,
                            size_t new_position,
                            size_t seek_append_size) {
   chunk_demuxer_->StartWaitingForSeek(seek_time);
 
   chunk_demuxer_->ResetParserState(kSourceId, base::TimeDelta(),
                                    kInfiniteDuration, &last_timestamp_offset_);
 
-  DCHECK_LT(new_position, file_data_->data_size());
+  CHECK_LT(new_position, file_data_->data_size());
   current_position_ = new_position;
 
   AppendData(seek_append_size);
 }
 
 void MockMediaSource::Seek(base::TimeDelta seek_time) {
   chunk_demuxer_->StartWaitingForSeek(seek_time);
 }
 
 void MockMediaSource::AppendData(size_t size) {
-  DCHECK(chunk_demuxer_);
-  DCHECK_LT(current_position_, file_data_->data_size());
-  DCHECK_LE(current_position_ + size, file_data_->data_size());
+  CHECK(chunk_demuxer_);
+  CHECK_LT(current_position_, file_data_->data_size());
+  CHECK_LE(current_position_ + size, file_data_->data_size());
 
   ASSERT_TRUE(chunk_demuxer_->AppendData(
       kSourceId, file_data_->data() + current_position_, size,
       base::TimeDelta(), kInfiniteDuration, &last_timestamp_offset_));
   current_position_ += size;
 }
 
 bool MockMediaSource::AppendAtTime(base::TimeDelta timestamp_offset,
                                    const uint8_t* pData,
                                    int size) {
@@ skipping 88 matching lines @@
     codecs_param = mimetype_.substr(codecs_param_start,
                                     codecs_param_end - codecs_param_start);
   }
 
   return chunk_demuxer_->AddId(kSourceId, type, codecs_param);
 }
 
 void MockMediaSource::OnEncryptedMediaInitData(
     EmeInitDataType init_data_type,
     const std::vector<uint8_t>& init_data) {
-  DCHECK(!init_data.empty());
+  CHECK(!init_data.empty());
   CHECK(!encrypted_media_init_data_cb_.is_null());
   encrypted_media_init_data_cb_.Run(init_data_type, init_data);
 }
 
 void MockMediaSource::InitSegmentReceived(std::unique_ptr<MediaTracks> tracks) {
   CHECK(tracks.get());
   EXPECT_GT(tracks->tracks().size(), 0u);
   CHECK(chunk_demuxer_);
   // Verify that track ids are unique.
   std::set<MediaTrack::Id> track_ids;
   for (const auto& track : tracks->tracks()) {
     EXPECT_EQ(track_ids.end(), track_ids.find(track->id()));
     track_ids.insert(track->id());
   }
   InitSegmentReceivedMock(tracks);
 }
 
 }  // namespace media