s/WebRtcVideoChannel2/WebRtcVideoChannel and s/WebRtcVideoEngine2/WebRtcVideoEngine

webrtc/media/engine/webrtcvideoengine.h

 /*
  *  Copyright (c) 2014 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_MEDIA_ENGINE_WEBRTCVIDEOENGINE2_H_
-#define WEBRTC_MEDIA_ENGINE_WEBRTCVIDEOENGINE2_H_
+#ifndef WEBRTC_MEDIA_ENGINE_WEBRTCVIDEOENGINE_H_
+#define WEBRTC_MEDIA_ENGINE_WEBRTCVIDEOENGINE_H_
 
 #include <map>
 #include <memory>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "webrtc/api/call/transport.h"
 #include "webrtc/api/video/video_frame.h"
 #include "webrtc/base/asyncinvoker.h"
@@ skipping 25 matching lines @@
 namespace cricket {
 
 class VideoCapturer;
 class VideoProcessor;
 class VideoRenderer;
 class VoiceMediaChannel;
 class WebRtcDecoderObserver;
 class WebRtcEncoderObserver;
 class WebRtcLocalStreamInfo;
 class WebRtcRenderAdapter;
-class WebRtcVideoChannel2;
+class WebRtcVideoChannel;
 class WebRtcVideoChannelRecvInfo;
 class WebRtcVideoChannelSendInfo;
 class WebRtcVoiceEngine;
 class WebRtcVoiceMediaChannel;
 
 struct Device;
 
 class UnsignalledSsrcHandler {
  public:
   enum Action {
     kDropPacket,
     kDeliverPacket,
   };
-  virtual Action OnUnsignalledSsrc(WebRtcVideoChannel2* channel,
+  virtual Action OnUnsignalledSsrc(WebRtcVideoChannel* channel,
                                    uint32_t ssrc) = 0;
   virtual ~UnsignalledSsrcHandler() = default;
 };
 
 // TODO(pbos): Remove, use external handlers only.
 class DefaultUnsignalledSsrcHandler : public UnsignalledSsrcHandler {
  public:
   DefaultUnsignalledSsrcHandler();
-  Action OnUnsignalledSsrc(WebRtcVideoChannel2* channel,
+  Action OnUnsignalledSsrc(WebRtcVideoChannel* channel,
                            uint32_t ssrc) override;
 
   rtc::VideoSinkInterface<webrtc::VideoFrame>* GetDefaultSink() const;
-  void SetDefaultSink(WebRtcVideoChannel2* channel,
+  void SetDefaultSink(WebRtcVideoChannel* channel,
                       rtc::VideoSinkInterface<webrtc::VideoFrame>* sink);
 
   virtual ~DefaultUnsignalledSsrcHandler() = default;
 
  private:
   rtc::VideoSinkInterface<webrtc::VideoFrame>* default_sink_;
 };
 
-// WebRtcVideoEngine2 is used for the new native WebRTC Video API (webrtc:1667).
-class WebRtcVideoEngine2 {
+// WebRtcVideoEngine is used for the new native WebRTC Video API (webrtc:1667).
+class WebRtcVideoEngine {
  public:
-  WebRtcVideoEngine2();
-  virtual ~WebRtcVideoEngine2();
+  WebRtcVideoEngine();
+  virtual ~WebRtcVideoEngine();
 
   // Basic video engine implementation.
   void Init();
 
-  WebRtcVideoChannel2* CreateChannel(webrtc::Call* call,
-                                     const MediaConfig& config,
-                                     const VideoOptions& options);
+  WebRtcVideoChannel* CreateChannel(webrtc::Call* call,
+                                    const MediaConfig& config,
+                                    const VideoOptions& options);
 
   std::vector<VideoCodec> codecs() const;
   RtpCapabilities GetCapabilities() const;
 
   // Set a WebRtcVideoDecoderFactory for external decoding. Video engine does
   // not take the ownership of |decoder_factory|. The caller needs to make sure
   // that |decoder_factory| outlives the video engine.
   void SetExternalDecoderFactory(WebRtcVideoDecoderFactory* decoder_factory);
   // Set a WebRtcVideoEncoderFactory for external encoding. Video engine does
   // not take the ownership of |encoder_factory|. The caller needs to make sure
   // that |encoder_factory| outlives the video engine.
   virtual void SetExternalEncoderFactory(
       WebRtcVideoEncoderFactory* encoder_factory);
 
  private:
   bool initialized_;
 
   WebRtcVideoDecoderFactory* external_decoder_factory_;
   WebRtcVideoEncoderFactory* external_encoder_factory_;
   std::unique_ptr<WebRtcVideoEncoderFactory> simulcast_encoder_factory_;
 };
 
-class WebRtcVideoChannel2 : public VideoMediaChannel, public webrtc::Transport {
+class WebRtcVideoChannel : public VideoMediaChannel, public webrtc::Transport {
  public:
-  WebRtcVideoChannel2(webrtc::Call* call,
-                      const MediaConfig& config,
-                      const VideoOptions& options,
-                      WebRtcVideoEncoderFactory* external_encoder_factory,
-                      WebRtcVideoDecoderFactory* external_decoder_factory);
-  ~WebRtcVideoChannel2() override;
+  WebRtcVideoChannel(webrtc::Call* call,
+                     const MediaConfig& config,
+                     const VideoOptions& options,
+                     WebRtcVideoEncoderFactory* external_encoder_factory,
+                     WebRtcVideoDecoderFactory* external_decoder_factory);
+  ~WebRtcVideoChannel() override;
 
   // VideoMediaChannel implementation
   rtc::DiffServCodePoint PreferredDscp() const override;
 
   bool SetSendParameters(const VideoSendParameters& params) override;
   bool SetRecvParameters(const VideoRecvParameters& params) override;
   webrtc::RtpParameters GetRtpSendParameters(uint32_t ssrc) const override;
   bool SetRtpSendParameters(uint32_t ssrc,
                             const webrtc::RtpParameters& parameters) override;
   webrtc::RtpParameters GetRtpReceiveParameters(uint32_t ssrc) const override;
@@ skipping 306 matching lines @@
     // Expands remote RTP timestamps to int64_t to be able to estimate how long
     // the stream has been running.
     rtc::TimestampWrapAroundHandler timestamp_wraparound_handler_
         GUARDED_BY(sink_lock_);
     int64_t first_frame_timestamp_ GUARDED_BY(sink_lock_);
     // Start NTP time is estimated as current remote NTP time (estimated from
     // RTCP) minus the elapsed time, as soon as remote NTP time is available.
     int64_t estimated_remote_start_ntp_time_ms_ GUARDED_BY(sink_lock_);
   };
 
-  void Construct(webrtc::Call* call, WebRtcVideoEngine2* engine);
+  void Construct(webrtc::Call* call, WebRtcVideoEngine* engine);
 
   bool SendRtp(const uint8_t* data,
                size_t len,
                const webrtc::PacketOptions& options) override;
   bool SendRtcp(const uint8_t* data, size_t len) override;
 
   static std::vector<VideoCodecSettings> MapCodecs(
       const std::vector<VideoCodec>& codecs);
   // Select what video codec will be used for sending, i.e. what codec is used
   // for local encoding, based on supported remote codecs. The first remote
@@ skipping 32 matching lines @@
   std::set<uint32_t> receive_ssrcs_ GUARDED_BY(stream_crit_);
 
   rtc::Optional<VideoCodecSettings> send_codec_;
   rtc::Optional<std::vector<webrtc::RtpExtension>> send_rtp_extensions_;
 
   WebRtcVideoEncoderFactory* const external_encoder_factory_;
   WebRtcVideoDecoderFactory* const external_decoder_factory_;
   std::vector<VideoCodecSettings> recv_codecs_;
   std::vector<webrtc::RtpExtension> recv_rtp_extensions_;
   // See reason for keeping track of the FlexFEC payload type separately in
-  // comment in WebRtcVideoChannel2::ChangedRecvParameters.
+  // comment in WebRtcVideoChannel::ChangedRecvParameters.
   int recv_flexfec_payload_type_;
   webrtc::Call::Config::BitrateConfig bitrate_config_;
   // TODO(deadbeef): Don't duplicate information between
   // send_params/recv_params, rtp_extensions, options, etc.
   VideoSendParameters send_params_;
   VideoOptions default_send_options_;
   VideoRecvParameters recv_params_;
   int64_t last_stats_log_ms_;
 };
 
 }  // namespace cricket
 
-#endif  // WEBRTC_MEDIA_ENGINE_WEBRTCVIDEOENGINE2_H_
+#endif  // WEBRTC_MEDIA_ENGINE_WEBRTCVIDEOENGINE_H_