Remove VCMPacketizationCallback

webrtc/modules/video_coding/generic_encoder.cc

 /*
 *  Copyright (c) 2012 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 54 matching lines @@
                                   const CodecSpecificInfo* codec_specific,
                                   const std::vector<FrameType>& frame_types) {
   TRACE_EVENT1("webrtc", "VCMGenericEncoder::Encode", "timestamp",
                frame.timestamp());
 
   for (FrameType frame_type : frame_types)
     RTC_DCHECK(frame_type == kVideoFrameKey || frame_type == kVideoFrameDelta);
 
   int32_t result = encoder_->Encode(frame, codec_specific, &frame_types);
 
-  if (vcm_encoded_frame_callback_) {
-    vcm_encoded_frame_callback_->SignalLastEncoderImplementationUsed(
-        encoder_->ImplementationName());
-  }
-
   if (is_screenshare_ &&
       result == WEBRTC_VIDEO_CODEC_TARGET_BITRATE_OVERSHOOT) {
     // Target bitrate exceeded, encoder state has been reset - try again.
     return encoder_->Encode(frame, codec_specific, &frame_types);
   }
 
   return result;
 }
 
+const char* VCMGenericEncoder::ImplementationName() const {
+  return encoder_->ImplementationName();
+}
+
 void VCMGenericEncoder::SetEncoderParameters(const EncoderParameters& params) {
   bool channel_parameters_have_changed;
   bool rates_have_changed;
   {
     rtc::CritScope lock(&params_lock_);
     channel_parameters_have_changed =
         params.loss_rate != encoder_params_.loss_rate ||
         params.rtt != encoder_params_.rtt;
     rates_have_changed =
         params.target_bitrate != encoder_params_.target_bitrate ||
@@ skipping 33 matching lines @@
 
 void VCMGenericEncoder::OnDroppedFrame() {
   encoder_->OnDroppedFrame();
 }
 
 bool VCMGenericEncoder::SupportsNativeHandle() const {
   return encoder_->SupportsNativeHandle();
 }
 
 VCMEncodedFrameCallback::VCMEncodedFrameCallback(
-    EncodedImageCallback* post_encode_callback)
-    : send_callback_(),
-      media_opt_(nullptr),
-      internal_source_(false),
-      post_encode_callback_(post_encode_callback) {}
+    EncodedImageCallback* post_encode_callback,
+    media_optimization::MediaOptimization* media_opt)
+    : internal_source_(false),
+      post_encode_callback_(post_encode_callback),
+      media_opt_(media_opt) {}
 
 VCMEncodedFrameCallback::~VCMEncodedFrameCallback() {}
 
-int32_t VCMEncodedFrameCallback::SetTransportCallback(
-    VCMPacketizationCallback* transport) {
-  send_callback_ = transport;
-  return VCM_OK;
-}
-
 int32_t VCMEncodedFrameCallback::Encoded(
     const EncodedImage& encoded_image,
     const CodecSpecificInfo* codec_specific,
     const RTPFragmentationHeader* fragmentation_header) {
   TRACE_EVENT_INSTANT1("webrtc", "VCMEncodedFrameCallback::Encoded",
                        "timestamp", encoded_image._timeStamp);
   int ret_val = post_encode_callback_->Encoded(encoded_image, codec_specific,
                                                fragmentation_header);
   if (ret_val < 0)
     return ret_val;
 
   if (media_opt_) {
     media_opt_->UpdateWithEncodedData(encoded_image);
     if (internal_source_)
       return media_opt_->DropFrame();  // Signal to encoder to drop next frame.
   }
   return VCM_OK;
 }
 
-void VCMEncodedFrameCallback::SetMediaOpt(
-    media_optimization::MediaOptimization* mediaOpt) {
-  media_opt_ = mediaOpt;
-}
-
-void VCMEncodedFrameCallback::SignalLastEncoderImplementationUsed(
-    const char* implementation_name) {
-  if (send_callback_)
-    send_callback_->OnEncoderImplementationName(implementation_name);
-}
 }  // namespace webrtc