Use std::unique_ptr in VideoProcessor.

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 172 matching lines @@
   void SetRates(int bit_rate, int frame_rate) override;
   // Return the size of the encoded frame in bytes.
   size_t EncodedFrameSize() override;
   // Return the encoded frame type (key or delta).
   FrameType EncodedFrameType() override;
   // Return the number of dropped frames.
   int NumberDroppedFrames() override;
   // Return the number of spatial resizes.
   int NumberSpatialResizes() override;
 
-  webrtc::VideoEncoder* encoder_;
-  webrtc::VideoDecoder* decoder_;
+  webrtc::VideoEncoder* const encoder_;
+  webrtc::VideoDecoder* const decoder_;
   std::unique_ptr<VideoBitrateAllocator> bitrate_allocator_;
-  FrameReader* frame_reader_;
-  FrameWriter* frame_writer_;
-  PacketManipulator* packet_manipulator_;
+  FrameReader* const frame_reader_;
+  FrameWriter* const frame_writer_;
+  PacketManipulator* const packet_manipulator_;
   const TestConfig& config_;
   Stats* stats_;
 
-  EncodedImageCallback* encode_callback_;
-  DecodedImageCallback* decode_callback_;
+  std::unique_ptr<EncodedImageCallback> encode_callback_;
+  std::unique_ptr<DecodedImageCallback> decode_callback_;
   // Keep track of the last successful frame, since we need to write that
   // when decoding fails:
-  uint8_t* last_successful_frame_buffer_;
+  std::unique_ptr<uint8_t[]> last_successful_frame_buffer_;

[sprang_webrtc, 2017/02/09 15:21:19]

..or maybe even an rtc::Buffer?
Then we won't have to deal with manual memcpy and hoping that don't cause any
buffer overflows...

[åsapersson, 2017/02/10 08:13:33]

Ok will look at it in a separate cl.

   // To keep track of if we have excluded the first key frame from packet loss:
   bool first_key_frame_has_been_excluded_;
   // To tell the decoder previous frame have been dropped due to packet loss:
   bool last_frame_missing_;
   // If Init() has executed successfully.
   bool initialized_;
   size_t encoded_frame_size_;
   FrameType encoded_frame_type_;
   int prev_time_stamp_;
   int num_dropped_frames_;
@@ skipping 11 matching lines @@
       : public webrtc::EncodedImageCallback {
    public:
     explicit VideoProcessorEncodeCompleteCallback(VideoProcessorImpl* vp)
         : video_processor_(vp) {}
     Result OnEncodedImage(
         const webrtc::EncodedImage& encoded_image,
         const webrtc::CodecSpecificInfo* codec_specific_info,
         const webrtc::RTPFragmentationHeader* fragmentation) override;
 
    private:
-    VideoProcessorImpl* video_processor_;
+    VideoProcessorImpl* const video_processor_;
   };
 
   // Callback class required to implement according to the VideoDecoder API.
   class VideoProcessorDecodeCompleteCallback
       : public webrtc::DecodedImageCallback {
    public:
     explicit VideoProcessorDecodeCompleteCallback(VideoProcessorImpl* vp)
         : video_processor_(vp) {}
     int32_t Decoded(webrtc::VideoFrame& image) override;
     int32_t Decoded(webrtc::VideoFrame& image,
                     int64_t decode_time_ms) override {
       RTC_NOTREACHED();
       return -1;
     }
 
    private:
-    VideoProcessorImpl* video_processor_;
+    VideoProcessorImpl* const video_processor_;
   };
 };
 
 }  // namespace test
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_VIDEO_CODING_CODECS_TEST_VIDEOPROCESSOR_H_