base: Remove the string logging from CHECK().

media/cast/test/fake_media_source.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 "media/cast/test/fake_media_source.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/scoped_file.h"
@@ skipping 271 matching lines @@
   if (keep_frames_)
     inserted_video_frame_queue_.push(video_frame);
   video_frame_input_->InsertRawVideoFrame(video_frame,
                                           start_time_ + video_time);
 
   // Send just enough audio data to match next video frame's time.
   base::TimeDelta audio_time = AudioFrameTime(audio_frame_count_);
   while (audio_time < video_time) {
     if (is_transcoding_audio()) {
       Decode(true);
-      CHECK(!audio_bus_queue_.empty()) << "No audio decoded.";
+      // No audio decoded.
+      CHECK(!audio_bus_queue_.empty());
       std::unique_ptr<AudioBus> bus(audio_bus_queue_.front());
       audio_bus_queue_.pop();
       audio_frame_input_->InsertAudio(std::move(bus), start_time_ + audio_time);
     } else {
       audio_frame_input_->InsertAudio(
           audio_bus_factory_->NextAudioBus(
               base::TimeDelta::FromMilliseconds(kAudioFrameMs)),
           start_time_ + audio_time);
     }
     audio_time = AudioFrameTime(++audio_frame_count_);
@@ skipping 119 matching lines @@
 
 base::TimeDelta FakeMediaSource::ScaleTimestamp(base::TimeDelta timestamp) {
   return base::TimeDelta::FromSecondsD(timestamp.InSecondsF() / playback_rate_);
 }
 
 base::TimeDelta FakeMediaSource::AudioFrameTime(int frame_number) {
   return frame_number * base::TimeDelta::FromMilliseconds(kAudioFrameMs);
 }
 
 void FakeMediaSource::Rewind() {
-  CHECK(av_seek_frame(av_format_context_, -1, 0, AVSEEK_FLAG_BACKWARD) >= 0)
-      << "Failed to rewind to the beginning.";
+  // Failed to rewind to the beginning.
+  CHECK(av_seek_frame(av_format_context_, -1, 0, AVSEEK_FLAG_BACKWARD) >= 0);
 }
 
 ScopedAVPacket FakeMediaSource::DemuxOnePacket(bool* audio) {
   ScopedAVPacket packet(new AVPacket());
   if (av_read_frame(av_format_context_, packet.get()) < 0) {
     VLOG(1) << "Failed to read one AVPacket.";
     packet.reset();
     return packet;
   }
 
@@ skipping 15 matching lines @@
   AVFrame* avframe = av_frame_alloc();
 
   // Make a shallow copy of packet so we can slide packet.data as frames are
   // decoded from the packet; otherwise av_packet_unref() will corrupt memory.
   AVPacket packet_temp = *packet.get();
 
   do {
     int frame_decoded = 0;
     int result = avcodec_decode_audio4(av_audio_context_.get(), avframe,
                                        &frame_decoded, &packet_temp);
-    CHECK(result >= 0) << "Failed to decode audio.";
+    // Failed to decode audio.
+    CHECK(result >= 0);
     packet_temp.size -= result;
     packet_temp.data += result;
     if (!frame_decoded)
       continue;
 
     int frames_read = avframe->nb_samples;
     if (frames_read < 0)
       break;
 
     if (!audio_sent_ts_) {
@@ skipping 50 matching lines @@
         output_audio_params_.sample_rate() / kAudioPacketsPerSecond));
     audio_converter_->Convert(resampled_bus.get());
     audio_bus_queue_.push(resampled_bus.release());
   }
 }
 
 void FakeMediaSource::DecodeVideo(ScopedAVPacket packet) {
   // Video.
   int got_picture;
   AVFrame* avframe = av_frame_alloc();
+  // Video decode error.
   CHECK(avcodec_decode_video2(av_video_context_.get(), avframe, &got_picture,
-                              packet.get()) >= 0)
-      << "Video decode error.";
+                              packet.get()) >= 0);
   if (!got_picture) {
     av_frame_free(&avframe);
     return;
   }
   gfx::Size size(av_video_context_->width, av_video_context_->height);
 
   if (!video_first_pts_set_) {
     video_first_pts_ = avframe->pts;
     video_first_pts_set_ = true;
   }
@@ skipping 68 matching lines @@
 AVStream* FakeMediaSource::av_audio_stream() {
   return av_format_context_->streams[audio_stream_index_];
 }
 
 AVStream* FakeMediaSource::av_video_stream() {
   return av_format_context_->streams[video_stream_index_];
 }
 
 }  // namespace cast
 }  // namespace media