Support for remote audio into tracks

talk/app/webrtc/rtpsenderreceiver_unittest.cc

 /*
  * libjingle
  * Copyright 2012 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
  *     this list of conditions and the following disclaimer in the documentation
  *     and/or other materials provided with the distribution.
  *  3. The name of the author may not be used to endorse or promote products
  *     derived from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include <string>
+#include <utility>
 
 #include "talk/app/webrtc/audiotrack.h"
 #include "talk/app/webrtc/mediastream.h"
 #include "talk/app/webrtc/remoteaudiosource.h"
+#include "talk/app/webrtc/remoteaudiotrack.h"
 #include "talk/app/webrtc/rtpreceiver.h"
 #include "talk/app/webrtc/rtpsender.h"
 #include "talk/app/webrtc/streamcollection.h"
 #include "talk/app/webrtc/videosource.h"
 #include "talk/app/webrtc/videotrack.h"
 #include "talk/media/base/fakevideocapturer.h"
 #include "talk/media/base/mediachannel.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/gunit.h"
 
 using ::testing::_;
 using ::testing::Exactly;
 
 static const char kStreamLabel1[] = "local_stream_1";
 static const char kVideoTrackId[] = "video_1";
 static const char kAudioTrackId[] = "audio_1";
 static const uint32_t kVideoSsrc = 98;
 static const uint32_t kVideoSsrc2 = 100;
 static const uint32_t kAudioSsrc = 99;
 static const uint32_t kAudioSsrc2 = 101;
 
 namespace webrtc {
 
 // Helper class to test RtpSender/RtpReceiver.
 class MockAudioProvider : public AudioProviderInterface {
  public:
-  virtual ~MockAudioProvider() {}
+  ~MockAudioProvider() override {}
+
   MOCK_METHOD2(SetAudioPlayout,
                void(uint32_t ssrc,
                     bool enable));
   MOCK_METHOD4(SetAudioSend,
                void(uint32_t ssrc,
                     bool enable,
                     const cricket::AudioOptions& options,
                     cricket::AudioRenderer* renderer));
   MOCK_METHOD2(SetAudioPlayoutVolume, void(uint32_t ssrc, double volume));
+
+  void SetRawAudioSink(uint32_t,

[the sun, 2015/12/11 16:32:04]

No. You just turned the mock into a fake. Please add a MOCK_METHOD2 for
SetRawAudioSink and make the appropriate ON_CALL or EXPECT_CALL setup in the
test.

[tommi (sloooow) - chröme, 2015/12/11 17:51:18]

There is some functionality here though and it's the one that applies to all the
test below.  The lifetime guarantees that come with setting the sink is
basically what this does.  So, it depends on what 'fake' means, but this is not
a no-op.

The mock macros do currently not work with this type of owner passing, so using
MOCK_METHOD2 does not work.  However, I could add a new method that can be
mocked for the sake of doing something with the sink.  It would look something
like:

void SetRawAudioSink(uint32_t ssrc, rtc::scoped_ptr<AudioSinkInterface> sink)
override {
  SetRawAudioSink(ssrc, &sink);
}

MOCK_METHOD2(SetRawAudioSink, void(uint32_t ssrc,
rtc::scoped_ptr<AudioSinkInterface>* sink));

In order to take ownership of the object and move it into a local, some gtest
macro magic is required. I currently don't see any WithArg() handling of
arguments in this code and figured it would make it unnecessarily complex.

So, in this case all the tests need the same functionality, MOCK doesn't work,
jumping through several gtest hoops is required to get the same functionality as
MockAudioProvider provides now (lifetime guarantees), so I took the easy way
out.

[the sun, 2015/12/11 19:46:28]

Does it work to add in SetUp() or CreateAudioRtpSender something like:
    EXPECT_CALL(audio_provider_, SetRawAudioSink(kSsrc, _))
        .WillOnce(Invoke([this](uint32_t ssrc,
rtc::scoped_ptr<AudioSinkInterface> sink) {
          sink_ = std::move(sink);
        }));
and keep the sink_ in the test class? Is it a problem with how the scoped_ptr is
forwarded to the lambda?

If that doesn't work I guess your chosen solution is the best trade off.

+                       rtc::scoped_ptr<AudioSinkInterface> sink) override {
+    sink_ = std::move(sink);
+  }
+
+ private:
+  rtc::scoped_ptr<AudioSinkInterface> sink_;
 };
 
 // Helper class to test RtpSender/RtpReceiver.
 class MockVideoProvider : public VideoProviderInterface {
  public:
   virtual ~MockVideoProvider() {}
   MOCK_METHOD2(SetCaptureDevice,
                bool(uint32_t ssrc, cricket::VideoCapturer* camera));
   MOCK_METHOD3(SetVideoPlayout,
                void(uint32_t ssrc,
@@ skipping 64 matching lines @@
     audio_rtp_sender_ = nullptr;
   }
 
   void DestroyVideoRtpSender() {
     EXPECT_CALL(video_provider_, SetCaptureDevice(kVideoSsrc, NULL)).Times(1);
     EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc, false, _)).Times(1);
     video_rtp_sender_ = nullptr;
   }
 
   void CreateAudioRtpReceiver() {
-    audio_track_ =
-        AudioTrack::Create(kAudioTrackId, RemoteAudioSource::Create().get());
+    audio_track_ = RemoteAudioTrack::Create(
+        kAudioTrackId, RemoteAudioSource::Create(kAudioSsrc, NULL));
     EXPECT_TRUE(stream_->AddTrack(audio_track_));
     EXPECT_CALL(audio_provider_, SetAudioPlayout(kAudioSsrc, true));
     audio_rtp_receiver_ = new AudioRtpReceiver(stream_->GetAudioTracks()[0],
                                                kAudioSsrc, &audio_provider_);
   }
 
   void CreateVideoRtpReceiver() {
     EXPECT_CALL(video_provider_,
                 SetVideoPlayout(kVideoSsrc, true,
                                 video_track_->GetSource()->FrameInput()));
@@ skipping 315 matching lines @@
                                video_track_->GetSource()->GetVideoCapturer()));
   EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc2, true, _));
   sender->SetSsrc(kVideoSsrc2);
 
   // Calls expected from destructor.
   EXPECT_CALL(video_provider_, SetCaptureDevice(kVideoSsrc2, nullptr)).Times(1);
   EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc2, false, _)).Times(1);
 }
 
 }  // namespace webrtc