Remove unused parameter "stream" from all variants of OnMoreData().

media/audio/audio_output_mixer.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_output_mixer.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 127 matching lines @@
 }
 
 void AudioOutputMixer::ClosePhysicalStream() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
   if (proxies_.empty() && physical_stream_.get() != NULL)
     physical_stream_.release()->Close();
 }
 
 // AudioSourceCallback implementation.
-uint32 AudioOutputMixer::OnMoreData(AudioOutputStream* stream,
-                                    uint8* dest,
+uint32 AudioOutputMixer::OnMoreData(uint8* dest,
                                     uint32 max_size,
                                     AudioBuffersState buffers_state) {
   max_size = std::min(max_size,
                       static_cast<uint32>(params_.GetBytesPerBuffer()));
   // TODO(enal): consider getting rid of lock as it is in time-critical code.
   //             E.g. swap |proxies_| with local variable, and merge 2 lists
   //             at the end. That would speed things up but complicate stopping
   //             the stream.
   base::AutoLock lock(lock_);
   if (proxies_.empty())
     return 0;
   uint32 actual_total_size = 0;
   uint32 bytes_per_sample = params_.bits_per_sample() >> 3;
 
   // Go through all the streams, getting data for every one of them
   // and mixing it into destination.
   // Minor optimization: for the first stream we are writing data directly into
   // destination. This way we don't have to mix the data when there is only one
   // active stream, and net win in other cases, too.
   bool first_stream = true;
   uint8* actual_dest = dest;
   for (ProxyMap::iterator it = proxies_.begin(); it != proxies_.end(); ++it) {
-    AudioOutputProxy* stream_proxy = it->first;
     ProxyData* proxy_data = &it->second;
     // TODO(enal): We don't know |pending _bytes| for individual stream, and we
     // should give that value to individual stream's OnMoreData(). I believe it
     // can be used there to evaluate exact position of data it should return.
     // Current code "sorta works" if everything works perfectly, but would have
     // problems if some of the buffers are only partially filled -- we don't
     // know how how much data was in the buffer OS returned to us, so we cannot
     // correctly calculate new value. If we know number of buffers we can solve
     // the problem by storing not one value but vector of them.
     int pending_bytes = std::min(proxy_data->pending_bytes,
                                  buffers_state.pending_bytes);
     // Note: there is no way we can deduce hardware_delay_bytes for the
     // particular proxy stream. Use zero instead.
     uint32 actual_size = proxy_data->audio_source_callback->OnMoreData(
-        stream_proxy,
         actual_dest,
         max_size,
         AudioBuffersState(pending_bytes, 0));
 
     // Should update pending_bytes for each proxy.
     // If stream ended, pending_bytes goes down by max_size.
     if (actual_size == 0) {
       pending_bytes -= max_size;
       proxy_data->pending_bytes = std::max(pending_bytes, 0);
       continue;
@@ skipping 44 matching lines @@
 }
 
 void AudioOutputMixer::WaitTillDataReady() {
   base::AutoLock lock(lock_);
   for (ProxyMap::iterator it = proxies_.begin(); it != proxies_.end(); ++it) {
     it->second.audio_source_callback->WaitTillDataReady();
   }
 }
 
 }  // namespace media