Remove CaptureManager and related calls in ChannelManager.

webrtc/pc/channelmanager.cc

 /*
  *  Copyright 2004 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.
  */
 
 #include "webrtc/pc/channelmanager.h"
 
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 
 #include <algorithm>
 
 #include "webrtc/api/mediacontroller.h"
 #include "webrtc/base/bind.h"
 #include "webrtc/base/common.h"
 #include "webrtc/base/logging.h"
-#include "webrtc/base/sigslotrepeater.h"
 #include "webrtc/base/stringencode.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/base/trace_event.h"
-#include "webrtc/media/base/capturemanager.h"
 #include "webrtc/media/base/device.h"
 #include "webrtc/media/base/hybriddataengine.h"
 #include "webrtc/media/base/rtpdataengine.h"
-#include "webrtc/media/base/videocapturer.h"
 #ifdef HAVE_SCTP
 #include "webrtc/media/sctp/sctpdataengine.h"
 #endif
 #include "webrtc/pc/srtpfilter.h"
 
 namespace cricket {
 
-enum {
-  MSG_VIDEOCAPTURESTATE = 1,
-};
 
 using rtc::Bind;
 
 static const int kNotSetOutputVolume = -1;
 
-struct CaptureStateParams : public rtc::MessageData {
-  CaptureStateParams(cricket::VideoCapturer* c, cricket::CaptureState s)
-      : capturer(c),
-        state(s) {}
-  cricket::VideoCapturer* capturer;
-  cricket::CaptureState state;
-};
-
 static DataEngineInterface* ConstructDataEngine() {
 #ifdef HAVE_SCTP
   return new HybridDataEngine(new RtpDataEngine(), new SctpDataEngine());
 #else
   return new RtpDataEngine();
 #endif
 }
 
 ChannelManager::ChannelManager(MediaEngineInterface* me,
                                DataEngineInterface* dme,
-                               CaptureManager* cm,
                                rtc::Thread* worker_thread) {
-  Construct(me, dme, cm, worker_thread);
+  Construct(me, dme, worker_thread);
 }
 
 ChannelManager::ChannelManager(MediaEngineInterface* me,
                                rtc::Thread* worker_thread) {
   Construct(me,
             ConstructDataEngine(),
-            new CaptureManager(),
             worker_thread);
 }
 
 void ChannelManager::Construct(MediaEngineInterface* me,
                                DataEngineInterface* dme,
-                               CaptureManager* cm,
                                rtc::Thread* worker_thread) {
   media_engine_.reset(me);
   data_media_engine_.reset(dme);
-  capture_manager_.reset(cm);
   initialized_ = false;
   main_thread_ = rtc::Thread::Current();
   worker_thread_ = worker_thread;
   audio_output_volume_ = kNotSetOutputVolume;
   capturing_ = false;
   enable_rtx_ = false;
-
-  capture_manager_->SignalCapturerStateChange.connect(
-      this, &ChannelManager::OnVideoCaptureStateChange);
 }
 
 ChannelManager::~ChannelManager() {
   if (initialized_) {
     Terminate();
     // If srtp is initialized (done by the Channel) then we must call
     // srtp_shutdown to free all crypto kernel lists. But we need to make sure
     // shutdown always called at the end, after channels are destroyed.
     // ChannelManager d'tor is always called last, it's safe place to call
     // shutdown.
     ShutdownSrtp();
   }
-  // Some deletes need to be on the worker thread for thread safe destruction,
-  // this includes the media engine and capture manager.
+  // The media engine needs to be deleted on the worker thread for thread safe
+  // destruction,
   worker_thread_->Invoke<void>(Bind(
       &ChannelManager::DestructorDeletes_w, this));
 }
 
 bool ChannelManager::SetVideoRtxEnabled(bool enable) {
   // To be safe, this call is only allowed before initialization. Apps like
   // Flute only have a singleton ChannelManager and we don't want this flag to
   // be toggled between calls or when there's concurrent calls. We expect apps
   // to enable this at startup and retain that setting for the lifetime of the
   // app.
@@ skipping 89 matching lines @@
   if (!initialized_) {
     return;
   }
   worker_thread_->Invoke<void>(Bind(&ChannelManager::Terminate_w, this));
   initialized_ = false;
 }
 
 void ChannelManager::DestructorDeletes_w() {
   ASSERT(worker_thread_ == rtc::Thread::Current());
   media_engine_.reset(NULL);
-  capture_manager_.reset(NULL);
 }
 
 void ChannelManager::Terminate_w() {
   ASSERT(worker_thread_ == rtc::Thread::Current());
   // Need to destroy the voice/video channels
   while (!video_channels_.empty()) {
     DestroyVideoChannel_w(video_channels_.back());
   }
   while (!voice_channels_.empty()) {
     DestroyVoiceChannel_w(voice_channels_.back());
@@ skipping 192 matching lines @@
              media_engine_.get(), level));
   }
 
   if (ret) {
     audio_output_volume_ = level;
   }
 
   return ret;
 }
 
