Log error instead of CHECKing input audio sequence.

media/audio/audio_input_device.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/audio/audio_input_device.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_vector.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time/time.h"
 #include "media/audio/audio_manager_base.h"
 #include "media/base/audio_bus.h"
 
+using base::IntToString;
+
 namespace media {
 
 // The number of shared memory buffer segments indicated to browser process
 // in order to avoid data overwriting. This number can be any positive number,
 // dependent how fast the renderer process can pick up captured data from
 // shared memory.
 static const int kRequestedSharedMemoryCount = 10;
 
 // Takes care of invoking the capture callback on the audio thread.
 // An instance of this class is created for each capture stream in
@@ skipping 146 matching lines @@
       break;
     case AUDIO_INPUT_IPC_DELEGATE_STATE_ERROR:
       DLOG(WARNING) << "AudioInputDevice::OnStateChanged(ERROR)";
       // Don't dereference the callback object if the audio thread
       // is stopped or stopping.  That could mean that the callback
       // object has been deleted.
       // TODO(tommi): Add an explicit contract for clearing the callback
       // object.  Possibly require calling Initialize again or provide
       // a callback object via Start() and clear it in Stop().
       if (!audio_thread_.IsStopped())
-        callback_->OnCaptureError();
+        callback_->OnCaptureError("AudioInputDevice::OnStateChanged(ERROR)");

[tommi (sloooow) - chröme, 2015/08/21 11:57:01]

nit: "AudioInputDevice::OnStateChanged - audio thread still running"

[Henrik Grunell, 2015/08/21 13:15:33]

Done.

       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
 void AudioInputDevice::OnIPCClosed() {
   DCHECK(task_runner()->BelongsToCurrentThread());
   state_ = IPC_CLOSED;
@@ skipping 98 matching lines @@
     media::AudioInputBuffer* buffer =
         reinterpret_cast<media::AudioInputBuffer*>(ptr);
     scoped_ptr<media::AudioBus> audio_bus =
         media::AudioBus::WrapMemory(audio_parameters_, buffer->audio);
     audio_buses_.push_back(audio_bus.Pass());
     ptr += segment_length_;
   }
 }
 
 void AudioInputDevice::AudioThreadCallback::Process(uint32 pending_data) {
-  CHECK_EQ(current_segment_id_, static_cast<int>(pending_data));
-
   // The shared memory represents parameters, size of the data buffer and the
   // actual data buffer containing audio data. Map the memory into this
   // structure and parse out parameters and the data area.
   uint8* ptr = static_cast<uint8*>(shared_memory_.memory());
   ptr += current_segment_id_ * segment_length_;
   AudioInputBuffer* buffer = reinterpret_cast<AudioInputBuffer*>(ptr);
 
   // Usually this will be equal but in the case of low sample rate (e.g. 8kHz,
   // the buffer may be bigger (on mac at least)).
   DCHECK_GE(buffer->params.size,
             segment_length_ - sizeof(AudioInputBufferParameters));
 
   // Verify correct sequence.
-  CHECK_EQ(last_buffer_id_ + 1, buffer->params.id);
+  if (buffer->params.id != last_buffer_id_ + 1) {
+    std::string message = "Incorrect buffer sequence. Expected = " +
+                          IntToString(last_buffer_id_ + 1) +
+                          " Actual = " + IntToString(buffer->params.id);

[tommi (sloooow) - chröme, 2015/08/21 11:57:01]

can we use StringPrintf?

[Henrik Grunell, 2015/08/21 13:15:33]

Sure, done.

+    LOG(ERROR) << message;
+    capture_callback_->OnCaptureError(message);
+  }
+  if (current_segment_id_ != static_cast<int>(pending_data)) {
+    std::string message = "Segment id not matching. Remote = " +
+                          IntToString(static_cast<int>(pending_data)) +
+                          " Local = " + IntToString(current_segment_id_);
+    LOG(ERROR) << message;
+    capture_callback_->OnCaptureError(message);
+  }
   last_buffer_id_ = buffer->params.id;
 
   // Use pre-allocated audio bus wrapping existing block of shared memory.
   media::AudioBus* audio_bus = audio_buses_[current_segment_id_];
 
   // Deliver captured data to the client in floating point format and update
   // the audio delay measurement.
   capture_callback_->Capture(
       audio_bus,
       buffer->params.hardware_delay_bytes / bytes_per_ms_,  // Delay in ms
       buffer->params.volume,
       buffer->params.key_pressed);
 
   if (++current_segment_id_ >= total_segments_)
     current_segment_id_ = 0;
 }
 
 }  // namespace media