Replace gmock's deprecated SetArgumentPointee with SetArgPointee.

media/audio/alsa/alsa_output_unittest.cc

 // Copyright 2013 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 <stdint.h>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
@@ skipping 16 matching lines @@
 using testing::AllOf;
 using testing::AtLeast;
 using testing::DoAll;
 using testing::Field;
 using testing::InSequence;
 using testing::Invoke;
 using testing::InvokeWithoutArgs;
 using testing::Mock;
 using testing::MockFunction;
 using testing::Return;
-using testing::SetArgumentPointee;
+using testing::SetArgPointee;
 using testing::StrictMock;
 using testing::StrEq;
 using testing::Unused;
 
 namespace media {
 
 class MockAlsaWrapper : public AlsaWrapper {
  public:
   MOCK_METHOD3(DeviceNameHint, int(int card,
                                    const char* iface,
@@ skipping 204 matching lines @@
 TEST_F(AlsaPcmOutputStreamTest, LatencyFloor) {
   const double kMicrosPerFrame =
       static_cast<double>(1000000) / kTestSampleRate;
   const double kPacketFramesInMinLatency =
       AlsaPcmOutputStream::kMinLatencyMicros / kMicrosPerFrame / 2.0;
 
   // Test that packets which would cause a latency under less than
   // AlsaPcmOutputStream::kMinLatencyMicros will get clipped to
   // AlsaPcmOutputStream::kMinLatencyMicros,
   EXPECT_CALL(mock_alsa_wrapper_, PcmOpen(_, _, _, _))
-      .WillOnce(DoAll(SetArgumentPointee<0>(kFakeHandle),
-                      Return(0)));
+      .WillOnce(DoAll(SetArgPointee<0>(kFakeHandle), Return(0)));
   EXPECT_CALL(mock_alsa_wrapper_,
               PcmSetParams(_, _, _, _, _, _,
                            AlsaPcmOutputStream::kMinLatencyMicros))
       .WillOnce(Return(0));
   EXPECT_CALL(mock_alsa_wrapper_, PcmGetParams(_, _, _))
-      .WillOnce(DoAll(SetArgumentPointee<1>(kTestFramesPerPacket),
-                      SetArgumentPointee<2>(kTestFramesPerPacket / 2),
-                      Return(0)));
+      .WillOnce(DoAll(SetArgPointee<1>(kTestFramesPerPacket),
+                      SetArgPointee<2>(kTestFramesPerPacket / 2), Return(0)));
 
   AlsaPcmOutputStream* test_stream = CreateStream(kTestChannelLayout,
                                                   kPacketFramesInMinLatency);
   ASSERT_TRUE(test_stream->Open());
 
   // Now close it and test that everything was released.
   EXPECT_CALL(mock_alsa_wrapper_, PcmClose(kFakeHandle)).WillOnce(Return(0));
   EXPECT_CALL(mock_alsa_wrapper_, PcmName(kFakeHandle))
       .WillOnce(Return(kTestDeviceName));
   test_stream->Close();
 
   Mock::VerifyAndClear(&mock_alsa_wrapper_);
   Mock::VerifyAndClear(mock_manager_.get());
 
   // Test that having more packets ends up with a latency based on packet size.
   const int kOverMinLatencyPacketSize = kPacketFramesInMinLatency + 1;
   int64_t expected_micros = AudioTimestampHelper::FramesToTime(
                                 kOverMinLatencyPacketSize * 2, kTestSampleRate)
                                 .InMicroseconds();
 
   EXPECT_CALL(mock_alsa_wrapper_, PcmOpen(_, _, _, _))
-      .WillOnce(DoAll(SetArgumentPointee<0>(kFakeHandle), Return(0)));
+      .WillOnce(DoAll(SetArgPointee<0>(kFakeHandle), Return(0)));
   EXPECT_CALL(mock_alsa_wrapper_,
               PcmSetParams(_, _, _, _, _, _, expected_micros))
       .WillOnce(Return(0));
   EXPECT_CALL(mock_alsa_wrapper_, PcmGetParams(_, _, _))
-      .WillOnce(DoAll(SetArgumentPointee<1>(kTestFramesPerPacket),
-                      SetArgumentPointee<2>(kTestFramesPerPacket / 2),
-                      Return(0)));
+      .WillOnce(DoAll(SetArgPointee<1>(kTestFramesPerPacket),
+                      SetArgPointee<2>(kTestFramesPerPacket / 2), Return(0)));
 
   test_stream = CreateStream(kTestChannelLayout,
                              kOverMinLatencyPacketSize);
   ASSERT_TRUE(test_stream->Open());
 
   // Now close it and test that everything was released.
   EXPECT_CALL(mock_alsa_wrapper_, PcmClose(kFakeHandle))
       .WillOnce(Return(0));
   EXPECT_CALL(mock_alsa_wrapper_, PcmName(kFakeHandle))
       .WillOnce(Return(kTestDeviceName));
   test_stream->Close();
 
   Mock::VerifyAndClear(&mock_alsa_wrapper_);
   Mock::VerifyAndClear(mock_manager_.get());
 }
 
 TEST_F(AlsaPcmOutputStreamTest, OpenClose) {
   int64_t expected_micros = AudioTimestampHelper::FramesToTime(
                                 2 * kTestFramesPerPacket, kTestSampleRate)
                                 .InMicroseconds();
 
   // Open() call opens the playback device, sets the parameters, posts a task
   // with the resulting configuration data, and transitions the object state to
   // kIsOpened.
   EXPECT_CALL(mock_alsa_wrapper_,
-              PcmOpen(_, StrEq(kTestDeviceName),
-                      SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK))
-      .WillOnce(DoAll(SetArgumentPointee<0>(kFakeHandle),
-                      Return(0)));
+              PcmOpen(_, StrEq(kTestDeviceName), SND_PCM_STREAM_PLAYBACK,
+                      SND_PCM_NONBLOCK))
+      .WillOnce(DoAll(SetArgPointee<0>(kFakeHandle), Return(0)));
   EXPECT_CALL(mock_alsa_wrapper_,
               PcmSetParams(kFakeHandle,
                            SND_PCM_FORMAT_U8,
                            SND_PCM_ACCESS_RW_INTERLEAVED,
                            ChannelLayoutToChannelCount(kTestChannelLayout),
                            kTestSampleRate,
                            1,
                            expected_micros))
       .WillOnce(Return(0));
   EXPECT_CALL(mock_alsa_wrapper_, PcmGetParams(kFakeHandle, _, _))
-      .WillOnce(DoAll(SetArgumentPointee<1>(kTestFramesPerPacket),
-                      SetArgumentPointee<2>(kTestFramesPerPacket / 2),
-                      Return(0)));
+      .WillOnce(DoAll(SetArgPointee<1>(kTestFramesPerPacket),
+                      SetArgPointee<2>(kTestFramesPerPacket / 2), Return(0)));
 
   // Open the stream.
   AlsaPcmOutputStream* test_stream = CreateStream(kTestChannelLayout);
   ASSERT_TRUE(test_stream->Open());
 
   EXPECT_EQ(AlsaPcmOutputStream::kIsOpened, test_stream->state());
   EXPECT_EQ(kFakeHandle, test_stream->playback_handle_);
   EXPECT_EQ(kTestFramesPerPacket, test_stream->frames_per_packet_);
   EXPECT_TRUE(test_stream->buffer_.get());
   EXPECT_FALSE(test_stream->stop_stream_);
@@ skipping 20 matching lines @@
   EXPECT_TRUE(test_stream->stop_stream_);
   EXPECT_TRUE(test_stream->playback_handle_ == NULL);
   EXPECT_FALSE(test_stream->buffer_.get());
 
   // Close the stream since we opened it to make destruction happy.
   test_stream->Close();
 }
 
 TEST_F(AlsaPcmOutputStreamTest, PcmSetParamsFailed) {
   EXPECT_CALL(mock_alsa_wrapper_, PcmOpen(_, _, _, _))
-      .WillOnce(DoAll(SetArgumentPointee<0>(kFakeHandle),
-                      Return(0)));
+      .WillOnce(DoAll(SetArgPointee<0>(kFakeHandle), Return(0)));
   EXPECT_CALL(mock_alsa_wrapper_, PcmSetParams(_, _, _, _, _, _, _))
       .WillOnce(Return(kTestFailedErrno));
   EXPECT_CALL(mock_alsa_wrapper_, PcmClose(kFakeHandle))
       .WillOnce(Return(0));
   EXPECT_CALL(mock_alsa_wrapper_, PcmName(kFakeHandle))
       .WillOnce(Return(kTestDeviceName));
   EXPECT_CALL(mock_alsa_wrapper_, StrError(kTestFailedErrno))
       .WillOnce(Return(kDummyMessage));
 
   // If open fails, the stream stays in kCreated because it has effectively had
   // no changes.
   AlsaPcmOutputStream* test_stream = CreateStream(kTestChannelLayout);
   ASSERT_FALSE(test_stream->Open());
   EXPECT_EQ(AlsaPcmOutputStream::kInError, test_stream->state());
 
   // Ensure internal state is set for a no-op stream if PcmSetParams() failes.
   EXPECT_TRUE(test_stream->stop_stream_);
   EXPECT_TRUE(test_stream->playback_handle_ == NULL);
   EXPECT_FALSE(test_stream->buffer_.get());
 
   // Close the stream since we opened it to make destruction happy.
   test_stream->Close();
 }
 
 TEST_F(AlsaPcmOutputStreamTest, StartStop) {
   // Open() call opens the playback device, sets the parameters, posts a task
   // with the resulting configuration data, and transitions the object state to
   // kIsOpened.
   EXPECT_CALL(mock_alsa_wrapper_, PcmOpen(_, _, _, _))
-      .WillOnce(DoAll(SetArgumentPointee<0>(kFakeHandle),
-                      Return(0)));
+      .WillOnce(DoAll(SetArgPointee<0>(kFakeHandle), Return(0)));
   EXPECT_CALL(mock_alsa_wrapper_, PcmSetParams(_, _, _, _, _, _, _))
       .WillOnce(Return(0));
   EXPECT_CALL(mock_alsa_wrapper_, PcmGetParams(_, _, _))
-      .WillOnce(DoAll(SetArgumentPointee<1>(kTestFramesPerPacket),
-                      SetArgumentPointee<2>(kTestFramesPerPacket / 2),
-                      Return(0)));
+      .WillOnce(DoAll(SetArgPointee<1>(kTestFramesPerPacket),
+                      SetArgPointee<2>(kTestFramesPerPacket / 2), Return(0)));
 
   // Open the stream.
   AlsaPcmOutputStream* test_stream = CreateStream(kTestChannelLayout);
   ASSERT_TRUE(test_stream->Open());
   base::SimpleTestTickClock* const tick_clock = new base::SimpleTestTickClock();
   tick_clock->SetNowTicks(base::TimeTicks::Now());
   test_stream->SetTickClockForTesting(base::WrapUnique(tick_clock));
 
   // Expect Device setup.
   EXPECT_CALL(mock_alsa_wrapper_, PcmDrop(kFakeHandle))
       .WillOnce(Return(0));
   EXPECT_CALL(mock_alsa_wrapper_, PcmPrepare(kFakeHandle))
       .WillOnce(Return(0));
 
   // Expect the pre-roll.
   MockAudioSourceCallback mock_callback;
   EXPECT_CALL(mock_alsa_wrapper_, PcmState(kFakeHandle))
       .WillRepeatedly(Return(SND_PCM_STATE_RUNNING));
   EXPECT_CALL(mock_alsa_wrapper_, PcmDelay(kFakeHandle, _))
-      .WillRepeatedly(DoAll(SetArgumentPointee<1>(0), Return(0)));
+      .WillRepeatedly(DoAll(SetArgPointee<1>(0), Return(0)));
   EXPECT_CALL(mock_callback,
               OnMoreData(base::TimeDelta(), tick_clock->NowTicks(), 0, _))
       .WillRepeatedly(DoAll(ClearBuffer(), Return(kTestFramesPerPacket)));
   EXPECT_CALL(mock_alsa_wrapper_, PcmWritei(kFakeHandle, _, _))
       .WillRepeatedly(Return(kTestFramesPerPacket));
 
   // Expect scheduling.
   EXPECT_CALL(mock_alsa_wrapper_, PcmAvailUpdate(kFakeHandle))
       .Times(AtLeast(2))
       .WillRepeatedly(Return(kTestFramesPerPacket));
@@ skipping 23 matching lines @@
 
   // Test empty buffer.
   test_stream->buffer_->Clear();
   test_stream->WritePacket();
   test_stream->Close();
 }
 
 TEST_F(AlsaPcmOutputStreamTest, WritePacket_NormalPacket) {
   // We need to open the stream before writing data to ALSA.
   EXPECT_CALL(mock_alsa_wrapper_, PcmOpen(_, _, _, _))
-      .WillOnce(DoAll(SetArgumentPointee<0>(kFakeHandle),
-                      Return(0)));
+      .WillOnce(DoAll(SetArgPointee<0>(kFakeHandle), Return(0)));
   EXPECT_CALL(mock_alsa_wrapper_, PcmSetParams(_, _, _, _, _, _, _))
       .WillOnce(Return(0));
   EXPECT_CALL(mock_alsa_wrapper_, PcmGetParams(_, _, _))
-      .WillOnce(DoAll(SetArgumentPointee<1>(kTestFramesPerPacket),
-                      SetArgumentPointee<2>(kTestFramesPerPacket / 2),
-                      Return(0)));
+      .WillOnce(DoAll(SetArgPointee<1>(kTestFramesPerPacket),
+                      SetArgPointee<2>(kTestFramesPerPacket / 2), Return(0)));
   AlsaPcmOutputStream* test_stream = CreateStream(kTestChannelLayout);
   ASSERT_TRUE(test_stream->Open());
   InitBuffer(test_stream);
   test_stream->TransitionTo(AlsaPcmOutputStream::kIsPlaying);
 
   // Write a little less than half the data.
   int written = packet_->data_size() / kTestBytesPerFrame / 2 - 1;
   EXPECT_CALL(mock_alsa_wrapper_, PcmAvailUpdate(kFakeHandle))
         .WillOnce(Return(written));
   EXPECT_CALL(mock_alsa_wrapper_, PcmWritei(kFakeHandle, packet_->data(), _))
@@ skipping 19 matching lines @@
   EXPECT_CALL(mock_alsa_wrapper_, PcmClose(kFakeHandle))
       .WillOnce(Return(0));
   EXPECT_CALL(mock_alsa_wrapper_, PcmName(kFakeHandle))
       .WillOnce(Return(kTestDeviceName));
   test_stream->Close();
 }
 
 TEST_F(AlsaPcmOutputStreamTest, WritePacket_WriteFails) {
   // We need to open the stream before writing data to ALSA.
   EXPECT_CALL(mock_alsa_wrapper_, PcmOpen(_, _, _, _))
-      .WillOnce(DoAll(SetArgumentPointee<0>(kFakeHandle),
-                      Return(0)));
+      .WillOnce(DoAll(SetArgPointee<0>(kFakeHandle), Return(0)));
   EXPECT_CALL(mock_alsa_wrapper_, PcmSetParams(_, _, _, _, _, _, _))
       .WillOnce(Return(0));
   EXPECT_CALL(mock_alsa_wrapper_, PcmGetParams(_, _, _))
-      .WillOnce(DoAll(SetArgumentPointee<1>(kTestFramesPerPacket),
-                      SetArgumentPointee<2>(kTestFramesPerPacket / 2),
-                      Return(0)));
+      .WillOnce(DoAll(SetArgPointee<1>(kTestFramesPerPacket),
+                      SetArgPointee<2>(kTestFramesPerPacket / 2), Return(0)));
   AlsaPcmOutputStream* test_stream = CreateStream(kTestChannelLayout);
   ASSERT_TRUE(test_stream->Open());
   InitBuffer(test_stream);
   test_stream->TransitionTo(AlsaPcmOutputStream::kIsPlaying);
 
   // Fail due to a recoverable error and see that PcmRecover code path
   // continues normally.
   EXPECT_CALL(mock_alsa_wrapper_, PcmAvailUpdate(kFakeHandle))
       .WillOnce(Return(kTestFramesPerPacket));
   EXPECT_CALL(mock_alsa_wrapper_, PcmWritei(kFakeHandle, _, _))
@@ skipping 44 matching lines @@
   base::SimpleTestTickClock* const tick_clock = new base::SimpleTestTickClock();
   tick_clock->SetNowTicks(base::TimeTicks::Now());
   test_stream->SetTickClockForTesting(base::WrapUnique(tick_clock));
   InitBuffer(test_stream);
   test_stream->buffer_->Clear();
 
   MockAudioSourceCallback mock_callback;
   EXPECT_CALL(mock_alsa_wrapper_, PcmState(_))
       .WillOnce(Return(SND_PCM_STATE_RUNNING));
   EXPECT_CALL(mock_alsa_wrapper_, PcmDelay(_, _))
-      .WillOnce(DoAll(SetArgumentPointee<1>(1), Return(0)));
+      .WillOnce(DoAll(SetArgPointee<1>(1), Return(0)));
   EXPECT_CALL(mock_alsa_wrapper_, PcmAvailUpdate(_))
       .WillRepeatedly(Return(0));  // Buffer is full.
 
   // Return a partially filled packet.
   EXPECT_CALL(mock_callback,
               OnMoreData(base::TimeDelta(), tick_clock->NowTicks(), 0, _))
       .WillOnce(DoAll(ClearBuffer(), Return(kTestFramesPerPacket / 2)));
 
   bool source_exhausted;
   test_stream->set_source_callback(&mock_callback);
@@ skipping 11 matching lines @@
   tick_clock->SetNowTicks(base::TimeTicks::Now());
   test_stream->SetTickClockForTesting(base::WrapUnique(tick_clock));
   InitBuffer(test_stream);
   test_stream->buffer_->Clear();
 
   // Simulate where the underrun has occurred right after checking the delay.
   MockAudioSourceCallback mock_callback;
   EXPECT_CALL(mock_alsa_wrapper_, PcmState(_))
       .WillOnce(Return(SND_PCM_STATE_RUNNING));
   EXPECT_CALL(mock_alsa_wrapper_, PcmDelay(_, _))
-      .WillOnce(DoAll(SetArgumentPointee<1>(-1), Return(0)));
+      .WillOnce(DoAll(SetArgPointee<1>(-1), Return(0)));
   EXPECT_CALL(mock_alsa_wrapper_, PcmAvailUpdate(_))
       .WillRepeatedly(Return(0));  // Buffer is full.
   EXPECT_CALL(mock_callback,
               OnMoreData(base::TimeDelta(), tick_clock->NowTicks(), 0, _))
       .WillOnce(DoAll(ClearBuffer(), Return(kTestFramesPerPacket / 2)));
 
   bool source_exhausted;
   test_stream->set_source_callback(&mock_callback);
   test_stream->packet_size_ = kTestPacketSize;
   test_stream->BufferPacket(&source_exhausted);
@@ skipping 76 matching lines @@
     if (i == 3 || i == 4 || i == 5)  // invalid number of channels
       continue;
     SCOPED_TRACE(base::StringPrintf("Attempting %d Channel", i));
 
     // Hints will only be grabbed for channel numbers that have non-default
     // devices associated with them.
     if (kExpectedDeviceName[i] != AlsaPcmOutputStream::kDefaultDevice) {
       // The DeviceNameHint and DeviceNameFreeHint need to be paired to avoid a
       // memory leak.
       EXPECT_CALL(mock_alsa_wrapper_, DeviceNameHint(_, _, _))
-          .WillOnce(DoAll(SetArgumentPointee<2>(&kFakeHints[0]), Return(0)));
+          .WillOnce(DoAll(SetArgPointee<2>(&kFakeHints[0]), Return(0)));
       EXPECT_CALL(mock_alsa_wrapper_, DeviceNameFreeHint(&kFakeHints[0]))
           .Times(1);
     }
 
     EXPECT_CALL(mock_alsa_wrapper_,
                 PcmOpen(_, StrEq(kExpectedDeviceName[i]), _, _))
-        .WillOnce(DoAll(SetArgumentPointee<0>(kFakeHandle), Return(0)));
+        .WillOnce(DoAll(SetArgPointee<0>(kFakeHandle), Return(0)));
     EXPECT_CALL(mock_alsa_wrapper_,
                 PcmSetParams(kFakeHandle, _, _, i, _, _, _))
         .WillOnce(Return(0));
 
     // The parameters are specified by ALSA documentation, and are in constants
     // in the implementation files.
     EXPECT_CALL(mock_alsa_wrapper_, DeviceNameGetHint(_, StrEq("IOID")))
         .WillRepeatedly(Invoke(OutputHint));
     EXPECT_CALL(mock_alsa_wrapper_, DeviceNameGetHint(_, StrEq("NAME")))
         .WillRepeatedly(Invoke(EchoHint));
@@ skipping 26 matching lines @@
   const string first_try = kSurround50;
   const string second_try = string(AlsaPcmOutputStream::kPlugPrefix) +
                             kSurround50;
   const string third_try = string(AlsaPcmOutputStream::kPlugPrefix) +
                            kGenericSurround50;
   const string fourth_try = AlsaPcmOutputStream::kDefaultDevice;
   const string fifth_try = string(AlsaPcmOutputStream::kPlugPrefix) +
                            AlsaPcmOutputStream::kDefaultDevice;
 
   EXPECT_CALL(mock_alsa_wrapper_, DeviceNameHint(_, _, _))
-      .WillOnce(DoAll(SetArgumentPointee<2>(&kFakeHints[0]), Return(0)));
+      .WillOnce(DoAll(SetArgPointee<2>(&kFakeHints[0]), Return(0)));
   EXPECT_CALL(mock_alsa_wrapper_, DeviceNameFreeHint(&kFakeHints[0]))
       .Times(1);
   EXPECT_CALL(mock_alsa_wrapper_, DeviceNameGetHint(_, StrEq("IOID")))
       .WillRepeatedly(Invoke(OutputHint));
   EXPECT_CALL(mock_alsa_wrapper_, DeviceNameGetHint(_, StrEq("NAME")))
       .WillRepeatedly(Invoke(EchoHint));
   EXPECT_CALL(mock_alsa_wrapper_, StrError(kTestFailedErrno))
       .WillRepeatedly(Return(kDummyMessage));
 
   InSequence s;
@@ skipping 13 matching lines @@
   test_stream->Close();
 }
 
 TEST_F(AlsaPcmOutputStreamTest, AutoSelectDevice_HintFail) {
   // Should get |kDefaultDevice|, and force a 2-channel downmix on a failure to
   // enumerate devices.
   EXPECT_CALL(mock_alsa_wrapper_, DeviceNameHint(_, _, _))
       .WillRepeatedly(Return(kTestFailedErrno));
   EXPECT_CALL(mock_alsa_wrapper_,
               PcmOpen(_, StrEq(AlsaPcmOutputStream::kDefaultDevice), _, _))
-      .WillOnce(DoAll(SetArgumentPointee<0>(kFakeHandle), Return(0)));
+      .WillOnce(DoAll(SetArgPointee<0>(kFakeHandle), Return(0)));
   EXPECT_CALL(mock_alsa_wrapper_,
               PcmSetParams(kFakeHandle, _, _, 2, _, _, _))
       .WillOnce(Return(0));
   EXPECT_CALL(mock_alsa_wrapper_, StrError(kTestFailedErrno))
       .WillOnce(Return(kDummyMessage));
 
   AlsaPcmOutputStream* test_stream = CreateStream(CHANNEL_LAYOUT_5_0);
   EXPECT_TRUE(test_stream->AutoSelectDevice(5));
   EXPECT_TRUE(test_stream->channel_mixer_);
   test_stream->Close();
@@ skipping 46 matching lines @@
 
   // TODO(ajwong): Find a way to test whether or not another task has been
   // posted so we can verify that the Alsa code will indeed break the task
   // posting loop.
 
   test_stream->TransitionTo(AlsaPcmOutputStream::kIsClosed);
   test_stream->Close();
 }
 
 }  // namespace media