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

media/audio/win/audio_low_latency_output_win_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 <windows.h>
 #include <mmsystem.h>
 
 #include "base/basictypes.h"
 #include "base/environment.h"
 #include "base/file_util.h"
@@ skipping 35 matching lines @@
 
 MATCHER_P(HasValidDelay, value, "") {
   // It is difficult to come up with a perfect test condition for the delay
   // estimation. For now, verify that the produced output delay is always
   // larger than the selected buffer size.
   return arg.hardware_delay_bytes > value.hardware_delay_bytes;
 }
 
 class MockAudioSourceCallback : public AudioOutputStream::AudioSourceCallback {
  public:
-  MOCK_METHOD4(OnMoreData, uint32(AudioOutputStream* stream,
-                                  uint8* dest,
+  MOCK_METHOD3(OnMoreData, uint32(uint8* dest,
                                   uint32 max_size,
                                   AudioBuffersState buffers_state));
   MOCK_METHOD2(OnError, void(AudioOutputStream* stream, int code));
 };
 
 // This audio source implementation should be used for manual tests only since
 // it takes about 20 seconds to play out a file.
 class ReadFromFileAudioSource : public AudioOutputStream::AudioSourceCallback {
  public:
   explicit ReadFromFileAudioSource(const std::string& name)
@@ skipping 28 matching lines @@
     size_t elements_written = 0;
     while (elements_written < elements_to_write_) {
       fprintf(text_file_, "%d\n", delta_times_[elements_written]);
       ++elements_written;
     }
 
     file_util::CloseFile(text_file_);
   }
 
   // AudioOutputStream::AudioSourceCallback implementation.
-  virtual uint32 OnMoreData(AudioOutputStream* stream,
-                            uint8* dest,
+  virtual uint32 OnMoreData(uint8* dest,
                             uint32 max_size,
                             AudioBuffersState buffers_state) {
     // Store time difference between two successive callbacks in an array.
     // These values will be written to a file in the destructor.
     int diff = (base::Time::Now() - previous_call_time_).InMilliseconds();
     previous_call_time_ = base::Time::Now();
     if (elements_to_write_ < kMaxDeltaSamples) {
       delta_times_[elements_to_write_] = diff;
       ++elements_to_write_;
     }
@@ skipping 275 matching lines @@
   EXPECT_TRUE(aos->Open());
 
   // Derive the expected size in bytes of each packet.
   uint32 bytes_per_packet = aosw.channels() * aosw.samples_per_packet() *
                            (aosw.bits_per_sample() / 8);
 
   // Set up expected minimum delay estimation.
   AudioBuffersState state(0, bytes_per_packet);
 
   // Wait for the first callback and verify its parameters.
-  EXPECT_CALL(source, OnMoreData(aos, NotNull(), bytes_per_packet,
+  EXPECT_CALL(source, OnMoreData(NotNull(), bytes_per_packet,
                                  HasValidDelay(state)))
       .WillOnce(
           DoAll(
               InvokeWithoutArgs(
                   CreateFunctor(&QuitMessageLoop, proxy.get())),
               Return(bytes_per_packet)));
 
   aos->Start(&source);
   loop.PostDelayedTask(FROM_HERE, MessageLoop::QuitClosure(),
                        TestTimeouts::action_timeout());
@@ skipping 21 matching lines @@
   EXPECT_TRUE(aos->Open());
 
   // Derive the expected size in bytes of each packet.
   uint32 bytes_per_packet = aosw.channels() * aosw.samples_per_packet() *
                            (aosw.bits_per_sample() / 8);
 
   // Set up expected minimum delay estimation.
   AudioBuffersState state(0, bytes_per_packet);
 
   // Wait for the first callback and verify its parameters.
-  EXPECT_CALL(source, OnMoreData(aos, NotNull(), bytes_per_packet,
+  EXPECT_CALL(source, OnMoreData(NotNull(), bytes_per_packet,
                                  HasValidDelay(state)))
       .WillOnce(
           DoAll(
               InvokeWithoutArgs(
                   CreateFunctor(&QuitMessageLoop, proxy.get())),
               Return(bytes_per_packet)));
 
   aos->Start(&source);
   loop.PostDelayedTask(FROM_HERE, MessageLoop::QuitClosure(),
                        TestTimeouts::action_timeout());
@@ skipping 25 matching lines @@
     aos->Close();
     return;
   }
   // Derive the expected size in bytes of each packet.
   uint32 bytes_per_packet = aosw.channels() * aosw.samples_per_packet() *
                            (aosw.bits_per_sample() / 8);
 
   // Set up expected minimum delay estimation.
   AudioBuffersState state(0, bytes_per_packet);
 
-  EXPECT_CALL(source, OnMoreData(aos, NotNull(), bytes_per_packet,
+  EXPECT_CALL(source, OnMoreData(NotNull(), bytes_per_packet,
                                  HasValidDelay(state)))
       .WillOnce(
           DoAll(
               InvokeWithoutArgs(
                   CreateFunctor(&QuitMessageLoop, proxy.get())),
               Return(bytes_per_packet)));
 
   aos->Start(&source);
   loop.PostDelayedTask(FROM_HERE, MessageLoop::QuitClosure(),
                        TestTimeouts::action_timeout());
@@ skipping 40 matching lines @@
   aos->Start(&file_source);
   base::PlatformThread::Sleep(
       base::TimeDelta::FromMilliseconds(kFileDurationMs));
   aos->Stop();
 
   LOG(INFO) << ">> File playout has stopped.";
   aos->Close();
 }
 
 }  // namespace media