Delete all use of cricket::VideoFrame and cricket::WebRtcVideoFrame.

webrtc/media/engine/webrtcvideoengine2.cc

 /*
  *  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.
  */
 
@@ skipping 529 matching lines @@
   LOG(LS_INFO) << "Creating default receive stream for SSRC=" << ssrc << ".";
   if (!channel->AddRecvStream(sp, true)) {
     LOG(LS_WARNING) << "Could not create default receive stream.";
   }
 
   channel->SetSink(ssrc, default_sink_);
   default_recv_ssrc_ = ssrc;
   return kDeliverPacket;
 }
 
-rtc::VideoSinkInterface<VideoFrame>*
+rtc::VideoSinkInterface<webrtc::VideoFrame>*
 DefaultUnsignalledSsrcHandler::GetDefaultSink() const {
   return default_sink_;
 }
 
 void DefaultUnsignalledSsrcHandler::SetDefaultSink(
     VideoMediaChannel* channel,
-    rtc::VideoSinkInterface<VideoFrame>* sink) {
+    rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) {
   default_sink_ = sink;
   if (default_recv_ssrc_ != 0) {
     channel->SetSink(default_recv_ssrc_, default_sink_);
   }
 }
 
 WebRtcVideoEngine2::WebRtcVideoEngine2()
     : initialized_(false),
       external_decoder_factory_(NULL),
       external_encoder_factory_(NULL) {
@@ skipping 533 matching lines @@
   return true;
 }
 
 // TODO(nisse): The enable argument was used for mute logic which has
 // been moved to VideoBroadcaster. So remove the argument from this
 // method.
 bool WebRtcVideoChannel2::SetVideoSend(
     uint32_t ssrc,
     bool enable,
     const VideoOptions* options,
-    rtc::VideoSourceInterface<cricket::VideoFrame>* source) {
+    rtc::VideoSourceInterface<webrtc::VideoFrame>* source) {
   TRACE_EVENT0("webrtc", "SetVideoSend");
   RTC_DCHECK(ssrc != 0);
   LOG(LS_INFO) << "SetVideoSend (ssrc= " << ssrc << ", enable = " << enable
                << ", options: " << (options ? options->ToString() : "nullptr")
                << ", source = " << (source ? "(source)" : "nullptr") << ")";
 
   rtc::CritScope stream_lock(&stream_crit_);
   const auto& kv = send_streams_.find(ssrc);
   if (kv == send_streams_.end()) {
     // Allow unknown ssrc only if source is null.
@@ skipping 220 matching lines @@
   if (stream == receive_streams_.end()) {
     LOG(LS_ERROR) << "Stream not found for ssrc: " << ssrc;
     return false;
   }
   DeleteReceiveStream(stream->second);
   receive_streams_.erase(stream);
 
   return true;
 }
 
-bool WebRtcVideoChannel2::SetSink(uint32_t ssrc,
-                                  rtc::VideoSinkInterface<VideoFrame>* sink) {
+bool WebRtcVideoChannel2::SetSink(
+    uint32_t ssrc,
+    rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) {
   LOG(LS_INFO) << "SetSink: ssrc:" << ssrc << " "
                << (sink ? "(ptr)" : "nullptr");
   if (ssrc == 0) {
     default_unsignalled_ssrc_handler_.SetDefaultSink(this, sink);
     return true;
   }
 
   rtc::CritScope stream_lock(&stream_crit_);
   std::map<uint32_t, WebRtcVideoReceiveStream*>::iterator it =
       receive_streams_.find(ssrc);
@@ skipping 288 matching lines @@
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::UpdateHistograms() const {
   const int kMinRequiredFrames = 200;
   if (frame_count_ > kMinRequiredFrames) {
     RTC_HISTOGRAM_PERCENTAGE("WebRTC.Video.CpuLimitedResolutionInPercent",
                              cpu_restricted_frame_count_ * 100 / frame_count_);
   }
 }
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::OnFrame(
-    const VideoFrame& frame) {
+    const webrtc::VideoFrame& frame) {
   TRACE_EVENT0("webrtc", "WebRtcVideoSendStream::OnFrame");
   webrtc::VideoFrame video_frame(frame.video_frame_buffer(),
                                  frame.rotation(),
                                  frame.timestamp_us());
 
   rtc::CritScope cs(&lock_);
 
   if (video_frame.width() != last_frame_info_.width ||
       video_frame.height() != last_frame_info_.height ||
       video_frame.rotation() != last_frame_info_.rotation ||
@@ skipping 22 matching lines @@
 
   // Forward frame to the encoder regardless if we are sending or not. This is
   // to ensure that the encoder can be reconfigured with the correct frame size
   // as quickly as possible.
   encoder_sink_->OnFrame(video_frame);
 }
 
 bool WebRtcVideoChannel2::WebRtcVideoSendStream::SetVideoSend(
     bool enable,
     const VideoOptions* options,
-    rtc::VideoSourceInterface<cricket::VideoFrame>* source) {
+    rtc::VideoSourceInterface<webrtc::VideoFrame>* source) {
   TRACE_EVENT0("webrtc", "WebRtcVideoSendStream::SetVideoSend");
   RTC_DCHECK_RUN_ON(&thread_checker_);
 
   // Ignore |options| pointer if |enable| is false.
   bool options_present = enable && options;
   bool source_changing = source_ != source;
   if (source_changing) {
     DisconnectSource();
   }
 
@@ skipping 794 matching lines @@
   }
 
   sink_->OnFrame(frame);
 }
 
 bool WebRtcVideoChannel2::WebRtcVideoReceiveStream::IsDefaultStream() const {
   return default_stream_;
 }
 
 void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetSink(
-    rtc::VideoSinkInterface<cricket::VideoFrame>* sink) {
+    rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) {
   rtc::CritScope crit(&sink_lock_);
   sink_ = sink;
 }
 
 std::string
 WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetCodecNameFromPayloadType(
     int payload_type) {
   for (const webrtc::VideoReceiveStream::Decoder& decoder : config_.decoders) {
     if (decoder.payload_type == payload_type) {
       return decoder.payload_name;
@@ skipping 161 matching lines @@
         rtx_mapping[video_codecs[i].codec.id] !=
             ulpfec_config.red_payload_type) {
       video_codecs[i].rtx_payload_type = rtx_mapping[video_codecs[i].codec.id];
     }
   }
 
   return video_codecs;
 }
 
 }  // namespace cricket