Remove unnecessary RTPFragmentationHeader from VideoProcessor callbacks.

webrtc/modules/video_coding/codecs/test/videoprocessor.h

 /*
  *  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 190 matching lines @@
         : video_processor_(video_processor),
           task_queue_(rtc::TaskQueue::Current()) {}
 
     Result OnEncodedImage(
         const webrtc::EncodedImage& encoded_image,
         const webrtc::CodecSpecificInfo* codec_specific_info,
         const webrtc::RTPFragmentationHeader* fragmentation) override {
       RTC_CHECK(codec_specific_info);
 
       if (task_queue_ && !task_queue_->IsCurrent()) {
-        task_queue_->PostTask(std::unique_ptr<rtc::QueuedTask>(
-            new EncodeCallbackTask(video_processor_, encoded_image,
-                                   codec_specific_info, fragmentation)));
+        task_queue_->PostTask(
+            std::unique_ptr<rtc::QueuedTask>(new EncodeCallbackTask(
+                video_processor_, encoded_image, codec_specific_info)));
         return Result(Result::OK, 0);
       }
 
       video_processor_->FrameEncoded(codec_specific_info->codecType,
-                                     encoded_image, fragmentation);
+                                     encoded_image);
       return Result(Result::OK, 0);
     }
 
    private:
     class EncodeCallbackTask : public rtc::QueuedTask {
      public:
       EncodeCallbackTask(VideoProcessor* video_processor,
                          const webrtc::EncodedImage& encoded_image,
-                         const webrtc::CodecSpecificInfo* codec_specific_info,
-                         const webrtc::RTPFragmentationHeader* fragmentation)
+                         const webrtc::CodecSpecificInfo* codec_specific_info)
           : video_processor_(video_processor),
             buffer_(encoded_image._buffer, encoded_image._length),
             encoded_image_(encoded_image),
             codec_specific_info_(*codec_specific_info) {
         encoded_image_._buffer = buffer_.data();
-        RTC_CHECK(fragmentation);
-        fragmentation_.CopyFrom(*fragmentation);
       }
 
       bool Run() override {
         video_processor_->FrameEncoded(codec_specific_info_.codecType,
-                                       encoded_image_, &fragmentation_);
+                                       encoded_image_);
         return true;
       }
 
      private:
       VideoProcessor* const video_processor_;
       rtc::Buffer buffer_;
       webrtc::EncodedImage encoded_image_;
       const webrtc::CodecSpecificInfo codec_specific_info_;
-      webrtc::RTPFragmentationHeader fragmentation_;
     };
 
     VideoProcessor* const video_processor_;
     rtc::TaskQueue* const task_queue_;
   };
 
   class VideoProcessorDecodeCompleteCallback
       : public webrtc::DecodedImageCallback {
    public:
     explicit VideoProcessorDecodeCompleteCallback(
         VideoProcessor* video_processor)
         : video_processor_(video_processor),
           task_queue_(rtc::TaskQueue::Current()) {}
 
     int32_t Decoded(webrtc::VideoFrame& image) override {
       if (task_queue_ && !task_queue_->IsCurrent()) {
         task_queue_->PostTask(
             [this, image]() { video_processor_->FrameDecoded(image); });
         return 0;
       }
-
       video_processor_->FrameDecoded(image);
       return 0;
     }
 
     int32_t Decoded(webrtc::VideoFrame& image,
                     int64_t decode_time_ms) override {
       return Decoded(image);
     }
 
     void Decoded(webrtc::VideoFrame& image,
                  rtc::Optional<int32_t> decode_time_ms,
                  rtc::Optional<uint8_t> qp) override {
       Decoded(image);
     }
 
    private:
     VideoProcessor* const video_processor_;
     rtc::TaskQueue* const task_queue_;
   };
 
   // Invoked by the callback adapter when a frame has completed encoding.
   void FrameEncoded(webrtc::VideoCodecType codec,
-                    const webrtc::EncodedImage& encodedImage,
-                    const webrtc::RTPFragmentationHeader* fragmentation);
+                    const webrtc::EncodedImage& encodedImage);
 
   // Invoked by the callback adapter when a frame has completed decoding.
   void FrameDecoded(const webrtc::VideoFrame& image);
 
   // Use the frame number as the basis for timestamp to identify frames. Let the
   // first timestamp be non-zero, to not make the IvfFileWriter believe that we
   // want to use capture timestamps in the IVF files.
   uint32_t FrameNumberToTimestamp(int frame_number) const;
   int TimestampToFrameNumber(uint32_t timestamp) const;
 
@@ skipping 45 matching lines @@
 
   rtc::SequencedTaskChecker sequence_checker_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(VideoProcessor);
 };
 
 }  // namespace test
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_VIDEO_CODING_CODECS_TEST_VIDEOPROCESSOR_H_