Removed unused async_invoker_ in WebRtcVideoCapturer

webrtc/media/engine/webrtcvideocapturer.cc

 /*
  *  Copyright (c) 2011 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 92 matching lines @@
 };
 
 ///////////////////////////////////////////////////////////////////////////
 // Implementation of class WebRtcVideoCapturer
 ///////////////////////////////////////////////////////////////////////////
 
 WebRtcVideoCapturer::WebRtcVideoCapturer()
     : factory_(new WebRtcVcmFactory),
       module_(nullptr),
       captured_frames_(0),
-      start_thread_(nullptr),
-      async_invoker_(nullptr) {}
+      start_thread_(nullptr) {}
 
 WebRtcVideoCapturer::WebRtcVideoCapturer(WebRtcVcmFactoryInterface* factory)
     : factory_(factory),
       module_(nullptr),
       captured_frames_(0),
-      start_thread_(nullptr),
-      async_invoker_(nullptr) {}
+      start_thread_(nullptr) {}
 
 WebRtcVideoCapturer::~WebRtcVideoCapturer() {}
 
 bool WebRtcVideoCapturer::Init(const Device& device) {
   RTC_DCHECK(!start_thread_);
   if (module_) {
     LOG(LS_ERROR) << "The capturer is already initialized";
     return false;
   }
 
@@ skipping 117 matching lines @@
     return CS_FAILED;
   }
   if (start_thread_) {
     LOG(LS_ERROR) << "The capturer is already running";
     RTC_DCHECK(start_thread_->IsCurrent())
         << "Trying to start capturer on different threads";
     return CS_FAILED;
   }
 
   start_thread_ = rtc::Thread::Current();
-  RTC_DCHECK(!async_invoker_);
-  async_invoker_.reset(new rtc::AsyncInvoker());
   captured_frames_ = 0;
 
   SetCaptureFormat(&capture_format);
 
   webrtc::VideoCaptureCapability cap;
   if (!FormatToCapability(capture_format, &cap)) {
     LOG(LS_ERROR) << "Invalid capture format specified";
     return CS_FAILED;
   }
 
   int64_t start = rtc::TimeMillis();
   module_->RegisterCaptureDataCallback(this);
   if (module_->StartCapture(cap) != 0) {
     LOG(LS_ERROR) << "Camera '" << GetId() << "' failed to start";
     module_->DeRegisterCaptureDataCallback();
-    async_invoker_.reset();
     SetCaptureFormat(nullptr);
     start_thread_ = nullptr;
     return CS_FAILED;
   }
 
   LOG(LS_INFO) << "Camera '" << GetId() << "' started with format "
                << capture_format.ToString() << ", elapsed time "
                << rtc::TimeSince(start) << " ms";
 
   SetCaptureState(CS_RUNNING);
   return CS_STARTING;
 }
 
 void WebRtcVideoCapturer::Stop() {
   if (!start_thread_) {
     LOG(LS_ERROR) << "The capturer is already stopped";
     return;
   }
   RTC_DCHECK(start_thread_);
   RTC_DCHECK(start_thread_->IsCurrent());
-  RTC_DCHECK(async_invoker_);
   if (IsRunning()) {
     // The module is responsible for OnIncomingCapturedFrame being called, if
     // we stop it we will get no further callbacks.
     module_->StopCapture();
   }
   module_->DeRegisterCaptureDataCallback();
 
   // TODO(juberti): Determine if the VCM exposes any drop stats we can use.
   double drop_ratio = 0.0;
   LOG(LS_INFO) << "Camera '" << GetId() << "' stopped after capturing "
                << captured_frames_ << " frames and dropping "
                << drop_ratio << "%";
 
-  // Clear any pending async invokes (that OnIncomingCapturedFrame may have
-  // caused).
-  async_invoker_.reset();
-
   SetCaptureFormat(NULL);
   start_thread_ = nullptr;
   SetCaptureState(CS_STOPPED);
 }
 
 bool WebRtcVideoCapturer::IsRunning() {
   return (module_ != NULL && module_->CaptureStarted());
 }
 
 bool WebRtcVideoCapturer::GetPreferredFourccs(std::vector<uint32_t>* fourccs) {
   if (!fourccs) {
     return false;
   }
 
   fourccs->clear();
   for (size_t i = 0; i < arraysize(kSupportedFourCCs); ++i) {
     fourccs->push_back(kSupportedFourCCs[i].fourcc);
   }
   return true;
 }
 
 void WebRtcVideoCapturer::OnFrame(
     const webrtc::VideoFrame& sample) {
   // This can only happen between Start() and Stop().
   RTC_DCHECK(start_thread_);
-  RTC_DCHECK(async_invoker_);
 
   ++captured_frames_;
   // Log the size and pixel aspect ratio of the first captured frame.
   if (1 == captured_frames_) {
     LOG(LS_INFO) << "Captured frame size "
                  << sample.width() << "x" << sample.height()
                  << ". Expected format " << GetCaptureFormat()->ToString();
   }
 
   VideoCapturer::OnFrame(sample, sample.width(), sample.height());
 }
 
 }  // namespace cricket