Remove scoped_ptrs for VCM sender_ and receiver_.

webrtc/modules/video_coding/main/source/video_coding_impl.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 59 matching lines @@
 };
 
 class VideoCodingModuleImpl : public VideoCodingModule {
  public:
   VideoCodingModuleImpl(Clock* clock,
                         EventFactory* event_factory,
                         bool owns_event_factory,
                         VideoEncoderRateObserver* encoder_rate_observer,
                         VCMQMSettingsCallback* qm_settings_callback)
       : VideoCodingModule(),
-        sender_(new vcm::VideoSender(clock,
-                                     &post_encode_callback_,
-                                     encoder_rate_observer,
-                                     qm_settings_callback)),
-        receiver_(new vcm::VideoReceiver(clock, event_factory)),
+        sender_(clock,
+                &post_encode_callback_,
+                encoder_rate_observer,
+                qm_settings_callback),
+        receiver_(clock, event_factory),
         own_event_factory_(owns_event_factory ? event_factory : NULL) {}
 
   virtual ~VideoCodingModuleImpl() {
-    sender_.reset();
-    receiver_.reset();
     own_event_factory_.reset();
   }
 
   int64_t TimeUntilNextProcess() override {
-    int64_t sender_time = sender_->TimeUntilNextProcess();
-    int64_t receiver_time = receiver_->TimeUntilNextProcess();
+    int64_t sender_time = sender_.TimeUntilNextProcess();
+    int64_t receiver_time = receiver_.TimeUntilNextProcess();
     assert(sender_time >= 0);
     assert(receiver_time >= 0);
     return VCM_MIN(sender_time, receiver_time);
   }
 
   int32_t Process() override {
-    int32_t sender_return = sender_->Process();
-    int32_t receiver_return = receiver_->Process();
+    int32_t sender_return = sender_.Process();
+    int32_t receiver_return = receiver_.Process();
     if (sender_return != VCM_OK)
       return sender_return;
     return receiver_return;
   }
 
   int32_t RegisterSendCodec(const VideoCodec* sendCodec,
                             uint32_t numberOfCores,
                             uint32_t maxPayloadSize) override {
-    return sender_->RegisterSendCodec(sendCodec, numberOfCores, maxPayloadSize);
+    return sender_.RegisterSendCodec(sendCodec, numberOfCores, maxPayloadSize);
   }
 
   const VideoCodec& GetSendCodec() const override {
-    return sender_->GetSendCodec();
+    return sender_.GetSendCodec();
   }
 
   // DEPRECATED.
   int32_t SendCodec(VideoCodec* currentSendCodec) const override {
-    return sender_->SendCodecBlocking(currentSendCodec);
+    return sender_.SendCodecBlocking(currentSendCodec);
   }
 
   // DEPRECATED.
   VideoCodecType SendCodec() const override {
-    return sender_->SendCodecBlocking();
+    return sender_.SendCodecBlocking();
   }
 
   int32_t RegisterExternalEncoder(VideoEncoder* externalEncoder,
                                   uint8_t payloadType,
                                   bool internalSource) override {
-    return sender_->RegisterExternalEncoder(
-        externalEncoder, payloadType, internalSource);
+    return sender_.RegisterExternalEncoder(externalEncoder, payloadType,
+                                           internalSource);
   }
 
   int Bitrate(unsigned int* bitrate) const override {
-    return sender_->Bitrate(bitrate);
+    return sender_.Bitrate(bitrate);
   }
 
   int FrameRate(unsigned int* framerate) const override {
-    return sender_->FrameRate(framerate);
+    return sender_.FrameRate(framerate);
   }
 
   int32_t SetChannelParameters(uint32_t target_bitrate,  // bits/s.
                                uint8_t lossRate,
                                int64_t rtt) override {
-    return sender_->SetChannelParameters(target_bitrate, lossRate, rtt);
+    return sender_.SetChannelParameters(target_bitrate, lossRate, rtt);
   }
 
   int32_t RegisterTransportCallback(
       VCMPacketizationCallback* transport) override {
-    return sender_->RegisterTransportCallback(transport);
+    return sender_.RegisterTransportCallback(transport);
   }
 
   int32_t RegisterSendStatisticsCallback(
       VCMSendStatisticsCallback* sendStats) override {
-    return sender_->RegisterSendStatisticsCallback(sendStats);
+    return sender_.RegisterSendStatisticsCallback(sendStats);
   }
 
   int32_t RegisterProtectionCallback(
       VCMProtectionCallback* protection) override {
-    return sender_->RegisterProtectionCallback(protection);
+    return sender_.RegisterProtectionCallback(protection);
   }
 
   int32_t SetVideoProtection(VCMVideoProtection videoProtection,
                              bool enable) override {
     // TODO(pbos): Remove enable from receive-side protection modes as well.
     if (enable)
-      sender_->SetVideoProtection(videoProtection);
-    return receiver_->SetVideoProtection(videoProtection, enable);
+      sender_.SetVideoProtection(videoProtection);
+    return receiver_.SetVideoProtection(videoProtection, enable);
   }
 
   int32_t AddVideoFrame(const VideoFrame& videoFrame,
                         const VideoContentMetrics* contentMetrics,
                         const CodecSpecificInfo* codecSpecificInfo) override {
-    return sender_->AddVideoFrame(
-        videoFrame, contentMetrics, codecSpecificInfo);
+    return sender_.AddVideoFrame(videoFrame, contentMetrics, codecSpecificInfo);
   }
 
   int32_t IntraFrameRequest(int stream_index) override {
-    return sender_->IntraFrameRequest(stream_index);
+    return sender_.IntraFrameRequest(stream_index);
   }
 
   int32_t EnableFrameDropper(bool enable) override {
-    return sender_->EnableFrameDropper(enable);
+    return sender_.EnableFrameDropper(enable);
   }
 
   void SuspendBelowMinBitrate() override {
-    return sender_->SuspendBelowMinBitrate();
+    return sender_.SuspendBelowMinBitrate();
   }
 
-  bool VideoSuspended() const override { return sender_->VideoSuspended(); }
+  bool VideoSuspended() const override { return sender_.VideoSuspended(); }
 
   int32_t RegisterReceiveCodec(const VideoCodec* receiveCodec,
                                int32_t numberOfCores,
                                bool requireKeyFrame) override {
-    return receiver_->RegisterReceiveCodec(
-        receiveCodec, numberOfCores, requireKeyFrame);
+    return receiver_.RegisterReceiveCodec(receiveCodec, numberOfCores,
+                                          requireKeyFrame);
   }
 
   int32_t RegisterExternalDecoder(VideoDecoder* externalDecoder,
                                   uint8_t payloadType,
                                   bool internalRenderTiming) override {
-    return receiver_->RegisterExternalDecoder(
-        externalDecoder, payloadType, internalRenderTiming);
+    return receiver_.RegisterExternalDecoder(externalDecoder, payloadType,
+                                             internalRenderTiming);
   }
 
   int32_t RegisterReceiveCallback(
       VCMReceiveCallback* receiveCallback) override {
-    return receiver_->RegisterReceiveCallback(receiveCallback);
+    return receiver_.RegisterReceiveCallback(receiveCallback);
   }
 
   int32_t RegisterReceiveStatisticsCallback(
       VCMReceiveStatisticsCallback* receiveStats) override {
-    return receiver_->RegisterReceiveStatisticsCallback(receiveStats);
+    return receiver_.RegisterReceiveStatisticsCallback(receiveStats);
   }
 
   int32_t RegisterDecoderTimingCallback(
       VCMDecoderTimingCallback* decoderTiming) override {
-    return receiver_->RegisterDecoderTimingCallback(decoderTiming);
+    return receiver_.RegisterDecoderTimingCallback(decoderTiming);
   }
 
   int32_t RegisterFrameTypeCallback(
       VCMFrameTypeCallback* frameTypeCallback) override {
-    return receiver_->RegisterFrameTypeCallback(frameTypeCallback);
+    return receiver_.RegisterFrameTypeCallback(frameTypeCallback);
   }
 
   int32_t RegisterPacketRequestCallback(
       VCMPacketRequestCallback* callback) override {
-    return receiver_->RegisterPacketRequestCallback(callback);
+    return receiver_.RegisterPacketRequestCallback(callback);
   }
 
   int RegisterRenderBufferSizeCallback(
       VCMRenderBufferSizeCallback* callback) override {
-    return receiver_->RegisterRenderBufferSizeCallback(callback);
+    return receiver_.RegisterRenderBufferSizeCallback(callback);
   }
 
   int32_t Decode(uint16_t maxWaitTimeMs) override {
-    return receiver_->Decode(maxWaitTimeMs);
+    return receiver_.Decode(maxWaitTimeMs);
   }
 
-  int32_t ResetDecoder() override { return receiver_->ResetDecoder(); }
+  int32_t ResetDecoder() override { return receiver_.ResetDecoder(); }
 
   int32_t ReceiveCodec(VideoCodec* currentReceiveCodec) const override {
-    return receiver_->ReceiveCodec(currentReceiveCodec);
+    return receiver_.ReceiveCodec(currentReceiveCodec);
   }
 
   VideoCodecType ReceiveCodec() const override {
-    return receiver_->ReceiveCodec();
+    return receiver_.ReceiveCodec();
   }
 
   int32_t IncomingPacket(const uint8_t* incomingPayload,
                          size_t payloadLength,
                          const WebRtcRTPHeader& rtpInfo) override {
-    return receiver_->IncomingPacket(incomingPayload, payloadLength, rtpInfo);
+    return receiver_.IncomingPacket(incomingPayload, payloadLength, rtpInfo);
   }
 
   int32_t SetMinimumPlayoutDelay(uint32_t minPlayoutDelayMs) override {
-    return receiver_->SetMinimumPlayoutDelay(minPlayoutDelayMs);
+    return receiver_.SetMinimumPlayoutDelay(minPlayoutDelayMs);
   }
 
   int32_t SetRenderDelay(uint32_t timeMS) override {
-    return receiver_->SetRenderDelay(timeMS);
+    return receiver_.SetRenderDelay(timeMS);
   }
 
-  int32_t Delay() const override { return receiver_->Delay(); }
+  int32_t Delay() const override { return receiver_.Delay(); }
 
   uint32_t DiscardedPackets() const override {
-    return receiver_->DiscardedPackets();
+    return receiver_.DiscardedPackets();
   }
 
   int SetReceiverRobustnessMode(ReceiverRobustness robustnessMode,
                                 VCMDecodeErrorMode errorMode) override {
-    return receiver_->SetReceiverRobustnessMode(robustnessMode, errorMode);
+    return receiver_.SetReceiverRobustnessMode(robustnessMode, errorMode);
   }
 
   void SetNackSettings(size_t max_nack_list_size,
                        int max_packet_age_to_nack,
                        int max_incomplete_time_ms) override {
-    return receiver_->SetNackSettings(
-        max_nack_list_size, max_packet_age_to_nack, max_incomplete_time_ms);
+    return receiver_.SetNackSettings(max_nack_list_size, max_packet_age_to_nack,
+                                     max_incomplete_time_ms);
   }
 
   void SetDecodeErrorMode(VCMDecodeErrorMode decode_error_mode) override {
-    return receiver_->SetDecodeErrorMode(decode_error_mode);
+    return receiver_.SetDecodeErrorMode(decode_error_mode);
   }
 
   int SetMinReceiverDelay(int desired_delay_ms) override {
-    return receiver_->SetMinReceiverDelay(desired_delay_ms);
+    return receiver_.SetMinReceiverDelay(desired_delay_ms);
   }
 
   int32_t SetReceiveChannelParameters(int64_t rtt) override {
-    return receiver_->SetReceiveChannelParameters(rtt);
+    return receiver_.SetReceiveChannelParameters(rtt);
   }
 
   void RegisterPreDecodeImageCallback(EncodedImageCallback* observer) override {
-    receiver_->RegisterPreDecodeImageCallback(observer);
+    receiver_.RegisterPreDecodeImageCallback(observer);
   }
 
   void RegisterPostEncodeImageCallback(
       EncodedImageCallback* observer) override {
     post_encode_callback_.Register(observer);
   }
 
-  void TriggerDecoderShutdown() override {
-    receiver_->TriggerDecoderShutdown();
-  }
+  void TriggerDecoderShutdown() override { receiver_.TriggerDecoderShutdown(); }
 
  private:
   EncodedImageCallbackWrapper post_encode_callback_;
-  // TODO(tommi): Change sender_ and receiver_ to be non pointers
-  // (construction is 1 alloc instead of 3).
-  rtc::scoped_ptr<vcm::VideoSender> sender_;
-  rtc::scoped_ptr<vcm::VideoReceiver> receiver_;
+  vcm::VideoSender sender_;
+  vcm::VideoReceiver receiver_;
   rtc::scoped_ptr<EventFactory> own_event_factory_;
 };
 }  // namespace
 
 uint8_t VideoCodingModule::NumberOfCodecs() {
   return VCMCodecDataBase::NumberOfCodecs();
 }
 
 int32_t VideoCodingModule::Codec(uint8_t listId, VideoCodec* codec) {
   if (codec == NULL) {
@@ skipping 25 matching lines @@
   return new VideoCodingModuleImpl(clock, event_factory, false, nullptr,
                                    nullptr);
 }
 
 void VideoCodingModule::Destroy(VideoCodingModule* module) {
   if (module != NULL) {
     delete static_cast<VideoCodingModuleImpl*>(module);
   }
 }
 }  // namespace webrtc