Privitize WaitTillDataReady() and DataReady().

media/audio/audio_output_controller_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/bind.h"
 #include "base/environment.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 37 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(MockAudioOutputControllerEventHandler);
 };
 
 class MockAudioOutputControllerSyncReader
     : public AudioOutputController::SyncReader {
  public:
   MockAudioOutputControllerSyncReader() {}
 
   MOCK_METHOD1(UpdatePendingBytes, void(uint32 bytes));
-  MOCK_METHOD2(Read, int(AudioBus* source, AudioBus* dest));
+  MOCK_METHOD3(Read, int(bool block, const AudioBus* source, AudioBus* dest));
   MOCK_METHOD0(Close, void());
-  MOCK_METHOD0(DataReady, bool());
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockAudioOutputControllerSyncReader);
 };
 
 class MockAudioOutputStream : public AudioOutputStream {
  public:
   MOCK_METHOD0(Open, bool());
   MOCK_METHOD1(Start, void(AudioSourceCallback* callback));
   MOCK_METHOD0(Stop, void());
   MOCK_METHOD1(SetVolume, void(double volume));
   MOCK_METHOD1(GetVolume, void(double* volume));
   MOCK_METHOD0(Close, void());
 
   // Set/get the callback passed to Start().
   AudioSourceCallback* callback() const { return callback_; }
   void SetCallback(AudioSourceCallback* asc) { callback_ = asc; }
 
  private:
   AudioSourceCallback* callback_;
 };
 
 ACTION_P(SignalEvent, event) {
   event->Signal();
 }
 
 static const float kBufferNonZeroData = 1.0f;
 ACTION(PopulateBuffer) {
-  arg1->Zero();
+  arg2->Zero();
   // Note: To confirm the buffer will be populated in these tests, it's
   // sufficient that only the first float in channel 0 is set to the value.
-  arg1->channel(0)[0] = kBufferNonZeroData;
+  arg2->channel(0)[0] = kBufferNonZeroData;
 }
 
 class AudioOutputControllerTest : public testing::Test {
  public:
   AudioOutputControllerTest()
       : audio_manager_(AudioManager::Create()),
         create_event_(false, false),
         play_event_(false, false),
         read_event_(false, false),
         pause_event_(false, false) {
@@ skipping 32 matching lines @@
     // OnAudible() calls.
     EXPECT_CALL(mock_event_handler_, OnPlaying())
         .WillOnce(SignalEvent(&play_event_));
     EXPECT_CALL(mock_event_handler_, OnAudible(_))
         .Times(AtLeast(1));
 
     // During playback, the mock pretends to provide audio data rendered and
     // sent from the render process.
     EXPECT_CALL(mock_sync_reader_, UpdatePendingBytes(_))
         .Times(AtLeast(1));
-    EXPECT_CALL(mock_sync_reader_, Read(_, _))
+    EXPECT_CALL(mock_sync_reader_, Read(_, _, _))
         .WillRepeatedly(DoAll(PopulateBuffer(),
                               SignalEvent(&read_event_),
                               Return(params_.frames_per_buffer())));
-    EXPECT_CALL(mock_sync_reader_, DataReady())
-        .WillRepeatedly(Return(true));
-
     controller_->Play();
   }
 
   void Pause() {
     // Expect the event handler to receive one OnPaused() call.
     EXPECT_CALL(mock_event_handler_, OnPaused())
         .WillOnce(SignalEvent(&pause_event_));
 
     controller_->Pause();
   }
@@ skipping 212 matching lines @@
 
 TEST_F(AudioOutputControllerTest, DivertRevertClose) {
   Create(kSamplesPerPacket);
   WaitForCreate();
   DivertNeverPlaying();
   RevertWasNotPlaying();
   Close();
 }
 
 }  // namespace media