Revert of Replace interface VideoCapturerInput with VideoSinkInterface.

webrtc/video/vie_encoder.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 223 matching lines @@
       vie_encoder_->dropped_frame_count_ = 0;
     }
     return true;
   }
   VideoFrame frame_;
   ViEEncoder* const vie_encoder_;
   const int64_t time_when_posted_ms_;
   const bool log_stats_;
 };
 
-// VideoSourceProxy is responsible ensuring thread safety between calls to
-// ViEEncoder::SetSource that will happen on libjingles worker thread when a
-// video capturer is connected to the encoder and the encoder task queue
-// (encoder_queue_) where the encoder reports its VideoSinkWants.
-class ViEEncoder::VideoSourceProxy {
- public:
-  explicit VideoSourceProxy(ViEEncoder* vie_encoder)
-      : vie_encoder_(vie_encoder), source_(nullptr) {}
-
-  void SetSource(rtc::VideoSourceInterface<VideoFrame>* source) {
-    RTC_DCHECK_CALLED_SEQUENTIALLY(&main_checker_);
-    rtc::VideoSourceInterface<VideoFrame>* old_source = nullptr;
-    {
-      rtc::CritScope lock(&crit_);
-      old_source = source_;
-      source_ = source;
-    }
-
-    if (old_source != source && old_source != nullptr) {
-      old_source->RemoveSink(vie_encoder_);
-    }
-
-    if (!source) {
-      return;
-    }
-
-    // TODO(perkj): Let VideoSourceProxy implement LoadObserver and truly send
-    // CPU load as sink wants.
-    rtc::VideoSinkWants wants;
-    source->AddOrUpdateSink(vie_encoder_, wants);
-  }
-
- private:
-  rtc::CriticalSection crit_;
-  rtc::SequencedTaskChecker main_checker_;
-  ViEEncoder* vie_encoder_;
-  rtc::VideoSourceInterface<VideoFrame>* source_ GUARDED_BY(&crit_);
-
-  RTC_DISALLOW_COPY_AND_ASSIGN(VideoSourceProxy);
-};
-
 ViEEncoder::ViEEncoder(uint32_t number_of_cores,
                        SendStatisticsProxy* stats_proxy,
                        const VideoSendStream::Config::EncoderSettings& settings,
                        rtc::VideoSinkInterface<VideoFrame>* pre_encode_callback,
                        LoadObserver* overuse_callback,
                        EncodedFrameObserver* encoder_timing)
     : shutdown_event_(true /* manual_reset */, false),
       number_of_cores_(number_of_cores),
-      source_proxy_(new VideoSourceProxy(this)),
       settings_(settings),
       vp_(VideoProcessing::Create()),
       video_sender_(Clock::GetRealTimeClock(), this, this),
       overuse_detector_(Clock::GetRealTimeClock(),
                         GetCpuOveruseOptions(settings.full_overuse_time),
                         this,
                         encoder_timing,
                         stats_proxy),
       load_observer_(overuse_callback),
       stats_proxy_(stats_proxy),
@@ skipping 19 matching lines @@
 
   encoder_queue_.PostTask([this, encoder_timing] {
     RTC_DCHECK_RUN_ON(&encoder_queue_);
     video_sender_.RegisterExternalEncoder(
         settings_.encoder, settings_.payload_type, settings_.internal_source);
     overuse_detector_.StartCheckForOveruse();
   });
 }
 
 ViEEncoder::~ViEEncoder() {
-  RTC_DCHECK_RUN_ON(&thread_checker_);
   RTC_DCHECK(shutdown_event_.Wait(0))
       << "Must call ::Stop() before destruction.";
 }
 
 void ViEEncoder::Stop() {
-  RTC_DCHECK_RUN_ON(&thread_checker_);
-  source_proxy_->SetSource(nullptr);
-  encoder_queue_.PostTask([this] {
-    RTC_DCHECK_RUN_ON(&encoder_queue_);
-    video_sender_.RegisterExternalEncoder(nullptr, settings_.payload_type,
-                                          false);
-    overuse_detector_.StopCheckForOveruse();
-    shutdown_event_.Set();
-  });
-
-  shutdown_event_.Wait(rtc::Event::kForever);
+  if (!encoder_queue_.IsCurrent()) {
+    encoder_queue_.PostTask([this] { Stop(); });
+    shutdown_event_.Wait(rtc::Event::kForever);
+    return;
+  }
+  RTC_DCHECK_RUN_ON(&encoder_queue_);
+  video_sender_.RegisterExternalEncoder(nullptr, settings_.payload_type, false);
+  overuse_detector_.StopCheckForOveruse();
+  shutdown_event_.Set();
 }
 
 void ViEEncoder::RegisterProcessThread(ProcessThread* module_process_thread) {
-  RTC_DCHECK_RUN_ON(&thread_checker_);
   RTC_DCHECK(!module_process_thread_);
   module_process_thread_ = module_process_thread;
   module_process_thread_->RegisterModule(&video_sender_);
   module_process_thread_checker_.DetachFromThread();
 }
 
 void ViEEncoder::DeRegisterProcessThread() {
-  RTC_DCHECK_RUN_ON(&thread_checker_);
   module_process_thread_->DeRegisterModule(&video_sender_);
 }
 
-void ViEEncoder::SetSource(rtc::VideoSourceInterface<VideoFrame>* source) {
-  RTC_DCHECK_RUN_ON(&thread_checker_);
-  source_proxy_->SetSource(source);
-}
-
 void ViEEncoder::SetSink(EncodedImageCallback* sink) {
   encoder_queue_.PostTask([this, sink] {
     RTC_DCHECK_RUN_ON(&encoder_queue_);
     sink_ = sink;
   });
 }
 
 void ViEEncoder::SetStartBitrate(int start_bitrate_bps) {
   encoder_queue_.PostTask([this, start_bitrate_bps] {
     RTC_DCHECK_RUN_ON(&encoder_queue_);
@@ skipping 49 matching lines @@
         content_type = VideoEncoderConfig::ContentType::kScreen;
         break;
       default:
         RTC_NOTREACHED();
         break;
     }
     stats_proxy_->SetContentType(content_type);
   }
 }
 
-void ViEEncoder::OnFrame(const VideoFrame& video_frame) {
+void ViEEncoder::IncomingCapturedFrame(const VideoFrame& video_frame) {
   RTC_DCHECK_RUNS_SERIALIZED(&incoming_frame_race_checker_);
   stats_proxy_->OnIncomingFrame(video_frame.width(), video_frame.height());
 
   VideoFrame incoming_frame = video_frame;
 
   // Local time in webrtc time base.
   int64_t current_time = clock_->TimeInMilliseconds();
   incoming_frame.set_render_time_ms(current_time);
 
   // Capture time may come from clock with an offset and drift from clock_.
@@ skipping 221 matching lines @@
     load_observer_->OnLoadUpdate(LoadObserver::kOveruse);
 }
 
 void ViEEncoder::NormalUsage() {
   RTC_DCHECK_RUN_ON(&encoder_queue_);
   if (load_observer_)
     load_observer_->OnLoadUpdate(LoadObserver::kUnderuse);
 }
 
 }  // namespace webrtc