Modifies AudioInputCallback::OnData and use media::AudioBus instead of plain byte vector (Relanding)

media/audio/audio_low_latency_input_output_unittest.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 "base/basictypes.h"
 #include "base/environment.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/synchronization/lock.h"
@@ skipping 166 matching lines @@
               state.input_delay_ms,
               state.output_delay_ms);
       ++elements_written;
     }
 
     base::CloseFile(text_file);
   }
 
   // AudioInputStream::AudioInputCallback.
   virtual void OnData(AudioInputStream* stream,
-                      const uint8* src, uint32 size,
+                      const AudioBus* src,
                       uint32 hardware_delay_bytes,
                       double volume) OVERRIDE {
     base::AutoLock lock(lock_);
 
     // Update three components in the AudioDelayState for this recorded
     // audio packet.
     const base::TimeTicks now_time = base::TimeTicks::Now();
     const int diff = (now_time - previous_write_time_).InMilliseconds();
     previous_write_time_ = now_time;
     if (input_elements_to_write_ < kMaxDelayMeasurements) {
       delay_states_[input_elements_to_write_].delta_time_ms = diff;
       delay_states_[input_elements_to_write_].buffer_delay_ms =
           BytesToMilliseconds(buffer_->forward_bytes());
       delay_states_[input_elements_to_write_].input_delay_ms =
           BytesToMilliseconds(hardware_delay_bytes);
       ++input_elements_to_write_;
     }
 
+    // TODO(henrika): fix this and use AudioFifo instead.
     // Store the captured audio packet in a seekable media buffer.
-    if (!buffer_->Append(src, size)) {
-      // An attempt to write outside the buffer limits has been made.
-      // Double the buffer capacity to ensure that we have a buffer large
-      // enough to handle the current sample test scenario.
-      buffer_->set_forward_capacity(2 * buffer_->forward_capacity());
-      buffer_->Clear();
-    }
+    // if (!buffer_->Append(src, size)) {
+    // An attempt to write outside the buffer limits has been made.
+    // Double the buffer capacity to ensure that we have a buffer large
+    // enough to handle the current sample test scenario.
+    //   buffer_->set_forward_capacity(2 * buffer_->forward_capacity());
+    //   buffer_->Clear();
+    // }
   }
 
   virtual void OnError(AudioInputStream* stream) OVERRIDE {}
 
   // AudioOutputStream::AudioSourceCallback.
   virtual int OnMoreData(AudioBus* audio_bus,
                          AudioBuffersState buffers_state) OVERRIDE {
     base::AutoLock lock(lock_);
 
     // Update one component in the AudioDelayState for the packet
@@ skipping 213 matching lines @@
 
   // All Close() operations that run on the mocked audio thread,
   // should be synchronous and not post additional close tasks to
   // mocked the audio thread. Hence, there is no need to call
   // message_loop()->RunUntilIdle() after the Close() methods.
   aos->Close();
   ais->Close();
 }
 
 }  // namespace media