Make fake file audio input device not crash when it fails to read.

media/audio/simple_sources.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.
 // MSVC++ requires this to be set before any other includes to get M_PI.
 #define _USE_MATH_DEFINES
 #include <cmath>
 
 #include "media/audio/simple_sources.h"
 
 #include <algorithm>
 
 #include "base/files/file.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "media/audio/sounds/wav_audio_handler.h"
 #include "media/base/audio_bus.h"
 
 namespace media {
 
 // Opens |wav_filename|, reads it and loads it as a wav file. This function will
-// bluntly trigger CHECKs if we can't read the file or if it's malformed. The
+// return a null pointer if we can't read the file or if it's malformed. The
 // caller takes ownership of the returned data. The size of the data is stored
 // in |read_length|.
 static scoped_ptr<uint8[]> ReadWavFile(const base::FilePath& wav_filename,
                                        size_t* file_length) {
   base::File wav_file(
       wav_filename, base::File::FLAG_OPEN | base::File::FLAG_READ);
-  CHECK(wav_file.IsValid())
-      << "Failed to read " << wav_filename.value()
-      << " as input to the fake device.";
+  if (!wav_file.IsValid()) {
+    LOG(ERROR) << "Failed to read " << wav_filename.value()
+               << " as input to the fake device.";
+    return nullptr;
+  }
 
   size_t wav_file_length = wav_file.GetLength();
-  CHECK_GT(wav_file_length, 0u)
-      << "Input file to fake device is empty: " << wav_filename.value();
+  if (wav_file_length == 0u) {
+    LOG(ERROR) << "Input file to fake device is empty: "
+               << wav_filename.value();
+    return nullptr;
+  }
 
   uint8* wav_file_data = new uint8[wav_file_length];
   size_t read_bytes = wav_file.Read(0, reinterpret_cast<char*>(wav_file_data),
                                     wav_file_length);
-  CHECK_EQ(read_bytes, wav_file_length)
-      << "Failed to read all bytes of " << wav_filename.value();
+  if (read_bytes != wav_file_length) {
+    LOG(ERROR) << "Failed to read all bytes of " << wav_filename.value();
+    return nullptr;
+  }
   *file_length = wav_file_length;
   return scoped_ptr<uint8[]>(wav_file_data);
 }
 
 // Opens |wav_filename|, reads it and loads it as a wav file. This function will
 // bluntly trigger CHECKs if we can't read the file or if it's malformed.
 static scoped_ptr<WavAudioHandler> CreateWavAudioHandler(
     const base::FilePath& wav_filename, const uint8* wav_file_data,
     size_t wav_file_length, const AudioParameters& expected_params) {
   base::StringPiece wav_data(reinterpret_cast<const char*>(wav_file_data),
@@ skipping 94 matching lines @@
 
 void SineWaveAudioSource::Reset() {
   base::AutoLock auto_lock(time_lock_);
   time_state_ = 0;
 }
 
 FileSource::FileSource(const AudioParameters& params,
                        const base::FilePath& path_to_wav_file)
     : params_(params),
       path_to_wav_file_(path_to_wav_file),
-      wav_file_read_pos_(0) {
+      wav_file_read_pos_(0),
+      load_failed_(false) {
 }
 
 FileSource::~FileSource() {
 }
 
 void FileSource::LoadWavFile(const base::FilePath& path_to_wav_file) {
+  // Don't try again if we already failed.
+  if (load_failed_)
+    return;
+
   // Read the file, and put its data in a scoped_ptr so it gets deleted later.
   size_t file_length = 0;
   wav_file_data_ = ReadWavFile(path_to_wav_file, &file_length);
+  if (!wav_file_data_) {
+    load_failed_ = true;
+    return;
+  }
+
   wav_audio_handler_ = CreateWavAudioHandler(
       path_to_wav_file, wav_file_data_.get(), file_length, params_);
 
   // Hook us up so we pull in data from the file into the converter. We need to
   // modify the wav file's audio parameters since we'll be reading small slices
   // of it at a time and not the whole thing (like 10 ms at a time).
   AudioParameters file_audio_slice(
       wav_audio_handler_->params().format(),
       wav_audio_handler_->params().channel_layout(),
       wav_audio_handler_->params().sample_rate(),
       wav_audio_handler_->params().bits_per_sample(),
       params_.frames_per_buffer());
 
   file_audio_converter_.reset(
       new AudioConverter(file_audio_slice, params_, false));
   file_audio_converter_->AddInput(this);
 }
 
 int FileSource::OnMoreData(AudioBus* audio_bus, uint32 total_bytes_delay) {
   // Load the file if we haven't already. This load needs to happen on the
   // audio thread, otherwise we'll run on the UI thread on Mac for instance.
   // This will massively delay the first OnMoreData, but we'll catch up.
   if (!wav_audio_handler_)
     LoadWavFile(path_to_wav_file_);
+  if (load_failed_)
+    return 0;
 
   DCHECK(wav_audio_handler_.get());
 
   // Stop playing if we've played out the whole file.
   if (wav_audio_handler_->AtEnd(wav_file_read_pos_))
     return 0;
 
   // This pulls data from ProvideInput.
   file_audio_converter_->Convert(audio_bus);
   return audio_bus->frames();
@@ skipping 78 matching lines @@
 }
 
 void BeepingSource::OnError(AudioOutputStream* stream) {
 }
 
 void BeepingSource::BeepOnce() {
   g_beep_context.Pointer()->SetBeepOnce(true);
 }
 
 }  // namespace media