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

media/audio/win/audio_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/base_paths.h"
 #include "base/file_util.h"
@@ skipping 27 matching lines @@
 
 // This class allows to find out if the callbacks are occurring as
 // expected and if any error has been reported.
 class TestSourceBasic : public AudioOutputStream::AudioSourceCallback {
  public:
   explicit TestSourceBasic()
       : callback_count_(0),
         had_error_(0) {
   }
   // AudioSourceCallback::OnMoreData implementation:
-  virtual uint32 OnMoreData(AudioOutputStream* stream, uint8* dest,
-                            uint32 max_size, AudioBuffersState buffers_state) {
+  virtual uint32 OnMoreData(uint8* dest,
+                            uint32 max_size,
+                            AudioBuffersState buffers_state) {
     ++callback_count_;
     // Touch the first byte to make sure memory is good.
     if (max_size)
       reinterpret_cast<char*>(dest)[0] = 1;
     return max_size;
   }
   // AudioSourceCallback::OnError implementation:
   virtual void OnError(AudioOutputStream* stream, int code) {
     ++had_error_;
   }
@@ skipping 19 matching lines @@
 // Specializes TestSourceBasic to detect that the AudioStream is using
 // triple buffering correctly.
 class TestSourceTripleBuffer : public TestSourceBasic {
  public:
   TestSourceTripleBuffer() {
     buffer_address_[0] = NULL;
     buffer_address_[1] = NULL;
     buffer_address_[2] = NULL;
   }
   // Override of TestSourceBasic::OnMoreData.
-  virtual uint32 OnMoreData(AudioOutputStream* stream,
-                            uint8* dest, uint32 max_size,
+  virtual uint32 OnMoreData(uint8* dest,
+                            uint32 max_size,
                             AudioBuffersState buffers_state) {
     // Call the base, which increments the callback_count_.
-    TestSourceBasic::OnMoreData(stream, dest, max_size, buffers_state);
+    TestSourceBasic::OnMoreData(dest, max_size, buffers_state);
     if (callback_count() % kNumBuffers == 2) {
       set_error(!CompareExistingIfNotNULL(2, dest));
     } else if (callback_count() % kNumBuffers == 1) {
       set_error(!CompareExistingIfNotNULL(1, dest));
     } else {
       set_error(!CompareExistingIfNotNULL(0, dest));
     }
     if (callback_count() > kNumBuffers) {
       set_error(buffer_address_[0] == buffer_address_[1]);
       set_error(buffer_address_[1] == buffer_address_[2]);
@@ skipping 12 matching lines @@
   void* buffer_address_[kNumBuffers];
 };
 
 // Specializes TestSourceBasic to simulate a source that blocks for some time
 // in the OnMoreData callback.
 class TestSourceLaggy : public TestSourceBasic {
  public:
   TestSourceLaggy(int laggy_after_buffer, int lag_in_ms)
       : laggy_after_buffer_(laggy_after_buffer), lag_in_ms_(lag_in_ms) {
   }
-  virtual uint32 OnMoreData(AudioOutputStream* stream,
-                            uint8* dest, uint32 max_size,
+  virtual uint32 OnMoreData(uint8* dest,
+                            uint32 max_size,
                             AudioBuffersState buffers_state) {
     // Call the base, which increments the callback_count_.
-    TestSourceBasic::OnMoreData(stream, dest, max_size, buffers_state);
+    TestSourceBasic::OnMoreData(dest, max_size, buffers_state);
     if (callback_count() > kNumBuffers) {
       ::Sleep(lag_in_ms_);
     }
     return max_size;
   }
  private:
   int laggy_after_buffer_;
   int lag_in_ms_;
 };
 
 class MockAudioSource : 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));
 };
 
 // Helper class to memory map an entire file. The mapping is read-only. Don't
 // use for gigabyte-sized files. Attempts to write to this memory generate
 // memory access violations.
 class ReadOnlyMappedFile {
  public:
@@ skipping 444 matching lines @@
   EXPECT_TRUE(oas->Open());
 
   uint32 bytes_100_ms = samples_100_ms * 2;
 
   // We expect the amount of pending bytes will reaching 2 times of
   // |bytes_100_ms| because the audio output stream has a triple buffer scheme.
   // From that it would decrease as we are playing the data but not providing
   // new one. And then we will try to provide zero data so the amount of
   // pending bytes will go down and eventually read zero.
   InSequence s;
-  EXPECT_CALL(source, OnMoreData(oas, NotNull(), bytes_100_ms,
+  EXPECT_CALL(source, OnMoreData(NotNull(), bytes_100_ms,
                                  Field(&AudioBuffersState::pending_bytes, 0)))
       .WillOnce(Return(bytes_100_ms));
-  EXPECT_CALL(source, OnMoreData(oas, NotNull(), bytes_100_ms,
+  EXPECT_CALL(source, OnMoreData(NotNull(), bytes_100_ms,
                                  Field(&AudioBuffersState::pending_bytes,
                                        bytes_100_ms)))
       .WillOnce(Return(bytes_100_ms));
-  EXPECT_CALL(source, OnMoreData(oas, NotNull(), bytes_100_ms,
+  EXPECT_CALL(source, OnMoreData(NotNull(), bytes_100_ms,
                                  Field(&AudioBuffersState::pending_bytes,
                                        2 * bytes_100_ms)))
       .WillOnce(Return(bytes_100_ms));
-  EXPECT_CALL(source, OnMoreData(oas, NotNull(), bytes_100_ms,
+  EXPECT_CALL(source, OnMoreData(NotNull(), bytes_100_ms,
                                  Field(&AudioBuffersState::pending_bytes,
                                        2 * bytes_100_ms)))
       .Times(AnyNumber())
       .WillRepeatedly(Return(0));
-  EXPECT_CALL(source, OnMoreData(oas, NotNull(), bytes_100_ms,
+  EXPECT_CALL(source, OnMoreData(NotNull(), bytes_100_ms,
                                  Field(&AudioBuffersState::pending_bytes,
                                        bytes_100_ms)))
       .Times(AnyNumber())
       .WillRepeatedly(Return(0));
-  EXPECT_CALL(source, OnMoreData(oas, NotNull(), bytes_100_ms,
+  EXPECT_CALL(source, OnMoreData(NotNull(), bytes_100_ms,
                                  Field(&AudioBuffersState::pending_bytes, 0)))
       .Times(AnyNumber())
       .WillRepeatedly(Return(0));
 
   oas->Start(&source);
   ::Sleep(500);
   oas->Stop();
   oas->Close();
 }
 
 // Simple source that uses a SyncSocket to retrieve the audio data
 // from a potentially remote thread.
 class SyncSocketSource : public AudioOutputStream::AudioSourceCallback {
  public:
   explicit SyncSocketSource(base::SyncSocket* socket)
       : socket_(socket) {}
 
   ~SyncSocketSource() {
   }
 
   // AudioSourceCallback::OnMoreData implementation:
-  virtual uint32 OnMoreData(AudioOutputStream* stream,
-                            uint8* dest, uint32 max_size,
+  virtual uint32 OnMoreData(uint8* dest,
+                            uint32 max_size,
                             AudioBuffersState buffers_state) {
     socket_->Send(&buffers_state, sizeof(buffers_state));
     uint32 got = socket_->Receive(dest, max_size);
     return got;
   }
   // AudioSourceCallback::OnError implementation:
   virtual void OnError(AudioOutputStream* stream, int code) {
   }
 
  private:
@@ skipping 14 matching lines @@
 //                  <--- audio packet ----------
 //
 DWORD __stdcall SyncSocketThread(void* context) {
   SyncThreadContext& ctx = *(reinterpret_cast<SyncThreadContext*>(context));
 
   const int kTwoSecBytes =
       AudioParameters::kAudioCDSampleRate * 2 * sizeof(uint16);  // NOLINT
   uint8* buffer = new uint8[kTwoSecBytes];
   SineWaveAudioSource sine(SineWaveAudioSource::FORMAT_16BIT_LINEAR_PCM,
                            1, ctx.sine_freq, ctx.sample_rate);
-  sine.OnMoreData(NULL, buffer, kTwoSecBytes, AudioBuffersState());
+  sine.OnMoreData(buffer, kTwoSecBytes, AudioBuffersState());
 
   AudioBuffersState buffers_state;
   int times = 0;
   for (int ix = 0; ix < kTwoSecBytes; ix += ctx.packet_size_bytes) {
     if (ctx.socket->Receive(&buffers_state, sizeof(buffers_state)) == 0)
       break;
     if ((times > 0) && (buffers_state.pending_bytes < 1000)) __debugbreak();
     ctx.socket->Send(&buffer[ix], ctx.packet_size_bytes);
     ++times;
   }
@@ skipping 43 matching lines @@
   oas->Start(&source);
 
   ::WaitForSingleObject(thread, INFINITE);
   ::CloseHandle(thread);
 
   oas->Stop();
   oas->Close();
 }
 
 }  // namespace media