Move video send/receive stream headers to webrtc/call.

webrtc/call/video_receive_stream.h

 /*
  *  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.
  */
 
-#ifndef WEBRTC_VIDEO_RECEIVE_STREAM_H_
-#define WEBRTC_VIDEO_RECEIVE_STREAM_H_
+#ifndef WEBRTC_CALL_VIDEO_RECEIVE_STREAM_H_
+#define WEBRTC_CALL_VIDEO_RECEIVE_STREAM_H_
 
 #include <limits>
 #include <map>
 #include <string>
 #include <vector>
 
 #include "webrtc/api/call/transport.h"
 #include "webrtc/common_types.h"
 #include "webrtc/common_video/include/frame_callback.h"
 #include "webrtc/config.h"
 #include "webrtc/media/base/videosinkinterface.h"
 #include "webrtc/rtc_base/platform_file.h"
 
 namespace webrtc {
 
 class RtpPacketSinkInterface;
 class VideoDecoder;
 
 class VideoReceiveStream {
  public:
   // TODO(mflodman) Move all these settings to VideoDecoder and move the
   // declaration to common_types.h.
   struct Decoder {
+    Decoder();
+    Decoder(const Decoder&);
+    ~Decoder();
     std::string ToString() const;
 
     // The actual decoder instance.
     VideoDecoder* decoder = nullptr;
 
     // Received RTP packets with this payload type will be sent to this decoder
     // instance.
     int payload_type = 0;
 
     // Name of the decoded payload (such as VP8). Maps back to the depacketizer
     // used to unpack incoming packets.
     std::string payload_name;
 
     // This map contains the codec specific parameters from SDP, i.e. the "fmtp"
     // parameters. It is the same as cricket::CodecParameterMap used in
     // cricket::VideoCodec.
     std::map<std::string, std::string> codec_params;
   };
 
   struct Stats {
+    Stats();
+    ~Stats();
     std::string ToString(int64_t time_ms) const;
 
     int network_frame_rate = 0;
     int decode_frame_rate = 0;
     int render_frame_rate = 0;
     uint32_t frames_rendered = 0;
 
     // Decoder stats.
     std::string decoder_implementation_name = "unknown";
     FrameCounts frame_counts;
@@ skipping 22 matching lines @@
     std::string c_name;
     StreamDataCounters rtp_stats;
     RtcpPacketTypeCounter rtcp_packet_type_counts;
     RtcpStatistics rtcp_stats;
   };
 
   struct Config {
    private:
     // Access to the copy constructor is private to force use of the Copy()
     // method for those exceptional cases where we do use it.
-    Config(const Config&) = default;
+    Config(const Config&);
 
    public:
     Config() = delete;
-    Config(Config&&) = default;
-    explicit Config(Transport* rtcp_send_transport)
-        : rtcp_send_transport(rtcp_send_transport) {}
-
-    Config& operator=(Config&&) = default;
+    Config(Config&&);
+    explicit Config(Transport* rtcp_send_transport);
+    Config& operator=(Config&&);
     Config& operator=(const Config&) = delete;
+    ~Config();
 
     // Mostly used by tests.  Avoid creating copies if you can.
     Config Copy() const { return Config(*this); }
 
     std::string ToString() const;
 
     // Decoders for every payload that we can receive.
     std::vector<Decoder> decoders;
 
     // Receive-stream specific RTP settings.
     struct Rtp {
+      Rtp();
+      Rtp(const Rtp&);
+      ~Rtp();
       std::string ToString() const;
 
       // Synchronization source (stream identifier) to be received.
       uint32_t remote_ssrc = 0;
 
       // Sender SSRC used for sending RTCP (such as receiver reports).
       uint32_t local_ssrc = 0;
 
       // See RtcpMode for description.
       RtcpMode rtcp_mode = RtcpMode::kCompound;
@@ skipping 99 matching lines @@
   // themselves as secondary sinks.
   virtual void AddSecondarySink(RtpPacketSinkInterface* sink) = 0;
   virtual void RemoveSecondarySink(const RtpPacketSinkInterface* sink) = 0;
 
  protected:
   virtual ~VideoReceiveStream() {}
 };
 
 }  // namespace webrtc
 
-#endif  // WEBRTC_VIDEO_RECEIVE_STREAM_H_
+#endif  // WEBRTC_CALL_VIDEO_RECEIVE_STREAM_H_