Revert of Deprecate VCMPacketizationCallback::SendData and use EncodedImageCallback instead.

webrtc/modules/video_coding/video_sender_unittest.cc

 /*
  *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 68 matching lines @@
                              (width_ + 1) / 2);
     return frame_.get();
   }
 
  private:
   const int width_;
   const int height_;
   std::unique_ptr<VideoFrame> frame_;
 };
 
-class EncodedImageCallbackImpl : public EncodedImageCallback {
+class PacketizationCallback : public VCMPacketizationCallback {
  public:
-  explicit EncodedImageCallbackImpl(Clock* clock)
+  explicit PacketizationCallback(Clock* clock)
       : clock_(clock), start_time_ms_(clock_->TimeInMilliseconds()) {}
 
-  virtual ~EncodedImageCallbackImpl() {}
+  virtual ~PacketizationCallback() {}
 
-  int32_t Encoded(const EncodedImage& encoded_image,
-                  const CodecSpecificInfo* codec_specific_info,
-                  const RTPFragmentationHeader* fragmentation) override {
-    assert(codec_specific_info);
-    frame_data_.push_back(
-        FrameData(encoded_image._length, *codec_specific_info));
+  int32_t SendData(uint8_t payload_type,
+                   const EncodedImage& encoded_image,
+                   const RTPFragmentationHeader* fragmentation_header,
+                   const RTPVideoHeader* rtp_video_header) override {
+    assert(rtp_video_header);
+    frame_data_.push_back(FrameData(encoded_image._length, *rtp_video_header));
     return 0;
   }
 
   void Reset() {
     frame_data_.clear();
     start_time_ms_ = clock_->TimeInMilliseconds();
   }
 
   float FramerateFpsWithinTemporalLayer(int temporal_layer) {
     return CountFramesWithinTemporalLayer(temporal_layer) *
@@ skipping 11 matching lines @@
       info.framerate_fps[tl] = FramerateFpsWithinTemporalLayer(tl);
       info.bitrate_kbps[tl] = BitrateKbpsWithinTemporalLayer(tl);
     }
     return info;
   }
 
  private:
   struct FrameData {
     FrameData() {}
 
-    FrameData(size_t payload_size, const CodecSpecificInfo& codec_specific_info)
-        : payload_size(payload_size),
-          codec_specific_info(codec_specific_info) {}
+    FrameData(size_t payload_size, const RTPVideoHeader& rtp_video_header)
+        : payload_size(payload_size), rtp_video_header(rtp_video_header) {}
 
     size_t payload_size;
-    CodecSpecificInfo codec_specific_info;
+    RTPVideoHeader rtp_video_header;
   };
 
   int64_t interval_ms() {
     int64_t diff = (clock_->TimeInMilliseconds() - start_time_ms_);
     EXPECT_GT(diff, 0);
     return diff;
   }
 
   int CountFramesWithinTemporalLayer(int temporal_layer) {
     int frames = 0;
     for (size_t i = 0; i < frame_data_.size(); ++i) {
-      EXPECT_EQ(kVideoCodecVP8, frame_data_[i].codec_specific_info.codecType);
+      EXPECT_EQ(kRtpVideoVp8, frame_data_[i].rtp_video_header.codec);
       const uint8_t temporal_idx =
-          frame_data_[i].codec_specific_info.codecSpecific.VP8.temporalIdx;
+          frame_data_[i].rtp_video_header.codecHeader.VP8.temporalIdx;
       if (temporal_idx <= temporal_layer || temporal_idx == kNoTemporalIdx)
         frames++;
     }
     return frames;
   }
 
   size_t SumPayloadBytesWithinTemporalLayer(int temporal_layer) {
     size_t payload_size = 0;
     for (size_t i = 0; i < frame_data_.size(); ++i) {
-      EXPECT_EQ(kVideoCodecVP8, frame_data_[i].codec_specific_info.codecType);
+      EXPECT_EQ(kRtpVideoVp8, frame_data_[i].rtp_video_header.codec);
       const uint8_t temporal_idx =
-          frame_data_[i].codec_specific_info.codecSpecific.VP8.temporalIdx;
+          frame_data_[i].rtp_video_header.codecHeader.VP8.temporalIdx;
       if (temporal_idx <= temporal_layer || temporal_idx == kNoTemporalIdx)
         payload_size += frame_data_[i].payload_size;
     }
     return payload_size;
   }
 
   Clock* clock_;
   int64_t start_time_ms_;
   vector<FrameData> frame_data_;
 };
 
 class TestVideoSender : public ::testing::Test {
  protected:
   // Note: simulated clock starts at 1 seconds, since parts of webrtc use 0 as
   // a special case (e.g. frame rate in media optimization).
-  TestVideoSender() : clock_(1000), encoded_frame_callback_(&clock_) {}
+  TestVideoSender() : clock_(1000), packetization_callback_(&clock_) {}
 
   void SetUp() override {
     sender_.reset(
-        new VideoSender(&clock_, &encoded_frame_callback_, nullptr, nullptr));
+        new VideoSender(&clock_, &post_encode_callback_, nullptr, nullptr));
+    EXPECT_EQ(0, sender_->RegisterTransportCallback(&packetization_callback_));
   }
 
   void AddFrame() {
     assert(generator_.get());
     sender_->AddVideoFrame(*generator_->NextFrame(), NULL, NULL);
   }
 
   SimulatedClock clock_;
-  EncodedImageCallbackImpl encoded_frame_callback_;
+  PacketizationCallback packetization_callback_;
+  MockEncodedImageCallback post_encode_callback_;
   // Used by subclassing tests, need to outlive sender_.
   std::unique_ptr<VideoEncoder> encoder_;
   std::unique_ptr<VideoSender> sender_;
   std::unique_ptr<FrameGenerator> generator_;
 };
 
 class TestVideoSenderWithMockEncoder : public TestVideoSender {
  protected:
   void SetUp() override {
     TestVideoSender::SetUp();
@@ skipping 203 matching lines @@
     VideoCodingModule::Codec(kVideoCodecVP8, &codec);
     codec.width = width;
     codec.height = height;
     codec.codecSpecific.VP8.numberOfTemporalLayers = temporal_layers;
     return codec;
   }
 
   void InsertFrames(float framerate, float seconds) {
     for (int i = 0; i < seconds * framerate; ++i) {
       clock_.AdvanceTimeMilliseconds(1000.0f / framerate);
+      EXPECT_CALL(post_encode_callback_, Encoded(_, NULL, NULL))
+          .WillOnce(Return(0));
       AddFrame();
       // SetChannelParameters needs to be called frequently to propagate
       // framerate from the media optimization into the encoder.
       // Note: SetChannelParameters fails if less than 2 frames are in the
       // buffer since it will fail to calculate the framerate.
       if (i != 0) {
         EXPECT_EQ(VCM_OK, sender_->SetChannelParameters(
                               available_bitrate_kbps_ * 1000, 0, 200));
       }
     }
   }
 
   Vp8StreamInfo SimulateWithFramerate(float framerate) {
     const float short_simulation_interval = 5.0;
     const float long_simulation_interval = 10.0;
     // It appears that this 5 seconds simulation is needed to allow
     // bitrate and framerate to stabilize.
     InsertFrames(framerate, short_simulation_interval);
-    encoded_frame_callback_.Reset();
+    packetization_callback_.Reset();
 
     InsertFrames(framerate, long_simulation_interval);
-    return encoded_frame_callback_.CalculateVp8StreamInfo();
+    return packetization_callback_.CalculateVp8StreamInfo();
   }
 
  protected:
   VideoCodec codec_;
   int codec_bitrate_kbps_;
   int available_bitrate_kbps_;
 };
 
 #if defined(WEBRTC_ANDROID) || defined(WEBRTC_IOS)
 #define MAYBE_FixedTemporalLayersStrategy DISABLED_FixedTemporalLayersStrategy
@@ skipping 51 matching lines @@
   }
   {
     // TODO(andresp): Find out why this fails with framerate = 7.5
     Vp8StreamInfo expected = {{7.0, 7.0, 7.0}, {high_b, high_b, high_b}};
     EXPECT_THAT(SimulateWithFramerate(7.0), MatchesVp8StreamInfo(expected));
   }
 }
 }  // namespace
 }  // namespace vcm
 }  // namespace webrtc