Remove unused parameter to OnError()

media/audio/win/audio_unified_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 "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/test/test_timeouts.h"
@@ skipping 34 matching lines @@
 }
 
 class MockUnifiedSourceCallback
     : public AudioOutputStream::AudioSourceCallback {
  public:
   MOCK_METHOD2(OnMoreData, int(AudioBus* audio_bus,
                                AudioBuffersState buffers_state));
   MOCK_METHOD3(OnMoreIOData, int(AudioBus* source,
                                  AudioBus* dest,
                                  AudioBuffersState buffers_state));
-  MOCK_METHOD2(OnError, void(AudioOutputStream* stream, int code));
+  MOCK_METHOD1(OnError, void(AudioOutputStream* stream));
 };
 
 // AudioOutputStream::AudioSourceCallback implementation which enables audio
 // play-through. It also creates a text file that contains times between two
 // successive callbacks. Units are in milliseconds. This file can be used for
 // off-line analysis of the callback sequence.
 class UnifiedSourceCallback : public AudioOutputStream::AudioSourceCallback {
  public:
   explicit UnifiedSourceCallback()
       : previous_call_time_(base::Time::Now()),
@@ skipping 36 matching lines @@
     if (elements_to_write_ < kMaxDeltaSamples) {
       delta_times_[elements_to_write_] = diff;
       ++elements_to_write_;
     }
 
     // Play out the recorded audio samples in loop back.
     source->CopyTo(dest);
     return source->frames();
   };
 
-  virtual void OnError(AudioOutputStream* stream, int code) {
+  virtual void OnError(AudioOutputStream* stream) {
     NOTREACHED();
   }
 
  private:
   base::Time previous_call_time_;
   scoped_array<int> delta_times_;
   FILE* text_file_;
   size_t elements_to_write_;
 };
 
@@ skipping 68 matching lines @@
 TEST(WASAPIUnifiedStreamTest, OpenStartAndClose) {
   scoped_ptr<AudioManager> audio_manager(AudioManager::Create());
   if (!CanRunUnifiedAudioTests(audio_manager.get()))
     return;
 
   MockUnifiedSourceCallback source;
   AudioUnifiedStreamWrapper ausw(audio_manager.get());
   WASAPIUnifiedStream* wus = ausw.Create();
 
   EXPECT_TRUE(wus->Open());
-  EXPECT_CALL(source, OnError(wus, _))
+  EXPECT_CALL(source, OnError(wus))
       .Times(0);
   EXPECT_CALL(source, OnMoreIOData(NotNull(), NotNull(), _))
       .Times(Between(0, 1))
       .WillOnce(Return(ausw.frames_per_buffer()));
   wus->Start(&source);
   wus->Close();
 }
 
 // Verify that IO callbacks starts as they should.
 TEST(WASAPIUnifiedStreamTest, StartLoopbackAudio) {
   scoped_ptr<AudioManager> audio_manager(AudioManager::Create());
   if (!CanRunUnifiedAudioTests(audio_manager.get()))
     return;
 
   MessageLoopForUI loop;
   MockUnifiedSourceCallback source;
   AudioUnifiedStreamWrapper ausw(audio_manager.get());
   WASAPIUnifiedStream* wus = ausw.Create();
 
   // Set up expected minimum delay estimation where we use a minium delay
   // which is equal to the sum of render and capture sizes. We can never
   // reach a delay lower than this value.
   AudioBuffersState min_total_audio_delay(0, 2 * ausw.bytes_per_buffer());
 
   EXPECT_TRUE(wus->Open());
-  EXPECT_CALL(source, OnError(wus, _))
+  EXPECT_CALL(source, OnError(wus))
       .Times(0);
   EXPECT_CALL(source, OnMoreIOData(
       NotNull(), NotNull(), DelayGreaterThan(min_total_audio_delay)))
       .Times(AtLeast(2))
       .WillOnce(Return(ausw.frames_per_buffer()))
       .WillOnce(DoAll(
           QuitLoop(loop.message_loop_proxy()),
           Return(ausw.frames_per_buffer())));
   wus->Start(&source);
   loop.PostDelayedTask(FROM_HERE, MessageLoop::QuitClosure(),
@@ skipping 17 matching lines @@
 
   EXPECT_TRUE(wus->Open());
   wus->Start(&source);
   loop.PostDelayedTask(FROM_HERE, MessageLoop::QuitClosure(),
                        base::TimeDelta::FromMilliseconds(10000));
   loop.Run();
   wus->Close();
 }
 
 }  // namespace media