-std::vector<cricket::VideoFormat> ChannelManager::GetSupportedFormats(
-    VideoCapturer* capturer) const {
-  ASSERT(capturer != NULL);
-  std::vector<VideoFormat> formats;
-  worker_thread_->Invoke<void>(rtc::Bind(&ChannelManager::GetSupportedFormats_w,
-                                         this, capturer, &formats));
-  return formats;
-}
-
-void ChannelManager::GetSupportedFormats_w(
-    VideoCapturer* capturer,
-    std::vector<cricket::VideoFormat>* out_formats) const {
-  const std::vector<VideoFormat>* formats = capturer->GetSupportedFormats();
-  if (formats != NULL)
-    *out_formats = *formats;
-}
-
-// The following are done in the new "CaptureManager" style that
-// all local video capturers, processors, and managers should move
-// to.
-// TODO(pthatcher): Add more of the CaptureManager interface.
-bool ChannelManager::StartVideoCapture(
-    VideoCapturer* capturer, const VideoFormat& video_format) {
-  return initialized_ && worker_thread_->Invoke<bool>(
-      Bind(&CaptureManager::StartVideoCapture,
-           capture_manager_.get(), capturer, video_format));
-}
-
-bool ChannelManager::StopVideoCapture(
-    VideoCapturer* capturer, const VideoFormat& video_format) {
-  return initialized_ && worker_thread_->Invoke<bool>(
-      Bind(&CaptureManager::StopVideoCapture,
-           capture_manager_.get(), capturer, video_format));
-}
-
-void ChannelManager::AddVideoSink(
-    VideoCapturer* capturer, rtc::VideoSinkInterface<VideoFrame>* sink) {
-  if (initialized_)
-    worker_thread_->Invoke<void>(
-        Bind(&CaptureManager::AddVideoSink,
-             capture_manager_.get(), capturer, sink));
-}
-
-void ChannelManager::RemoveVideoSink(
-    VideoCapturer* capturer, rtc::VideoSinkInterface<VideoFrame>* sink) {
-  if (initialized_)
-    worker_thread_->Invoke<void>(
-        Bind(&CaptureManager::RemoveVideoSink,
-             capture_manager_.get(), capturer, sink));
-}
-
-bool ChannelManager::IsScreencastRunning() const {
-  return initialized_ && worker_thread_->Invoke<bool>(
-      Bind(&ChannelManager::IsScreencastRunning_w, this));
-}
-
-bool ChannelManager::IsScreencastRunning_w() const {
-  VideoChannels::const_iterator it = video_channels_.begin();
-  for ( ; it != video_channels_.end(); ++it) {
-    if ((*it) && (*it)->IsScreencasting()) {
-      return true;
-    }
-  }
-  return false;
-}
-
-void ChannelManager::OnVideoCaptureStateChange(VideoCapturer* capturer,
-                                               CaptureState result) {
-  // TODO(whyuan): Check capturer and signal failure only for camera video, not
-  // screencast.
-  capturing_ = result == CS_RUNNING;
-  main_thread_->Post(this, MSG_VIDEOCAPTURESTATE,
-                     new CaptureStateParams(capturer, result));
-}
-
-void ChannelManager::OnMessage(rtc::Message* message) {
-  switch (message->message_id) {
-    case MSG_VIDEOCAPTURESTATE: {
-      CaptureStateParams* data =
-          static_cast<CaptureStateParams*>(message->pdata);
-      SignalVideoCaptureStateChange(data->capturer, data->state);
-      delete data;
-      break;
-    }
-  }
-}
 
 bool ChannelManager::StartAecDump(rtc::PlatformFile file,
                                   int64_t max_size_bytes) {
   return worker_thread_->Invoke<bool>(Bind(&MediaEngineInterface::StartAecDump,
                                            media_engine_.get(), file,
                                            max_size_bytes));
 }
 
 void ChannelManager::StopAecDump() {
   worker_thread_->Invoke<void>(
       Bind(&MediaEngineInterface::StopAecDump, media_engine_.get()));
 }
 
 bool ChannelManager::StartRtcEventLog(rtc::PlatformFile file) {
   return worker_thread_->Invoke<bool>(
       Bind(&MediaEngineInterface::StartRtcEventLog, media_engine_.get(), file));
 }
 
 void ChannelManager::StopRtcEventLog() {
   worker_thread_->Invoke<void>(
       Bind(&MediaEngineInterface::StopRtcEventLog, media_engine_.get()));
 }
 
 }  // namespace cricket